From 5d539bbb8124ded91d00b67a7c38491870a83129 Mon Sep 17 00:00:00 2001
From: Zach Laine <whatwasthataddress@gmail.com>
Date: Mon, 5 Dec 2016 18:26:52 -0600
Subject: [PATCH] Swap order of template params to terminal<> and
 expression_ref<> aliases to match the convention of the rest of the library.

---
 boost/yap/detail/expression.hpp               |   6 +-
 boost/yap/expression_fwd.hpp                  |   4 +-
 example/lazy_vector.cpp                       |   8 +-
 example/tarray.cpp                            |  12 +-
 example/vec3.cpp                              |   2 +-
 perf/code_gen_samples.cpp                     |   2 +-
 test/call_expr.cpp                            |  17 ++-
 test/call_expr_implicit.cpp                   |   9 +-
 test/compile_const_term.cpp                   |  24 +--
 test/compile_copy_only_types.cpp              |   3 +-
 test/compile_is_expr.cpp                      |  17 ++-
 test/compile_move_only_types.cpp              |  12 +-
 test/compile_placeholders.cpp                 |  12 +-
 test/compile_term_plus_expr.cpp               | 144 +++++++++---------
 test/compile_term_plus_term.cpp               |  61 ++++----
 test/compile_term_plus_x.cpp                  |  33 ++--
 ...compile_term_plus_x_this_ref_overloads.cpp |  33 ++--
 test/compile_x_plus_term.cpp                  |  33 ++--
 test/default_eval.cpp                         |  19 ++-
 test/depth_stress_test_left.cpp               |   2 +-
 test/depth_stress_test_right.cpp              |   2 +-
 test/deref.cpp                                |  25 +--
 test/lazy_vector_alloc_test.cpp               |   8 +-
 test/left.cpp                                 |  57 +++----
 test/operators_unary.cpp                      |   6 +-
 test/placeholder_eval.cpp                     |  11 +-
 test/print.cpp                                |  19 ++-
 test/reference_returns.cpp                    |   2 +-
 test/right.cpp                                |  31 ++--
 test/user_eval_expression_as.cpp              |  11 +-
 test/user_expression_transform.cpp            |   2 +-
 test/user_expression_transform_2.cpp          |   2 +-
 test/user_expression_transform_3.cpp          |  23 +--
 test/user_operator_and_eval_expression_as.cpp |  11 +-
 test/user_operator_eval.cpp                   |  11 +-
 test/value.cpp                                |  25 +--
 36 files changed, 384 insertions(+), 315 deletions(-)

