Upkeep.h

Go to the documentation of this file.

#pragma once

 
#include <concepts>
#include <cstddef>
#include <expected>
#include <optional>
#include <random>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
 
#include <EmrysFilter/Core/Execution.h>
#include <EmrysFilter/Core/Macros.h>
#include <EmrysFilter/Core/Multiply.h>
#include <EmrysFilter/Core/NumericError.h>
#include <EmrysFilter/Distributions/Categorical.h>
#include <EmrysFilter/Distributions/Mixture.h>
#include <EmrysFilter/Distributions/ParticleSet.h>
#include <EmrysFilter/Core/Resampling.h>
#include <EmrysFilter/Distributions/Roots.h>
#include <EmrysFilter/Distributions/SampleSet.h>
#include <EmrysFilter/Distributions/Sampling.h>
#include <EmrysFilter/Distributions/Statistics.h>
#include <EmrysFilter/Core/Weights.h>
 
namespace Emrys
{

 
namespace internal
{

template <typename Actions, typename State>
[[nodiscard]] std::expected<bool, WeightError>
runActions(Actions const & actions, State & state)
{
    return std::apply(
        [&](auto const &... action) {
            auto changed = std::expected<bool, WeightError>{false};
            auto const run = [&](auto const & next) {
                if (!changed)
                {
                    return;
                }
                std::expected<bool, WeightError> const result = next(state);
                if (!result)
                {
                    changed = std::unexpected{result.error()};
                }
                else
                {
                    changed = *changed || *result;
                }
            };
            (run(action), ...);
            return changed;
        },
        actions
    );
}

template <typename Removed>
[[nodiscard]] std::expected<bool, WeightError>
prunedAny(Removed const & removed)
{
    if constexpr (isExpected<Removed>)
    {
        using Scalar = typename Removed::value_type;
        return removed.transform([](Scalar logRemoved) {
            return logRemoved > -Eigen::NumTraits<Scalar>::infinity();
        });
    }
    else
    {
        return removed > -Eigen::NumTraits<Removed>::infinity();
    }
}

template <typename Result>
[[nodiscard]] std::expected<void, NumericError>
factorizeOutcome(Result const & result)
{
    if (result)
    {
        return {};
    }
    if constexpr (std::same_as<typename Result::error_type, NumericError>)
    {
        return std::unexpected{result.error()};
    }
    else
    {
        return std::unexpected{std::visit(
            [](auto const & error) {
                if constexpr (std::same_as<std::remove_cvref_t<decltype(error)>, NumericError>)
                {
                    return error;
                }
                else
                {
                    return NumericError(error.error);
                }
            },
            result.error()
        )};
    }
}

template <typename Test, typename... Args>
concept UpkeepTest = std::predicate<Test const &, Args...>
                  || (std::invocable<Test const &, Args...>
                      && std::same_as<std::invoke_result_t<Test const &, Args...>, std::expected<bool, WeightError>>);

template <typename Result>
[[nodiscard]] std::expected<bool, WeightError>
testOutcome(Result const & result)
{
    if constexpr (std::same_as<Result, std::expected<bool, WeightError>>)
    {
        return result;
    }
    else
    {
        return bool(result);
    }
}

template <typename Compare, RealScalar Scalar_, ExecutionPolicy Policy_ = execution::Sequential>
    requires std::predicate<Compare const &, Scalar_, Scalar_>
struct EssTest
{
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Compare compare;   
    Scalar_ fraction;                                 
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Policy_ policy{};  

    template <typename State>
        requires requires(State const & state) {
            state.ess();
            state.size();
        }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State const & state) const
    {
        if constexpr (!internal::isSequential<Policy_> && requires { state.ess(policy); })
        {
            return holds(state.ess(policy), state.size());
        }
        else
        {
            return holds(state.ess(), state.size());
        }
    }
 
private:

