From d6df84fb8486b9effcd384dd577cf109145d5c32 Mon Sep 17 00:00:00 2001 From: Zach Laine Date: Tue, 8 Nov 2016 18:56:43 -0600 Subject: [PATCH] Use eval_expression_as() in the recursive cases of default_eval_expression(). --- detail/default_eval.hpp | 18 ++++++++++-------- expression.hpp | 23 ++++++++++++++--------- expression_fwd.hpp | 7 +++++++ sketch.cpp | 12 +++++------- 4 files changed, 36 insertions(+), 24 deletions(-) diff --git a/detail/default_eval.hpp b/detail/default_eval.hpp index 1d74aa8..497f14b 100644 --- a/detail/default_eval.hpp +++ b/detail/default_eval.hpp @@ -16,6 +16,8 @@ namespace boost::proto17 { template decltype(auto) default_eval_expr (expression const & expr, Tuple && args) { + using void_type = hana::basic_type; + using namespace hana::literals; if constexpr (Kind == expr_kind::terminal) { static_assert(sizeof...(T) == 1); @@ -28,8 +30,8 @@ namespace boost::proto17 { #define BOOST_PROTO17_UNARY_OPERATOR_CASE(op_name) \ else if constexpr (Kind == expr_kind:: op_name) { \ return \ - eval_## op_name( \ - default_eval_expr(expr.elements[0_c], static_cast(args)) \ + eval_ ## op_name( \ + eval_expression_as(expr.elements[0_c], void_type{}, static_cast(args)) \ ); \ } @@ -49,9 +51,9 @@ namespace boost::proto17 { #define BOOST_PROTO17_BINARY_OPERATOR_CASE(op_name) \ else if constexpr (Kind == expr_kind:: op_name) { \ return \ - eval_## op_name( \ - default_eval_expr(expr.elements[0_c], static_cast(args)), \ - default_eval_expr(expr.elements[1_c], static_cast(args)) \ + eval_ ## op_name( \ + eval_expression_as(expr.elements[0_c], void_type{}, static_cast(args)), \ + eval_expression_as(expr.elements[1_c], void_type{}, static_cast(args)) \ ); \ } @@ -77,8 +79,8 @@ namespace boost::proto17 { else if constexpr (Kind == expr_kind::comma) { return eval_comma( - default_eval_expr(expr.elements[0_c], static_cast(args)), - default_eval_expr(expr.elements[1_c], static_cast(args)) + eval_expression_as(expr.elements[0_c], void_type{}, static_cast(args)), + eval_expression_as(expr.elements[1_c], void_type{}, static_cast(args)) ); } @@ -101,7 +103,7 @@ namespace boost::proto17 { else if constexpr (Kind == expr_kind::call) { return hana::unpack( hana::transform(expr.elements, [&args] (auto && element) { - return default_eval_expr(element, static_cast(args)); + return eval_expression_as(element, void_type{}, static_cast(args)); }), eval_call ); diff --git a/expression.hpp b/expression.hpp index 063bfad..e57ecfb 100644 --- a/expression.hpp +++ b/expression.hpp @@ -3,7 +3,6 @@ #include "expression_fwd.hpp" #include "detail/expression.hpp" -#include "detail/default_eval.hpp" #include #include @@ -14,15 +13,19 @@ namespace boost::proto17 { namespace adl_detail { - template - constexpr decltype(auto) eval_expression_as (E const & expr, hana::basic_type, T && ...t) - { return static_cast(detail::default_eval_expr(expr, hana::make_tuple(static_cast(t)...))); } + template + constexpr decltype(auto) eval_expression_as (E const & expr, hana::basic_type, Tuple && args) + { return static_cast(detail::default_eval_expr(expr, static_cast(args))); } + + template + constexpr decltype(auto) eval_expression_as (E const & expr, hana::basic_type, Tuple && args) + { return detail::default_eval_expr(expr, static_cast(args)); } struct eval_expression_as_fn { - template - constexpr decltype(auto) operator() (E const & expr, hana::basic_type rtype, T && ...t) const - { return eval_expression_as(expr, rtype, static_cast(t)...); } + template + constexpr decltype(auto) operator() (E const & expr, hana::basic_type rtype, Tuple && args) const + { return eval_expression_as(expr, rtype, static_cast(args)); } }; } @@ -43,7 +46,7 @@ namespace boost::proto17 { // TODO: static assert/SFINAE sizeof...(T) >= highest-indexed placeholder + 1 template decltype(auto) evaluate_as (Expr const & expr, T && ...t) - { return eval_expression_as(expr, hana::basic_type{}, static_cast(t)...); } + { return eval_expression_as(expr, hana::basic_type{}, hana::make_tuple(static_cast(t)...)); } template struct expression @@ -75,7 +78,7 @@ namespace boost::proto17 { template operator R () - { return eval_expression_as(*this, hana::basic_type{}); } + { return eval_expression_as(*this, hana::basic_type{}, hana::tuple<>{}); } decltype(auto) value () const { @@ -232,4 +235,6 @@ namespace boost::proto17 { } +#include "detail/default_eval.hpp" + #endif diff --git a/expression_fwd.hpp b/expression_fwd.hpp index 24d72e9..0b89cc3 100644 --- a/expression_fwd.hpp +++ b/expression_fwd.hpp @@ -80,6 +80,13 @@ namespace boost::proto17 { } + namespace detail { + + template + decltype(auto) default_eval_expr (expression const & expr, Tuple && args); + + } + } #endif diff --git a/sketch.cpp b/sketch.cpp index 3efa98c..c070ea7 100644 --- a/sketch.cpp +++ b/sketch.cpp @@ -923,18 +923,15 @@ namespace user { inline auto eval_plus (A a, B b) { return number{a.value - b.value}; } - template + template constexpr auto eval_expression_as ( E const & expr, boost::hana::basic_type, - T && ...t) + Tuple && args) { std::cout << "User eval! "; return static_cast( - bp17::detail::default_eval_expr( - expr, - boost::hana::make_tuple(static_cast(t)...) - ) + bp17::detail::default_eval_expr(expr, static_cast(args)) ); } @@ -1099,7 +1096,8 @@ namespace user_2 { #else auto eval_expression_as ( decltype(term{{0.0}} * number{} + number{}) const & expr, - boost::hana::basic_type) + boost::hana::basic_type, + boost::hana::tuple<>) { std::cout << "User naxpy! "; return naxpy(