diff --git a/boost/yap/detail/expression.hpp b/boost/yap/detail/expression.hpp
index 836dfb6..48159eb 100644
--- a/boost/yap/detail/expression.hpp
+++ b/boost/yap/detail/expression.hpp
@@ -97,7 +97,7 @@ namespace boost { namespace yap {
 
         template <template <expr_kind, class> class ExprTemplate, typename T>
         struct expr_ref
-        { using type = expression_ref<T, ExprTemplate>; };
+        { using type = expression_ref<ExprTemplate, T>; };
 
         template <template <expr_kind, class> class ExprTemplate, typename Tuple>
         struct expr_ref<ExprTemplate, ExprTemplate<expr_kind::expr_ref, Tuple> &>
@@ -147,11 +147,11 @@ namespace boost { namespace yap {
 
         template <template <expr_kind, class> class ExprTemplate, typename T, typename U, bool IsLRef>
         struct operand_type<ExprTemplate, T, U, true, false, IsLRef>
-        { using type = terminal<std::remove_reference_t<U>, ExprTemplate>; };
+        { using type = terminal<ExprTemplate, std::remove_reference_t<U>>; };
 
         template <template <expr_kind, class> class ExprTemplate, typename T, typename U, bool IsLRef>
         struct operand_type<ExprTemplate, T, U, false, false, IsLRef>
-        { using type = terminal<U, ExprTemplate>; };
+        { using type = terminal<ExprTemplate, U>; };
 
         template <template <expr_kind, class> class ExprTemplate, typename T>
         using operand_type_t = typename operand_type<ExprTemplate, T>::type;
diff --git a/boost/yap/expression_fwd.hpp b/boost/yap/expression_fwd.hpp
index 8039959..374f2e2 100644
--- a/boost/yap/expression_fwd.hpp
+++ b/boost/yap/expression_fwd.hpp
@@ -80,12 +80,12 @@ namespace boost { namespace yap {
 
     /** A convenience alias for a terminal expression holding a \a T,
         instantiated from expression template \a expr_template. */
-    template <typename T, template <expr_kind, class> class expr_template = expression>
+    template <template <expr_kind, class> class expr_template, typename T>
     using terminal = expr_template<expr_kind::terminal, hana::tuple<T>>;
 
     /** A convenience alias for a reference expression holding an expression
         \a T, instantiated from expression template \a expr_template. */
-    template <typename T, template <expr_kind, class> class expr_template = expression>
+    template <template <expr_kind, class> class expr_template, typename T>
     using expression_ref = expr_template<expr_kind::expr_ref, hana::tuple<std::remove_reference_t<T> *>>;
 
 #endif // BOOST_YAP_DOXYGEN
diff --git a/example/lazy_vector.cpp b/example/lazy_vector.cpp
index 4982d3a..697b29f 100644
--- a/example/lazy_vector.cpp
+++ b/example/lazy_vector.cpp
@@ -13,8 +13,8 @@ struct lazy_vector_expr;
 
 struct take_nth
 {
-    boost::yap::terminal<double, lazy_vector_expr>
-    operator() (boost::yap::terminal<std::vector<double>, lazy_vector_expr> const & expr);
+    boost::yap::terminal<lazy_vector_expr, double>
+    operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr);
 
     std::size_t n;
 };
@@ -36,8 +36,8 @@ struct lazy_vector_expr
 
 };
 
-boost::yap::terminal<double, lazy_vector_expr>
-take_nth::operator() (boost::yap::terminal<std::vector<double>, lazy_vector_expr> const & expr)
+boost::yap::terminal<lazy_vector_expr, double>
+take_nth::operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr)
 {
     double x = boost::yap::value(expr)[n];
     return boost::yap::make_terminal<lazy_vector_expr, double>(std::move(x));
diff --git a/example/tarray.cpp b/example/tarray.cpp
index b496503..366ee25 100644
--- a/example/tarray.cpp
+++ b/example/tarray.cpp
@@ -10,8 +10,8 @@ struct tarray_expr;
 
 struct take_nth
 {
-    boost::yap::terminal<int, tarray_expr>
-    operator() (boost::yap::terminal<std::array<int, 3>, tarray_expr> const & expr);
+    boost::yap::terminal<tarray_expr, int>
+    operator() (boost::yap::terminal<tarray_expr, std::array<int, 3>> const & expr);
 
     std::size_t n;
 };
@@ -48,18 +48,18 @@ BOOST_YAP_USER_FREE_BINARY_OPERATOR(multiplies, ::tarray_expr)
 BOOST_YAP_USER_FREE_BINARY_OPERATOR(divides, ::tarray_expr)
 
 
-boost::yap::terminal<int, tarray_expr>
-take_nth::operator() (boost::yap::terminal<std::array<int, 3>, tarray_expr> const & expr)
+boost::yap::terminal<tarray_expr, int>
+take_nth::operator() (boost::yap::terminal<tarray_expr, std::array<int, 3>> const & expr)
 {
     int x = boost::yap::value(expr)[n];
     return boost::yap::make_terminal<tarray_expr>(std::move(x));
 }
 
 
-std::ostream & operator<< (std::ostream & os, boost::yap::terminal<int, tarray_expr> expr)
+std::ostream & operator<< (std::ostream & os, boost::yap::terminal<tarray_expr, int> expr)
 { return os << '{' << boost::yap::value(expr) << '}'; }
 
-std::ostream & operator<< (std::ostream & os, boost::yap::terminal<std::array<int, 3>, tarray_expr> expr)
+std::ostream & operator<< (std::ostream & os, boost::yap::terminal<tarray_expr, std::array<int, 3>> expr)
 {
     std::array<int, 3> const & a = boost::yap::value(expr);
     return os << '{' << a[0] << ", " << a[1] << ", " << a[2] << '}';
diff --git a/example/vec3.cpp b/example/vec3.cpp
index 358afe2..6482c8e 100644
--- a/example/vec3.cpp
+++ b/example/vec3.cpp
@@ -6,7 +6,7 @@
 
 struct take_nth
 {
-    auto operator() (boost::yap::terminal<std::array<int, 3>> const & expr)
+    auto operator() (boost::yap::terminal<boost::yap::expression, std::array<int, 3>> const & expr)
     {
         int x = boost::yap::value(expr)[n];
         return boost::yap::make_terminal(std::move(x));
diff --git a/perf/code_gen_samples.cpp b/perf/code_gen_samples.cpp
index 5bf78cc..293066f 100644
--- a/perf/code_gen_samples.cpp
+++ b/perf/code_gen_samples.cpp
@@ -3,7 +3,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
diff --git a/test/call_expr.cpp b/test/call_expr.cpp
index 5b70039..2e08394 100644
--- a/test/call_expr.cpp
+++ b/test/call_expr.cpp
@@ -6,7 +6,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -52,7 +55,7 @@ namespace user {
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<user::tag_type> >,
+                    ref<term<user::tag_type> >,
                     term<user::number>,
                     term<int>
                 >
@@ -69,8 +72,8 @@ namespace user {
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<user::tag_type> >,
-                    yap::expression_ref<term<user::number>>,
+                    ref<term<user::tag_type> >,
+                    ref<term<user::number>>,
                     term<int>
                 >
             > const & expr
@@ -99,7 +102,7 @@ namespace user {
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<user::tag_type> >,
+                    ref<term<user::tag_type> >,
                     term<user::number>,
                     term<int>
                 >
@@ -116,8 +119,8 @@ namespace user {
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<user::tag_type> >,
-                    yap::expression_ref<term<user::number>>,
+                    ref<term<user::tag_type> >,
+                    ref<term<user::number>>,
                     term<int>
                 >
             > const & expr
diff --git a/test/call_expr_implicit.cpp b/test/call_expr_implicit.cpp
index ac7249d..376e824 100644
--- a/test/call_expr_implicit.cpp
+++ b/test/call_expr_implicit.cpp
@@ -7,7 +7,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -171,7 +174,7 @@ TEST(call_expr, test_call_expr)
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<decltype(min_lambda)>& >,
+                    ref<term<decltype(min_lambda)>& >,
                     term<int>,
                     term<int>
                 >
@@ -200,7 +203,7 @@ TEST(call_expr, test_call_expr)
             yap::expression<
                 yap::expr_kind::call,
                 bh::tuple<
-                    yap::expression_ref<term<user::tag_type>& >,
+                    ref<term<user::tag_type>& >,
                     term<int>,
                     term<int>
                 >
diff --git a/test/compile_const_term.cpp b/test/compile_const_term.cpp
index e3d2035..cc80fb1 100644
--- a/test/compile_const_term.cpp
+++ b/test/compile_const_term.cpp
@@ -1,7 +1,11 @@
 #include <boost/yap/expression.hpp>
 
+
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -16,18 +20,18 @@ void compile_const_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double const> &>,
+                ref<term<double const> &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double const> &>,
+                ref<term<double const> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double const> &>,
+                        ref<term<double const> &>,
                         term<int &&>
                     >
                 >
@@ -43,18 +47,18 @@ void compile_const_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> const &>,
+                ref<term<double> const &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> const &>,
+                ref<term<double> const &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> const &>,
+                        ref<term<double> const &>,
                         term<int &&>
                     >
                 >
@@ -70,18 +74,18 @@ void compile_const_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const &>
             >
         > const expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int const &>
                     >
                 >
diff --git a/test/compile_copy_only_types.cpp b/test/compile_copy_only_types.cpp
index 55da7ac..547ecd3 100644
--- a/test/compile_copy_only_types.cpp
+++ b/test/compile_copy_only_types.cpp
@@ -2,8 +2,9 @@
 
 #include <memory>
 
+
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 
diff --git a/test/compile_is_expr.cpp b/test/compile_is_expr.cpp
index 9a80536..c4ee45c 100644
--- a/test/compile_is_expr.cpp
+++ b/test/compile_is_expr.cpp
@@ -1,5 +1,6 @@
 #include <boost/yap/expression.hpp>
 
+
 namespace yap = boost::yap;
 
 struct alternate_expr_1
@@ -58,21 +59,21 @@ void compile_is_expr ()
     static_assert(
         yap::detail::is_hana_tuple<
             yap::detail::remove_cv_ref_t<
-                decltype(std::declval<yap::terminal<double>>().elements)
+                decltype(std::declval<yap::terminal<yap::expression, double>>().elements)
             >
         >::value
     );
 
-    static_assert(yap::detail::is_expr<yap::terminal<double>>::value);
+    static_assert(yap::detail::is_expr<yap::terminal<yap::expression, double>>::value);
 
-    static_assert(yap::detail::is_expr<yap::terminal<double> const>::value);
-    static_assert(yap::detail::is_expr<yap::terminal<double> const &>::value);
-    static_assert(yap::detail::is_expr<yap::terminal<double> &>::value);
-    static_assert(yap::detail::is_expr<yap::terminal<double> &&>::value);
+    static_assert(yap::detail::is_expr<yap::terminal<yap::expression, double> const>::value);
+    static_assert(yap::detail::is_expr<yap::terminal<yap::expression, double> const &>::value);
+    static_assert(yap::detail::is_expr<yap::terminal<yap::expression, double> &>::value);
+    static_assert(yap::detail::is_expr<yap::terminal<yap::expression, double> &&>::value);
 
     static_assert(yap::detail::is_expr<yap::placeholder<1>>::value);
-    static_assert(yap::detail::is_expr<yap::expression<yap::expr_kind::unary_plus, boost::hana::tuple<yap::terminal<double>>>>::value);
-    static_assert(yap::detail::is_expr<yap::expression<yap::expr_kind::plus, boost::hana::tuple<yap::terminal<double>, yap::terminal<double>>>>::value);
+    static_assert(yap::detail::is_expr<yap::expression<yap::expr_kind::unary_plus, boost::hana::tuple<yap::terminal<yap::expression, double>>>>::value);
+    static_assert(yap::detail::is_expr<yap::expression<yap::expr_kind::plus, boost::hana::tuple<yap::terminal<yap::expression, double>, yap::terminal<yap::expression, double>>>>::value);
 
     static_assert(yap::detail::is_expr<alternate_expr_1>::value);
     static_assert(yap::detail::is_expr<alternate_expr_2>::value);
diff --git a/test/compile_move_only_types.cpp b/test/compile_move_only_types.cpp
index 6489349..d5416a4 100644
--- a/test/compile_move_only_types.cpp
+++ b/test/compile_move_only_types.cpp
@@ -2,8 +2,12 @@
 
 #include <memory>
 
+
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -19,7 +23,7 @@ void compile_move_only_types ()
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<std::unique_ptr<int>>
         >
     > expr_1 = unity + std::move(i);
@@ -27,11 +31,11 @@ void compile_move_only_types ()
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<double> &>,
+                    ref<term<double> &>,
                     term<std::unique_ptr<int>>
                 >
             >
diff --git a/test/compile_placeholders.cpp b/test/compile_placeholders.cpp
index bfbaade..0aeb9c9 100644
--- a/test/compile_placeholders.cpp
+++ b/test/compile_placeholders.cpp
@@ -1,7 +1,11 @@
 #include <boost/yap/expression.hpp>
 
+
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -22,8 +26,8 @@ void compile_placeholders ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<yap::placeholder<1> &>,
-                yap::expression_ref<term<double> &>
+                ref<yap::placeholder<1> &>,
+                ref<term<double> &>
             >
         > expr = p1 + unity;
         (void)expr;
@@ -34,7 +38,7 @@ void compile_placeholders ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<yap::placeholder<1> &>,
+                ref<yap::placeholder<1> &>,
                 yap::placeholder<2>
             >
         > expr = p1 + 2_p;
diff --git a/test/compile_term_plus_expr.cpp b/test/compile_term_plus_expr.cpp
index d7fa264..5040796 100644
--- a/test/compile_term_plus_expr.cpp
+++ b/test/compile_term_plus_expr.cpp
@@ -1,7 +1,11 @@
 #include <boost/yap/expression.hpp>
 
+
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -16,19 +20,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int> &>
+                ref<term<double> &>,
+                ref<term<int> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int> &>
+                        ref<term<double> &>,
+                        ref<term<int> &>
                     >
                 > &>
             >
@@ -42,19 +46,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const> &>
+                ref<term<double> &>,
+                ref<term<int const> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int const> &>
+                        ref<term<double> &>,
+                        ref<term<int const> &>
                     >
                 > &>
             >
@@ -68,18 +72,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int>
                     >
                 > &>
@@ -95,19 +99,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int> const &>
+                ref<term<double> &>,
+                ref<term<int> const &>
             >
         > const expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int> const &>
+                        ref<term<double> &>,
+                        ref<term<int> const &>
                     >
                 > const &>
             >
@@ -121,19 +125,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int> &>
+                ref<term<double> &>,
+                ref<term<int> &>
             >
         > const expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int> &>
+                        ref<term<double> &>,
+                        ref<term<int> &>
                     >
                 > const &>
             >
@@ -149,19 +153,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int &> &>
+                ref<term<double> &>,
+                ref<term<int &> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int &> &>
+                        ref<term<double> &>,
+                        ref<term<int &> &>
                     >
                 > &>
             >
@@ -176,19 +180,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const &> &>
+                ref<term<double> &>,
+                ref<term<int const &> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int const &> &>
+                        ref<term<double> &>,
+                        ref<term<int const &> &>
                     >
                 > &>
             >
@@ -203,18 +207,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<yap::expression<
+                ref<term<double> &>,
+                ref<yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &>
                     >
                 > &>
@@ -230,19 +234,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int &> &>
+                ref<term<double> &>,
+                ref<term<int &> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int &> &>
+                        ref<term<double> &>,
+                        ref<term<int &> &>
                     >
                 >
             >
@@ -257,19 +261,19 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const &> &>
+                ref<term<double> &>,
+                ref<term<int const &> &>
             >
         > expr = unity + i;
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
-                        yap::expression_ref<term<int const &> &>
+                        ref<term<double> &>,
+                        ref<term<int const &> &>
                     >
                 >
             >
@@ -284,18 +288,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &>
                     >
                 >
@@ -312,18 +316,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &&>
                     >
                 >
@@ -339,18 +343,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &&>
                     >
                 >
@@ -366,18 +370,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &&>
                     >
                 >
@@ -393,18 +397,18 @@ void compile_term_plus_expr ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > expr = unity + std::move(i);
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 yap::expression<
                     yap::expr_kind::plus,
                     bh::tuple<
-                        yap::expression_ref<term<double> &>,
+                        ref<term<double> &>,
                         term<int &&>
                     >
                 >
diff --git a/test/compile_term_plus_term.cpp b/test/compile_term_plus_term.cpp
index 1fd7d2f..1aa8c66 100644
--- a/test/compile_term_plus_term.cpp
+++ b/test/compile_term_plus_term.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -20,7 +23,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<char const *>
             >
         > unevaluated_expr = unity + term<char const *>{"3"};
@@ -33,7 +36,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<std::string>
             >
         > unevaluated_expr = unity + term<std::string>{"3"s};
@@ -48,8 +51,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int *> &>
+                ref<term<double> &>,
+                ref<term<int *> &>
             >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
@@ -62,8 +65,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const *> &>
+                ref<term<double> &>,
+                ref<term<int const *> &>
             >
         > unevaluated_expr = unity + ints;
         (void)unevaluated_expr;
@@ -76,7 +79,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + std::move(ints);
@@ -91,8 +94,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int * const> &>
+                ref<term<double> &>,
+                ref<term<int * const> &>
             >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
@@ -105,8 +108,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const * const> &>
+                ref<term<double> &>,
+                ref<term<int const * const> &>
             >
         > unevaluated_expr = unity + int_ptr;
         (void)unevaluated_expr;
@@ -119,7 +122,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * const>
             >
         > unevaluated_expr = unity + std::move(int_ptr);
@@ -133,8 +136,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int> &>
+                ref<term<double> &>,
+                ref<term<int> &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -146,8 +149,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const> &>
+                ref<term<double> &>,
+                ref<term<int const> &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -159,7 +162,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         > unevaluated_expr = unity + std::move(i);
@@ -173,8 +176,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int> const &>
+                ref<term<double> &>,
+                ref<term<int> const &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -186,8 +189,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const> const &>
+                ref<term<double> &>,
+                ref<term<int const> const &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -201,8 +204,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int &> &>
+                ref<term<double> &>,
+                ref<term<int &> &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -215,8 +218,8 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
-                yap::expression_ref<term<int const &> &>
+                ref<term<double> &>,
+                ref<term<int const &> &>
             >
         > unevaluated_expr = unity + i;
         (void)unevaluated_expr;
@@ -229,7 +232,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &>
             >
         > unevaluated_expr = unity + std::move(i);
@@ -244,7 +247,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > unevaluated_expr = unity + std::move(i);
@@ -258,7 +261,7 @@ void compile_term_plus_term ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &&>
             >
         > unevaluated_expr = unity + std::move(i);
diff --git a/test/compile_term_plus_x.cpp b/test/compile_term_plus_x.cpp
index 3af5fea..b8cebe8 100644
--- a/test/compile_term_plus_x.cpp
+++ b/test/compile_term_plus_x.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -20,7 +23,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<char const *>
             >
         > unevaluated_expr = unity + "3";
@@ -33,7 +36,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<std::string>
             >
         > unevaluated_expr = unity + "3"s;
@@ -47,7 +50,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + ints;
@@ -60,7 +63,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const *>
             >
         > unevaluated_expr = unity + ints;
@@ -73,7 +76,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + std::move(ints);
@@ -88,7 +91,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -102,7 +105,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const * &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -116,7 +119,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + std::move(int_ptr);
@@ -131,7 +134,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * const &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -145,7 +148,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const * const &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -159,7 +162,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * const>
             >
         > unevaluated_expr = unity + std::move(int_ptr);
@@ -173,7 +176,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &>
             >
         > unevaluated_expr = unity + i;
@@ -186,7 +189,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const &>
             >
         > unevaluated_expr = unity + i;
@@ -199,7 +202,7 @@ void compile_term_plus_x ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         > unevaluated_expr = unity + std::move(i);
diff --git a/test/compile_term_plus_x_this_ref_overloads.cpp b/test/compile_term_plus_x_this_ref_overloads.cpp
index e651783..3d3702c 100644
--- a/test/compile_term_plus_x_this_ref_overloads.cpp
+++ b/test/compile_term_plus_x_this_ref_overloads.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -20,7 +23,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<char const *>
             >
         > unevaluated_expr = unity + "3";
@@ -33,7 +36,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<std::string>
             >
         > unevaluated_expr = unity + "3"s;
@@ -47,7 +50,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + ints;
@@ -60,7 +63,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const *>
             >
         > unevaluated_expr = unity + ints;
@@ -73,7 +76,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + std::move(ints);
@@ -88,7 +91,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -102,7 +105,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const * &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -116,7 +119,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int *>
             >
         > unevaluated_expr = unity + std::move(int_ptr);
@@ -131,7 +134,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * const &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -145,7 +148,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const * const &>
             >
         > unevaluated_expr = unity + int_ptr;
@@ -159,7 +162,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int * const>
             >
         > unevaluated_expr = unity + std::move(int_ptr);
@@ -173,7 +176,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int &>
             >
         > unevaluated_expr = unity + i;
@@ -186,7 +189,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int const &>
             >
         > unevaluated_expr = unity + i;
@@ -199,7 +202,7 @@ void compile_term_plus_x_this_ref_overloads ()
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         > unevaluated_expr = unity + std::move(i);
diff --git a/test/compile_x_plus_term.cpp b/test/compile_x_plus_term.cpp
index 345e939..a32703c 100644
--- a/test/compile_x_plus_term.cpp
+++ b/test/compile_x_plus_term.cpp
@@ -5,7 +5,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -22,7 +25,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<char const *>,
-                yap::expression_ref <term<double>&>
+                ref <term<double>&>
             >
         > unevaluated_expr = "3" + unity;
         (void)unevaluated_expr;
@@ -35,7 +38,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<std::string>,
-                yap::expression_ref<term<double> const &>
+                ref<term<double> const &>
             >
         > unevaluated_expr = "3"s + unity;
         (void)unevaluated_expr;
@@ -49,7 +52,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int *>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = ints + unity;
         (void)unevaluated_expr;
@@ -62,7 +65,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int const *>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = ints + unity;
         (void)unevaluated_expr;
@@ -75,7 +78,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int *>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = std::move(ints) + unity;
         (void)unevaluated_expr;
@@ -90,7 +93,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int * &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
@@ -104,7 +107,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int const * &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
@@ -118,7 +121,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int *>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = std::move(int_ptr) + unity;
         (void)unevaluated_expr;
@@ -133,7 +136,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int * const &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
@@ -147,7 +150,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int const * const &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = int_ptr + unity;
         (void)unevaluated_expr;
@@ -161,7 +164,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int * const>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = std::move(int_ptr) + unity;
         (void)unevaluated_expr;
@@ -175,7 +178,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = i + unity;
         (void)unevaluated_expr;
@@ -188,7 +191,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int const &>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = i + unity;
         (void)unevaluated_expr;
@@ -201,7 +204,7 @@ void compile_x_plus_term ()
             yap::expr_kind::plus,
             bh::tuple<
                 term<int>,
-                yap::expression_ref<term<double> &>
+                ref<term<double> &>
             >
         > unevaluated_expr = std::move(i) + unity;
         (void)unevaluated_expr;
diff --git a/test/default_eval.cpp b/test/default_eval.cpp
index e4178f5..d657f30 100644
--- a/test/default_eval.cpp
+++ b/test/default_eval.cpp
@@ -5,7 +5,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -19,18 +22,18 @@ TEST(default_eval, default_eval)
     yap::expression<
         yap::expr_kind::minus,
         bh::tuple<
-            boost::yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int &&>
         >
     > expr = unity - std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            boost::yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             yap::expression<
                 yap::expr_kind::minus,
                 bh::tuple<
-                    boost::yap::expression_ref<term<double> &>,
+                    ref<term<double> &>,
                     term<int &&>
                 >
             >
@@ -40,8 +43,8 @@ TEST(default_eval, default_eval)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            boost::yap::expression_ref<term<double> &>,
-            boost::yap::expression_ref<term<double> &>
+            ref<term<double> &>,
+            ref<term<double> &>
         >
     > unevaluated_expr_2 = unity + unity;
 
@@ -49,8 +52,8 @@ TEST(default_eval, default_eval)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            boost::yap::expression_ref<term<double> &>,
-            boost::yap::expression_ref<term<double> const &>
+            ref<term<double> &>,
+            ref<term<double> const &>
         >
     > unevaluated_expr_3 = unity + const_unity;
 
diff --git a/test/depth_stress_test_left.cpp b/test/depth_stress_test_left.cpp
index fb0e3d3..995743c 100644
--- a/test/depth_stress_test_left.cpp
+++ b/test/depth_stress_test_left.cpp
@@ -7,7 +7,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 
diff --git a/test/depth_stress_test_right.cpp b/test/depth_stress_test_right.cpp
index 3717311..5081cc5 100644
--- a/test/depth_stress_test_right.cpp
+++ b/test/depth_stress_test_right.cpp
@@ -7,7 +7,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 
diff --git a/test/deref.cpp b/test/deref.cpp
index 01cdd23..2c3ab10 100644
--- a/test/deref.cpp
+++ b/test/deref.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -23,10 +26,10 @@ struct user_expr
 };
 
 template <typename T>
-using user_term = boost::yap::terminal<T, user_expr>;
+using user_term = boost::yap::terminal<user_expr, T>;
 
 template <typename T>
-using user_ref = boost::yap::expression_ref<T, user_expr>;
+using user_ref = boost::yap::expression_ref<user_expr, T>;
 
 
 TEST(expression, test_deref)
@@ -35,7 +38,7 @@ TEST(expression, test_deref)
     using plus_expr_type = yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int>
         >
     >;
@@ -43,17 +46,17 @@ TEST(expression, test_deref)
     plus_expr_type plus_expr = unity + term<int>{{1}};
 
     {
-        yap::expression_ref<term<double> &> ref = bh::front(plus_expr.elements);
+        ref<term<double> &> ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::deref(std::move(ref))), term<double> &>::value));
     }
 
     {
-        yap::expression_ref<term<double> &> ref = bh::front(plus_expr.elements);
+        ref<term<double> &> ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::deref(ref)), term<double> &>::value));
     }
 
     {
-        yap::expression_ref<term<double> &> const ref = bh::front(plus_expr.elements);
+        ref<term<double> &> const ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::deref(ref)), term<double> &>::value));
     }
 
@@ -62,23 +65,23 @@ TEST(expression, test_deref)
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> const &>,
+                ref<term<double> const &>,
                 term<int>
             >
         > plus_expr = unity + term<int>{{1}};
 
         {
-            yap::expression_ref<term<double> const &> ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::deref(std::move(ref))), term<double> const &>::value));
         }
 
         {
-            yap::expression_ref<term<double> const &> ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::deref(ref)), term<double> const &>::value));
         }
 
         {
-            yap::expression_ref<term<double> const &> const ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> const ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::deref(ref)), term<double> const &>::value));
         }
     }