    template <typename Ess, typename Index>
    [[nodiscard]] std::expected<bool, WeightError>
    holds(Ess const & ess, Index size) const
    {
        if (!ess)
        {
            return std::unexpected{ess.error()};
        }
        using Scalar = typename Ess::value_type;
        return bool(compare(*ess, Scalar(Scalar(fraction) * scalarFromCount<Scalar>(size))));
    }
};

template <typename Compare>
    requires std::predicate<Compare const &, std::ptrdiff_t, std::ptrdiff_t>
struct SizeTest
{
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Compare compare;  
    std::ptrdiff_t limit;                            

    template <typename State>
        requires requires(State const & state) { state.size(); }
    [[nodiscard]] bool
    operator()(State const & state) const
    {
        return bool(compare(std::ptrdiff_t(state.size()), limit));
    }
};

template <typename State, typename G, typename R, typename P>
concept ResamplableBy = requires(State & state, G & rng, Eigen::Index newSize, R const & resampler, P const & policy) {
    state.size();
    requires(!isSequential<P>) || requires { state.resample(rng, newSize, resampler); };
    requires isSequential<P> || requires { state.resample(policy, rng, newSize, resampler); };
};

struct Always
{
    template <typename State>
    [[nodiscard]] constexpr bool
    operator()(State const &) const
    {
        return true;
    }
};
 
}  // namespace internal

template <typename T, typename State>
concept UpkeepOperation = requires(T const & operation, State & state) {
    { operation(state) } -> std::same_as<std::expected<bool, NumericError>>;
};

namespace upkeep
{

template <
    std::uniform_random_bit_generator G,
    typename Resampler_ = resamplers::Systematic,
    ExecutionPolicy Policy_ = execution::Sequential>
class Resample
{
public:

    constexpr explicit Resample(
        G & generator,
        Resampler_ resampler = {},
        std::optional<Eigen::Index> size = std::nullopt,
        Policy_ policy = {}
    )
        : generator_{&generator}
        , resampler_{std::move(resampler)}
        , size_{size}
        , policy_{std::move(policy)}
    {}

    template <typename State>
        requires internal::ResamplableBy<State, G, Resampler_, Policy_>
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        auto const resampled = [&] {
            if constexpr (internal::isSequential<Policy_>)
            {
                return state.resample(*generator_, newSize(state), resampler_);
            }
            else
            {
                return state.resample(policy_, *generator_, newSize(state), resampler_);
            }
        }();
        if (!resampled)
        {
            return std::unexpected{resampled.error()};
        }
        return true;
    }

    [[nodiscard]] constexpr G &
    generator() const noexcept
    {
        return *generator_;
    }

    [[nodiscard]] constexpr Resampler_ const &
    resampler() const noexcept
    {
        return resampler_;
    }

    [[nodiscard]] constexpr std::optional<Eigen::Index>
    size() const noexcept
    {
        return size_;
    }

    [[nodiscard]] constexpr Policy_ const &
    policy() const noexcept
    {
        return policy_;
    }
 
private:

    template <typename State>
    [[nodiscard]] Eigen::Index
    newSize(State const & state) const
    {
        return size_ ? *size_ : Eigen::Index(state.size());
    }
 
    G * generator_;                                        
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Resampler_ resampler_;  
    std::optional<Eigen::Index> size_;                     
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Policy_ policy_;        
};

template <std::uniform_random_bit_generator G, typename R = resamplers::Systematic>
    requires(!std::integral<R>)
[[nodiscard]] constexpr Resample<G, R>
resample(G & generator, R resampler = {})
{
    return Resample<G, R>{generator, std::move(resampler)};
}

template <std::uniform_random_bit_generator G, typename R = resamplers::Systematic>
    requires(!std::integral<R>)
[[nodiscard]] constexpr Resample<G, R>
resample(G & generator, Eigen::Index size, R resampler = {})
{
    EMRYS_FILTER_ASSERT(size > 0 && "a resample needs a positive size");
    return Resample<G, R>{generator, std::move(resampler), size};
}

template <ExecutionPolicy P, std::uniform_random_bit_generator G, typename R = resamplers::Systematic>
    requires(!std::integral<R>)
