diff --git a/detail/default_eval.hpp b/detail/default_eval.hpp
index 1ef90bf..55b08ba 100644
--- a/detail/default_eval.hpp
+++ b/detail/default_eval.hpp
@@ -198,7 +198,7 @@ namespace boost::proto17 {
                     );
                 }
             );
-            using return_type = typename expression_from_tuple<Kind, decltype(transformed_tuple)>::type;
+            using return_type = expression<Kind, decltype(transformed_tuple)>;
             return return_type(std::move(transformed_tuple));
         }
 
diff --git a/detail/expression.hpp b/detail/expression.hpp
index 45b5eec..07a0cef 100644
--- a/detail/expression.hpp
+++ b/detail/expression.hpp
@@ -14,9 +14,7 @@ namespace boost::proto17 {
 
         template <typename T>
         struct partial_decay
-        {
-            using type = T;
-        };
+        { using type = T; };
 
         template <typename T>
         struct partial_decay<T[]> { using type = T *; };
@@ -33,9 +31,11 @@ namespace boost::proto17 {
         template <typename R, typename ...A>
         struct partial_decay<R(A..., ...)> { using type = R(*)(A..., ...); };
 
-        template <typename T,
-                  typename U = typename detail::partial_decay<T>::type,
-                  bool AddRValueRef = std::is_same_v<T, U> && !std::is_const_v<U>>
+        template <
+            typename T,
+            typename U = typename detail::partial_decay<T>::type,
+            bool AddRValueRef = std::is_same_v<T, U> && !std::is_const_v<U>
+        >
         struct operand_value_type_phase_1;
 
         template <typename T, typename U>
@@ -73,14 +73,16 @@ namespace boost::proto17 {
         >
         {
             static bool const value =
-                std::is_same<remove_cv_ref_t<decltype(Expr::kind)>, expr_kind>{} &&
+                std::is_same<std::remove_cv_t<decltype(Expr::kind)>, expr_kind>{} &&
                 is_hana_tuple<remove_cv_ref_t<decltype(std::declval<Expr>().elements)>>::value;
         };
 
-        template <typename T,
-                  typename U = typename operand_value_type_phase_1<T>::type,
-                  bool RemoveRefs = std::is_rvalue_reference_v<U>,
-                  bool IsExpr = is_expr<remove_cv_ref_t<T>>::value>
+        template <
+            typename T,
+            typename U = typename operand_value_type_phase_1<T>::type,
+            bool RemoveRefs = std::is_rvalue_reference_v<U>,
+            bool IsExpr = is_expr<remove_cv_ref_t<T>>::value
+        >
         struct operand_type;
 
         template <typename T, typename U, bool RemoveRefs>
@@ -98,21 +100,6 @@ namespace boost::proto17 {
         template <typename T>
         using operand_type_t = typename operand_type<T>::type;
 
-        template <expr_kind Kind, typename T>
-        struct expression_from_tuple;
-
-        template <expr_kind Kind, typename ...T>
-        struct expression_from_tuple<Kind, hana::tuple<T...>>
-        { using type = expression<Kind, T...>; };
-
-        template <typename Tuple, typename ...T>
-        constexpr auto make_call_expression (T && ...args)
-        {
-            return typename expression_from_tuple<expr_kind::call, Tuple>::type{
-                Tuple{static_cast<T &&>(args)...}
-            };
-        }
-
     }
 
 }
diff --git a/expression.hpp b/expression.hpp
index 9f01097..dfedced 100644
--- a/expression.hpp
+++ b/expression.hpp
@@ -4,7 +4,6 @@
 #include "expression_fwd.hpp"
 #include "detail/expression.hpp"
 
-#include <boost/hana/tuple.hpp>
 #include <boost/hana/size.hpp>
 #include <boost/hana/comparing.hpp>
 
@@ -42,15 +41,15 @@ namespace boost::proto17 {
     template <typename Expr, typename Transform>
     auto transform (Expr && expr, Transform && transform);
 
-    template <expr_kind Kind, typename ...T>
+    template <expr_kind Kind, typename Tuple>
     struct expression
     {
-        using this_type = expression<Kind, T...>;
-        using tuple_type = hana::tuple<T...>;
+        using this_type = expression<Kind, Tuple>;
+        using tuple_type = Tuple;
 
         static const expr_kind kind = Kind;
 
-        expression (hana::tuple<T...> && rhs) :
+        expression (tuple_type && rhs) :
             elements (std::move(rhs))
         {}
 
@@ -155,14 +154,16 @@ namespace boost::proto17 {
 #define BOOST_PROTO17_UNARY_MEMBER_OPERATOR(op, op_name)                \
         auto operator op const &                                        \
         {                                                               \
-            return expression<expr_kind::op_name, this_type>{           \
-                hana::tuple<this_type>{*this}                           \
+            using tuple_type = hana::tuple<this_type>;                  \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{*this}                                       \
             };                                                          \
         }                                                               \
         auto operator op &&                                             \
         {                                                               \
-            return expression<expr_kind::op_name, this_type>{           \
-                hana::tuple<this_type>{std::move(*this)}                \
+            using tuple_type = hana::tuple<this_type>;                  \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{std::move(*this)}                            \
             };                                                          \
         }
 
@@ -184,8 +185,9 @@ namespace boost::proto17 {
         auto operator op (U && rhs) const &                             \
         {                                                               \
             using rhs_type = detail::operand_type_t<U>;                 \
-            return expression<expr_kind::op_name, this_type, rhs_type>{ \
-                hana::tuple<this_type, rhs_type>{                       \
+            using tuple_type = hana::tuple<this_type, rhs_type>;        \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{                                             \
                     *this,                                              \
                     static_cast<U &&>(rhs)                              \
                 }                                                       \
@@ -195,8 +197,9 @@ namespace boost::proto17 {
         auto operator op (U && rhs) &&                                  \
         {                                                               \
             using rhs_type = detail::operand_type_t<U>;                 \
-            return expression<expr_kind::op_name, this_type, rhs_type>{ \
-                hana::tuple<this_type, rhs_type>{                       \
+            using tuple_type = hana::tuple<this_type, rhs_type>;        \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{                                             \
                     std::move(*this),                                   \
                     static_cast<U &&>(rhs)                              \
                 }                                                       \
@@ -226,16 +229,18 @@ namespace boost::proto17 {
         auto operator, (U && rhs) const &
         {
             using rhs_type = detail::operand_type_t<U>;
-            return expression<expr_kind::comma, this_type, rhs_type>{
-                hana::tuple<this_type, rhs_type>{*this, static_cast<U &&>(rhs)}
+            using tuple_type = hana::tuple<this_type, rhs_type>;
+            return expression<expr_kind::comma, tuple_type>{
+                tuple_type{*this, static_cast<U &&>(rhs)}
             };
         }
         template <typename U>
         auto operator, (U && rhs) &&
         {
             using rhs_type = detail::operand_type_t<U>;
-            return expression<expr_kind::comma, this_type, rhs_type>{
-                hana::tuple<this_type, rhs_type>{std::move(*this), static_cast<U &&>(rhs)}
+            using tuple_type = hana::tuple<this_type, rhs_type>;
+            return expression<expr_kind::comma, tuple_type>{
+                tuple_type{std::move(*this), static_cast<U &&>(rhs)}
             };
         }
 
@@ -259,13 +264,17 @@ namespace boost::proto17 {
         auto operator() (U && ...u) const &
         {
             using tuple_type = hana::tuple<this_type, detail::operand_type_t<U>...>;
-            return detail::make_call_expression<tuple_type>(*this, static_cast<U &&>(u)...);
+            return expression<expr_kind::call, tuple_type>{
+                tuple_type{*this, static_cast<U &&>(u)...}
+            };
         }
         template <typename ...U>
         auto operator() (U && ...u) &&
         {
             using tuple_type = hana::tuple<this_type, detail::operand_type_t<U>...>;
-            return detail::make_call_expression<tuple_type>(std::move(*this), static_cast<U &&>(u)...);
+            return expression<expr_kind::call, tuple_type>{
+                tuple_type{std::move(*this), static_cast<U &&>(u)...}
+            };
         }
     };
 
@@ -386,14 +395,16 @@ namespace boost::proto17 {
 #define BOOST_PROTO17_UNARY_MEMBER_OPERATOR(op, op_name)                \
         auto operator op const &                                        \
         {                                                               \
-            return expression<expr_kind::op_name, this_type>{           \
-                hana::tuple<this_type>{*this}                           \
+            using tuple_type = hana::tuple<this_type>;                  \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{*this}                                       \
             };                                                          \
         }                                                               \
         auto operator op &&                                             \
         {                                                               \
-            return expression<expr_kind::op_name, this_type>{           \
-                hana::tuple<this_type>{std::move(*this)}                \
+            using tuple_type = hana::tuple<this_type>;                  \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{std::move(*this)}                            \
             };                                                          \
         }
 
@@ -415,22 +426,18 @@ namespace boost::proto17 {
         auto operator op (U && rhs) const &                             \
         {                                                               \
             using rhs_type = detail::operand_type_t<U>;                 \
-            return expression<expr_kind::op_name, this_type, rhs_type>{ \
-                hana::tuple<this_type, rhs_type>{                       \
-                    *this,                                              \
-                    static_cast<U &&>(rhs)                              \
-                }                                                       \
+            using tuple_type = hana::tuple<this_type, rhs_type>;        \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{std::move(*this), static_cast<U &&>(rhs)}    \
             };                                                          \
         }                                                               \
         template <typename U>                                           \
         auto operator op (U && rhs) &&                                  \
         {                                                               \
             using rhs_type = detail::operand_type_t<U>;                 \
-            return expression<expr_kind::op_name, this_type, rhs_type>{ \
-                hana::tuple<this_type, rhs_type>{                       \
-                    std::move(*this),                                   \
-                    static_cast<U &&>(rhs)                              \
-                }                                                       \
+            using tuple_type = hana::tuple<this_type, rhs_type>;        \
+            return expression<expr_kind::op_name, tuple_type>{          \
+                tuple_type{std::move(*this), static_cast<U &&>(rhs)}    \
             };                                                          \
         }
 
@@ -457,16 +464,18 @@ namespace boost::proto17 {
         auto operator, (U && rhs) const &
         {
             using rhs_type = detail::operand_type_t<U>;
-            return expression<expr_kind::comma, this_type, rhs_type>{
-                hana::tuple<this_type, rhs_type>{*this, static_cast<U &&>(rhs)}
+            using tuple_type = hana::tuple<this_type, rhs_type>;
+            return expression<expr_kind::comma, tuple_type>{
+                tuple_type{*this, static_cast<U &&>(rhs)}
             };
         }
         template <typename U>
         auto operator, (U && rhs) &&
         {
             using rhs_type = detail::operand_type_t<U>;
-            return expression<expr_kind::comma, this_type, rhs_type>{
-                hana::tuple<this_type, rhs_type>{std::move(*this), static_cast<U &&>(rhs)}
+            using tuple_type = hana::tuple<this_type, rhs_type>;
+            return expression<expr_kind::comma, tuple_type>{
+                tuple_type{std::move(*this), static_cast<U &&>(rhs)}
             };
         }
 
@@ -490,16 +499,23 @@ namespace boost::proto17 {
         auto operator() (U && ...u) const &
         {
             using tuple_type = hana::tuple<this_type, detail::operand_type_t<U>...>;
-            return detail::make_call_expression<tuple_type>(*this, static_cast<U &&>(u)...);
+            return expression<expr_kind::call, tuple_type>{
+                tuple_type{*this, static_cast<U &&>(u)...}
+            };
         }
         template <typename ...U>
         auto operator() (U && ...u) &&
         {
             using tuple_type = hana::tuple<this_type, detail::operand_type_t<U>...>;
-            return detail::make_call_expression<tuple_type>(std::move(*this), static_cast<U &&>(u)...);
+            return expression<expr_kind::call, tuple_type>{
+                tuple_type{std::move(*this), static_cast<U &&>(u)...}
+            };
         }
     };
 
+    template <long long I>
+    using placeholder = expression<expr_kind::placeholder, hana::tuple<hana::llong<I>>>;
+
     template <typename Expr>
     decltype(auto) value (Expr const & expr)
     {
@@ -601,38 +617,42 @@ namespace boost::proto17 {
 
     namespace detail {
 
-        template <expr_kind OpKind, typename T, typename U,
-                  bool Expr = detail::is_expr<remove_cv_ref_t<T>>::value>
+        template <
+            expr_kind OpKind, typename T, typename U,
+            bool TNonExprUExpr =
+                !detail::is_expr<remove_cv_ref_t<T>>::value &&
+                detail::is_expr<U>::value
+        >
         struct binary_op_result
         {
             using lhs_type = detail::operand_type_t<T>;
             using rhs_type = U;
-            using type = expression<OpKind, lhs_type, rhs_type>;
+            using type = expression<OpKind, hana::tuple<lhs_type, rhs_type>>;
         };
 
         template <expr_kind OpKind, typename T, typename U>
-        struct binary_op_result<OpKind, T, U, true>
+        struct binary_op_result<OpKind, T, U, false>
         {};
 
     }
 
 #define BOOST_PROTO17_BINARY_NON_MEMBER_OPERATOR(op, op_name)           \
-    template <typename T, expr_kind Kind, typename ...U>                \
-    auto operator op (T && lhs, expression<Kind, U...> const & rhs)     \
-        -> typename detail::binary_op_result<expr_kind::op_name, T, expression<Kind, U...>>::type \
+    template <typename T, typename Expr>                                \
+    auto operator op (T && lhs, Expr const & rhs)                       \
+        -> typename detail::binary_op_result<expr_kind::op_name, T, Expr>::type \
     {                                                                   \
         using lhs_type = detail::operand_type_t<T>;                     \
-        using rhs_type = expression<Kind, U...>;                        \
+        using rhs_type = Expr;                                          \
         return {                                                        \
             hana::tuple<lhs_type, rhs_type>{static_cast<T &&>(lhs), rhs} \
         };                                                              \
     }                                                                   \
-    template <typename T, expr_kind Kind, typename ...U>                \
-    auto operator op (T && lhs, expression<Kind, U...> && rhs)          \
-        -> typename detail::binary_op_result<expr_kind::op_name, T, expression<Kind, U...>>::type \
+    template <typename T, typename Expr>                                \
+    auto operator op (T && lhs, detail::remove_cv_ref_t<Expr> && rhs)   \
+        -> typename detail::binary_op_result<expr_kind::op_name, T, detail::remove_cv_ref_t<Expr>>::type \
     {                                                                   \
         using lhs_type = detail::operand_type_t<T>;                     \
-        using rhs_type = expression<Kind, U...>;                        \
+        using rhs_type = detail::remove_cv_ref_t<Expr>;                 \
         return {                                                        \
             hana::tuple<lhs_type, rhs_type>{static_cast<T &&>(lhs), static_cast<rhs_type &&>(rhs)} \
         };                                                              \
@@ -662,32 +682,34 @@ namespace boost::proto17 {
     template <expr_kind Kind, typename ...T>
     auto make_expression (T &&... t)
     {
-        return expression<Kind, T...>{
-            hana::tuple<T...>{static_cast<T &&>(t)...}
+        using tuple_type = hana::tuple<detail::operand_type_t<T>...>;
+        return expression<Kind, tuple_type>{
+            tuple_type{static_cast<T &&>(t)...}
         };
     }
 
     template <typename T>
     auto make_terminal (T && t)
     {
-        return expression<expr_kind::terminal, T>{
-            hana::tuple<T>{static_cast<T &&>(t)}
-        };
+        static_assert(!detail::is_expr<T>::value);
+        using result_type = detail::operand_type_t<T>;
+        using tuple_type = typename result_type::tuple_type;
+        return result_type{tuple_type{static_cast<T &&>(t)}};
     }
 
-    template <expr_kind Kind, typename ...T>
+    template <typename Expr>
     struct expression_function
     {
         template <typename ...U>
         decltype(auto) operator() (U &&... u)
         { return evaluate(expr, static_cast<U &&>(u)...); }
 
-        expression<Kind, T...> expr;
+        Expr expr;
     };
 
-    template <expr_kind Kind, typename ...T>
-    auto make_expression_function (expression<Kind, T...> && expr)
-    { return expression_function<Kind, T...>{std::move(expr)}; }
+    template <typename Expr>
+    auto make_expression_function (Expr && expr)
+    { return expression_function<Expr>{std::move(expr)}; }
 
 }
 
diff --git a/expression_fwd.hpp b/expression_fwd.hpp
index 11452fd..ada3613 100644
--- a/expression_fwd.hpp
+++ b/expression_fwd.hpp
@@ -2,6 +2,7 @@
 #define BOOST_PROTO17_EXPRESSION_FWD_HPP_INCLUDED
 
 #include <boost/hana/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
 
 
 namespace boost::proto17 {
@@ -60,15 +61,12 @@ namespace boost::proto17 {
         call // ()
     };
 
-    template <expr_kind Kind, typename ...T>
+    template <expr_kind Kind, typename Tuple>
     struct expression;
 
     template <typename T>
     using terminal = expression<expr_kind::terminal, T>;
 
-    template <long long I>
-    using placeholder = expression<expr_kind::placeholder, hana::llong<I>>;
-
     namespace literals {
 
         template <char ...c>
@@ -76,7 +74,7 @@ namespace boost::proto17 {
         {
             using i = hana::llong<hana::ic_detail::parse<sizeof...(c)>({c...})>;
             static_assert(1 <= i::value, "Placeholders must be >= 1.");
-            return expression<expr_kind::placeholder, i>(i{});
+            return expression<expr_kind::placeholder, hana::tuple<i>>(i{});
         }
 
     }
diff --git a/perf/code_gen_samples.cpp b/perf/code_gen_samples.cpp
index 7bdbf1c..1e5e102 100644
--- a/perf/code_gen_samples.cpp
+++ b/perf/code_gen_samples.cpp
@@ -6,6 +6,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -28,12 +29,16 @@ namespace user {
     decltype(auto) transform_expression (
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                Expr1,
-                Expr2
-            >,
-            Expr3
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        Expr1,
+                        Expr2
+                    >
+                >,
+                Expr3
+            >
         > const & expr
     ) {
         return naxpy(
diff --git a/test/call_expr.cpp b/test/call_expr.cpp
index dc69265..4602a6b 100644
--- a/test/call_expr.cpp
+++ b/test/call_expr.cpp
@@ -10,6 +10,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -53,9 +54,11 @@ TEST(call_expr, test_call_expr)
     {
         bp17::expression<
             bp17::expr_kind::call,
-            bp17::placeholder<1>,
-            bp17::placeholder<2>,
-            bp17::placeholder<3>
+            bh::tuple<
+                bp17::placeholder<1>,
+                bp17::placeholder<2>,
+                bp17::placeholder<3>
+            >
         > expr = 1_p(2_p, 3_p);
 
         {
@@ -103,10 +106,12 @@ TEST(call_expr, test_call_expr)
         struct min_function_object_t
         {
             auto operator() (int a, int b) const { return a < b ? a : b; }
-        } min_function_object;
+        };
+
+        min_function_object_t min_function_object;
 
         {
-            term<min_function_object_t> min = bp17::make_terminal(min_function_object);
+            term<min_function_object_t &> min = bp17::make_terminal(min_function_object);
             auto expr = min(1_p, 2_p);
 
             {
@@ -165,9 +170,11 @@ TEST(call_expr, test_call_expr)
             term<decltype(min_lambda)> min = {{min_lambda}};
             bp17::expression<
                 bp17::expr_kind::call,
-                term<decltype(min_lambda)>,
-                term<int>,
-                term<int>
+                bh::tuple<
+                    term<decltype(min_lambda)>,
+                    term<int>,
+                    term<int>
+                >
             > expr = min(0, 1);
 
             {
@@ -192,9 +199,11 @@ TEST(call_expr, test_call_expr)
             term<user::tag_type> plus = {{user::tag_type{}}};
             bp17::expression<
                 bp17::expr_kind::call,
-                term<user::tag_type>,
-                term<int>,
-                term<int>
+                bh::tuple<
+                    term<user::tag_type>,
+                    term<int>,
+                    term<int>
+                >
             > expr = plus(0, 1);
 
             {
diff --git a/test/compile_const_term.cpp b/test/compile_const_term.cpp
index 2f6aada..2715eed 100644
--- a/test/compile_const_term.cpp
+++ b/test/compile_const_term.cpp
@@ -5,6 +5,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_const_term ()
@@ -15,16 +16,22 @@ void compile_const_term ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double const>,
-            term<int &&>
+            bh::tuple<
+                term<double const>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double const>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double const>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double const>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -36,16 +43,22 @@ void compile_const_term ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -57,16 +70,22 @@ void compile_const_term ()
         term<int const &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
+            bh::tuple<
+                term<double>,
+                term<int const &>
+            >
         > const expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int const &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int const &>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
diff --git a/test/compile_is_expr.cpp b/test/compile_is_expr.cpp
index b2deafc..6093dd9 100644
--- a/test/compile_is_expr.cpp
+++ b/test/compile_is_expr.cpp
@@ -65,8 +65,8 @@ void compile_is_expr ()
 
     static_assert(bp17::detail::is_expr<bp17::terminal<double>>::value);
     static_assert(bp17::detail::is_expr<bp17::placeholder<1>>::value);
-    static_assert(bp17::detail::is_expr<bp17::expression<bp17::expr_kind::unary_plus, bp17::terminal<double>>>::value);
-    static_assert(bp17::detail::is_expr<bp17::expression<bp17::expr_kind::plus, bp17::terminal<double>, bp17::terminal<double>>>::value);
+    static_assert(bp17::detail::is_expr<bp17::expression<bp17::expr_kind::unary_plus, boost::hana::tuple<bp17::terminal<double>>>>::value);
+    static_assert(bp17::detail::is_expr<bp17::expression<bp17::expr_kind::plus, boost::hana::tuple<bp17::terminal<double>, bp17::terminal<double>>>>::value);
 
     static_assert(bp17::detail::is_expr<alternate_expr_1>::value);
     static_assert(bp17::detail::is_expr<alternate_expr_2>::value);
diff --git a/test/compile_move_only_types.cpp b/test/compile_move_only_types.cpp
index 41aca07..b3b67a1 100644
--- a/test/compile_move_only_types.cpp
+++ b/test/compile_move_only_types.cpp
@@ -6,6 +6,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 inline auto double_to_float (term<double> expr)
@@ -17,17 +18,23 @@ void compile_move_only_types ()
     term<std::unique_ptr<int>> i{new int{7}};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        term<std::unique_ptr<int>>
+        bh::tuple<
+            term<double>,
+            term<std::unique_ptr<int>>
+        >
     > expr_1 = unity + std::move(i);
 
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<double>,
-            term<std::unique_ptr<int>>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<double>,
+                    term<std::unique_ptr<int>>
+                >
+            >
         >
     > expr_2 = unity + std::move(expr_1);
 
diff --git a/test/compile_placeholders.cpp b/test/compile_placeholders.cpp
index 5573a04..1806507 100644
--- a/test/compile_placeholders.cpp
+++ b/test/compile_placeholders.cpp
@@ -5,6 +5,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_placeholders ()
@@ -21,8 +22,10 @@ void compile_placeholders ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::placeholder<1>,
-            term<double>
+            bh::tuple<
+                bp17::placeholder<1>,
+                term<double>
+            >
         > expr = p1 + unity;
         (void)expr;
     }
@@ -31,8 +34,10 @@ void compile_placeholders ()
         bp17::placeholder<1> p1 = 1_p;
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::placeholder<1>,
-            bp17::placeholder<2>
+            bh::tuple<
+                bp17::placeholder<1>,
+                bp17::placeholder<2>
+            >
         > expr = p1 + 2_p;
         (void)expr;
     }
diff --git a/test/compile_term_plus_expr.cpp b/test/compile_term_plus_expr.cpp
index c47bbe2..707378c 100644
--- a/test/compile_term_plus_expr.cpp
+++ b/test/compile_term_plus_expr.cpp
@@ -5,6 +5,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_term_plus_expr ()
@@ -15,16 +16,22 @@ void compile_term_plus_expr ()
         term<int> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -35,16 +42,22 @@ void compile_term_plus_expr ()
         term<int const> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const>
+            bh::tuple<
+                term<double>,
+                term<int const>
+            >
         > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int const>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int const>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -55,16 +68,22 @@ void compile_term_plus_expr ()
         term<int> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -76,16 +95,22 @@ void compile_term_plus_expr ()
         term<int> const i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > const expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -96,16 +121,22 @@ void compile_term_plus_expr ()
         term<int> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > const expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -118,16 +149,22 @@ void compile_term_plus_expr ()
         term<int &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -139,37 +176,22 @@ void compile_term_plus_expr ()
         term<int const &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
-        > expr = unity + i;
-        bp17::expression<
-            bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
                 term<int const &>
             >
-        > unevaluated_expr = unity + expr;
-        (void)unevaluated_expr;
-    }
-
-    {
-        term<double> unity{1.0};
-        int i_ = 1;
-        term<int &> i{i_};
+        > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
-        > expr = unity + std::move(i);
-        bp17::expression<
-            bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int const &>
+                    >
+                >
             >
         > unevaluated_expr = unity + expr;
         (void)unevaluated_expr;
@@ -181,16 +203,49 @@ void compile_term_plus_expr ()
         term<int &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
+        > expr = unity + std::move(i);
+        bp17::expression<
+            bp17::expr_kind::plus,
+            bh::tuple<
+                term<double>,
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &>
+                    >
+                >
+            >
+        > unevaluated_expr = unity + expr;
+        (void)unevaluated_expr;
+    }
+
+    {
+        term<double> unity{1.0};
+        int i_ = 1;
+        term<int &> i{i_};
+        bp17::expression<
+            bp17::expr_kind::plus,
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -202,16 +257,22 @@ void compile_term_plus_expr ()
         term<int const &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
+            bh::tuple<
+                term<double>,
+                term<int const &>
+            >
         > expr = unity + i;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int const &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int const &>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -223,16 +284,22 @@ void compile_term_plus_expr ()
         term<int &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -245,16 +312,22 @@ void compile_term_plus_expr ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -266,16 +339,22 @@ void compile_term_plus_expr ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -287,16 +366,22 @@ void compile_term_plus_expr ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
@@ -308,16 +393,22 @@ void compile_term_plus_expr ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > expr = unity + std::move(i);
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
                 term<double>,
-                term<int &&>
+                bp17::expression<
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        term<double>,
+                        term<int &&>
+                    >
+                >
             >
         > unevaluated_expr = unity + std::move(expr);
         (void)unevaluated_expr;
diff --git a/test/compile_term_plus_term.cpp b/test/compile_term_plus_term.cpp
index b4c3b5b..203f5d0 100644
--- a/test/compile_term_plus_term.cpp
+++ b/test/compile_term_plus_term.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_term_plus_term ()
@@ -19,8 +20,10 @@ void compile_term_plus_term ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<char const *>
+            bh::tuple<
+                term<double>,
+                term<char const *>
+            >
         > unevaluated_expr = unity + term<char const *>{"3"};
         (void)unevaluated_expr;
     }
@@ -30,8 +33,10 @@ void compile_term_plus_term ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<std::string>
+            bh::tuple<
+                term<double>,
+                term<std::string>
+            >
         > unevaluated_expr = unity + term<std::string>{"3"s};
         (void)unevaluated_expr;
     }
@@ -43,8 +48,10 @@ void compile_term_plus_term ()
         term<int *> ints = {ints_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -55,8 +62,10 @@ void compile_term_plus_term ()
         term<int const *> ints = {ints_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const *>
+            bh::tuple<
+                term<double>,
+                term<int const *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -67,8 +76,10 @@ void compile_term_plus_term ()
         term<int *> ints = {ints_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + std::move(ints);
         (void)unevaluated_expr;
     }
@@ -80,8 +91,10 @@ void compile_term_plus_term ()
         term<int * const> int_ptr = {ints};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const>
+            bh::tuple<
+                term<double>,
+                term<int * const>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -92,8 +105,10 @@ void compile_term_plus_term ()
         term<int const * const> int_ptr = {ints};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const * const>
+            bh::tuple<
+                term<double>,
+                term<int const * const>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -104,8 +119,10 @@ void compile_term_plus_term ()
         term<int * const> int_ptr = {ints};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const>
+            bh::tuple<
+                term<double>,
+                term<int * const>
+            >
         > unevaluated_expr = unity + std::move(int_ptr);
         (void)unevaluated_expr;
     }
@@ -116,8 +133,10 @@ void compile_term_plus_term ()
         term<int> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -127,8 +146,10 @@ void compile_term_plus_term ()
         term<int const> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const>
+            bh::tuple<
+                term<double>,
+                term<int const>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -138,8 +159,10 @@ void compile_term_plus_term ()
         term<int> i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
@@ -150,8 +173,10 @@ void compile_term_plus_term ()
         term<int> const i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -161,8 +186,10 @@ void compile_term_plus_term ()
         term<int const> const i = {1};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const>
+            bh::tuple<
+                term<double>,
+                term<int const>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -174,8 +201,10 @@ void compile_term_plus_term ()
         term<int &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -186,8 +215,10 @@ void compile_term_plus_term ()
         term<int const &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
+            bh::tuple<
+                term<double>,
+                term<int const &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -198,8 +229,10 @@ void compile_term_plus_term ()
         term<int &> i{i_};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
@@ -211,8 +244,10 @@ void compile_term_plus_term ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
@@ -223,8 +258,10 @@ void compile_term_plus_term ()
         term<int &&> i{std::move(i_)};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &&>
+            bh::tuple<
+                term<double>,
+                term<int &&>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
diff --git a/test/compile_term_plus_x.cpp b/test/compile_term_plus_x.cpp
index 0c981a2..8f48d9a 100644
--- a/test/compile_term_plus_x.cpp
+++ b/test/compile_term_plus_x.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_term_plus_x ()
@@ -19,8 +20,10 @@ void compile_term_plus_x ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<char const *>
+            bh::tuple<
+                term<double>,
+                term<char const *>
+            >
         > unevaluated_expr = unity + "3";
         (void)unevaluated_expr;
     }
@@ -30,8 +33,10 @@ void compile_term_plus_x ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<std::string>
+            bh::tuple<
+                term<double>,
+                term<std::string>
+            >
         > unevaluated_expr = unity + "3"s;
         (void)unevaluated_expr;
     }
@@ -42,8 +47,10 @@ void compile_term_plus_x ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -53,8 +60,10 @@ void compile_term_plus_x ()
         int const ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const *>
+            bh::tuple<
+                term<double>,
+                term<int const *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -64,8 +73,10 @@ void compile_term_plus_x ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + std::move(ints);
         (void)unevaluated_expr;
     }
@@ -77,8 +88,10 @@ void compile_term_plus_x ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * &>
+            bh::tuple<
+                term<double>,
+                term<int * &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -89,8 +102,10 @@ void compile_term_plus_x ()
         int const * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const * &>
+            bh::tuple<
+                term<double>,
+                term<int const * &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -101,8 +116,10 @@ void compile_term_plus_x ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + std::move(int_ptr);
         (void)unevaluated_expr;
     }
@@ -114,8 +131,10 @@ void compile_term_plus_x ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const &>
+            bh::tuple<
+                term<double>,
+                term<int * const &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -126,8 +145,10 @@ void compile_term_plus_x ()
         int const * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const * const &>
+            bh::tuple<
+                term<double>,
+                term<int const * const &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -138,8 +159,10 @@ void compile_term_plus_x ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const>
+            bh::tuple<
+                term<double>,
+                term<int * const>
+            >
         > unevaluated_expr = unity + std::move(int_ptr);
         (void)unevaluated_expr;
     }
@@ -150,8 +173,10 @@ void compile_term_plus_x ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -161,8 +186,10 @@ void compile_term_plus_x ()
         int const i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
+            bh::tuple<
+                term<double>,
+                term<int const &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -172,8 +199,10 @@ void compile_term_plus_x ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
diff --git a/test/compile_term_plus_x_this_ref_overloads.cpp b/test/compile_term_plus_x_this_ref_overloads.cpp
index 9440c90..e994741 100644
--- a/test/compile_term_plus_x_this_ref_overloads.cpp
+++ b/test/compile_term_plus_x_this_ref_overloads.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_term_plus_x_this_ref_overloads ()
@@ -19,8 +20,10 @@ void compile_term_plus_x_this_ref_overloads ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<char const *>
+            bh::tuple<
+                term<double>,
+                term<char const *>
+            >
         > unevaluated_expr = unity + "3";
         (void)unevaluated_expr;
     }
@@ -30,8 +33,10 @@ void compile_term_plus_x_this_ref_overloads ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<std::string>
+            bh::tuple<
+                term<double>,
+                term<std::string>
+            >
         > unevaluated_expr = unity + "3"s;
         (void)unevaluated_expr;
     }
@@ -42,8 +47,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -53,8 +60,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int const ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const *>
+            bh::tuple<
+                term<double>,
+                term<int const *>
+            >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
     }
@@ -64,8 +73,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + std::move(ints);
         (void)unevaluated_expr;
     }
@@ -77,8 +88,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * &>
+            bh::tuple<
+                term<double>,
+                term<int * &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -89,8 +102,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int const * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const * &>
+            bh::tuple<
+                term<double>,
+                term<int const * &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -101,8 +116,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int *>
+            bh::tuple<
+                term<double>,
+                term<int *>
+            >
         > unevaluated_expr = unity + std::move(int_ptr);
         (void)unevaluated_expr;
     }
@@ -114,8 +131,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const &>
+            bh::tuple<
+                term<double>,
+                term<int * const &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -126,8 +145,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int const * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const * const &>
+            bh::tuple<
+                term<double>,
+                term<int const * const &>
+            >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
     }
@@ -138,8 +159,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int * const>
+            bh::tuple<
+                term<double>,
+                term<int * const>
+            >
         > unevaluated_expr = unity + std::move(int_ptr);
         (void)unevaluated_expr;
     }
@@ -150,8 +173,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int &>
+            bh::tuple<
+                term<double>,
+                term<int &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -161,8 +186,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int const i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int const &>
+            bh::tuple<
+                term<double>,
+                term<int const &>
+            >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
     }
@@ -172,8 +199,10 @@ void compile_term_plus_x_this_ref_overloads ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<double>,
-            term<int>
+            bh::tuple<
+                term<double>,
+                term<int>
+            >
         > unevaluated_expr = unity + std::move(i);
         (void)unevaluated_expr;
     }
diff --git a/test/compile_x_plus_term.cpp b/test/compile_x_plus_term.cpp
index a371339..73315eb 100644
--- a/test/compile_x_plus_term.cpp
+++ b/test/compile_x_plus_term.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 void compile_x_plus_term ()
@@ -19,8 +20,10 @@ void compile_x_plus_term ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<char const *>,
-            term<double>
+            bh::tuple<
+                term<char const *>,
+                term<double>
+            >
         > unevaluated_expr = "3" + unity;
         (void)unevaluated_expr;
     }
@@ -30,8 +33,10 @@ void compile_x_plus_term ()
         term<double> unity{1.0};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<std::string>,
-            term<double>
+            bh::tuple<
+                term<std::string>,
+                term<double>
+            >
         > unevaluated_expr = "3"s + unity;
         (void)unevaluated_expr;
     }
@@ -42,8 +47,10 @@ void compile_x_plus_term ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int *>,
-            term<double>
+            bh::tuple<
+                term<int *>,
+                term<double>
+            >
         > unevaluated_expr = ints + unity;
         (void)unevaluated_expr;
     }
@@ -53,8 +60,10 @@ void compile_x_plus_term ()
         int const ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int const *>,
-            term<double>
+            bh::tuple<
+                term<int const *>,
+                term<double>
+            >
         > unevaluated_expr = ints + unity;
         (void)unevaluated_expr;
     }
@@ -64,8 +73,10 @@ void compile_x_plus_term ()
         int ints[] = {1, 2};
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int *>,
-            term<double>
+            bh::tuple<
+                term<int *>,
+                term<double>
+            >
         > unevaluated_expr = std::move(ints) + unity;
         (void)unevaluated_expr;
     }
@@ -77,8 +88,10 @@ void compile_x_plus_term ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int * &>,
-            term<double>
+            bh::tuple<
+                term<int * &>,
+                term<double>
+            >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
     }
@@ -89,8 +102,10 @@ void compile_x_plus_term ()
         int const * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int const * &>,
-            term<double>
+            bh::tuple<
+                term<int const * &>,
+                term<double>
+            >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
     }
@@ -101,8 +116,10 @@ void compile_x_plus_term ()
         int * int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int *>,
-            term<double>
+            bh::tuple<
+                term<int *>,
+                term<double>
+            >
         > unevaluated_expr = std::move(int_ptr) + unity;
         (void)unevaluated_expr;
     }
@@ -114,8 +131,10 @@ void compile_x_plus_term ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int * const &>,
-            term<double>
+            bh::tuple<
+                term<int * const &>,
+                term<double>
+            >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
     }
@@ -126,8 +145,10 @@ void compile_x_plus_term ()
         int const * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int const * const &>,
-            term<double>
+            bh::tuple<
+                term<int const * const &>,
+                term<double>
+            >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
     }
@@ -138,8 +159,10 @@ void compile_x_plus_term ()
         int * const int_ptr = ints;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int * const>,
-            term<double>
+            bh::tuple<
+                term<int * const>,
+                term<double>
+            >
         > unevaluated_expr = std::move(int_ptr) + unity;
         (void)unevaluated_expr;
     }
@@ -150,8 +173,10 @@ void compile_x_plus_term ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int &>,
-            term<double>
+            bh::tuple<
+                term<int &>,
+                term<double>
+            >
         > unevaluated_expr = i + unity;
         (void)unevaluated_expr;
     }
@@ -161,8 +186,10 @@ void compile_x_plus_term ()
         int const i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int const &>,
-            term<double>
+            bh::tuple<
+                term<int const &>,
+                term<double>
+            >
         > unevaluated_expr = i + unity;
         (void)unevaluated_expr;
     }
@@ -172,8 +199,10 @@ void compile_x_plus_term ()
         int i = 1;
         bp17::expression<
             bp17::expr_kind::plus,
-            term<int>,
-            term<double>
+            bh::tuple<
+                term<int>,
+                term<double>
+            >
         > unevaluated_expr = std::move(i) + unity;
         (void)unevaluated_expr;
     }
diff --git a/test/default_eval.cpp b/test/default_eval.cpp
index 6ee0b20..86e3e89 100644
--- a/test/default_eval.cpp
+++ b/test/default_eval.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 TEST(default_eval, default_eval)
@@ -17,16 +18,22 @@ TEST(default_eval, default_eval)
     term<int &&> i{std::move(i_)};
     bp17::expression<
         bp17::expr_kind::minus,
-        term<double>,
-        term<int &&>
+        bh::tuple<
+            term<double>,
+            term<int &&>
+        >
     > expr = unity - std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        bp17::expression<
-            bp17::expr_kind::minus,
+        bh::tuple<
             term<double>,
-            term<int &&>
+            bp17::expression<
+                bp17::expr_kind::minus,
+                bh::tuple<
+                    term<double>,
+                    term<int &&>
+                >
+            >
         >
     > unevaluated_expr = unity + std::move(expr);
 
diff --git a/test/placeholder_eval.cpp b/test/placeholder_eval.cpp
index 9793042..fef0554 100644
--- a/test/placeholder_eval.cpp
+++ b/test/placeholder_eval.cpp
@@ -9,6 +9,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 TEST(placeholder_eval, test_placeholder_eval)
@@ -20,16 +21,22 @@ TEST(placeholder_eval, test_placeholder_eval)
     term<int> i{std::move(i_)};
     bp17::expression<
         bp17::expr_kind::plus,
-        bp17::placeholder<3>,
-        term<int>
+        bh::tuple<
+            bp17::placeholder<3>,
+            term<int>
+        >
     > expr = p3 + std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        bp17::placeholder<3>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             bp17::placeholder<3>,
-            term<int>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    bp17::placeholder<3>,
+                    term<int>
+                >
+            >
         >
     > unevaluated_expr = p3 + std::move(expr);
 
diff --git a/test/print.cpp b/test/print.cpp
index f076ec5..99f5d06 100644
--- a/test/print.cpp
+++ b/test/print.cpp
@@ -10,6 +10,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 TEST(print, test_print)
@@ -19,16 +20,22 @@ TEST(print, test_print)
     term<int &&> i{std::move(i_)};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        term<int &&>
+        bh::tuple<
+            term<double>,
+            term<int &&>
+        >
     > expr = unity + std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<double>,
-            term<int &&>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<double>,
+                    term<int &&>
+                >
+            >
         >
     > unevaluated_expr = unity + std::move(expr);
 
diff --git a/test/user_eval_expression_as.cpp b/test/user_eval_expression_as.cpp
index 2c1cd6f..c842fa9 100644
--- a/test/user_eval_expression_as.cpp
+++ b/test/user_eval_expression_as.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -42,16 +43,22 @@ TEST(user_eval_expression_as, test_user_eval_expression_as)
     term<user::number> i{{d_}};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        term<user::number>
+        bh::tuple<
+            term<user::number>,
+            term<user::number>
+        >
     > expr = unity + std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<user::number>,
-            term<user::number>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<user::number>,
+                    term<user::number>
+                >
+            >
         >
     > unevaluated_expr = unity + std::move(expr);
 
diff --git a/test/user_expression_transform.cpp b/test/user_expression_transform.cpp
index f33ac09..e730fae 100644
--- a/test/user_expression_transform.cpp
+++ b/test/user_expression_transform.cpp
@@ -10,6 +10,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -32,12 +33,16 @@ namespace user {
     auto eval_expression_as (
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                term<number>,
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        term<number>,
+                        term<number>
+                    >,
+                >,
                 term<number>
-            >,
-            term<number>
+            >
         > const & expr,
         boost::hana::basic_type<number>)
     {
@@ -84,16 +89,22 @@ TEST(user_expression_transform, test_user_expression_transform)
     {
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
+            bh::tuple<
                 bp17::expression<
                     bp17::expr_kind::multiplies,
-                    term<user::number>,
-                    term<user::number>
+                    bh::tuple<
+                        bp17::expression<
+                            bp17::expr_kind::multiplies,
+                            bh::tuple<
+                                term<user::number>,
+                                term<user::number>
+                            >
+                        >,
+                        term<user::number>
+                    >
                 >,
                 term<user::number>
-            >,
-            term<user::number>
+            >
         > expr = k * a * x + y;
 
         user::number result = expr;
@@ -103,12 +114,16 @@ TEST(user_expression_transform, test_user_expression_transform)
     {
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                term<user::number>,
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        term<user::number>,
+                        term<user::number>
+                    >
+                >,
                 term<user::number>
-            >,
-            term<user::number>
+            >
         > expr = a * x + y;
 
         user::number result = expr;
@@ -118,15 +133,21 @@ TEST(user_expression_transform, test_user_expression_transform)
     {
         bp17::expression<
             bp17::expr_kind::multiplies,
-            term<user::number>,
-            bp17::expression<
-                bp17::expr_kind::plus,
+            bh::tuple<
+                term<user::number>,
                 bp17::expression<
-                    bp17::expr_kind::multiplies,
-                    term<user::number>,
-                    term<user::number>
-                >,
-                term<user::number>
+                    bp17::expr_kind::plus,
+                    bh::tuple<
+                        bp17::expression<
+                            bp17::expr_kind::multiplies,
+                            bh::tuple<
+                                term<user::number>,
+                                term<user::number>
+                            >
+                        >,
+                        term<user::number>
+                    >
+                >
             >
         > expr = k * (a * x + y);
 
diff --git a/test/user_expression_transform_2.cpp b/test/user_expression_transform_2.cpp
index f0d8102..9c206d4 100644
--- a/test/user_expression_transform_2.cpp
+++ b/test/user_expression_transform_2.cpp
@@ -10,6 +10,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -32,12 +33,16 @@ namespace user {
     decltype(auto) transform_expression (
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                Expr1,
-                Expr2
-            >,
-            Expr3
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        Expr1,
+                        Expr2
+                    >
+                >,
+                Expr3
+            >
         > const & expr
     ) {
         return naxpy(
diff --git a/test/user_expression_transform_3.cpp b/test/user_expression_transform_3.cpp
index 924d64f..8161242 100644
--- a/test/user_expression_transform_3.cpp
+++ b/test/user_expression_transform_3.cpp
@@ -7,6 +7,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -37,19 +38,23 @@ namespace user {
     struct plus_to_minus_xform
     {
         template <typename Expr1, typename Expr2>
-        decltype(auto) operator() (bp17::expression<bp17::expr_kind::plus, Expr1, Expr2> const & expr)
+        decltype(auto) operator() (bp17::expression<bp17::expr_kind::plus, bh::tuple<Expr1, Expr2>> const & expr)
         { return bp17::make_expression<bp17::expr_kind::minus>(expr.left(), expr.right()); }
     };
 
     decltype(auto) naxpy_eager_nontemplate_xform (
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                term<user::number>,
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        term<user::number>,
+                        term<user::number>
+                    >
+                >,
                 term<user::number>
-            >,
-            term<user::number>
+            >
         > const & expr
     ) {
         auto a = evaluate(expr.left().left());
@@ -61,12 +66,16 @@ namespace user {
     decltype(auto) naxpy_lazy_nontemplate_xform (
         bp17::expression<
             bp17::expr_kind::plus,
-            bp17::expression<
-                bp17::expr_kind::multiplies,
-                term<user::number>,
+            bh::tuple<
+                bp17::expression<
+                    bp17::expr_kind::multiplies,
+                    bh::tuple<
+                        term<user::number>,
+                        term<user::number>
+                    >
+                >,
                 term<user::number>
-            >,
-            term<user::number>
+            >
         > const & expr
     ) {
         auto a = expr.left().left();
@@ -81,12 +90,16 @@ namespace user {
         decltype(auto) operator() (
             bp17::expression<
                 bp17::expr_kind::plus,
-                bp17::expression<
-                    bp17::expr_kind::multiplies,
-                    Expr1,
-                    Expr2
-                >,
-                Expr3
+                bh::tuple<
+                    bp17::expression<
+                        bp17::expr_kind::multiplies,
+                        bh::tuple<
+                            Expr1,
+                            Expr2
+                        >
+                    >,
+                    Expr3
+                >
             > const & expr
         ) {
             auto a = transform(expr.left().left(), naxpy_xform{});
@@ -218,17 +231,23 @@ TEST(move_only, test_user_expression_transform_3)
     term<std::unique_ptr<int>> i{new int{7}};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        term<std::unique_ptr<int>>
+        bh::tuple<
+            term<double>,
+            term<std::unique_ptr<int>>
+        >
     > expr_1 = unity + std::move(i);
 
     bp17::expression<
         bp17::expr_kind::plus,
-        term<double>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<double>,
-            term<std::unique_ptr<int>>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<double>,
+                    term<std::unique_ptr<int>>
+                >
+            >
         >
     > expr_2 = unity + std::move(expr_1);
 
diff --git a/test/user_operator_and_eval_expression_as.cpp b/test/user_operator_and_eval_expression_as.cpp
index 298e605..62eab21 100644
--- a/test/user_operator_and_eval_expression_as.cpp
+++ b/test/user_operator_and_eval_expression_as.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -44,16 +45,22 @@ TEST(user_eval_expression_as, test_user_eval_expression_as)
     term<user::number> i{{d_}};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        term<user::number>
+        bh::tuple<
+            term<user::number>,
+            term<user::number>
+        >
     > expr = unity + std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<user::number>,
-            term<user::number>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<user::number>,
+                    term<user::number>
+                >
+            >
         >
     > unevaluated_expr = unity + std::move(expr);
 
diff --git a/test/user_operator_eval.cpp b/test/user_operator_eval.cpp
index 4bc2f9a..d8a90a9 100644
--- a/test/user_operator_eval.cpp
+++ b/test/user_operator_eval.cpp
@@ -8,6 +8,7 @@ template <typename T>
 using term = boost::proto17::terminal<T>;
 
 namespace bp17 = boost::proto17;
+namespace bh = boost::hana;
 
 
 namespace user {
@@ -33,16 +34,22 @@ TEST(user_operator_eval, test_user_operator_eval)
     term<user::number> i{{d_}};
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        term<user::number>
+        bh::tuple<
+            term<user::number>,
+            term<user::number>
+        >
     > expr = unity + std::move(i);
     bp17::expression<
         bp17::expr_kind::plus,
-        term<user::number>,
-        bp17::expression<
-            bp17::expr_kind::plus,
+        bh::tuple<
             term<user::number>,
-            term<user::number>
+            bp17::expression<
+                bp17::expr_kind::plus,
+                bh::tuple<
+                    term<user::number>,
+                    term<user::number>
+                >
+            >
         >
     > unevaluated_expr = unity + std::move(expr);