diff --git a/test/lazy_vector_alloc_test.cpp b/test/lazy_vector_alloc_test.cpp
index 81884e9..5af88b7 100644
--- a/test/lazy_vector_alloc_test.cpp
+++ b/test/lazy_vector_alloc_test.cpp
@@ -27,8 +27,8 @@ struct lazy_vector_expr;
 
 struct take_nth
 {
-    boost::yap::terminal<double, lazy_vector_expr>
-    operator() (boost::yap::terminal<std::vector<double>, lazy_vector_expr> const & expr);
+    boost::yap::terminal<lazy_vector_expr, double>
+    operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr);
 
     std::size_t n;
 };
@@ -50,8 +50,8 @@ struct lazy_vector_expr
 
 };
 
-boost::yap::terminal<double, lazy_vector_expr>
-take_nth::operator() (boost::yap::terminal<std::vector<double>, lazy_vector_expr> const & expr)
+boost::yap::terminal<lazy_vector_expr, double>
+take_nth::operator() (boost::yap::terminal<lazy_vector_expr, std::vector<double>> const & expr)
 {
     double x = boost::yap::value(expr)[n];
     return boost::yap::make_terminal<lazy_vector_expr, double>(std::move(x));
diff --git a/test/left.cpp b/test/left.cpp
index a9b4285..d1aea83 100644
--- a/test/left.cpp
+++ b/test/left.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -23,10 +26,10 @@ struct user_expr
 };
 
 template <typename T>