[[nodiscard]] constexpr Resample<G, R, std::remove_cvref_t<P>>
resample(P && policy, G & generator, R resampler = {})
{
    return Resample<G, R, std::remove_cvref_t<P>>{
        generator,
        std::move(resampler),
        std::nullopt,
        std::forward<P>(policy)
    };
}

template <ExecutionPolicy P, std::uniform_random_bit_generator G, typename R = resamplers::Systematic>
    requires(!std::integral<R>)
[[nodiscard]] constexpr Resample<G, R, std::remove_cvref_t<P>>
resample(P && policy, G & generator, Eigen::Index size, R resampler = {})
{
    EMRYS_FILTER_ASSERT(size > 0 && "a resample needs a positive size");
    return Resample<G, R, std::remove_cvref_t<P>>{generator, std::move(resampler), size, std::forward<P>(policy)};
}

template <
    std::uniform_random_bit_generator G,
    RealScalar Scalar_ = double,
    ExecutionPolicy Policy_ = execution::Sequential>
class Roughen
{
public:

    constexpr explicit Roughen(G & generator, Scalar_ scale = 1, Policy_ policy = {})
        : generator_{&generator}
        , scale_{scale}
        , policy_{std::move(policy)}
    {}

    template <typename Space, typename Scalar, typename Allocator>
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(ParticleSet<Space, Scalar, Allocator> & particles) const
    {
        using Set = ParticleSet<Space, Scalar, Allocator>;
        using Vector = typename Set::VectorType;
        using Difference = typename Set::DifferenceVectorType;
        static_assert(std::floating_point<Scalar>, "sampling requires a standard floating-point scalar");
        EMRYS_FILTER_ASSERT(scale_ >= Scalar_(0) && "the kernel scale must not be negative");
        G & rng = *generator_;
        if (scale_ == Scalar_(0))
        {
            return particles.logTotalWeight(policy_).transform([](Scalar) {
                return false;
            });
        }
        auto const bandwidth = particles.kdeBandwidth(policy_);
        if (!bandwidth)
        {
            return std::unexpected{bandwidth.error()};
        }
        auto const kernel = internal::defaultRoot((Scalar(scale_) * *bandwidth).eval());
        auto const & space = particles.space();
        Eigen::Index const rows = particles.differenceDimension();
        if constexpr (internal::isSequential<Policy_>)
        {
            // One distribution for every draw, which may keep a value between them, so that the draws
            // are those of filling all the particles' normals at once, as another policy does.
            auto normal = std::normal_distribution<Scalar>{};
            auto z = Difference{};
            z.resize(rows);
            for (Eigen::Index i = 0; i < particles.size(); ++i)
            {
                internal::fillStandardNormal(z, rng, normal);
                Vector const moved = Emrys::plus(space, particles.state(i), Difference{internal::multiply(kernel, z)});
                particles.setState(i, moved);
            }
        }
        else
        {
            using Normals = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>;
            auto draws = internal::scratchVector<Scalar>(policy_, std::size_t(rows * particles.size()));
            auto normals = Eigen::Map<Normals>{draws.data(), rows, particles.size()};
            internal::fillStandardNormal(normals, rng);
            particles.forEach(policy_, [&](auto & particle) {
                Vector const moved =
                    Emrys::plus(space, particle.state(), Difference{kernel * normals.col(particle.index())});
                particle.setState(moved);
            });
        }
        return true;
    }

    template <typename State>
        requires requires(State & state) { state.setParticleStates(state.particles().states()); }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        auto particles = state.particles();
        std::expected<bool, WeightError> const roughened = (*this)(particles);
        if (roughened && *roughened)
        {
            state.setParticleStates(particles.states());
        }
        return roughened;
    }

    [[nodiscard]] constexpr G &
    generator() const noexcept
    {
        return *generator_;
    }

    [[nodiscard]] constexpr Scalar_
    scale() const noexcept
    {
        return scale_;
    }

    [[nodiscard]] constexpr Policy_ const &
    policy() const noexcept
    {
        return policy_;
    }
 
private:
 
    G * generator_;                                  
    Scalar_ scale_;                                  
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Policy_ policy_;  
};

