Edit: /usr/include/boost/hof/compose.hpp (5042B)
/*=============================================================================
Copyright (c) 2014 Paul Fultz II
compose.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_COMPOSE_H
#define BOOST_HOF_GUARD_FUNCTION_COMPOSE_H
/// compose
/// =======
///
/// Description
/// -----------
///
/// The `compose` function adaptor provides function composition. It produces
/// a function object that composes a set of functions, ie the output of one
/// function becomes the input of the second function. So, `compose(f, g)(0)`
/// is equivalent to `f(g(0))`.
///
///
/// Synopsis
/// --------
///
/// template
/// constexpr compose_adaptor compose(Fs... fs);
///
/// Semantics
/// ---------
///
/// assert(compose(f, g)(xs...) == f(g(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 = compose(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 compose_kernel : detail::compressed_pair, compose_function_result_type
{
typedef detail::compressed_pair base_type;
BOOST_HOF_INHERIT_CONSTRUCTOR(compose_kernel, base_type)
BOOST_HOF_RETURNS_CLASS(compose_kernel);
template
constexpr BOOST_HOF_SFINAE_RESULT(const F1&, result_of...>)
operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
(
BOOST_HOF_MANGLE_CAST(const F1&)(BOOST_HOF_CONST_THIS->first(xs...))(
BOOST_HOF_MANGLE_CAST(const F2&)(BOOST_HOF_CONST_THIS->second(xs...))(BOOST_HOF_FORWARD(Ts)(xs)...)
)
);
};
}
template
struct compose_adaptor
: detail::compose_kernel, BOOST_HOF_JOIN(compose_adaptor, detail::callable_base...)>
{
typedef compose_adaptor fit_rewritable_tag;
typedef BOOST_HOF_JOIN(compose_adaptor, detail::callable_base...) tail;
typedef detail::compose_kernel, tail> base_type;
BOOST_HOF_INHERIT_DEFAULT(compose_adaptor, base_type)
template, X),
BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(tail, Xs...)
>
constexpr compose_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 compose_adaptor(X&& f1)
BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(base_type, X&&)
: base_type(BOOST_HOF_FORWARD(X)(f1))
{}
};
template
struct compose_adaptor : detail::callable_base
{
typedef compose_adaptor fit_rewritable_tag;
BOOST_HOF_INHERIT_DEFAULT(compose_adaptor, detail::callable_base)
template)>
constexpr compose_adaptor(X&& f1)
BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(detail::callable_base, X&&)
: detail::callable_base(BOOST_HOF_FORWARD(X)(f1))
{}
};
template
struct compose_adaptor
: detail::compose_kernel, detail::callable_base>
{
typedef compose_adaptor fit_rewritable_tag;
typedef detail::compose_kernel, detail::callable_base> base_type;
BOOST_HOF_INHERIT_CONSTRUCTOR(compose_adaptor, base_type)
};
BOOST_HOF_DECLARE_STATIC_VAR(compose, detail::make);
}} // namespace boost::hof
#endif