-using user_term = boost::yap::terminal<T, user_expr>;
+using user_term = boost::yap::terminal<user_expr, T>;
 
 template <typename T>
-using user_ref = boost::yap::expression_ref<T, user_expr>;
+using user_ref = boost::yap::expression_ref<user_expr, T>;
 
 
 TEST(expression, test_left)
@@ -35,7 +38,7 @@ TEST(expression, test_left)
     using plus_expr_type = yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int>
         >
     >;
@@ -44,7 +47,7 @@ TEST(expression, test_left)
         plus_expr_type plus_expr = unity + term<int>{{1}};
         EXPECT_TRUE((
             std::is_same<decltype(yap::left(std::move(plus_expr))),
-            yap::expression_ref<term<double> &> &&>::value
+            ref<term<double> &> &&>::value
         ));
     }
 
@@ -52,7 +55,7 @@ TEST(expression, test_left)
         plus_expr_type plus_expr = unity + term<int>{{1}};
         EXPECT_TRUE((
             std::is_same<decltype(yap::left(plus_expr)),
-            yap::expression_ref<term<double> &> &>::value
+            ref<term<double> &> &>::value
         ));
     }
 
@@ -60,7 +63,7 @@ TEST(expression, test_left)
         plus_expr_type const plus_expr = unity + term<int>{{1}};
         EXPECT_TRUE((
             std::is_same<decltype(yap::left(plus_expr)),
-            yap::expression_ref<term<double> &> const &>::value
+            ref<term<double> &> const &>::value
         ));
     }
 
