From 5b7cd4c71e0840b4e2a86d97138b58b115126db5 Mon Sep 17 00:00:00 2001
From: Zach Laine <whatwasthataddress@gmail.com>
Date: Sat, 19 Nov 2016 12:18:57 -0600
Subject: [PATCH] typename operand_type<>::type -> operand_type_t<>

---
 detail/expression.hpp |  3 +++
 expression.hpp        | 18 +++++++++---------
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/detail/expression.hpp b/detail/expression.hpp
index 991ba61..ff3f400 100644
--- a/detail/expression.hpp
+++ b/detail/expression.hpp
@@ -79,6 +79,9 @@ namespace boost::proto17 {
         struct operand_type<T, U, false, false>
         { using type = terminal<U>; };
 
+        template <typename T>
+        using operand_type_t = typename operand_type<T>::type;
+
         template <expr_kind Kind, typename T>
         struct expression_from_tuple;
 
diff --git a/expression.hpp b/expression.hpp
index d082a89..8a3318d 100644
--- a/expression.hpp
+++ b/expression.hpp
@@ -127,7 +127,7 @@ namespace boost::proto17 {
         template <typename U>                                           \
         auto operator op (U && rhs) const &                             \
         {                                                               \
-            using rhs_type = typename detail::operand_type<U>::type;    \
+            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,                                              \
@@ -138,7 +138,7 @@ namespace boost::proto17 {
         template <typename U>                                           \
         auto operator op (U && rhs) &&                                  \
         {                                                               \
-            using rhs_type = typename detail::operand_type<U>::type;    \
+            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),                                   \
@@ -169,7 +169,7 @@ namespace boost::proto17 {
         template <typename U>
         auto operator, (U && rhs) const &
         {
-            using rhs_type = typename detail::operand_type<U>::type;
+            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)}
             };
@@ -177,7 +177,7 @@ namespace boost::proto17 {
         template <typename U>
         auto operator, (U && rhs) &&
         {
-            using rhs_type = typename detail::operand_type<U>::type;
+            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)}
             };
@@ -202,13 +202,13 @@ namespace boost::proto17 {
         template <typename ...U>
         auto operator() (U && ...u) const &
         {
-            using tuple_type = hana::tuple<this_type, typename detail::operand_type<U>::type...>;
+            using tuple_type = hana::tuple<this_type, detail::operand_type_t<U>...>;
             return detail::make_call_expression<tuple_type>(*this, static_cast<U &&>(u)...);
         }
         template <typename ...U>
         auto operator() (U && ...u) &&
         {
-            using tuple_type = hana::tuple<this_type, typename detail::operand_type<U>::type...>;
+            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)...);
         }
     };
@@ -219,7 +219,7 @@ namespace boost::proto17 {
                   bool Expr = detail::is_expr<remove_cv_ref_t<T>>::value>
         struct binary_op_result
         {
-            using lhs_type = typename detail::operand_type<T>::type;
+            using lhs_type = detail::operand_type_t<T>;
             using rhs_type = U;
             using type = expression<OpKind, lhs_type, rhs_type>;
         };
@@ -235,7 +235,7 @@ namespace boost::proto17 {
     auto operator op (T && lhs, expression<Kind, U...> const & rhs)     \
         -> typename detail::binary_op_result<expr_kind::op_name, T, expression<Kind, U...>>::type \
     {                                                                   \
-        using lhs_type = typename detail::operand_type<T>::type;        \
+        using lhs_type = detail::operand_type_t<T>;                     \
         using rhs_type = expression<Kind, U...>;                        \
         return {                                                        \
             hana::tuple<lhs_type, rhs_type>{static_cast<T &&>(lhs), rhs} \
@@ -245,7 +245,7 @@ namespace boost::proto17 {
     auto operator op (T && lhs, expression<Kind, U...> && rhs)          \
         -> typename detail::binary_op_result<expr_kind::op_name, T, expression<Kind, U...>>::type \
     {                                                                   \
-        using lhs_type = typename detail::operand_type<T>::type;        \
+        using lhs_type = detail::operand_type_t<T>;                     \
         using rhs_type = expression<Kind, U...>;                        \
         return {                                                        \
             hana::tuple<lhs_type, rhs_type>{static_cast<T &&>(lhs), static_cast<rhs_type &&>(rhs)} \