boost/yap
2
0
Fork 0
mirror of https://github.com/boostorg/yap.git synced 2026-02-23 16:22:09 +00:00
Code Issues Projects Releases Wiki Activity

Implement expression::{value,left,right}() in terms of the free versions.

Browse Source
This commit is contained in:
Zach Laine
2016-11-23 19:52:59 -06:00
parent 37940c5ec1
commit ae35d5b552
2 changed files with 48 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
expression.hpp
View File

@@ -33,15 +33,6 @@ namespace boost::proto17 {
}
template <typename Expr, typename ...T>
decltype(auto) evaluate (Expr const & expr, T && ...t);
template <typename R, typename Expr, typename ...T>
decltype(auto) evaluate_as (Expr const & expr, T && ...t);
template <typename Expr, typename Transform>
auto transform (Expr && expr, Transform && transform);
template <expr_kind Kind, typename Tuple>
struct expression
{
@@ -63,106 +54,31 @@ namespace boost::proto17 {
#endif
decltype(auto) value () const &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 1UL,
"value() is only defined for unary expressions."
);
if constexpr (kind == expr_kind::expr_ref) {
return *elements[0_c];
} else {
return elements[0_c];
}
}
{ return ::boost::proto17::value(*this); }
decltype(auto) value () &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 1UL,
"value() is only defined for unary expressions."
);
if constexpr (kind == expr_kind::expr_ref) {
return *elements[0_c];
} else {
return elements[0_c];
}
}
{ return ::boost::proto17::value(*this); }
decltype(auto) value () &&
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 1UL,
"value() is only defined for unary expressions."
);
if constexpr (kind == expr_kind::expr_ref) {
return std::move(*elements[0_c]); // TODO: Move-through as here, or re-bind?
} else {
return std::move(elements[0_c]);
}
}
{ return ::boost::proto17::value(std::move(*this)); }
decltype(auto) left () const &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return elements[0_c];
}
{ return ::boost::proto17::left(*this); }
decltype(auto) left () &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return elements[0_c];
}
{ return ::boost::proto17::left(*this); }
decltype(auto) left () &&
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return static_cast<tuple_type &&>(elements)[0_c];
}
{ return ::boost::proto17::left(std::move(*this)); }
decltype(auto) right () const &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return elements[1_c];
}
{ return ::boost::proto17::right(*this); }
decltype(auto) right () &
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return elements[1_c];
}
{ return ::boost::proto17::right(*this); }
decltype(auto) right () &&
{
using namespace hana::literals;
static_assert(
decltype(hana::size(elements))::value == 2UL,
"left() and right() are only defined for binary expressions."
);
return static_cast<tuple_type &&>(elements)[1_c];
}
{ return ::boost::proto17::right(std::move(*this)); }
#define BOOST_PROTO17_UNARY_MEMBER_OPERATOR(op, op_name) \
BOOST_PROTO17_USER_UNARY_OPERATOR_MEMBER(op, op_name, this_type, expression)
@@ -251,22 +167,13 @@ namespace boost::proto17 {
#endif
decltype(auto) value () const &
{
using namespace hana::literals;
return elements[0_c];
}
{ return ::boost::proto17::value(*this); }
decltype(auto) value () &
{
using namespace hana::literals;
return elements[0_c];
}
{ return ::boost::proto17::value(*this); }
decltype(auto) value () &&
{
using namespace hana::literals;
return static_cast<tuple_type &&>(elements)[0_c];
}
{ return ::boost::proto17::value(std::move(*this)); }
#define BOOST_PROTO17_UNARY_MEMBER_OPERATOR(op, op_name) \
BOOST_PROTO17_USER_UNARY_OPERATOR_MEMBER(op, op_name, this_type, expression)

36
expression_fwd.hpp
View File

@@ -72,6 +72,42 @@ namespace boost::proto17 {
template <typename T>
using expression_ref = expression<expr_kind::expr_ref, hana::tuple<std::remove_reference_t<T> *>>;
template <typename Expr, typename ...T>
decltype(auto) evaluate (Expr const & expr, T && ...t);
template <typename R, typename Expr, typename ...T>
decltype(auto) evaluate_as (Expr const & expr, T && ...t);
template <typename Expr, typename Transform>
auto transform (Expr && expr, Transform && transform);
template <typename Expr>
decltype(auto) value (Expr const & expr);
template <typename Expr>
decltype(auto) value (Expr & expr);
template <typename Expr>
decltype(auto) value (std::remove_reference_t<Expr> && expr);
template <typename Expr>
decltype(auto) left (Expr const & expr);
template <typename Expr>
decltype(auto) left (Expr & expr);
template <typename Expr>
decltype(auto) left (std::remove_reference_t<Expr> && expr);
template <typename Expr>
decltype(auto) right (Expr const & expr);
template <typename Expr>
decltype(auto) right (Expr & expr);;
template <typename Expr>
decltype(auto) right (std::remove_reference_t<Expr> && expr);
namespace literals {
template <char ...c>