@@ -69,7 +72,7 @@ TEST(expression, test_left)
         using plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> const &>,
+                ref<term<double> const &>,
                 term<int>
             >
         >;
@@ -78,7 +81,7 @@ TEST(expression, test_left)
             plus_expr_type plus_expr = unity + term<int>{{1}};
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(std::move(plus_expr))),
-                yap::expression_ref<term<double> const &> &&>::value
+                ref<term<double> const &> &&>::value
             ));
         }
 
@@ -86,7 +89,7 @@ TEST(expression, test_left)
             plus_expr_type plus_expr = unity + term<int>{{1}};
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr)),
-                yap::expression_ref<term<double> const &> &>::value
+                ref<term<double> const &> &>::value
             ));
         }
 
@@ -94,7 +97,7 @@ TEST(expression, test_left)
             plus_expr_type const plus_expr = unity + term<int>{{1}};
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr)),
-                yap::expression_ref<term<double> const &> const &>::value
+                ref<term<double> const &> const &>::value
             ));
         }
     }
@@ -104,7 +107,7 @@ TEST(expression, test_left)
         using plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         >;
@@ -113,36 +116,36 @@ TEST(expression, test_left)
         using plus_plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<plus_expr_type &>,
+                ref<plus_expr_type &>,
                 term<int>
             >
         >;
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(std::move(plus_expr_ref))),
-                yap::expression_ref<term<double> &> &>::value
+                ref<term<double> &> &>::value
             ));
 
         }
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr_ref)),
-                yap::expression_ref<term<double> &> &>::value
+                ref<term<double> &> &>::value
             ));
         }
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr_ref)),
-                yap::expression_ref<term<double> &> &>::value
+                ref<term<double> &> &>::value
             ));
         }
     }