template <std::uniform_random_bit_generator G, typename Value = double>
    requires std::is_arithmetic_v<Value>
[[nodiscard]] constexpr Roughen<G, internal::DeducedScalar<Value>>
roughen(G & generator, Value scale = 1)
{
    return Roughen<G, internal::DeducedScalar<Value>>{generator, internal::DeducedScalar<Value>(scale)};
}

template <ExecutionPolicy P, std::uniform_random_bit_generator G, typename Value = double>
    requires std::is_arithmetic_v<Value>
[[nodiscard]] constexpr Roughen<G, internal::DeducedScalar<Value>, std::remove_cvref_t<P>>
roughen(P && policy, G & generator, Value scale = 1)
{
    return Roughen<G, internal::DeducedScalar<Value>, std::remove_cvref_t<P>>{
        generator,
        internal::DeducedScalar<Value>(scale),
        std::forward<P>(policy)
    };
}

template <typename Predicate, typename... Actions>
struct When
{
    EMRYS_FILTER_NO_UNIQUE_ADDRESS Predicate predicate;  
    std::tuple<Actions...> actions;                      

    When(Predicate test, Actions... toRun)
        : predicate{std::move(test)}
        , actions{std::move(toRun)...}
    {}

    template <typename State>
        requires internal::UpkeepTest<Predicate, State const &> && (UpkeepOperation<Actions, State> && ...)
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        std::expected<bool, WeightError> const holds = internal::testOutcome(predicate(std::as_const(state)));
        if (!holds || !*holds)
        {
            return holds;
        }
        return internal::runActions(actions, state);
    }
};

template <typename Predicate, typename... Actions>
[[nodiscard]] When<Predicate, Actions...>
when(Predicate predicate, Actions... actions)
{
    return When<Predicate, Actions...>{std::move(predicate), std::move(actions)...};
}

template <typename Compare, RealScalar Scalar_, typename... Actions>
using WhenEss = When<internal::EssTest<Compare, Scalar_>, Actions...>;

template <typename Compare, typename Value, typename... Actions>
    requires(!ExecutionPolicy<Compare>) && std::is_arithmetic_v<Value>
         && std::predicate<Compare const &, internal::DeducedScalar<Value>, internal::DeducedScalar<Value>>
[[nodiscard]] WhenEss<Compare, internal::DeducedScalar<Value>, Actions...>
whenEss(Compare compare, Value fraction, Actions... actions)
{
    using Test = internal::EssTest<Compare, internal::DeducedScalar<Value>>;
    return when(Test{std::move(compare), internal::DeducedScalar<Value>(fraction)}, std::move(actions)...);
}

template <ExecutionPolicy P, typename Compare, typename Value, typename... Actions>
    requires std::is_arithmetic_v<Value>
          && std::predicate<Compare const &, internal::DeducedScalar<Value>, internal::DeducedScalar<Value>>
[[nodiscard]] When<internal::EssTest<Compare, internal::DeducedScalar<Value>, std::remove_cvref_t<P>>, Actions...>
whenEss(P && policy, Compare compare, Value fraction, Actions... actions)
{
    using Test = internal::EssTest<Compare, internal::DeducedScalar<Value>, std::remove_cvref_t<P>>;
    return when(
        Test{std::move(compare), internal::DeducedScalar<Value>(fraction), std::forward<P>(policy)},
        std::move(actions)...
    );
}

template <typename Compare, typename... Actions>
using WhenSize = When<internal::SizeTest<Compare>, Actions...>;

template <typename Compare, typename... Actions>
    requires std::predicate<Compare const &, std::ptrdiff_t, std::ptrdiff_t>
[[nodiscard]] WhenSize<Compare, Actions...>
whenSize(Compare compare, std::ptrdiff_t limit, Actions... actions)
{
    return when(internal::SizeTest<Compare>{std::move(compare), limit}, std::move(actions)...);
}

template <typename... Actions>
using Sequence = When<internal::Always, Actions...>;

template <typename... Actions>
[[nodiscard]] Sequence<Actions...>
sequence(Actions... actions)
{
    return when(internal::Always{}, std::move(actions)...);
}

