diff --git a/ostd/array.hh b/ostd/array.hh
index fb2d1ae..e861b1e 100644
--- a/ostd/array.hh
+++ b/ostd/array.hh
@@ -77,7 +77,7 @@ struct Array {
 };
 
 template<typename T, Size N>
-struct TupleSize<Array<T, N>>: IntegralConstant<Size, N> {};
+struct TupleSize<Array<T, N>>: Constant<Size, N> {};
 
 template<Size I, typename T, Size N>
 struct TupleElementBase<I, Array<T, N>> {
diff --git a/ostd/internal/tuple.hh b/ostd/internal/tuple.hh
index 47196e3..89de645 100644
--- a/ostd/internal/tuple.hh
+++ b/ostd/internal/tuple.hh
@@ -143,7 +143,7 @@ public:
 };
 
 template<typename ...T> struct TupleSize<detail::TupleTypes<T...>>:
-    IntegralConstant<Size, sizeof...(T)> {};
+    Constant<Size, sizeof...(T)> {};
 
 template<typename ...T> struct IsTupleLike<detail::TupleTypes<T...>>: True {};
 
@@ -185,7 +185,7 @@ namespace detail {
 
     template<typename T, typename ...TT, typename U, typename ...UU>
     struct TupleConvertibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        IntegralConstant<bool, IsConvertible<T, U> &&
+        Constant<bool, IsConvertible<T, U> &&
                                TupleConvertibleBase<TupleTypes<TT...>,
                                                     TupleTypes<UU...>>::value> {};
 
@@ -218,7 +218,7 @@ namespace detail {
 
     template<typename T, typename ...TT, typename U, typename ...UU>
     struct TupleConstructibleBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        IntegralConstant<bool, IsConstructible<U, T> &&
+        Constant<bool, IsConstructible<U, T> &&
                                TupleConstructibleBase<TupleTypes<TT...>,
                                                       TupleTypes<UU...>>::value> {};
 
@@ -251,7 +251,7 @@ namespace detail {
 
     template<typename T, typename ...TT, typename U, typename ...UU>
     struct TupleAssignableBase<TupleTypes<T, TT...>, TupleTypes<U, UU...>>:
-        IntegralConstant<bool, IsAssignable<U &, T> &&
+        Constant<bool, IsAssignable<U &, T> &&
                                TupleAssignableBase<TupleTypes<TT...>,
                                                    TupleTypes<UU...>>::value> {};
 
diff --git a/ostd/memory.hh b/ostd/memory.hh
index be1d52d..5ae0a36 100644
--- a/ostd/memory.hh
+++ b/ostd/memory.hh
@@ -208,7 +208,7 @@ namespace detail {
     template<typename T>
     static char ptr_test(typename T::Pointer * = 0);
 
-    template<typename T> struct HasPtr: IntegralConstant<bool,
+    template<typename T> struct HasPtr: Constant<bool,
         (sizeof(ptr_test<T>(0)) == 1)
     > {};
 
@@ -327,7 +327,7 @@ namespace detail {
         RemoveCv<PointerElement<T>>,
         RemoveCv<PointerElement<U>>
     >> struct SameOrLessCvQualifiedBase:
-        IntegralConstant<bool, IsConvertible<T, U>> {};
+        Constant<bool, IsConvertible<T, U>> {};
 
     template<typename T, typename U>
     struct SameOrLessCvQualifiedBase<T, U, false>: False {};
@@ -850,7 +850,7 @@ namespace detail {
 
     template<typename A, bool = IsAlwaysEqualTest<A>::value>
     struct IsAlwaysEqualBase {
-        using Type = IntegralConstant<bool, IsEmpty<A>>;
+        using Type = Constant<bool, IsEmpty<A>>;
     };
 
     template<typename A>
@@ -880,7 +880,7 @@ namespace detail {
         -> False;
 
     template<typename A, typename S, typename CVP>
-    struct AllocateHintTest: IntegralConstant<bool,
+    struct AllocateHintTest: Constant<bool,
         IsSame<decltype(allocate_hint_test(declval<A>(),
                                            declval<S>(),
                                            declval<CVP>())), True
@@ -933,7 +933,7 @@ namespace detail {
         -> False;
 
     template<typename A, typename T, typename ...Args>
-    struct ConstructTest: IntegralConstant<bool,
+    struct ConstructTest: Constant<bool,
         IsSame< decltype(construct_test(declval<A>(),
                                        declval<T>(),
                                        declval<Args>()...)), True
@@ -967,7 +967,7 @@ namespace detail {
     auto destroy_test(const A &, P &&) -> False;
 
     template<typename A, typename P>
-    struct DestroyTest: IntegralConstant<bool,
+    struct DestroyTest: Constant<bool,
         IsSame<decltype(destroy_test(declval<A>(), declval<P>())), True>
     > {};
 
@@ -997,7 +997,7 @@ namespace detail {
     auto alloc_max_size_test(const A &) -> False;
 
     template<typename A>
-    struct AllocMaxSizeTest: IntegralConstant<bool,
+    struct AllocMaxSizeTest: Constant<bool,
         IsSame<decltype(alloc_max_size_test(declval<A &>())), True>
     > {};
 
@@ -1027,7 +1027,7 @@ namespace detail {
     auto alloc_copy_test(const A &) -> False;
 
     template<typename A>
-    struct AllocCopyTest: IntegralConstant<bool,
+    struct AllocCopyTest: Constant<bool,
         IsSame<decltype(alloc_copy_test(declval<A &>())), True>
     > {};
 
@@ -1065,7 +1065,7 @@ namespace detail {
     };
 
     template<typename T, typename A, bool = HasAllocatorType<T>::value>
-    struct UsesAllocatorBase: IntegralConstant<bool,
+    struct UsesAllocatorBase: Constant<bool,
         IsConvertible<A, typename T::Allocator>
     > {};
 
@@ -1090,7 +1090,7 @@ namespace detail {
 }
 
 template<typename T, typename A, typename ...Args>
-struct UsesAllocatorConstructor: IntegralConstant<int,
+struct UsesAllocatorConstructor: Constant<int,
     detail::UsesAllocCtor<T, A, Args...>::value
 > {};
 
diff --git a/ostd/string.hh b/ostd/string.hh
index b1f5fd5..d92b29c 100644
--- a/ostd/string.hh
+++ b/ostd/string.hh
@@ -658,7 +658,7 @@ namespace detail {
 
     template<typename T, typename R>
     auto test_stringify(int) ->
-        IntegralConstant<bool, IsSame<decltype(declval<T>().stringify()), String>>;
+        Constant<bool, IsSame<decltype(declval<T>().stringify()), String>>;
 
     template<typename T, typename R>
     static True test_stringify(decltype(declval<const T &>().to_string
diff --git a/ostd/tuple.hh b/ostd/tuple.hh
index cea2d5c..ea466fc 100644
--- a/ostd/tuple.hh
+++ b/ostd/tuple.hh
@@ -18,7 +18,7 @@ namespace ostd {
 /* tuple size */
 
 template<typename ...T> struct TupleSize<Tuple<T...>>:
-    IntegralConstant<Size, sizeof...(T)> {};
+    Constant<Size, sizeof...(T)> {};
 
 /* tuple element */
 
@@ -38,17 +38,17 @@ namespace detail {
         }
 
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 0>, const A &): p_value() {
+        TupleLeaf(Constant<int, 0>, const A &): p_value() {
             static_assert(!IsReference<H>,
                 "attempt to default construct a reference element in a tuple");
         }
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 1>, const A &a): p_value(allocator_arg, a) {
+        TupleLeaf(Constant<int, 1>, const A &a): p_value(allocator_arg, a) {
             static_assert(!IsReference<H>,
                 "attempt to default construct a reference element in a tuple");
         }
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 2>, const A &a): p_value(a) {
+        TupleLeaf(Constant<int, 2>, const A &a): p_value(a) {
             static_assert(!IsReference<H>,
                 "attempt to default construct a reference element in a tuple");
         }
@@ -68,7 +68,7 @@ namespace detail {
         }
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 0>, const A &, T &&t):
+        explicit TupleLeaf(Constant<int, 0>, const A &, T &&t):
                            p_value(forward<T>(t)) {
             static_assert(!IsLvalueReference<H> ||
                           (IsLvalueReference<H> &&
@@ -79,7 +79,7 @@ namespace detail {
         }
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 1>, const A &a, T &&t):
+        explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t):
                            p_value(allocator_arg, a, forward<T>(t)) {
             static_assert(!IsLvalueReference<H> ||
                           (IsLvalueReference<H> &&
@@ -90,7 +90,7 @@ namespace detail {
         }
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 2>, const A &a, T &&t):
+        explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t):
                            p_value(forward<T>(t), a) {
             static_assert(!IsLvalueReference<H> ||
                           (IsLvalueReference<H> &&
@@ -126,29 +126,29 @@ namespace detail {
         constexpr TupleLeaf() {}
 
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 0>, const A &) {}
+        TupleLeaf(Constant<int, 0>, const A &) {}
 
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 1>, const A &a):
+        TupleLeaf(Constant<int, 1>, const A &a):
             H(allocator_arg, a) {}
 
         template<typename A>
-        TupleLeaf(IntegralConstant<int, 2>, const A &a): H(a) {}
+        TupleLeaf(Constant<int, 2>, const A &a): H(a) {}
 
         template<typename T, typename = EnableIf<
             !IsSame<Decay<T>, TupleLeaf> && IsConstructible<H, T>
         >> explicit TupleLeaf(T &&t): H(forward<T>(t)) {}
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 0>, const A &, T &&t):
+        explicit TupleLeaf(Constant<int, 0>, const A &, T &&t):
             H(forward<T>(t)) {}
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 1>, const A &a, T &&t):
+        explicit TupleLeaf(Constant<int, 1>, const A &a, T &&t):
             H(allocator_arg, a, forward<T>(t)) {}
 
         template<typename T, typename A>
-        explicit TupleLeaf(IntegralConstant<int, 2>, const A &a, T &&t):
+        explicit TupleLeaf(Constant<int, 2>, const A &a, T &&t):
             H(forward<T>(t), a) {}
 
         TupleLeaf(const TupleLeaf &) = default;
@@ -179,7 +179,7 @@ namespace detail {
     inline void tuple_swallow(A &&...) {}
 
     template<bool ...A> struct TupleAll:
-        IntegralConstant<bool, IsSame<TupleAll<A...>, TupleAll<(A, true)...>>> {};
+        Constant<bool, IsSame<TupleAll<A...>, TupleAll<(A, true)...>>> {};
 
     template<typename T>
     struct TupleAllDefaultConstructible;
diff --git a/ostd/type_traits.hh b/ostd/type_traits.hh
index e3eb8f2..a0073ce 100644
--- a/ostd/type_traits.hh
+++ b/ostd/type_traits.hh
@@ -49,20 +49,20 @@ namespace detail {
 /* integral constant */
 
 template<typename T, T val>
-struct IntegralConstant {
+struct Constant {
     static constexpr T value = val;
 
     using Value = T;
-    using Type = IntegralConstant<T, val>;
+    using Type = Constant<T, val>;
 
     constexpr operator Value() const { return value; }
     constexpr Value operator()() const { return value; }
 };
 
-using True = IntegralConstant<bool, true>;
-using False = IntegralConstant<bool, false>;
+using True = Constant<bool, true>;
+using False = Constant<bool, false>;
 
-template<typename T, T val> constexpr T IntegralConstant<T, val>::value;
+template<typename T, T val> constexpr T Constant<T, val>::value;
 
 /* type equality */
 
@@ -609,7 +609,7 @@ namespace detail {
     template<typename F, typename T, bool = IsVoid<F>
         || IsFunction<T> || IsArray<T>
     > struct IsConvertibleBase {
-        using Type = IntegralConstant<bool, IsVoid<T>>;
+        using Type = Constant<bool, IsVoid<T>>;
     };
 
     template<typename F, typename T>
diff --git a/ostd/utility.hh b/ostd/utility.hh
index dec9fd1..3de716c 100644
--- a/ostd/utility.hh
+++ b/ostd/utility.hh
@@ -50,7 +50,7 @@ template<typename T> AddRvalueReference<T> declval();
 namespace detail {
     template<typename T>
     auto test_swap(int) ->
-        IntegralConstant<bool, IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
+        Constant<bool, IsVoid<decltype(declval<T>().swap(declval<T &>()))>>;
     template<typename>
     False test_swap(...);
 
@@ -209,7 +209,7 @@ inline constexpr bool operator>=(const Pair<T, U> &x, const Pair<T, U> &y) {
 }
 
 template<typename T, typename U>
-struct TupleSize<Pair<T, U>>: IntegralConstant<Size, 2> {};
+struct TupleSize<Pair<T, U>>: Constant<Size, 2> {};
 
 template<typename T, typename U>
 struct TupleElementBase<0, Pair<T, U>> {