diff options
Diffstat (limited to 'boost/hof/reverse_fold.hpp')
| -rw-r--r-- | boost/hof/reverse_fold.hpp | 173 |
1 files changed, 173 insertions, 0 deletions
diff --git a/boost/hof/reverse_fold.hpp b/boost/hof/reverse_fold.hpp new file mode 100644 index 0000000000..771cb95c41 --- /dev/null +++ b/boost/hof/reverse_fold.hpp @@ -0,0 +1,173 @@ +/*============================================================================= + Copyright (c) 2015 Paul Fultz II + reverse_fold.h + Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +==============================================================================*/ + +#ifndef BOOST_HOF_GUARD_REVERSE_FOLD_H +#define BOOST_HOF_GUARD_REVERSE_FOLD_H + +/// reverse_fold +/// ======== +/// +/// Description +/// ----------- +/// +/// The `reverse_fold` function adaptor uses a binary function to apply a +/// reverse [fold] +/// (https://en.wikipedia.org/wiki/Fold_%28higher-order_function%29)(ie right +/// fold in functional programming terms) operation to the arguments passed to +/// the function. Additionally, an optional initial state can be provided, +/// otherwise the first argument is used as the initial state. +/// +/// The arguments to the binary function, take first the state and then the +/// argument. +/// +/// Synopsis +/// -------- +/// +/// template<class F, class State> +/// constexpr reverse_fold_adaptor<F, State> reverse_fold(F f, State s); +/// +/// template<class F> +/// constexpr reverse_fold_adaptor<F> reverse_fold(F f); +/// +/// Semantics +/// --------- +/// +/// assert(reverse_fold(f, z)() == z); +/// assert(reverse_fold(f, z)(x, xs...) == f(reverse_fold(f, z)(xs...), x)); +/// assert(reverse_fold(f)(x) == x); +/// assert(reverse_fold(f)(x, xs...) == f(reverse_fold(f)(xs...), x)); +/// +/// Requirements +/// ------------ +/// +/// State must be: +/// +/// * CopyConstructible +/// +/// F must be: +/// +/// * [BinaryInvocable](BinaryInvocable) +/// * MoveConstructible +/// +/// Example +/// ------- +/// +/// #include <boost/hof.hpp> +/// #include <cassert> +/// +/// struct max_f +/// { +/// template<class T, class U> +/// constexpr T operator()(T x, U y) const +/// { +/// return x > y ? x : y; +/// } +/// }; +/// +/// int main() { +/// assert(boost::hof::reverse_fold(max_f())(2, 3, 4, 5) == 5); +/// } +/// +/// References +/// ---------- +/// +/// * [Projections](Projections) +/// * [Variadic print](<Variadic print>) +/// + +#include <boost/hof/detail/callable_base.hpp> +#include <boost/hof/detail/delegate.hpp> +#include <boost/hof/detail/compressed_pair.hpp> +#include <boost/hof/detail/move.hpp> +#include <boost/hof/detail/make.hpp> +#include <boost/hof/detail/static_const_var.hpp> + +namespace boost { namespace hof { namespace detail { + +struct v_reverse_fold +{ + BOOST_HOF_RETURNS_CLASS(v_reverse_fold); + template<class F, class State, class T, class... Ts> + constexpr BOOST_HOF_SFINAE_MANUAL_RESULT(const F&, result_of<const v_reverse_fold&, id_<const F&>, id_<State>, id_<Ts>...>, id_<T>) + operator()(const F& f, State&& state, T&& x, Ts&&... xs) const BOOST_HOF_SFINAE_MANUAL_RETURNS + ( + f((*BOOST_HOF_CONST_THIS)(f, BOOST_HOF_FORWARD(State)(state), BOOST_HOF_FORWARD(Ts)(xs)...), BOOST_HOF_FORWARD(T)(x)) + ); + + template<class F, class State> + constexpr State operator()(const F&, State&& state) const noexcept + { + return BOOST_HOF_FORWARD(State)(state); + } +}; + +} + +template<class F, class State=void> +struct reverse_fold_adaptor +: detail::compressed_pair<detail::callable_base<F>, State> +{ + typedef detail::compressed_pair<detail::callable_base<F>, State> base_type; + BOOST_HOF_INHERIT_CONSTRUCTOR(reverse_fold_adaptor, base_type) + + template<class... Ts> + constexpr const detail::callable_base<F>& base_function(Ts&&... xs) const noexcept + { + return this->first(xs...); + } + + template<class... Ts> + constexpr State get_state(Ts&&... xs) const noexcept + { + return this->second(xs...); + } + + BOOST_HOF_RETURNS_CLASS(reverse_fold_adaptor); + + template<class... Ts> + constexpr BOOST_HOF_SFINAE_RESULT(detail::v_reverse_fold, id_<const detail::callable_base<F>&>, id_<State>, id_<Ts>...) + operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS + ( + detail::v_reverse_fold()( + BOOST_HOF_MANGLE_CAST(const detail::callable_base<F>&)(BOOST_HOF_CONST_THIS->base_function(xs...)), + BOOST_HOF_MANGLE_CAST(State)(BOOST_HOF_CONST_THIS->get_state(xs...)), + BOOST_HOF_FORWARD(Ts)(xs)... + ) + ) +}; + + +template<class F> +struct reverse_fold_adaptor<F, void> +: detail::callable_base<F> +{ + BOOST_HOF_INHERIT_CONSTRUCTOR(reverse_fold_adaptor, detail::callable_base<F>) + + template<class... Ts> + constexpr const detail::callable_base<F>& base_function(Ts&&... xs) const noexcept + { + return boost::hof::always_ref(*this)(xs...); + } + + BOOST_HOF_RETURNS_CLASS(reverse_fold_adaptor); + + template<class... Ts> + constexpr BOOST_HOF_SFINAE_RESULT(detail::v_reverse_fold, id_<const detail::callable_base<F>&>, id_<Ts>...) + operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS + ( + detail::v_reverse_fold()( + BOOST_HOF_MANGLE_CAST(const detail::callable_base<F>&)(BOOST_HOF_CONST_THIS->base_function(xs...)), + BOOST_HOF_FORWARD(Ts)(xs)... + ) + ) +}; + +BOOST_HOF_DECLARE_STATIC_VAR(reverse_fold, detail::make<reverse_fold_adaptor>); + +}} // namespace boost::hof + +#endif |