struct None
{
    template <typename State>
    [[nodiscard]] constexpr std::expected<bool, NumericError>
    operator()(State &) const
    {
        return false;
    }
};

[[nodiscard]] constexpr None
none()
{
    return {};
}

template <RealScalar Scalar_ = double>
struct PruneBelow
{
    Scalar_ probability;  

    template <typename State>
        requires requires(State & state, typename State::Scalar logThreshold) { state.pruneBelow(logThreshold); }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        using Scalar = typename State::Scalar;
        EMRYS_FILTER_ASSERT(
            probability >= Scalar_(0) && probability < Scalar_(1) && "the threshold is a probability below one"
        );
        return internal::prunedAny(state.pruneBelow(Eigen::numext::log(Scalar(probability))));
    }
};

template <typename Value>
    requires std::is_arithmetic_v<Value>
[[nodiscard]] constexpr PruneBelow<internal::DeducedScalar<Value>>
pruneBelow(Value probability)
{
    return {internal::DeducedScalar<Value>(probability)};
}

template <RealScalar Scalar_ = double>
struct PruneTail
{
    Scalar_ fraction;  

    template <typename State>
        requires requires(State & state, typename State::Scalar logFraction) { state.pruneTail(logFraction); }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        using Scalar = typename State::Scalar;
        EMRYS_FILTER_ASSERT(
            fraction >= Scalar_(0) && fraction < Scalar_(1) && "the fraction pruned is a probability below one"
        );
        return internal::prunedAny(state.pruneTail(Eigen::numext::log(Scalar(fraction))));
    }
};

template <typename Value>
    requires std::is_arithmetic_v<Value>
[[nodiscard]] constexpr PruneTail<internal::DeducedScalar<Value>>
pruneTail(Value fraction)
{
    return {internal::DeducedScalar<Value>(fraction)};
}

struct PruneToSize
{
    std::ptrdiff_t maxSize;  

    template <typename State>
        requires requires(State & state, Eigen::Index size) { state.pruneToSize(size); }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        return internal::prunedAny(state.pruneToSize(Eigen::Index(maxSize)));
    }
};

[[nodiscard]] constexpr PruneToSize
pruneToSize(std::ptrdiff_t maxSize)
{
    return {maxSize};
}

struct Subdivide
{
    std::ptrdiff_t factor = 2;  

    template <typename State>
        requires requires(State & state, Eigen::Index factor) { state.subdivide(factor); }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        state.subdivide(Eigen::Index(factor));
        return factor > 1;
    }
};

[[nodiscard]] constexpr Subdivide
subdivide(std::ptrdiff_t factor = 2)
{
    return {factor};
}

template <RealScalar Scalar_ = double>
struct FloorModes
{
    Scalar_ probability;  

    template <typename State>
        requires requires(State & state) {
            state.modes().logTotalWeight();
            state.modes().logWeights();
            state.setModes(state.modes());
        }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(State & state) const
    {
        using ModesType = std::remove_cvref_t<decltype(state.modes())>;
        auto floored = flooredLogWeights(state.modes());
        if (!floored)
        {
            return std::unexpected{floored.error()};
        }
        if (!*floored)
        {
            return false;
        }
        state.setModes(ModesType{state.modes().space(), **floored});
        return true;
    }

    template <typename Space, typename Scalar>
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(CategoricalParams<Space, Scalar> & categorical) const
    {
        auto floored = flooredLogWeights(categorical);
        if (!floored)
        {
            return std::unexpected{floored.error()};
        }
        if (!*floored)
        {
            return false;
        }
        categorical.setLogWeights(**floored);
        return true;
    }

