From bc0c3f7577846844c6f2530ff62e57f2d4ac1885 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Sat, 16 Jan 2016 18:45:55 +0000
Subject: [PATCH] convert some stuff to variable templates

---
 ostd/internal/tuple.hh | 72 +++++++++++++++++++-----------------------
 ostd/tuple.hh          | 27 ++++++++--------
 2 files changed, 46 insertions(+), 53 deletions(-)

diff --git a/ostd/internal/tuple.hh b/ostd/internal/tuple.hh
index 89de645..a12789d 100644
--- a/ostd/internal/tuple.hh
+++ b/ostd/internal/tuple.hh
@@ -181,99 +181,93 @@ namespace detail {
 
 namespace detail {
     template<typename, typename>
-    struct TupleConvertibleBase: False {};
+    constexpr bool TupleConvertibleBase = false;
 
     template<typename T, typename ...TT, typename U, typename ...UU>
-    struct TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        Constant<bool, IsConvertible<T, U> &&
-                               TupleConvertibleBase<TupleTypes<TT...>,
-                                                    TupleTypes<UU...>>::value> {};
+    constexpr bool TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
+        = IsConvertible<T, U> && TupleConvertibleBase<TupleTypes<TT...>,
+                                                      TupleTypes<UU...>>;
 
     template<>
-    struct TupleConvertibleBase<TupleTypes<>, TupleTypes<>>: True {};
+    constexpr bool TupleConvertibleBase<TupleTypes<>, TupleTypes<>> = true;
 
     template<bool, typename, typename>
-    struct TupleConvertibleApply: False {};
+    constexpr bool TupleConvertibleApply = false;
 
     template<typename T, typename U>
-    struct TupleConvertibleApply<true, T, U>: TupleConvertibleBase<
-        MakeTupleTypes<T>, MakeTupleTypes<U>
-    > {};
+    constexpr bool TupleConvertibleApply<true, T, U>
+        = TupleConvertibleBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
 
     template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
                                      bool = IsTupleLike<U>::value>
-    struct TupleConvertible: False {};
+    constexpr bool TupleConvertible = false;
 
     template<typename T, typename U>
-    struct TupleConvertible<T, U, true, true>: TupleConvertibleApply<
+    constexpr bool TupleConvertible<T, U, true, true> = TupleConvertibleApply<
         TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
-    > {};
+    >;
 }
 
 /* tuple constructible */
 
 namespace detail {
     template<typename, typename>
-    struct TupleConstructibleBase: False {};
+    constexpr bool TupleConstructibleBase = false;
 
     template<typename T, typename ...TT, typename U, typename ...UU>
-    struct TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        Constant<bool, IsConstructible<U, T> &&
-                               TupleConstructibleBase<TupleTypes<TT...>,
-                                                      TupleTypes<UU...>>::value> {};
+    constexpr bool TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
+        = IsConstructible<U, T> && TupleConstructibleBase<TupleTypes<TT...>,
+                                                          TupleTypes<UU...>>;
 
     template<>
-    struct TupleConstructibleBase<TupleTypes<>, TupleTypes<>>: True {};
+    constexpr bool TupleConstructibleBase<TupleTypes<>, TupleTypes<>> = true;
 
     template<bool, typename, typename>
-    struct TupleConstructibleApply: False {};
+    constexpr bool TupleConstructibleApply = false;
 
     template<typename T, typename U>
-    struct TupleConstructibleApply<true, T, U>: TupleConstructibleBase<
-        MakeTupleTypes<T>, MakeTupleTypes<U>
-    > {};
+    constexpr bool TupleConstructibleApply<true, T, U>
+        = TupleConstructibleBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
 
     template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
                                      bool = IsTupleLike<U>::value>
-    struct TupleConstructible: False {};
+    constexpr bool TupleConstructible = false;
 
     template<typename T, typename U>
-    struct TupleConstructible<T, U, true, true>: TupleConstructibleApply<
+    constexpr bool TupleConstructible<T, U, true, true> = TupleConstructibleApply<
         TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
-    > {};
+    >;
 }
 
 /* tuple assignable */
 
 namespace detail {
     template<typename, typename>
-    struct TupleAssignableBase: False {};
+    constexpr bool TupleAssignableBase = false;
 
     template<typename T, typename ...TT, typename U, typename ...UU>
-    struct TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        Constant<bool, IsAssignable<U &, T> &&
-                               TupleAssignableBase<TupleTypes<TT...>,
-                                                   TupleTypes<UU...>>::value> {};
+    constexpr bool TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>
+        = IsAssignable<U &, T> && TupleAssignableBase<TupleTypes<TT...>,
+                                                      TupleTypes<UU...>>;
 
     template<>
-    struct TupleAssignableBase<TupleTypes<>, TupleTypes<>>: True {};
+    constexpr bool TupleAssignableBase<TupleTypes<>, TupleTypes<>> = true;
 
     template<bool, typename, typename>
-    struct TupleAssignableApply: False {};
+    constexpr bool TupleAssignableApply = false;
 
     template<typename T, typename U>
-    struct TupleAssignableApply<true, T, U>: TupleAssignableBase<
-        MakeTupleTypes<T>, MakeTupleTypes<U>
-    > {};
+    constexpr bool TupleAssignableApply<true, T, U>
+        = TupleAssignableBase<MakeTupleTypes<T>, MakeTupleTypes<U>>;
 
     template<typename T, typename U, bool = IsTupleLike<RemoveReference<T>>::value,
                                      bool = IsTupleLike<U>::value>
-    struct TupleAssignable: False {};
+    constexpr bool TupleAssignable = false;
 
     template<typename T, typename U>
-    struct TupleAssignable<T, U, true, true>: TupleAssignableApply<
+    constexpr bool TupleAssignable<T, U, true, true> = TupleAssignableApply<
         TupleSize<RemoveReference<T>>::value == TupleSize<U>::value, T, U
-    > {};
+    >;
 }
 
 } /* namespace ostd */
