Edit: /usr/include/boost/hof/fix.hpp (6314B)
/*=============================================================================
Copyright (c) 2014 Paul Fultz II
fix.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_FIX_H
#define BOOST_HOF_GUARD_FUNCTION_FIX_H
/// fix
/// ===
///
/// Description
/// -----------
///
/// The `fix` function adaptor implements a fixed-point combinator. This can be
/// used to write recursive functions.
///
/// When using `constexpr`, a function can recurse to a depth that is defined by
/// `BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH`(default is 16). There is no limitiation on
/// recursion depth for non-constexpr functions. In addition, due to the
/// eagerness of `constexpr` to instantiation templates, in some cases, an
/// explicit return type must be specified in order to avoid reaching the
/// recursion limits of the compiler. This can be accomplished using
/// [`boost::hof::result`](/include/boost/hof/result):
///
/// int r = boost::hof::result
(factorial)(5);
///
/// Synopsis
/// --------
///
/// template
/// constexpr fix_adaptor fix(F f);
///
/// Semantics
/// ---------
///
/// assert(fix(f)(xs...) == f(fix(f), xs...));
///
/// Requirements
/// ------------
///
/// F must be:
///
/// * [ConstFunctionObject](ConstFunctionObject)
/// * MoveConstructible
///
/// Example
/// -------
///
/// #include
/// #include
///
/// int main() {
/// auto factorial = boost::hof::fix(
/// [](auto recurse, auto x) -> decltype(x) {
/// return x == 0 ? 1 : x * recurse(x-1);
/// }
/// );
/// int r = boost::hof::result(factorial)(5);
/// assert(r == 5*4*3*2*1);
/// }
///
/// References
/// ----------
///
/// * [Fixed-point combinator](https://en.wikipedia.org/wiki/Fixed-point_combinator)
/// * [Recursive](Recursive)
///
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { namespace hof {
namespace detail{
template
struct compute_indirect_ref
{ typedef indirect_adaptor type; };
template
struct compute_indirect_ref>
{ typedef indirect_adaptor type; };
template
constexpr indirect_adaptor make_indirect_ref(const F& f) noexcept
{
return indirect_adaptor(&f);
}
template
constexpr indirect_adaptor make_indirect_ref(const indirect_adaptor& f) noexcept
{
return f;
}
template
struct fix_result
{
template
struct apply
{
typedef decltype(std::declval()(std::declval()...)) type;
};
};
template
struct fix_result::type>
{
template
struct apply
{
typedef typename F::result_type type;
};
};
template
struct fix_adaptor_base : F
{
BOOST_HOF_INHERIT_CONSTRUCTOR(fix_adaptor_base, F);
typedef typename compute_indirect_ref::type base_ref_type;
typedef fix_adaptor_base derived;
template
constexpr const F& base_function(Ts&&... xs) const noexcept
{
return boost::hof::always_ref(*this)(xs...);
}
template
constexpr derived derived_function(Ts&&... xs) const noexcept
{
return derived(boost::hof::detail::make_indirect_ref(this->base_function(xs...)));
}
struct fix_failure
{
template
struct apply
{
template
struct of
: Failure::template of
{};
};
};
struct failure
: failure_map
{};
BOOST_HOF_RETURNS_CLASS(fix_adaptor_base);
template
constexpr BOOST_HOF_SFINAE_RESULT(const F&, id_, id_...)
operator()(Ts&&... xs) const BOOST_HOF_SFINAE_RETURNS
(
BOOST_HOF_MANGLE_CAST(const F&)(BOOST_HOF_CONST_THIS->base_function(xs...))
(
BOOST_HOF_MANGLE_CAST(derived)(BOOST_HOF_CONST_THIS->derived_function(xs...)),
BOOST_HOF_FORWARD(Ts)(xs)...
)
);
};
template
struct fix_adaptor_base : F
{
BOOST_HOF_INHERIT_CONSTRUCTOR(fix_adaptor_base, F);
template
const F& base_function(Ts&&...) const noexcept
{
return *this;
}
struct fix_failure
{
template
struct apply
{
template
struct of
: Failure::template of
{};
};
};
struct failure
: failure_map
{};
BOOST_HOF_RETURNS_CLASS(fix_adaptor_base);
template
typename Result::template apply::type
operator()(Ts&&... xs) const
{
return this->base_function(xs...)(*this, BOOST_HOF_FORWARD(Ts)(xs)...);
}
};
}
template
struct fix_adaptor : detail::fix_adaptor_base, BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH>
{
typedef fix_adaptor fit_rewritable1_tag;
typedef detail::fix_adaptor_base, BOOST_HOF_RECURSIVE_CONSTEXPR_DEPTH> base;
BOOST_HOF_INHERIT_CONSTRUCTOR(fix_adaptor, base);
};
template
struct result_adaptor>
: fix_adaptor>
{
typedef fix_adaptor> base;
BOOST_HOF_INHERIT_CONSTRUCTOR(result_adaptor, base)
};
BOOST_HOF_DECLARE_STATIC_VAR(fix, detail::make);
}} // namespace boost::hof
#endif