@@ -152,7 +155,7 @@ TEST(expression, test_left)
         using plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         >;
@@ -161,36 +164,36 @@ TEST(expression, test_left)
         using plus_plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<plus_expr_type const &>,
+                ref<plus_expr_type const &>,
                 term<int>
             >
         >;
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(std::move(plus_expr_ref))),
-                yap::expression_ref<term<double> &> const &>::value
+                ref<term<double> &> const &>::value
             ));
 
         }
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr_ref)),
-                yap::expression_ref<term<double> &> const &>::value
+                ref<term<double> &> const &>::value
             ));
         }
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::left(plus_expr_ref)),
-                yap::expression_ref<term<double> &> const &>::value
+                ref<term<double> &> const &>::value
             ));
         }
     }
diff --git a/test/operators_unary.cpp b/test/operators_unary.cpp
index 678fd8d..92a4fed 100644
--- a/test/operators_unary.cpp
+++ b/test/operators_unary.cpp
@@ -6,13 +6,13 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 template <typename T>
-using term_ref = boost::yap::expression_ref<boost::yap::terminal<T> &>;
+using term_ref = boost::yap::expression_ref<boost::yap::expression, term<T> &>;
 
 template <typename T>
-using term_cref = boost::yap::expression_ref<boost::yap::terminal<T> const &>;
+using term_cref = boost::yap::expression_ref<boost::yap::expression, term<T> const &>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
diff --git a/test/placeholder_eval.cpp b/test/placeholder_eval.cpp
index a6a33f1..0d0b45f 100644
--- a/test/placeholder_eval.cpp
+++ b/test/placeholder_eval.cpp
@@ -6,7 +6,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -22,18 +25,18 @@ TEST(placeholder_eval, test_placeholder_eval)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<yap::placeholder<3> &>,
+            ref<yap::placeholder<3> &>,
             term<int>
         >
     > expr = p3 + std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<yap::placeholder<3> &>,