diff --git a/ostd/tuple.hh b/ostd/tuple.hh
index ea466fc..ac6375d 100644
--- a/ostd/tuple.hh
+++ b/ostd/tuple.hh
@@ -218,13 +218,13 @@ namespace detail {
         {}
 
         template<typename T, typename = EnableIf<
-            TupleConstructible<T, Tuple<A...>>::value
+            TupleConstructible<T, Tuple<A...>>
         >> TupleBase(T &&t): TupleLeaf<I, A>(forward<
             TupleElement<I, MakeTupleTypes<T>>
         >(get<I>(t)))... {}
 
         template<typename Alloc, typename T, typename = EnableIf<
-            TupleConvertible<T, Tuple<A...>>::value
+            TupleConvertible<T, Tuple<A...>>
         >> TupleBase(AllocatorArg, const Alloc &a, T &&t):
             TupleLeaf<I, A>(UsesAllocatorConstructor<
                 A, Alloc, TupleElement<I, MakeTupleTypes<T>>
@@ -232,7 +232,7 @@ namespace detail {
         {}
 
         template<typename T>
-        EnableIf<TupleAssignable<T, Tuple<A...>>::value, TupleBase &>
+        EnableIf<TupleAssignable<T, Tuple<A...>>, TupleBase &>
         operator=(T &&t) {
             tuple_swallow(TupleLeaf<I, A>::operator=(forward<
                 TupleElement<I, MakeTupleTypes<T>>
@@ -302,7 +302,7 @@ public:
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
                                               : sizeof...(A)
             >
-        >::value &&
+        > &&
         detail::TupleAllDefaultConstructible<
             detail::MakeTupleTypes<Tuple, sizeof...(A),
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@@ -325,14 +325,14 @@ public:
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
                                               : sizeof...(A)
             >
-        >::value &&
+        > &&
         !detail::TupleConvertible<
             Tuple<T...>,
             detail::MakeTupleTypes<Tuple,
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
                                               : sizeof...(A)
             >
-        >::value &&
+        > &&
         detail::TupleAllDefaultConstructible<
             detail::MakeTupleTypes<Tuple, sizeof...(A),
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@@ -355,7 +355,7 @@ public:
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
                                               : sizeof...(A)
             >
-        >::value &&
+        > &&
         detail::TupleAllDefaultConstructible<
             detail::MakeTupleTypes<Tuple, sizeof...(A),
                 (sizeof...(T) < sizeof...(A)) ? sizeof...(T)
@@ -370,22 +370,21 @@ public:
                forward<T>(t)...) {}
 
     template<typename T, EnableIf<
-        detail::TupleConvertible<T, Tuple>::value, bool
+        detail::TupleConvertible<T, Tuple>, bool
     > = true> Tuple(T &&t): p_base(forward<T>(t)) {}
 
     template<typename T, EnableIf<
-        detail::TupleConstructible<T, Tuple>::value &&
-        !detail::TupleConvertible<T, Tuple>::value, bool
+        detail::TupleConstructible<T, Tuple> &&
+        !detail::TupleConvertible<T, Tuple>, bool
     > = true> Tuple(T &&t): p_base(forward<T>(t)) {}
 
     template<typename Alloc, typename T, typename = EnableIf<
-        detail::TupleConvertible<T, Tuple>::value
+        detail::TupleConvertible<T, Tuple>
     >> Tuple(AllocatorArg, const Alloc &a, T &&t):
         p_base(allocator_arg, a, forward<T>(t)) {}
 
-    template<typename T, typename = EnableIf<
-        detail::TupleAssignable<T, Tuple>::value
-    >> Tuple &operator=(T &&t) {
+    template<typename T, typename = EnableIf<detail::TupleAssignable<T, Tuple>>>
+    Tuple &operator=(T &&t) {
         p_base.operator=(forward<T>(t));
         return *this;
     }