Edit: /usr/include/boost/hof/flow.hpp (5060B)
/*=============================================================================
Copyright (c) 2015 Paul Fultz II
flow.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_FUNCTION_FLOW_H
#define BOOST_HOF_GUARD_FUNCTION_FLOW_H
/// flow
/// ====
///
/// Description
/// -----------
///
/// The `flow` function adaptor provides function composition. It is useful as
/// an alternative to using the pipe operator `|` when chaining functions. It is
/// similiar to [`compose`](compose.md) except the evaluation order is
/// reversed. So, `flow(f, g)(0)` is equivalent to `g(f(0))`.
///
///
/// Synopsis
/// --------
///
/// template
/// constexpr flow_adaptor flow(Fs... fs);
///
/// Semantics
/// ---------
///
/// assert(flow(f, g)(xs...) == g(f(xs...)));
///
/// Requirements
/// ------------
///
/// Fs must be:
///
/// * [ConstInvocable](ConstInvocable)
/// * MoveConstructible
///
/// Example
/// -------
///
/// #include
/// #include
/// using namespace boost::hof;
///
/// struct increment
/// {
/// template
/// T operator()(T x) const
/// {
/// return x + 1;
/// }
/// };
///
/// struct decrement
/// {
/// template
/// T operator()(T x) const
/// {
/// return x - 1;
/// }
/// };
///
/// int main() {
/// int r = flow(increment(), decrement(), increment())(3);
/// assert(r == 4);
/// }
///
/// References
/// ----------
///
/// * [Function composition](https://en.wikipedia.org/wiki/Function_composition)
///
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace hof { namespace detail {
template
struct flow_kernel : detail::compressed_pair, detail::callable_base>, compose_function_result_type
{
typedef detail::compressed_pair, detail::callable_base> base_type;
BOOST_HOF_INHERIT_CONSTRUCTOR(flow_kernel, base_type)
BOOST_HOF_RETURNS_CLASS(flow_kernel);
template
constexpr BOOST_HOF_SFINAE_RESULT(const detail::callable_base&, result_of&, id_...>)
operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
(
BOOST_HOF_MANGLE_CAST(const detail::callable_base&)(BOOST_HOF_CONST_THIS->second(xs...))(
BOOST_HOF_MANGLE_CAST(const detail::callable_base&)(BOOST_HOF_CONST_THIS->first(xs...))(BOOST_HOF_FORWARD(Ts)(xs)...)
)
);
};
}
template
struct flow_adaptor : detail::flow_kernel
{
typedef flow_adaptor fit_rewritable_tag;
typedef BOOST_HOF_JOIN(flow_adaptor, Fs...) tail;
typedef detail::flow_kernel base_type;
BOOST_HOF_INHERIT_DEFAULT(flow_adaptor, base_type)
template, X),
BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(tail, Xs...)
>
constexpr flow_adaptor(X&& f1, Xs&& ... fs)
BOOST_HOF_NOEXCEPT(BOOST_HOF_IS_NOTHROW_CONSTRUCTIBLE(base_type, X&&, tail) && BOOST_HOF_IS_NOTHROW_CONSTRUCTIBLE(tail, Xs&&...))
: base_type(BOOST_HOF_FORWARD(X)(f1), tail(BOOST_HOF_FORWARD(Xs)(fs)...))
{}
template, X)
>
constexpr flow_adaptor(X&& f1)
BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(base_type, X&&)
: base_type(BOOST_HOF_FORWARD(X)(f1))
{}
};
template
struct flow_adaptor : detail::callable_base
{
typedef flow_adaptor fit_rewritable_tag;
BOOST_HOF_INHERIT_DEFAULT(flow_adaptor, detail::callable_base)
template)>
constexpr flow_adaptor(X&& f1)
BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(detail::callable_base, X&&)
: detail::callable_base(BOOST_HOF_FORWARD(X)(f1))
{}
};
template
struct flow_adaptor
: detail::flow_kernel, detail::callable_base>
{
typedef flow_adaptor fit_rewritable_tag;
typedef detail::flow_kernel, detail::callable_base> base_type;
BOOST_HOF_INHERIT_CONSTRUCTOR(flow_adaptor, base_type)
};
BOOST_HOF_DECLARE_STATIC_VAR(flow, detail::make);
}} // namespace boost::hof
#endif