+            ref<yap::placeholder<3> &>,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<yap::placeholder<3> &>,
+                    ref<yap::placeholder<3> &>,
                     term<int>
                 >
             >
diff --git a/test/print.cpp b/test/print.cpp
index ee242b8..8a1acee 100644
--- a/test/print.cpp
+++ b/test/print.cpp
@@ -7,7 +7,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -26,10 +29,10 @@ struct user_expr
 };
 
 template <typename T>
-using user_term = boost::yap::terminal<T, user_expr>;
+using user_term = boost::yap::terminal<user_expr, T>;
 
 template <typename T>
-using user_ref = boost::yap::expression_ref<T, user_expr>;
+using user_ref = boost::yap::expression_ref<user_expr, T>;
 
 struct thing {};
 
@@ -41,18 +44,18 @@ TEST(expression, test_print)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int &&>
         >
     > expr = unity + std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<double> &>,
+                    ref<term<double> &>,
                     term<int &&>
                 >
             >
@@ -99,8 +102,8 @@ TEST(expression, test_print)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
-            yap::expression_ref<term<double> const &>
+            ref<term<double> &>,
+            ref<term<double> const &>
         >
     > nonconst_plus_const = unity + const_unity;
 
diff --git a/test/reference_returns.cpp b/test/reference_returns.cpp
index 7a21f71..fc4673e 100644
--- a/test/reference_returns.cpp
+++ b/test/reference_returns.cpp
@@ -5,7 +5,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 
diff --git a/test/right.cpp b/test/right.cpp
index 3204cbd..79e0e81 100644
--- a/test/right.cpp
+++ b/test/right.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -23,10 +26,10 @@ struct user_expr
 };
 
 template <typename T>
-using user_term = boost::yap::terminal<T, user_expr>;
+using user_term = boost::yap::terminal<user_expr, T>;
 
 template <typename T>
-using user_ref = boost::yap::expression_ref<T, user_expr>;
+using user_ref = boost::yap::expression_ref<user_expr, T>;
 
 
 TEST(expression, test_right)
@@ -35,7 +38,7 @@ TEST(expression, test_right)
     using plus_expr_type = yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int>
         >
     >;
@@ -69,7 +72,7 @@ TEST(expression, test_right)
         using plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         >;
@@ -78,14 +81,14 @@ TEST(expression, test_right)
         using plus_plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<plus_expr_type &>,
+                ref<plus_expr_type &>,
                 term<int>
             >
         >;
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(std::move(plus_expr_ref))),
                 term<int> &>::value
@@ -95,7 +98,7 @@ TEST(expression, test_right)
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(plus_expr_ref)),
                 term<int> &>::value
@@ -104,7 +107,7 @@ TEST(expression, test_right)
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(plus_expr_ref)),
                 term<int> &>::value
@@ -117,7 +120,7 @@ TEST(expression, test_right)
         using plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> &>,
+                ref<term<double> &>,
                 term<int>
             >
         >;
@@ -126,14 +129,14 @@ TEST(expression, test_right)
         using plus_plus_expr_type = yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<plus_expr_type const &>,
+                ref<plus_expr_type const &>,
                 term<int>
             >
         >;
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(std::move(plus_expr_ref))),
                 term<int> const &>::value
@@ -143,7 +146,7 @@ TEST(expression, test_right)
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(plus_expr_ref)),
                 term<int> const &>::value