    template <typename Component, typename Allocator>
        requires requires(typename MixtureParams<Component, Allocator>::ComponentType & hybrid) {
            hybrid.setModes(hybrid.modes());
        }
    [[nodiscard]] std::expected<bool, WeightError>
    operator()(MixtureParams<Component, Allocator> & mixture) const
    {
        // Every component's modes are checked before any is changed, so that a failure leaves the
        // mixture as it was, and a mixture with nothing to floor is not touched.
        using Scalar = typename MixtureParams<Component, Allocator>::ComponentType::ModesType::Scalar;
        Scalar const logFloor = Eigen::numext::log(Scalar(probability));
        bool any = false;
        for (Eigen::Index i = 0; i < mixture.size(); ++i)
        {
            auto const & modes = mixture[i].component.modes();
            auto const total = modes.logTotalWeight();
            if (!total)
            {
                return std::unexpected{total.error()};
            }
            any = any || ((modes.logWeights() - *total) < logFloor).any();
        }
        if (!any)
        {
            return false;
        }
        mixture.forEach([&](auto & entry) {
            entry.updateComponent([&](auto & hybrid) {
                (void)(*this)(hybrid);
            });
        });
        return true;
    }
 
private:

    template <typename Modes>
    [[nodiscard]] std::expected<std::optional<typename Modes::ArrayType>, WeightError>
    flooredLogWeights(Modes const & modes) const
    {
        using ArrayType = typename Modes::ArrayType;
        using Scalar = typename Modes::Scalar;
        auto const total = modes.logTotalWeight();
        if (!total)
        {
            return std::unexpected{total.error()};
        }
        ArrayType const logProbabilities = modes.logWeights() - *total;
        Eigen::Index const count = logProbabilities.size();
        EMRYS_FILTER_ASSERT(
            probability >= Scalar_(0) && Scalar(probability) * internal::scalarFromCount<Scalar>(count) <= Scalar(1)
            && "the floor is a probability no more than one over the number of modes"
        );
        Scalar const logFloor = Eigen::numext::log(Scalar(probability));
        // The floored modes are those below a threshold, which rises as each round floors more:
        // the modes above it are scaled by the rest of the mass over their own, and any that falls
        // below the floor lowers that scale.
        Scalar threshold = logFloor;
        Scalar scale = 0;
        Eigen::Index floored = (logProbabilities < threshold).count();
        if (floored == 0)
        {
            return std::optional<ArrayType>{};
        }
        while (true)
        {
            auto kept = LogSumExp<Scalar>{};
            for (Eigen::Index m = 0; m < count; ++m)
            {
                if (!(logProbabilities(m) < threshold))
                {
                    kept.add(logProbabilities(m));
                }
            }
            scale = Eigen::numext::log(Scalar(Scalar(1) - Scalar(floored) * Scalar(probability))) - kept.value();
            threshold = logFloor - scale;
            Eigen::Index const next = (logProbabilities < threshold).count();
            if (next == floored)
            {
                break;
            }
            floored = next;
        }
        return std::optional<ArrayType>{
            (logProbabilities < threshold).select(ArrayType::Constant(count, logFloor), logProbabilities + scale)
        };
    }
};

template <typename Value>
    requires std::is_arithmetic_v<Value>
[[nodiscard]] constexpr FloorModes<internal::DeducedScalar<Value>>
floorModes(Value probability)
{
    return {internal::DeducedScalar<Value>(probability)};
}

template <Repair Repair_ = roots::Ridge<>>
struct RepairCovariance
{
    Repair_ repair{};  

    template <typename State>
        requires requires(State & state, Repair_ const & repair) {
            std::as_const(state).factorize();
            state.factorize(repair);
        }
    [[nodiscard]] std::expected<bool, NumericError>
    operator()(State & state) const
    {
        std::expected<void, NumericError> const factorized =
            internal::factorizeOutcome(std::as_const(state).factorize());
        if (factorized)
        {
            return false;
        }
        if (factorized.error() != NumericError::NotPositiveDefinite)
        {
            return std::unexpected{factorized.error()};
        }
        std::expected<void, NumericError> const repaired = internal::factorizeOutcome(state.factorize(repair));
        if (!repaired)
        {
            return std::unexpected{repaired.error()};
        }
        return true;
    }
};

template <Repair R = roots::Ridge<>>
[[nodiscard]] constexpr RepairCovariance<R>
repairCovariance(R repair = {})
{
    return {std::move(repair)};
}
 
}  // namespace upkeep
 
}  // namespace Emrys