fold.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_VALUE_FUNCTIONS_FOLD_H
#define pRC_CORE_VALUE_FUNCTIONS_FOLD_H
 
#include <prc/core/basic/concepts.hpp>
#include <prc/core/basic/direction.hpp>
 
namespace pRC
{
    template<class F, Bool E = false, Direction D = Direction::Forwards,
        class X>
        requires(D == Direction::Forwards || D == Direction::Backwards)
    static inline constexpr decltype(auto) fold(X &&a)
    {
        if constexpr(E)
        {
            return eval(forward<X>(a));
        }
        else
        {
            return as(forward<X>(a));
        }
    }
 
    template<class F, Bool E = false, Direction D = Direction::Forwards,
        class XA, class XB>
        requires IsInvocable<F, XA, XB> &&
        (D == Direction::Forwards || D == Direction::Backwards)
    static inline constexpr decltype(auto) fold(XA &&a, XB &&b)
    {
        if constexpr(E)
        {
            return eval(F()(forward<XA>(a), forward<XB>(b)));
        }
        else
        {
            return F()(forward<XA>(a), forward<XB>(b));
        }
    }
 
    template<class F, Bool E = false, Direction D = Direction::Forwards,
        class XA, class XB, class... Xs>
        requires IsInvocable<F, XA, XB> &&
        ((D == Direction::Forwards || D == Direction::Backwards) &&
            sizeof...(Xs) > 0) &&
        requires {
            fold<F, E, D>(fold<F, E, D>(declval<XA>(), declval<XB>()),
                declval<Xs>()...);
        }
    static inline constexpr decltype(auto) fold(XA &&a, XB &&b, Xs &&...args)
    {
        if constexpr(D == Direction::Forwards)
        {
            auto const c = [&a, &b]() -> decltype(auto)
            {
                if constexpr(E)
                {
                    return eval(F()(forward<XA>(a), forward<XB>(b)));
                }
                else
                {
                    return F()(forward<XA>(a), forward<XB>(b));
                }
            };
 
            return fold<F, E, D>(c(), forward<Xs>(args)...);
        }
        if constexpr(D == Direction::Backwards)
        {
            auto const c = [&b, &args...]() -> decltype(auto)
            {
                return fold<F, E, D>(forward<XB>(b), forward<Xs>(args)...);
            };
 
            if constexpr(E)
            {
                return eval(F()(forward<XA>(a), c()));
            }
            else
            {
                return F()(forward<XA>(a), c());
            }
        }
    }
}
#endif // pRC_CORE_VALUE_FUNCTIONS_FOLD_H