@@ -152,7 +155,7 @@ TEST(expression, test_right)
 
         {
             plus_plus_expr_type plus_plus_expr = plus_expr + term<int>{{1}};
-            yap::expression_ref<plus_expr_type const &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
+            ref<plus_expr_type const &> const plus_expr_ref = bh::front(plus_plus_expr.elements);
             EXPECT_TRUE((
                 std::is_same<decltype(yap::right(plus_expr_ref)),
                 term<int> const &>::value
diff --git a/test/user_eval_expression_as.cpp b/test/user_eval_expression_as.cpp
index de2773f..759a860 100644
--- a/test/user_eval_expression_as.cpp
+++ b/test/user_eval_expression_as.cpp
@@ -5,7 +5,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -44,18 +47,18 @@ TEST(user_eval_expression_as, test_user_eval_expression_as)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             term<user::number>
         >
     > expr = unity + std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<user::number>& >,
+                    ref<term<user::number>& >,
                     term<user::number>
                 >
             >
diff --git a/test/user_expression_transform.cpp b/test/user_expression_transform.cpp
index c4e2bcf..3c9dc41 100644
--- a/test/user_expression_transform.cpp
+++ b/test/user_expression_transform.cpp
@@ -7,7 +7,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
diff --git a/test/user_expression_transform_2.cpp b/test/user_expression_transform_2.cpp
index 5d51e40..8f3583e 100644
--- a/test/user_expression_transform_2.cpp
+++ b/test/user_expression_transform_2.cpp
@@ -7,7 +7,7 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
diff --git a/test/user_expression_transform_3.cpp b/test/user_expression_transform_3.cpp
index 8ae3282..38a7404 100644
--- a/test/user_expression_transform_3.cpp
+++ b/test/user_expression_transform_3.cpp
@@ -6,7 +6,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -117,11 +120,11 @@ namespace user {
                 yap::expression<
                     yap::expr_kind::multiplies,
                     bh::tuple<
-                        yap::expression_ref<term<user::number> &>,
-                        yap::expression_ref<term<user::number> &>
+                        ref<term<user::number> &>,
+                        ref<term<user::number> &>
                     >
                 >,
-                yap::expression_ref<term<user::number> &>
+                ref<term<user::number> &>
             >
         > const & expr
     ) {
@@ -138,11 +141,11 @@ namespace user {
                 yap::expression<
                     yap::expr_kind::multiplies,
                     bh::tuple<
-                        yap::expression_ref<term<user::number> &>,
-                        yap::expression_ref<term<user::number> &>
+                        ref<term<user::number> &>,
+                        ref<term<user::number> &>
                     >
                 >,
-                yap::expression_ref<term<user::number> &>
+                ref<term<user::number> &>
             >
         > const & expr
     ) {
@@ -397,7 +400,7 @@ TEST(move_only, test_user_expression_transform_3)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<std::unique_ptr<int>>
         >
     > expr_1 = unity + std::move(i);
@@ -405,11 +408,11 @@ TEST(move_only, test_user_expression_transform_3)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<double> &>,
+                    ref<term<double> &>,
                     term<std::unique_ptr<int>>
                 >
             >
diff --git a/test/user_operator_and_eval_expression_as.cpp b/test/user_operator_and_eval_expression_as.cpp
index cfbe042..ef59cdf 100644
--- a/test/user_operator_and_eval_expression_as.cpp
+++ b/test/user_operator_and_eval_expression_as.cpp
@@ -5,7 +5,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -46,18 +49,18 @@ TEST(user_eval_expression_as, test_user_eval_expression_as)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             term<user::number>
         >
     > expr = unity + std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<user::number>& >,
+                    ref<term<user::number>& >,
                     term<user::number>
                 >
             >
diff --git a/test/user_operator_eval.cpp b/test/user_operator_eval.cpp
index 5ea9e5e..99975db 100644
--- a/test/user_operator_eval.cpp
+++ b/test/user_operator_eval.cpp
@@ -5,7 +5,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -35,18 +38,18 @@ TEST(user_operator_eval, test_user_operator_eval)
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             term<user::number>
         >
     > expr = unity + std::move(i);
     yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<user::number>& >,
+            ref<term<user::number>& >,
             yap::expression<
                 yap::expr_kind::plus,
                 bh::tuple<
-                    yap::expression_ref<term<user::number>& >,
+                    ref<term<user::number>& >,
                     term<user::number>
                 >
             >
diff --git a/test/value.cpp b/test/value.cpp
index 30abc32..f668192 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -4,7 +4,10 @@
 
 
 template <typename T>
-using term = boost::yap::terminal<T>;
+using term = boost::yap::terminal<boost::yap::expression, T>;
+
+template <typename T>
+using ref = boost::yap::expression_ref<boost::yap::expression, T>;
 
 namespace yap = boost::yap;
 namespace bh = boost::hana;
@@ -23,10 +26,10 @@ struct user_expr
 };
 
 template <typename T>
-using user_term = boost::yap::terminal<T, user_expr>;
+using user_term = boost::yap::terminal<user_expr, T>;
 
 template <typename T>
-using user_ref = boost::yap::expression_ref<T, user_expr>;
+using user_ref = boost::yap::expression_ref<user_expr, T>;
 
 
 TEST(builtin, test_value)
@@ -73,24 +76,24 @@ TEST(expression, test_value)
     using plus_expr_type = yap::expression<
         yap::expr_kind::plus,
         bh::tuple<
-            yap::expression_ref<term<double> &>,
+            ref<term<double> &>,
             term<int>
         >
     >;
     plus_expr_type plus_expr = unity + term<int>{{1}};
 
     {
-        yap::expression_ref<term<double> &> ref = bh::front(plus_expr.elements);
+        ref<term<double> &> ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::value(std::move(ref))), double &>::value));
     }
 
     {
-        yap::expression_ref<term<double> &> ref = bh::front(plus_expr.elements);
+        ref<term<double> &> ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::value(ref)), double &>::value));
     }
 
     {
-        yap::expression_ref<term<double> &> const ref = bh::front(plus_expr.elements);
+        ref<term<double> &> const ref = bh::front(plus_expr.elements);
         EXPECT_TRUE((std::is_same<decltype(yap::value(ref)), double &>::value));
     }
 
@@ -99,23 +102,23 @@ TEST(expression, test_value)
         yap::expression<
             yap::expr_kind::plus,
             bh::tuple<
-                yap::expression_ref<term<double> const &>,
+                ref<term<double> const &>,
                 term<int>
             >
         > plus_expr = unity + term<int>{{1}};
 
         {
-            yap::expression_ref<term<double> const &> ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::value(std::move(ref))), double const &>::value));
         }
 
         {
-            yap::expression_ref<term<double> const &> ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::value(ref)), double const &>::value));
         }
 
         {
-            yap::expression_ref<term<double> const &> const ref = bh::front(plus_expr.elements);
+            ref<term<double> const &> const ref = bh::front(plus_expr.elements);
             EXPECT_TRUE((std::is_same<decltype(yap::value(ref)), double const &>::value));
         }
     }