From fb0c7571c1c2bcb6d9e10c35726d6c21a1db39f4 Mon Sep 17 00:00:00 2001
From: q66 <daniel@octaforge.org>
Date: Sun, 3 May 2015 23:50:09 +0100
Subject: [PATCH] more style/consistency stuff

---
 octa/memory.h      |  50 +++----
 octa/type_traits.h | 328 ++++++++++++++++++++++-----------------------
 2 files changed, 189 insertions(+), 189 deletions(-)

diff --git a/octa/memory.h b/octa/memory.h
index 3a61cdb..b305263 100644
--- a/octa/memory.h
+++ b/octa/memory.h
@@ -33,17 +33,17 @@ namespace octa {
     struct __OctaPtrTraitsElementType;
 
     template<typename T> struct __OctaPtrTraitsElementType<T, true> {
-        typedef typename T::ElementType type;
+        typedef typename T::ElementType Type;
     };
 
     template<template<typename, typename...> class T, typename U, typename ...A>
     struct __OctaPtrTraitsElementType<T<U, A...>, true> {
-        typedef typename T<U, A...>::ElementType type;
+        typedef typename T<U, A...>::ElementType Type;
     };
 
     template<template<typename, typename...> class T, typename U, typename ...A>
     struct __OctaPtrTraitsElementType<T<U, A...>, false> {
-        typedef U type;
+        typedef U Type;
     };
 
     template<typename T>
@@ -51,18 +51,18 @@ namespace octa {
         template<typename U>
         static int  __octa_test(...);
         template<typename U>
-        static char __octa_test(typename U::difference_type * = 0);
+        static char __octa_test(typename U::DiffType * = 0);
 
         static constexpr bool value = (sizeof(__octa_test<T>(0)) == 1);
     };
 
     template<typename T, bool = __OctaHasDiffType<T>::value>
     struct __OctaPtrTraitsDiffType {
-        typedef ptrdiff_t type;
+        typedef ptrdiff_t Type;
     };
 
     template<typename T> struct __OctaPtrTraitsDiffType<T, true> {
-        typedef typename T::difference_type type;
+        typedef typename T::DiffType Type;
     };
 
     template<typename T, typename U>
@@ -77,66 +77,66 @@ namespace octa {
 
     template<typename T, typename U, bool = __OctaHasRebind<T, U>::value>
     struct __OctaPtrTraitsRebindType {
-        typedef typename T::template rebind<U> type;
+        typedef typename T::template rebind<U> Type;
     };
 
     template<template<typename, typename...> class T, typename U,
         typename ...A, typename V
     >
     struct __OctaPtrTraitsRebindType<T<U, A...>, V, true> {
-        typedef typename T<U, A...>::template rebind<V> type;
+        typedef typename T<U, A...>::template rebind<V> Type;
     };
 
     template<template<typename, typename...> class T, typename U,
         typename ...A, typename V
     >
     struct __OctaPtrTraitsRebindType<T<U, A...>, V, false> {
-        typedef T<V, A...> type;
+        typedef T<V, A...> Type;
     };
 
     template<typename T>
     struct __OctaPtrTraitsPointer {
-        typedef T type;
+        typedef T Type;
     };
 
     template<typename T>
     struct __OctaPtrTraitsPointer<T *> {
-        typedef T *type;
+        typedef T *Type;
     };
 
     template<typename T>
-    using PtrType = typename __OctaPtrTraitsPointer<T>::type;
+    using PtrType = typename __OctaPtrTraitsPointer<T>::Type;
 
     template<typename T>
     struct __OctaPtrTraitsElement {
-        typedef typename __OctaPtrTraitsElementType<T>::type type;
+        typedef typename __OctaPtrTraitsElementType<T>::Type Type;
     };
 
     template<typename T>
     struct __OctaPtrTraitsElement<T *> {
-        typedef T type;
+        typedef T Type;
     };
 
     template<typename T>
-    using PointerElement = typename __OctaPtrTraitsElement<T>::type;
+    using PointerElement = typename __OctaPtrTraitsElement<T>::Type;
 
     template<typename T>
     struct __OctaPtrTraitsDifference {
-        typedef typename __OctaPtrTraitsDiffType<T>::type type;
+        typedef typename __OctaPtrTraitsDiffType<T>::Type Type;
     };
 
 
     template<typename T>
     struct __OctaPtrTraitsDifference<T *> {
-        typedef ptrdiff_t difference_type;
+        typedef ptrdiff_t DiffType;
     };
 
     template<typename T>
-    using PointerDifference = typename __OctaPtrTraitsDifference<T>::type;
+    using PointerDifference = typename __OctaPtrTraitsDifference<T>::Type;
 
     template<typename T, typename U>
     struct __OctaPtrTraitsRebind {
-        using type = typename __OctaPtrTraitsRebindType<T, U>::type;
+        using type = typename __OctaPtrTraitsRebindType<T, U>::Type;
     };
 
     template<typename T, typename U>
@@ -145,7 +145,7 @@ namespace octa {
     };
 
     template<typename T, typename U>
-    using PointerRebind = typename __OctaPtrTraitsRebind<T, U>::type;
+    using PointerRebind = typename __OctaPtrTraitsRebind<T, U>::Type;
 
     struct __OctaPtrTraitsNat {};
 
@@ -250,22 +250,22 @@ namespace octa {
 
     template<typename T, typename D, bool = __OctaHasPtr<D>::value>
     struct __OctaPtrTypeBase {
-        typedef typename D::PtrType type;
+        typedef typename D::PtrType Type;
     };
 
     template<typename T, typename D> struct __OctaPtrTypeBase<T, D, false> {
-        typedef T *type;
+        typedef T *Type;
     };
 
     template<typename T, typename D> struct __OctaPtrType {
-        typedef typename __OctaPtrTypeBase<T, RemoveReference<D>>::type type;
+        typedef typename __OctaPtrTypeBase<T, RemoveReference<D>>::Type Type;
     };
 
     template<typename T, typename D = DefaultDelete<T>>
     struct Box {
         typedef T ElementType;
         typedef D DeleterType;
-        typedef typename __OctaPtrType<T, D>::type PtrType;
+        typedef typename __OctaPtrType<T, D>::Type PtrType;
 
     private:
         struct __OctaNat { int x; };
@@ -382,7 +382,7 @@ namespace octa {
     struct Box<T[], D> {
         typedef T ElementType;
         typedef D DeleterType;
-        typedef typename __OctaPtrType<T, D>::type PtrType;
+        typedef typename __OctaPtrType<T, D>::Type PtrType;
 
     private:
         struct __OctaNat { int x; };
diff --git a/octa/type_traits.h b/octa/type_traits.h
index d3cf47b..69dbb09 100644
--- a/octa/type_traits.h
+++ b/octa/type_traits.h
@@ -25,7 +25,7 @@ namespace octa {
     template<typename...> struct __OctaCommonType;
 
     /* declval also defined here to avoid including utility.h */
-    template<typename T> typename __OctaAddRr<T>::type __octa_declval();
+    template<typename T> typename __OctaAddRr<T>::Type __octa_declval();
 
     /* integral constant */
 
@@ -33,11 +33,11 @@ namespace octa {
     struct IntegralConstant {
         static constexpr T value = val;
 
-        typedef T value_type;
-        typedef IntegralConstant<T, val> type;
+        typedef T ValType;
+        typedef IntegralConstant<T, val> Type;
 
-        constexpr operator value_type() const { return value; }
-        constexpr value_type operator()() const { return value; }
+        constexpr operator ValType() const { return value; }
+        constexpr ValType operator()() const { return value; }
     };
 
     typedef IntegralConstant<bool, true>  True;
@@ -51,7 +51,7 @@ namespace octa {
     template<          > struct __OctaIsVoid<void>:  True {};
 
     template<typename T>
-    struct IsVoid: __OctaIsVoid<typename __OctaRemoveCv<T>::type> {};
+    struct IsVoid: __OctaIsVoid<typename __OctaRemoveCv<T>::Type> {};
 
     /* is null pointer */
 
@@ -59,7 +59,7 @@ namespace octa {
     template<        > struct __OctaIsNullPointer<nullptr_t>:  True {};
 
     template<typename T> struct IsNullPointer: __OctaIsNullPointer<
-        typename __OctaRemoveCv<T>::type
+        typename __OctaRemoveCv<T>::Type
     > {};
 
     /* is integer */
@@ -80,7 +80,7 @@ namespace octa {
     template<> struct __OctaIsIntegral<ullong>: True {};
 
     template<typename T>
-    struct IsIntegral: __OctaIsIntegral<typename __OctaRemoveCv<T>::type> {};
+    struct IsIntegral: __OctaIsIntegral<typename __OctaRemoveCv<T>::Type> {};
 
     /* is floating point */
 
@@ -91,7 +91,7 @@ namespace octa {
     template<> struct __OctaIsFloatingPoint<ldouble>: True {};
 
     template<typename T>
-    struct IsFloatingPoint: __OctaIsFloatingPoint<typename __OctaRemoveCv<T>::type> {};
+    struct IsFloatingPoint: __OctaIsFloatingPoint<typename __OctaRemoveCv<T>::Type> {};
 
     /* is array */
 
@@ -105,7 +105,7 @@ namespace octa {
     template<typename T> struct __OctaIsPointer<T *>:  True {};
 
     template<typename T>
-    struct IsPointer: __OctaIsPointer<typename __OctaRemoveCv<T>::type> {};
+    struct IsPointer: __OctaIsPointer<typename __OctaRemoveCv<T>::Type> {};
 
     /* is lvalue reference */
 
@@ -179,7 +179,7 @@ namespace octa {
 
     template<typename T>
     struct IsMemberPointer: __OctaIsMemberPointer<
-        typename __OctaRemoveCv<T>::type
+        typename __OctaRemoveCv<T>::Type
     > {};
 
     /* is pointer to member object */
@@ -193,7 +193,7 @@ namespace octa {
     > {};
 
     template<typename T> struct IsMemberObjectPointer:
-        __OctaIsMemberObjectPointer<typename __OctaRemoveCv<T>::type> {};
+        __OctaIsMemberObjectPointer<typename __OctaRemoveCv<T>::Type> {};
 
     /* is pointer to member function */
 
@@ -206,7 +206,7 @@ namespace octa {
     > {};
 
     template<typename T> struct IsMemberFunctionPointer:
-        __OctaIsMemberFunctionPointer<typename __OctaRemoveCv<T>::type> {};
+        __OctaIsMemberFunctionPointer<typename __OctaRemoveCv<T>::Type> {};
 
     /* is reference */
 
@@ -270,14 +270,14 @@ namespace octa {
 
     template<typename T>
     struct IsStandardLayout: IntegralConstant<bool,
-        IsScalar<typename __OctaRemoveAllExtents<T>::type>::value
+        IsScalar<typename __OctaRemoveAllExtents<T>::Type>::value
     > {};
 
     /* is literal type */
 
     template<typename T>
     struct IsLiteralType: IntegralConstant<bool,
-        IsReference<typename __OctaRemoveAllExtents<T>::type>::value
+        IsReference<typename __OctaRemoveAllExtents<T>::Type>::value
      || IsStandardLayout<T>::value
     > {};
 
@@ -285,7 +285,7 @@ namespace octa {
 
     template<typename T>
     struct IsTriviallyCopyable: IntegralConstant<bool,
-        IsScalar<typename __OctaRemoveAllExtents<T>::type>::value
+        IsScalar<typename __OctaRemoveAllExtents<T>::Type>::value
     > {};
 
     /* is trivial */
@@ -304,14 +304,14 @@ namespace octa {
 
     /* is constructible */
 
-#define __OCTA_MOVE(v) static_cast<typename __OctaRemoveReference<decltype(v)>::type &&>(v)
+#define __OCTA_MOVE(v) static_cast<typename __OctaRemoveReference<decltype(v)>::Type &&>(v)
 
-    template<typename, typename T> struct __OctaSelect2nd { typedef T type; };
+    template<typename, typename T> struct __OctaSelect2nd { typedef T Type; };
     struct __OctaAny { __OctaAny(...); };
 
     template<typename T, typename ...A> typename __OctaSelect2nd<
         decltype(__OCTA_MOVE(T(__octa_declval<A>()...))), True
-    >::type __octa_is_ctible_test(T &&, A &&...);
+    >::Type __octa_is_ctible_test(T &&, A &&...);
 
 #undef __OCTA_MOVE
 
@@ -321,7 +321,7 @@ namespace octa {
     struct __OctaCtibleCore: __OctaCommonType<
         decltype(__octa_is_ctible_test(__octa_declval<T>(),
             __octa_declval<A>()...))
-    >::type {};
+    >::Type {};
 
     /* function types are not constructible */
     template<typename R, typename ...A1, typename ...A2>
@@ -342,7 +342,7 @@ namespace octa {
     template<typename T, typename U>
     struct __OctaCtibleCore<true, T, U>: __OctaCommonType<
         decltype(__OctaCtibleRef<T>::test(__octa_declval<U>()))
-    >::type {};
+    >::Type {};
 
     /* scalars and references are not constructible from multiple args */
     template<typename T, typename U, typename ...A>
@@ -378,7 +378,7 @@ namespace octa {
     /* array types are default constructible if their element type is */
     template<typename T, size_t N>
     struct __OctaCtibleCore<false, T[N]>: __OctaCtible<
-        typename __OctaRemoveAllExtents<T>::type
+        typename __OctaRemoveAllExtents<T>::Type
     > {};
 
     /* otherwise array types are not constructible by this syntax */
@@ -399,27 +399,27 @@ namespace octa {
     /* is copy constructible */
 
     template<typename T> struct IsCopyConstructible: IsConstructible<T,
-        typename __OctaAddLr<typename __OctaAddConst<T>::type>::type
+        typename __OctaAddLr<typename __OctaAddConst<T>::Type>::Type
     > {};
 
     /* is move constructible */
 
     template<typename T> struct IsMoveConstructible: IsConstructible<T,
-        typename __OctaAddRr<T>::type
+        typename __OctaAddRr<T>::Type
     > {};
 
     /* is assignable */
 
     template<typename T, typename U> typename __OctaSelect2nd<
         decltype((__octa_declval<T>() = __octa_declval<U>())), True
-    >::type __octa_assign_test(T &&, U &&);
+    >::Type __octa_assign_test(T &&, U &&);
 
     template<typename T> False __octa_assign_test(__OctaAny, T &&);
 
     template<typename T, typename U, bool = IsVoid<T>::value || IsVoid<U>::value>
     struct __OctaIsAssignable: __OctaCommonType<
         decltype(__octa_assign_test(__octa_declval<T>(), __octa_declval<U>()))
-    >::type {};
+    >::Type {};
 
     template<typename T, typename U>
     struct __OctaIsAssignable<T, U, true>: False {};
@@ -430,25 +430,25 @@ namespace octa {
     /* is copy assignable */
 
     template<typename T> struct IsCopyAssignable: IsAssignable<
-        typename __OctaAddLr<T>::type,
-        typename __OctaAddLr<typename __OctaAddConst<T>::type>::type
+        typename __OctaAddLr<T>::Type,
+        typename __OctaAddLr<typename __OctaAddConst<T>::Type>::Type
     > {};
 
     /* is move assignable */
 
     template<typename T> struct IsMoveAssignable: IsAssignable<
-        typename __OctaAddLr<T>::type,
-        const typename __OctaAddRr<T>::type
+        typename __OctaAddLr<T>::Type,
+        const typename __OctaAddRr<T>::Type
     > {};
 
     /* is destructible */
 
-    template<typename> struct __OctaIsDtibleApply { typedef int type; };
+    template<typename> struct __OctaIsDtibleApply { typedef int Type; };
 
     template<typename T> struct IsDestructorWellformed {
         template<typename TT> static char test(typename __OctaIsDtibleApply<
             decltype(__octa_declval<TT &>().~TT())
-        >::type);
+        >::Type);
 
         template<typename TT> static int test(...);
 
@@ -459,7 +459,7 @@ namespace octa {
 
     template<typename T>
     struct __OctaDtibleImpl<T, false>: IntegralConstant<bool,
-        IsDestructorWellformed<typename __OctaRemoveAllExtents<T>::type>::value
+        IsDestructorWellformed<typename __OctaRemoveAllExtents<T>::Type>::value
     > {};
 
     template<typename T>
@@ -512,14 +512,14 @@ namespace octa {
 
     template<typename T>
     struct IsTriviallyCopyConstructible: IsTriviallyConstructible<T,
-        typename __OctaAddLr<const T>::type
+        typename __OctaAddLr<const T>::Type
     > {};
 
     /* is trivially move constructible */
 
     template<typename T>
     struct IsTriviallyMoveConstructible: IsTriviallyConstructible<T,
-        typename __OctaAddRr<T>::type
+        typename __OctaAddRr<T>::Type
     > {};
 
     /* is trivially assignable */
@@ -551,14 +551,14 @@ namespace octa {
 
     template<typename T>
     struct IsTriviallyCopyAssignable: IsTriviallyAssignable<T,
-        typename __OctaAddLr<const T>::type
+        typename __OctaAddLr<const T>::Type
     > {};
 
     /* is trivially move assignable */
 
     template<typename T>
     struct IsTriviallyMoveAssignable: IsTriviallyAssignable<T,
-        typename __OctaAddRr<T>::type
+        typename __OctaAddRr<T>::Type
     > {};
 
     /* is trivially destructible */
@@ -602,14 +602,14 @@ namespace octa {
 
     template<typename T>
     struct IsNothrowCopyConstructible: IsNothrowConstructible<T,
-        typename __OctaAddLr<const T>::type
+        typename __OctaAddLr<const T>::Type
     > {};
 
     /* is nothrow move constructible */
 
     template<typename T>
     struct IsNothrowMoveConstructible: IsNothrowConstructible<T,
-        typename __OctaAddRr<T>::type
+        typename __OctaAddRr<T>::Type
     > {};
 
     /* is nothrow assignable */
@@ -641,14 +641,14 @@ namespace octa {
 
     template<typename T>
     struct IsNothrowCopyAssignable: IsNothrowAssignable<T,
-        typename __OctaAddLr<const T>::type
+        typename __OctaAddLr<const T>::Type
     > {};
 
     /* is nothrow move assignable */
 
     template<typename T>
     struct IsNothrowMoveAssignable: IsNothrowAssignable<T,
-        typename __OctaAddRr<T>::type
+        typename __OctaAddRr<T>::Type
     > {};
 
     /* is nothrow destructible */
@@ -687,7 +687,7 @@ namespace octa {
     template<typename F, typename T, bool = IsVoid<F>::value
         || IsFunction<T>::value || IsArray<T>::value
     > struct __OctaIsConvertible {
-        typedef typename IsVoid<T>::type type;
+        typedef typename IsVoid<T>::Type Type;
     };
 
     template<typename F, typename T> struct __OctaIsConvertible<F, T, false> {
@@ -699,11 +699,11 @@ namespace octa {
 
         template<typename, typename> static False test(...);
 
-        typedef decltype(test<F, T>(0)) type;
+        typedef decltype(test<F, T>(0)) Type;
     };
 
     template<typename F, typename T>
-    struct IsConvertible: __OctaIsConvertible<F, T>::type {};
+    struct IsConvertible: __OctaIsConvertible<F, T>::Type {};
 
     /* type equality */
 
@@ -740,174 +740,174 @@ namespace octa {
     /* remove const, volatile, cv */
 
     template<typename T>
-    struct __OctaRemoveConst          { typedef T type; };
+    struct __OctaRemoveConst          { typedef T Type; };
     template<typename T>
-    struct __OctaRemoveConst<const T> { typedef T type; };
+    struct __OctaRemoveConst<const T> { typedef T Type; };
 
     template<typename T>
-    struct __OctaRemoveVolatile             { typedef T type; };
+    struct __OctaRemoveVolatile             { typedef T Type; };
     template<typename T>
-    struct __OctaRemoveVolatile<volatile T> { typedef T type; };
+    struct __OctaRemoveVolatile<volatile T> { typedef T Type; };
 
     template<typename T>
     struct __OctaRemoveCv {
         typedef typename __OctaRemoveVolatile<
-            typename __OctaRemoveConst<T>::type
-        >::type type;
+            typename __OctaRemoveConst<T>::Type
+        >::Type Type;
     };
 
     template<typename T>
-    using RemoveConst = typename __OctaRemoveConst<T>::type;
+    using RemoveConst = typename __OctaRemoveConst<T>::Type;
     template<typename T>
-    using RemoveVolatile = typename __OctaRemoveVolatile<T>::type;
+    using RemoveVolatile = typename __OctaRemoveVolatile<T>::Type;
     template<typename T>
-    using RemoveCv = typename __OctaRemoveCv<T>::type;
+    using RemoveCv = typename __OctaRemoveCv<T>::Type;
 
     /* add const, volatile, cv */
 
     template<typename T, bool = IsReference<T>::value
          || IsFunction<T>::value || IsConst<T>::value>
-    struct __Octa__OctaAddConst { typedef T type; };
+    struct __Octa__OctaAddConst { typedef T Type; };
 
     template<typename T> struct __Octa__OctaAddConst<T, false> {
-        typedef const T type;
+        typedef const T Type;
     };
 
     template<typename T> struct __OctaAddConst {
-        typedef typename __Octa__OctaAddConst<T>::type type;
+        typedef typename __Octa__OctaAddConst<T>::Type Type;
     };
 
     template<typename T, bool = IsReference<T>::value
          || IsFunction<T>::value || IsVolatile<T>::value>
-    struct __Octa__OctaAddVolatile { typedef T type; };
+    struct __Octa__OctaAddVolatile { typedef T Type; };
 
     template<typename T> struct __Octa__OctaAddVolatile<T, false> {
-        typedef volatile T type;
+        typedef volatile T Type;
     };
 
     template<typename T> struct __OctaAddVolatile {
-        typedef typename __Octa__OctaAddVolatile<T>::type type;
+        typedef typename __Octa__OctaAddVolatile<T>::Type Type;
     };
 
     template<typename T>
     struct __OctaAddCv {
         typedef typename __OctaAddConst<
-            typename __OctaAddVolatile<T>::type
-        >::type type;
+            typename __OctaAddVolatile<T>::Type
+        >::Type Type;
     };
 
     template<typename T>
-    using AddConst = typename __OctaAddConst<T>::type;
+    using AddConst = typename __OctaAddConst<T>::Type;
     template<typename T>
-    using AddVolatile = typename __OctaAddVolatile<T>::type;
+    using AddVolatile = typename __OctaAddVolatile<T>::Type;
     template<typename T>
-    using AddCv = typename __OctaAddCv<T>::type;
+    using AddCv = typename __OctaAddCv<T>::Type;
 
     /* remove reference */
 
     template<typename T>
-    struct __OctaRemoveReference       { typedef T type; };
+    struct __OctaRemoveReference       { typedef T Type; };
     template<typename T>
-    struct __OctaRemoveReference<T &>  { typedef T type; };
+    struct __OctaRemoveReference<T &>  { typedef T Type; };
     template<typename T>
-    struct __OctaRemoveReference<T &&> { typedef T type; };
+    struct __OctaRemoveReference<T &&> { typedef T Type; };
 
     template<typename T>
-    using RemoveReference = typename __OctaRemoveReference<T>::type;
+    using RemoveReference = typename __OctaRemoveReference<T>::Type;
 
     /* remove pointer */
 
     template<typename T>
-    struct __OctaRemovePointer                     { typedef T type; };
+    struct __OctaRemovePointer                     { typedef T Type; };
     template<typename T>
-    struct __OctaRemovePointer<T *               > { typedef T type; };
+    struct __OctaRemovePointer<T *               > { typedef T Type; };
     template<typename T>
-    struct __OctaRemovePointer<T * const         > { typedef T type; };
+    struct __OctaRemovePointer<T * const         > { typedef T Type; };
     template<typename T>
-    struct __OctaRemovePointer<T * volatile      > { typedef T type; };
+    struct __OctaRemovePointer<T * volatile      > { typedef T Type; };
     template<typename T>
-    struct __OctaRemovePointer<T * const volatile> { typedef T type; };
+    struct __OctaRemovePointer<T * const volatile> { typedef T Type; };
 
     template<typename T>
-    using RemovePointer = typename __OctaRemovePointer<T>::type;
+    using RemovePointer = typename __OctaRemovePointer<T>::Type;
 
     /* add pointer */
 
     template<typename T> struct __OctaAddPointer {
-        typedef typename __OctaRemoveReference<T>::type *type;
+        typedef typename __OctaRemoveReference<T>::Type *Type;
     };
 
     template<typename T>
-    using AddPointer = typename __OctaAddPointer<T>::type;
+    using AddPointer = typename __OctaAddPointer<T>::Type;
 
     /* add lvalue reference */
 
-    template<typename T> struct __OctaAddLr       { typedef T &type; };
-    template<typename T> struct __OctaAddLr<T  &> { typedef T &type; };
-    template<typename T> struct __OctaAddLr<T &&> { typedef T &type; };
+    template<typename T> struct __OctaAddLr       { typedef T &Type; };
+    template<typename T> struct __OctaAddLr<T  &> { typedef T &Type; };
+    template<typename T> struct __OctaAddLr<T &&> { typedef T &Type; };
     template<> struct __OctaAddLr<void> {
-        typedef void type;
+        typedef void Type;
     };
     template<> struct __OctaAddLr<const void> {
-        typedef const void type;
+        typedef const void Type;
     };
     template<> struct __OctaAddLr<volatile void> {
-        typedef volatile void type;
+        typedef volatile void Type;
     };
     template<> struct __OctaAddLr<const volatile void> {
-        typedef const volatile void type;
+        typedef const volatile void Type;
     };
 
     template<typename T>
-    using AddLvalueReference = typename __OctaAddLr<T>::type;
+    using AddLvalueReference = typename __OctaAddLr<T>::Type;
 
     /* add rvalue reference */
 
-    template<typename T> struct __OctaAddRr       { typedef T &&type; };
-    template<typename T> struct __OctaAddRr<T  &> { typedef T &&type; };
-    template<typename T> struct __OctaAddRr<T &&> { typedef T &&type; };
+    template<typename T> struct __OctaAddRr       { typedef T &&Type; };
+    template<typename T> struct __OctaAddRr<T  &> { typedef T &&Type; };
+    template<typename T> struct __OctaAddRr<T &&> { typedef T &&Type; };
     template<> struct __OctaAddRr<void> {
-        typedef void type;
+        typedef void Type;
     };
     template<> struct __OctaAddRr<const void> {
-        typedef const void type;
+        typedef const void Type;
     };
     template<> struct __OctaAddRr<volatile void> {
-        typedef volatile void type;
+        typedef volatile void Type;
     };
     template<> struct __OctaAddRr<const volatile void> {
-        typedef const volatile void type;
+        typedef const volatile void Type;
     };
 
     template<typename T>
-    using AddRvalueReference = typename __OctaAddRr<T>::type;
+    using AddRvalueReference = typename __OctaAddRr<T>::Type;
 
     /* remove extent */
 
     template<typename T>
-    struct __OctaRemoveExtent       { typedef T type; };
+    struct __OctaRemoveExtent       { typedef T Type; };
     template<typename T>
-    struct __OctaRemoveExtent<T[ ]> { typedef T type; };
+    struct __OctaRemoveExtent<T[ ]> { typedef T Type; };
     template<typename T, size_t N>
-    struct __OctaRemoveExtent<T[N]> { typedef T type; };
+    struct __OctaRemoveExtent<T[N]> { typedef T Type; };
 
     template<typename T>
-    using RemoveExtent = typename __OctaRemoveExtent<T>::type;
+    using RemoveExtent = typename __OctaRemoveExtent<T>::Type;
 
     /* remove all extents */
 
-    template<typename T> struct __OctaRemoveAllExtents { typedef T type; };
+    template<typename T> struct __OctaRemoveAllExtents { typedef T Type; };
 
     template<typename T> struct __OctaRemoveAllExtents<T[]> {
-        typedef typename __OctaRemoveAllExtents<T>::type type;
+        typedef typename __OctaRemoveAllExtents<T>::Type Type;
     };
 
     template<typename T, size_t N> struct __OctaRemoveAllExtents<T[N]> {
-        typedef typename __OctaRemoveAllExtents<T>::type type;
+        typedef typename __OctaRemoveAllExtents<T>::Type Type;
     };
 
     template<typename T>
-    using RemoveAllExtents = typename __OctaRemoveAllExtents<T>::type;
+    using RemoveAllExtents = typename __OctaRemoveAllExtents<T>::Type;
 
     /* make (un)signed
      *
@@ -945,49 +945,49 @@ namespace octa {
 
     template<typename T, typename U, size_t N>
     struct __OctaTypeFindFirst<__OctaTl<T, U>, N, true> {
-        typedef T type;
+        typedef T Type;
     };
 
     template<typename T, typename U, size_t N>
     struct __OctaTypeFindFirst<__OctaTl<T, U>, N, false> {
-        typedef typename __OctaTypeFindFirst<U, N>::type type;
+        typedef typename __OctaTypeFindFirst<U, N>::Type Type;
     };
 
     template<typename T, typename U,
-        bool = IsConst<typename __OctaRemoveReference<T>::type>::value,
-        bool = IsVolatile<typename __OctaRemoveReference<T>::type>::value
+        bool = IsConst<typename __OctaRemoveReference<T>::Type>::value,
+        bool = IsVolatile<typename __OctaRemoveReference<T>::Type>::value
     > struct __OctaApplyCv {
-        typedef U type;
+        typedef U Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T, U, true, false> { /* const */
-        typedef const U type;
+        typedef const U Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T, U, false, true> { /* volatile */
-        typedef volatile U type;
+        typedef volatile U Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T, U, true, true> { /* const volatile */
-        typedef const volatile U type;
+        typedef const volatile U Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T &, U, true, false> { /* const */
-        typedef const U &type;
+        typedef const U &Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T &, U, false, true> { /* volatile */
-        typedef volatile U &type;
+        typedef volatile U &Type;
     };
 
     template<typename T, typename U>
     struct __OctaApplyCv<T &, U, true, true> { /* const volatile */
-        typedef const volatile U &type;
+        typedef const volatile U &Type;
     };
 
     template<typename T, bool = IsIntegral<T>::value || IsEnum<T>::value>
@@ -998,73 +998,73 @@ namespace octa {
 
     template<typename T>
     struct __OctaMakeSigned<T, true> {
-        typedef typename __OctaTypeFindFirst<stypes, sizeof(T)>::type type;
+        typedef typename __OctaTypeFindFirst<stypes, sizeof(T)>::Type Type;
     };
 
     template<typename T>
     struct __OctaMakeUnsigned<T, true> {
-        typedef typename __OctaTypeFindFirst<utypes, sizeof(T)>::type type;
+        typedef typename __OctaTypeFindFirst<utypes, sizeof(T)>::Type Type;
     };
 
     template<> struct __OctaMakeSigned<bool  , true> {};
-    template<> struct __OctaMakeSigned<schar , true> { typedef schar type; };
-    template<> struct __OctaMakeSigned<uchar , true> { typedef schar type; };
-    template<> struct __OctaMakeSigned<short , true> { typedef short type; };
-    template<> struct __OctaMakeSigned<ushort, true> { typedef short type; };
-    template<> struct __OctaMakeSigned<int   , true> { typedef int   type; };
-    template<> struct __OctaMakeSigned<uint  , true> { typedef int   type; };
-    template<> struct __OctaMakeSigned<long  , true> { typedef long  type; };
-    template<> struct __OctaMakeSigned<ulong , true> { typedef long  type; };
-    template<> struct __OctaMakeSigned<llong , true> { typedef llong type; };
-    template<> struct __OctaMakeSigned<ullong, true> { typedef llong type; };
+    template<> struct __OctaMakeSigned<schar , true> { typedef schar Type; };
+    template<> struct __OctaMakeSigned<uchar , true> { typedef schar Type; };
+    template<> struct __OctaMakeSigned<short , true> { typedef short Type; };
+    template<> struct __OctaMakeSigned<ushort, true> { typedef short Type; };
+    template<> struct __OctaMakeSigned<int   , true> { typedef int   Type; };
+    template<> struct __OctaMakeSigned<uint  , true> { typedef int   Type; };
+    template<> struct __OctaMakeSigned<long  , true> { typedef long  Type; };
+    template<> struct __OctaMakeSigned<ulong , true> { typedef long  Type; };
+    template<> struct __OctaMakeSigned<llong , true> { typedef llong Type; };
+    template<> struct __OctaMakeSigned<ullong, true> { typedef llong Type; };
 
     template<> struct __OctaMakeUnsigned<bool  , true> {};
-    template<> struct __OctaMakeUnsigned<schar , true> { typedef uchar  type; };
-    template<> struct __OctaMakeUnsigned<uchar , true> { typedef uchar  type; };
-    template<> struct __OctaMakeUnsigned<short , true> { typedef ushort type; };
-    template<> struct __OctaMakeUnsigned<ushort, true> { typedef ushort type; };
-    template<> struct __OctaMakeUnsigned<int   , true> { typedef uint   type; };
-    template<> struct __OctaMakeUnsigned<uint  , true> { typedef uint   type; };
-    template<> struct __OctaMakeUnsigned<long  , true> { typedef ulong  type; };
-    template<> struct __OctaMakeUnsigned<ulong , true> { typedef ulong  type; };
-    template<> struct __OctaMakeUnsigned<llong , true> { typedef ullong type; };
-    template<> struct __OctaMakeUnsigned<ullong, true> { typedef ullong type; };
+    template<> struct __OctaMakeUnsigned<schar , true> { typedef uchar  Type; };
+    template<> struct __OctaMakeUnsigned<uchar , true> { typedef uchar  Type; };
+    template<> struct __OctaMakeUnsigned<short , true> { typedef ushort Type; };
+    template<> struct __OctaMakeUnsigned<ushort, true> { typedef ushort Type; };
+    template<> struct __OctaMakeUnsigned<int   , true> { typedef uint   Type; };
+    template<> struct __OctaMakeUnsigned<uint  , true> { typedef uint   Type; };
+    template<> struct __OctaMakeUnsigned<long  , true> { typedef ulong  Type; };
+    template<> struct __OctaMakeUnsigned<ulong , true> { typedef ulong  Type; };
+    template<> struct __OctaMakeUnsigned<llong , true> { typedef ullong Type; };
+    template<> struct __OctaMakeUnsigned<ullong, true> { typedef ullong Type; };
 
     template<typename T> struct __OctaMakeSignedBase {
         typedef typename __OctaApplyCv<T,
             typename __OctaMakeSigned<
-                typename __OctaRemoveCv<T>::type
-            >::type
-        >::type type;
+                typename __OctaRemoveCv<T>::Type
+            >::Type
+        >::Type Type;
     };
 
     template<typename T> struct __OctaMakeUnsignedBase {
         typedef typename __OctaApplyCv<T,
             typename __OctaMakeUnsigned<
-                typename __OctaRemoveCv<T>::type
-            >::type
-        >::type type;
+                typename __OctaRemoveCv<T>::Type
+            >::Type
+        >::Type Type;
     };
 
     template<typename T>
-    using MakeSigned = typename __OctaMakeSignedBase<T>::type;
+    using MakeSigned = typename __OctaMakeSignedBase<T>::Type;
     template<typename T>
-    using MakeUnsigned = typename __OctaMakeUnsignedBase<T>::type;
+    using MakeUnsigned = typename __OctaMakeUnsignedBase<T>::Type;
 
     /* conditional */
 
     template<bool cond, typename T, typename U>
     struct __OctaConditional {
-        typedef T type;
+        typedef T Type;
     };
 
     template<typename T, typename U>
     struct __OctaConditional<false, T, U> {
-        typedef U type;
+        typedef U Type;
     };
 
     template<bool cond, typename T, typename U>
-    using Conditional = typename __OctaConditional<cond, T, U>::type;
+    using Conditional = typename __OctaConditional<cond, T, U>::Type;
 
     /* result of call at compile time */
 
@@ -1108,57 +1108,57 @@ namespace octa {
     template<typename T> struct __OctaResultOfBase: __OctaResultOf<T> {};
 
     template<typename T>
-    using ResultOf = typename __OctaResultOfBase<T>::type;
+    using ResultOf = typename __OctaResultOfBase<T>::Type;
 
     /* enable if */
 
     template<bool B, typename T = void> struct __OctaEnableIf {};
 
-    template<typename T> struct __OctaEnableIf<true, T> { typedef T type; };
+    template<typename T> struct __OctaEnableIf<true, T> { typedef T Type; };
 
     template<bool B, typename T = void>
-    using EnableIf = typename __OctaEnableIf<B, T>::type;
+    using EnableIf = typename __OctaEnableIf<B, T>::Type;
 
     /* decay */
 
     template<typename T>
     struct __OctaDecay {
     private:
-        typedef typename __OctaRemoveReference<T>::type U;
+        typedef typename __OctaRemoveReference<T>::Type U;
     public:
         typedef typename __OctaConditional<IsArray<U>::value,
-            typename __OctaRemoveExtent<U>::type *,
+            typename __OctaRemoveExtent<U>::Type *,
             typename __OctaConditional<IsFunction<U>::value,
-                typename __OctaAddPointer<U>::type,
-                typename __OctaRemoveCv<U>::type
-            >::type
-        >::type type;
+                typename __OctaAddPointer<U>::Type,
+                typename __OctaRemoveCv<U>::Type
+            >::Type
+        >::Type Type;
     };
 
     template<typename T>
-    using Decay = typename __OctaDecay<T>::type;
+    using Decay = typename __OctaDecay<T>::Type;
 
     /* common type */
 
     template<typename ...T> struct __OctaCommonType;
 
     template<typename T> struct __OctaCommonType<T> {
-        typedef __OctaDecay<T> type;
+        typedef __OctaDecay<T> Type;
     };
 
     template<typename T, typename U> struct __OctaCommonType<T, U> {
         typedef __OctaDecay<decltype(true ? __octa_declval<T>()
-            : __octa_declval<U>())> type;
+            : __octa_declval<U>())> Type;
     };
 
     template<typename T, typename U, typename ...V>
     struct __OctaCommonType<T, U, V...> {
-        typedef typename __OctaCommonType<typename __OctaCommonType<T, U>::type,
-            V...>::type type;
+        typedef typename __OctaCommonType<typename __OctaCommonType<T, U>::Type,
+            V...>::Type Type;
     };
 
     template<typename T, typename U, typename ...V>
-    using CommonType = typename __OctaCommonType<T, U, V...>::type;
+    using CommonType = typename __OctaCommonType<T, U, V...>::Type;
 
     /* aligned storage */
 
@@ -1176,8 +1176,8 @@ namespace octa {
     };
 
     template<size_t N, size_t A
-        = alignof(typename __OctaAlignedTest<N>::type)
-    > using AlignedStorage = typename __OctaAlignedStorage<N, A>::type;
+        = alignof(typename __OctaAlignedTest<N>::Type)
+    > using AlignedStorage = typename __OctaAlignedStorage<N, A>::Type;
 
     /* aligned union */
 
@@ -1208,7 +1208,7 @@ namespace octa {
     };
 
     template<size_t N, typename ...T>
-    using AlignedUnion = typename __OctaAlignedUnion<N, T...>::type;
+    using AlignedUnion = typename __OctaAlignedUnion<N, T...>::Type;
 
     /* underlying type */
 
@@ -1217,11 +1217,11 @@ namespace octa {
     template<typename T> struct __OctaUnderlyingType<T, true> {
         typedef typename __OctaConditional<IsSigned<T>::value,
             MakeSigned<T>, MakeUnsigned<T>
-        >::type type;
+        >::Type Type;
     };
 
     template<typename T>
-    using UnderlyingType = typename __OctaUnderlyingType<T>::type;
+    using UnderlyingType = typename __OctaUnderlyingType<T>::Type;
 }
 
 #endif
\ No newline at end of file