// Copyright (C) 2016-2018 T. Zachary Laine
//
// 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_YAP_ALGORITHM_HPP_INCLUDED
#define BOOST_YAP_ALGORITHM_HPP_INCLUDED
#include <boost/yap/algorithm_fwd.hpp>
#include <boost/yap/user_macros.hpp>
#include <boost/yap/detail/algorithm.hpp>
#include <boost/hana/size.hpp>
#include <boost/hana/comparing.hpp>
namespace boost { namespace yap {
#ifdef BOOST_NO_CONSTEXPR_IF
namespace detail {
template<typename Expr, bool MutableRvalueRef>
struct deref_impl
{
constexpr decltype(auto) operator()(Expr && expr)
{
return std::move(*expr.elements[hana::llong_c<0>]);
}
};
template<typename Expr>
struct deref_impl<Expr, false>
{
constexpr decltype(auto) operator()(Expr && expr)
{
return *expr.elements[hana::llong_c<0>];
}
};
}
#endif
/** "Dereferences" a reference-expression, forwarding its referent to
the caller. */
template<typename Expr>
constexpr decltype(auto) deref(Expr && expr)
{
static_assert(
is_expr<Expr>::value, "deref() is only defined for expressions.");
static_assert(
detail::remove_cv_ref_t<Expr>::kind == expr_kind::expr_ref,
"deref() is only defined for expr_ref-kind expressions.");
#ifdef BOOST_NO_CONSTEXPR_IF
return detail::deref_impl < Expr,
std::is_rvalue_reference<Expr>::value &&
!std::is_const<std::remove_reference_t<Expr>>::value >
{}(static_cast<Expr &&>(expr));
#else
using namespace hana::literals;
if constexpr (
std::is_rvalue_reference<Expr>::value &&
!std::is_const<std::remove_reference_t<Expr>>::value) {
return std::move(*expr.elements[0_c]);
} else {
return *expr.elements[0_c];
}
#endif
}
namespace detail {
template<typename Tuple, long long I>
struct lvalue_ref_ith_element
: std::is_lvalue_reference<decltype(
std::declval<Tuple>()[hana::llong<I>{}])>
{
};
#ifdef BOOST_NO_CONSTEXPR_IF
template<bool ValueOfTerminalsOnly, typename T>
constexpr decltype(auto) value_impl(T && x);
template<
typename T,
bool IsExprRef,
bool ValueOfTerminalsOnly,
bool TakeValue,
bool IsLvalueRef>
struct value_expr_impl;
template<
typename T,
bool ValueOfTerminalsOnly,
bool TakeValue,
bool IsLvalueRef>
struct value_expr_impl<
T,
true,
ValueOfTerminalsOnly,
TakeValue,
IsLvalueRef>
{
constexpr decltype(auto) operator()(T && x)
{
return ::boost::yap::detail::value_impl<ValueOfTerminalsOnly>(
::boost::yap::deref(static_cast<T &&>(x)));
}
};
template<typename T, bool ValueOfTerminalsOnly>
struct value_expr_impl<T, false, ValueOfTerminalsOnly, true, true>
{
constexpr decltype(auto) operator()(T && x)
{
return x.elements[hana::llong_c<0>];
}
};
template<typename T, bool ValueOfTerminalsOnly>
struct value_expr_impl<T, false, ValueOfTerminalsOnly, true, false>
{
constexpr decltype(auto) operator()(T && x)
{
return std::move(x.elements[hana::llong_c<0>]);
}
};
template<typename T, bool ValueOfTerminalsOnly, bool IsLvalueRef>
struct value_expr_impl<
T,
false,
ValueOfTerminalsOnly,
false,
IsLvalueRef>
{
constexpr decltype(auto) operator()(T && x)
{
return static_cast<T &&>(x);
}
};
template<typename T, bool IsExpr, bool ValueOfTerminalsOnly>
struct value_impl_t
{
constexpr decltype(auto) operator()(T && x)
{
constexpr expr_kind kind = detail::remove_cv_ref_t<T>::kind;
constexpr detail::expr_arity arity = detail::arity_of<kind>();
return value_expr_impl < T, kind == expr_kind::expr_ref,
ValueOfTerminalsOnly,
(ValueOfTerminalsOnly && kind == expr_kind::terminal) ||
(!ValueOfTerminalsOnly &&
arity == detail::expr_arity::one),
std::is_lvalue_reference<T>::value ||
detail::lvalue_ref_ith_element<
decltype(x.elements),
0>::value > {}(static_cast<T &&>(x));
}
};
template<typename T, bool ValueOfTerminalsOnly>
struct value_impl_t<T, false, ValueOfTerminalsOnly>
{
constexpr decltype(auto) operator()(T && x)
{
return static_cast<T &&>(x);
}
};
template<bool ValueOfTerminalsOnly, typename T>
constexpr decltype(auto) value_impl(T && x)
{
return detail::
value_impl_t<T, is_expr<T>::value, ValueOfTerminalsOnly>{}(
static_cast<T &&>(x));
}
#else
template<bool ValueOfTerminalsOnly, typename T>
constexpr decltype(auto) value_impl(T && x)
{
if constexpr (is_expr<T>::value) {
using namespace hana::literals;
constexpr expr_kind kind = remove_cv_ref_t<T>::kind;
constexpr expr_arity arity = arity_of<kind>();
if constexpr (kind == expr_kind::expr_ref) {
return value_impl<ValueOfTerminalsOnly>(
::boost::yap::deref(static_cast<T &&>(x)));
} else if constexpr (
kind == expr_kind::terminal ||
(!ValueOfTerminalsOnly && arity == expr_arity::one)) {
if constexpr (
std::is_lvalue_reference<T>::value ||
detail::
lvalue_ref_ith_element<decltype(x.elements), 0>{}) {
return x.elements[0_c];
} else {
return std::move(x.elements[0_c]);
}
} else {
return static_cast<T &&>(x);
}
} else {
return static_cast<T &&>(x);
}
}
#endif
}
/** Forwards the sole element of \a x to the caller, possibly calling
<code>deref()</code> first if \a x is a reference expression, or
forwards \a x to the caller unchanged.
More formally:
- If \a x is not an expression, \a x is forwarded to the caller.
- Otherwise, if \a x is a reference expression, the result is
<code>value(deref(x))</code>.
- Otherwise, if \a x is an expression with only one value (a unary
expression or a terminal expression), the result is the forwarded
first element of \a x.
- Otherwise, \a x is forwarded to the caller. */
template<typename T>
constexpr decltype(auto) value(T && x)
{
return detail::value_impl<false>(static_cast<T &&>(x));
}
#ifdef BOOST_NO_CONSTEXPR_IF
template<typename Expr, typename I>
constexpr decltype(auto) get(Expr && expr, I const & i);
namespace detail {
template<long long I, typename Expr, bool IsExpr, bool IsLvalueRef>
struct get_impl;
template<long long I, typename Expr, bool IsLvalueRef>
struct get_impl<I, Expr, true, IsLvalueRef>
{
constexpr decltype(auto) operator()(Expr && expr, hana::llong<I> i)
{
return ::boost::yap::get(
::boost::yap::deref(static_cast<Expr &&>(expr)), i);
}
};
template<long long I, typename Expr>
struct get_impl<I, Expr, false, true>
{
constexpr decltype(auto) operator()(Expr && expr, hana::llong<I> i)
{
return expr.elements[i];
}
};
template<long long I, typename Expr>
struct get_impl<I, Expr, false, false>
{
constexpr decltype(auto) operator()(Expr && expr, hana::llong<I> i)
{
return std::move(expr.elements[i]);
}
};
}
#endif
/** Forwards the <i>i</i>-th element of \a expr to the caller. If \a
expr is a reference expression, the result is <code>get(deref(expr),
i)</code>.
\note <code>get()</code> is only valid if \a Expr is an expression.
*/
template<typename Expr, typename I>
constexpr decltype(auto) get(Expr && expr, I const & i)
{
static_assert(
is_expr<Expr>::value, "get() is only defined for expressions.");
static_assert(
hana::IntegralConstant<I>::value,
"'i' must be an IntegralConstant");
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref ||
(0 <= I::value &&
I::value < decltype(hana::size(expr.elements))::value),
"In get(expr, I), I must be a valid index into expr's tuple "
"elements.");
#ifdef BOOST_NO_CONSTEXPR_IF
return detail::get_impl<
I::value,
Expr,
kind == expr_kind::expr_ref,
std::is_lvalue_reference<Expr>::value>{}(static_cast<Expr &&>(expr), i);
#else
using namespace hana::literals;
if constexpr (kind == expr_kind::expr_ref) {
return ::boost::yap::get(
::boost::yap::deref(static_cast<Expr &&>(expr)), i);
} else {
if constexpr (std::is_lvalue_reference<Expr>::value) {
return expr.elements[i];
} else {
return std::move(expr.elements[i]);
}
}
#endif
}
/** Returns <code>get(expr, boost::hana::llong_c<I>)</code>. */
template<long long I, typename Expr>
constexpr decltype(auto) get_c(Expr && expr)
{
return ::boost::yap::get(static_cast<Expr &&>(expr), hana::llong_c<I>);
}
/** Returns the left operand in a binary operator expression.
Equivalent to <code>get(expr, 0_c)</code>.
\note <code>left()</code> is only valid if \a Expr is a binary
operator expression.
*/
template<typename Expr>
constexpr decltype(auto) left(Expr && expr)
{
using namespace hana::literals;
return ::boost::yap::get(static_cast<Expr &&>(expr), 0_c);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref ||
detail::arity_of<kind>() == detail::expr_arity::two,
"left() is only defined for binary expressions.");
}
/** Returns the right operand in a binary operator expression.
Equivalent to <code>get(expr, 1_c)</code>.
\note <code>right()</code> is only valid if \a Expr is a binary
operator expression.
*/
template<typename Expr>
constexpr decltype(auto) right(Expr && expr)
{
using namespace hana::literals;
return ::boost::yap::get(static_cast<Expr &&>(expr), 1_c);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref ||
detail::arity_of<kind>() == detail::expr_arity::two,
"right() is only defined for binary expressions.");
}
/** Returns the condition expression in an if_else expression.
Equivalent to <code>get(expr, 0_c)</code>.
\note <code>cond()</code> is only valid if \a Expr is an
<code>expr_kind::if_else</code> expression.
*/
template<typename Expr>
constexpr decltype(auto) cond(Expr && expr)
{
using namespace hana::literals;
return ::boost::yap::get(static_cast<Expr &&>(expr), 0_c);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref || kind == expr_kind::if_else,
"cond() is only defined for if_else expressions.");
}
/** Returns the then-expression in an if_else expression.
Equivalent to <code>get(expr, 1_c)</code>.
\note <code>then()</code> is only valid if \a Expr is an
<code>expr_kind::if_else</code> expression.
*/
template<typename Expr>
constexpr decltype(auto) then(Expr && expr)
{
using namespace hana::literals;
return ::boost::yap::get(static_cast<Expr &&>(expr), 1_c);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref || kind == expr_kind::if_else,
"then() is only defined for if_else expressions.");
}
/** Returns the else-expression in an if_else expression.
Equivalent to <code>get(expr, 2_c)</code>.
\note <code>else_()</code> is only valid if \a Expr is an
<code>expr_kind::if_else</code> expression.
*/
template<typename Expr>
constexpr decltype(auto) else_(Expr && expr)
{
using namespace hana::literals;
return ::boost::yap::get(static_cast<Expr &&>(expr), 2_c);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref || kind == expr_kind::if_else,
"else_() is only defined for if_else expressions.");
}
/** Returns the callable in a call expression.
Equivalent to <code>get(expr, 0)</code>.
\note <code>callable()</code> is only valid if \a Expr is an
<code>expr_kind::call</code> expression.
*/
template<typename Expr>
constexpr decltype(auto) callable(Expr && expr)
{
return ::boost::yap::get(static_cast<Expr &&>(expr), hana::llong_c<0>);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref ||
detail::arity_of<kind>() == detail::expr_arity::n,
"callable() is only defined for call expressions.");
}
/** Returns the <i>i-th</i> argument expression in a call expression.
Equivalent to <code>get(expr, i + 1)</code>.
\note <code>argument()</code> is only valid if \a Expr is an
<code>expr_kind::call</code> expression.
*/
template<long long I, typename Expr>
constexpr decltype(auto) argument(Expr && expr, hana::llong<I> i)
{
return ::boost::yap::get(
static_cast<Expr &&>(expr), hana::llong_c<I + 1>);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
static_assert(
kind == expr_kind::expr_ref ||
detail::arity_of<kind>() == detail::expr_arity::n,
"argument() is only defined for call expressions.");
static_assert(
kind == expr_kind::expr_ref ||
(0 <= I && I < decltype(hana::size(expr.elements))::value - 1),
"I must be a valid call-expression argument index.");
}
/** Makes a new expression instantiated from the expression template \a
ExprTemplate, of kind \a Kind, with the given values as its
elements.
For each parameter P:
- If P is an expression, P is moved into the result if P is an
rvalue and captured by reference into the result otherwise.
- Otherwise, P is wrapped in a terminal expression.
\note <code>make_expression()</code> is only valid if the number of
parameters passed is appropriate for \a Kind.
*/
template<
template<expr_kind, class> class ExprTemplate,
expr_kind Kind,
typename... T>
constexpr auto make_expression(T &&... t)
{
constexpr detail::expr_arity arity = detail::arity_of<Kind>();
static_assert(
(arity == detail::expr_arity::one && sizeof...(T) == 1) ||
(arity == detail::expr_arity::two && sizeof...(T) == 2) ||
(arity == detail::expr_arity::three && sizeof...(T) == 3) ||
arity == detail::expr_arity::n,
"The number of parameters passed to make_expression() must "
"match the arity "
"implied by the expr_kind template parameter.");
using tuple_type =
hana::tuple<detail::operand_type_t<ExprTemplate, T>...>;
return ExprTemplate<Kind, tuple_type>{tuple_type{
detail::make_operand<detail::operand_type_t<ExprTemplate, T>>{}(
static_cast<T &&>(t))...}};
}
/** Makes a new terminal expression instantiated from the expression
template \a ExprTemplate, with the given value as its sole element.
\note <code>make_terminal()</code> is only valid if \a T is \b not
an expression.
*/
template<template<expr_kind, class> class ExprTemplate, typename T>
constexpr auto make_terminal(T && t)
{
static_assert(
!is_expr<T>::value,
"make_terminal() is only defined for non expressions.");
using result_type = detail::operand_type_t<ExprTemplate, T>;
using tuple_type = decltype(std::declval<result_type>().elements);
return result_type{tuple_type{static_cast<T &&>(t)}};
}
#ifdef BOOST_NO_CONSTEXPR_IF
namespace detail {
template<
template<expr_kind, class> class ExprTemplate,
typename T,
bool IsExpr>
struct as_expr_impl
{
constexpr decltype(auto) operator()(T && t)
{
return static_cast<T &&>(t);
}
};
template<template<expr_kind, class> class ExprTemplate, typename T>
struct as_expr_impl<ExprTemplate, T, false>
{
constexpr decltype(auto) operator()(T && t)
{
return make_terminal<ExprTemplate>(static_cast<T &&>(t));
}
};
}
#endif
/** Returns an expression formed from \a t as follows:
- If \a t is an expression, \a t is forwarded to the caller.
- Otherwise, \a t is wrapped in a terminal expression.
*/
template<template<expr_kind, class> class ExprTemplate, typename T>
constexpr decltype(auto) as_expr(T && t)
{
#ifdef BOOST_NO_CONSTEXPR_IF
return detail::as_expr_impl<ExprTemplate, T, is_expr<T>::value>{}(
static_cast<T &&>(t));
#else
if constexpr (is_expr<T>::value) {
return static_cast<T &&>(t);
} else {
return make_terminal<ExprTemplate>(static_cast<T &&>(t));
}
#endif
}
/** A callable type that evaluates its contained expression when called.
\see <code>make_expression_function()</code>
*/
template<typename Expr>
struct expression_function
{
template<typename... U>
constexpr decltype(auto) operator()(U &&... u)
{
return ::boost::yap::evaluate(expr, static_cast<U &&>(u)...);
}
Expr expr;
};
namespace detail {
template<expr_kind Kind, typename Tuple>
struct expression_function_expr
{
static const expr_kind kind = Kind;
Tuple elements;
};
}
/** Returns a callable object that \a expr has been forwarded into. This
is useful for using expressions as function objects.
Lvalue expressions are stored in the result by reference; rvalue
expressions are moved into the result.
\note <code>make_expression_function()</code> is only valid if \a
Expr is an expression.
*/
template<typename Expr>
constexpr auto make_expression_function(Expr && expr)
{
static_assert(
is_expr<Expr>::value,
"make_expression_function() is only defined for expressions.");
using stored_type =
detail::operand_type_t<detail::expression_function_expr, Expr &&>;
return expression_function<stored_type>{
detail::make_operand<stored_type>{}(static_cast<Expr &&>(expr))};
}
}}
#include <boost/yap/detail/transform.hpp>
namespace boost { namespace yap {
/** Returns a transform object that replaces placeholders within an
expression with the given values.
*/
template<typename... T>
constexpr auto replacements(T &&... t)
{
return detail::placeholder_transform_t<T...>(static_cast<T &&>(t)...);
}
/** Returns \a expr with the placeholders replaced by YAP terminals
containing the given values.
\note <code>replace_placeholders(expr, t...)</code> is only valid if
\a expr is an expression, and <code>max_p <= sizeof...(t)</code>,
where <code>max_p</code> is the maximum placeholder index in \a expr.
*/
template<typename Expr, typename... T>
constexpr decltype(auto) replace_placeholders(Expr && expr, T &&... t)
{
static_assert(
is_expr<Expr>::value,
"evaluate() is only defined for expressions.");
return transform(
static_cast<Expr &&>(expr), replacements(static_cast<T &&>(t)...));
}
/** Returns a transform object that evaluates an expression using the
built-in semantics. The transform replaces any placeholders with the
given values.
*/
template<typename... T>
constexpr auto evaluation(T &&... t)
{
return detail::evaluation_transform_t<T...>(static_cast<T &&>(t)...);
}
/** Evaluates \a expr using the built-in semantics, replacing any
placeholders with the given values.
\note <code>evaluate(expr)</code> is only valid if \a expr is an
expression.
*/
template<typename Expr, typename... T>
constexpr decltype(auto) evaluate(Expr && expr, T &&... t)
{
static_assert(
is_expr<Expr>::value,
"evaluate() is only defined for expressions.");
return transform(
static_cast<Expr &&>(expr), evaluation(static_cast<T &&>(t)...));
}
namespace detail {
template<typename... Transforms>
constexpr auto make_transform_tuple(Transforms &... transforms)
{
return hana::tuple<Transforms *...>{&transforms...};
}
template<bool Strict>
struct transform_
{
template<typename Expr, typename Transform, typename... Transforms>
constexpr decltype(auto) operator()(
Expr && expr, Transform & transform, Transforms &... transforms) const
{
auto transform_tuple =
detail::make_transform_tuple(transform, transforms...);
constexpr expr_kind kind = detail::remove_cv_ref_t<Expr>::kind;
return detail::
transform_impl<Strict, 0, kind == expr_kind::expr_ref>{}(
static_cast<Expr &&>(expr), transform_tuple);
}
};
}
/** Returns the result of transforming (all or part of) \a expr using
whatever overloads of <code>Transform::operator()</code> match \a
expr.
\note Transformations can do anything: they may have side effects;
they may mutate values; they may mutate types; and they may do any
combination of these.
*/
template<typename Expr, typename Transform, typename... Transforms>
constexpr decltype(auto)
transform(Expr && expr, Transform && transform, Transforms &&... transforms)
{
static_assert(
is_expr<Expr>::value,
"transform() is only defined for expressions.");
return detail::transform_<false>{}(
static_cast<Expr &&>(expr), transform, transforms...);
}
/** Returns the result of transforming \a expr using whichever overload of
<code>Transform::operator()</code> best matches \a expr. If no
overload of <code>Transform::operator()</code> matches, a compile-time
error results.
\note Transformations can do anything: they may have side effects;
they may mutate values; they may mutate types; and they may do any
combination of these.
*/
template<typename Expr, typename Transform, typename... Transforms>
constexpr decltype(auto) transform_strict(
Expr && expr, Transform && transform, Transforms &&... transforms)
{
static_assert(
is_expr<Expr>::value,
"transform() is only defined for expressions.");
return detail::transform_<true>{}(
static_cast<Expr &&>(expr), transform, transforms...);
}
}}
#endif