diff --git a/octa/functional.h b/octa/functional.h
index d27a6be..6919c89 100644
--- a/octa/functional.h
+++ b/octa/functional.h
@@ -259,7 +259,7 @@ namespace octa {
 
     struct __OctaFunctionManager;
 
-    struct __OctaFMStorage {
+    struct __OctaFmStorage {
         __OctaFunctorData data;
         const __OctaFunctionManager *manager;
     };
@@ -277,15 +277,15 @@ namespace octa {
             };
         }
 
-        void (* const call_move_and_destroy)(__OctaFMStorage &lhs,
-            __OctaFMStorage &&rhs);
-        void (* const call_copy)(__OctaFMStorage &lhs,
-            const __OctaFMStorage &rhs);
-        void (* const call_destroy)(__OctaFMStorage &s);
+        void (* const call_move_and_destroy)(__OctaFmStorage &lhs,
+            __OctaFmStorage &&rhs);
+        void (* const call_copy)(__OctaFmStorage &lhs,
+            const __OctaFmStorage &rhs);
+        void (* const call_destroy)(__OctaFmStorage &s);
 
         template<typename T>
-        static void t_call_move_and_destroy(__OctaFMStorage &lhs,
-        __OctaFMStorage &&rhs) {
+        static void t_call_move_and_destroy(__OctaFmStorage &lhs,
+        __OctaFmStorage &&rhs) {
             typedef __OctaFunctorDataManager<T> spec;
             spec::move_f(lhs.data, move(rhs.data));
             spec::destroy_f(rhs.data);
@@ -293,15 +293,15 @@ namespace octa {
         }
 
         template<typename T>
-        static void t_call_copy(__OctaFMStorage &lhs,
-        const __OctaFMStorage &rhs) {
+        static void t_call_copy(__OctaFmStorage &lhs,
+        const __OctaFmStorage &rhs) {
             typedef __OctaFunctorDataManager<T> spec;
             lhs.manager = &__octa_get_default_fm<T>();
             spec::store_f(lhs.data, spec::get_ref(rhs.data));
         }
 
         template<typename T>
-        static void t_call_destroy(__OctaFMStorage &s) {
+        static void t_call_destroy(__OctaFmStorage &s) {
             typedef __OctaFunctorDataManager<T> spec;
             spec::destroy_f(s.data);
         }
@@ -381,7 +381,7 @@ namespace octa {
         }
 
         void swap(Function &f) {
-            __OctaFMStorage tmp;
+            __OctaFmStorage tmp;
             f.p_stor.manager->call_move_and_destroy(tmp, move(f.p_stor));
             p_stor.manager->call_move_and_destroy(f.p_stor, move(p_stor));
             tmp.manager->call_move_and_destroy(p_stor, move(tmp));
@@ -391,7 +391,7 @@ namespace octa {
         operator bool() const { return p_call != nullptr; }
 
     private:
-        __OctaFMStorage p_stor;
+        __OctaFmStorage p_stor;
         R (*p_call)(const __OctaFunctorData &, A...);
 
         template<typename T>
diff --git a/octa/memory.h b/octa/memory.h
index 31b011d..8deca1a 100644
--- a/octa/memory.h
+++ b/octa/memory.h
@@ -105,11 +105,11 @@ namespace octa {
         using rebind = typename __OctaPtrTraitsRebind<T, U>::type;
 
     private:
-        struct __OctaNAT {};
+        struct __OctaNat {};
 
     public:
         static T pointer_to(Conditional<IsVoid<element_type>::value,
-            __OctaNAT, element_type
+            __OctaNat, element_type
         > &r) {
             return T::pointer_to(r);
         }
@@ -125,11 +125,11 @@ namespace octa {
         template<typename U> using rebind = U *;
 
     private:
-        struct __OctaNAT {};
+        struct __OctaNat {};
 
     public:
         static T pointer_to(Conditional<IsVoid<element_type>::value,
-            __OctaNAT, element_type
+            __OctaNat, element_type
         > &r) {
             return octa::address_of(r);
         }
@@ -191,7 +191,7 @@ namespace octa {
         typedef typename __OctaPtrType<T, D>::type pointer;
 
     private:
-        struct __OctaNAT { int x; };
+        struct __OctaNat { int x; };
 
         typedef RemoveReference<D> &D_ref;
         typedef const RemoveReference<D> &D_cref;
@@ -227,7 +227,7 @@ namespace octa {
             && IsConvertible<typename Box<TT, DD>::pointer, pointer>::value
             && IsConvertible<DD, D>::value
             && (!IsReference<D>::value || IsSame<D, DD>::value)
-        > = __OctaNAT()): p_ptr(u.release()),
+        > = __OctaNat()): p_ptr(u.release()),
             p_del(forward<DD>(u.get_deleter())) {}
 
         Box &operator=(Box &&u) {
@@ -288,19 +288,19 @@ namespace octa {
     };
 
     template<typename T, typename U, bool = IsSame<
-        RemoveCV<typename PointerTraits<T>::element_type>,
-        RemoveCV<typename PointerTraits<U>::element_type>
-    >::value> struct __OctaSameOrLessCVQualifiedBase: IsConvertible<T, U> {};
+        RemoveCv<typename PointerTraits<T>::element_type>,
+        RemoveCv<typename PointerTraits<U>::element_type>
+    >::value> struct __OctaSameOrLessCvQualifiedBase: IsConvertible<T, U> {};
 
     template<typename T, typename U>
-    struct __OctaSameOrLessCVQualifiedBase<T, U, false>: False {};
+    struct __OctaSameOrLessCvQualifiedBase<T, U, false>: False {};
 
     template<typename T, typename U, bool = IsPointer<T>::value
         || IsSame<T, U>::value || __OctaHasElementType<T>::value
-    > struct __OctaSameOrLessCVQualified: __OctaSameOrLessCVQualifiedBase<T, U> {};
+    > struct __OctaSameOrLessCvQualified: __OctaSameOrLessCvQualifiedBase<T, U> {};
 
     template<typename T, typename U>
-    struct __OctaSameOrLessCVQualified<T, U, false>: False {};
+    struct __OctaSameOrLessCvQualified<T, U, false>: False {};
 
     template<typename T, typename D>
     struct Box<T[], D> {
@@ -309,7 +309,7 @@ namespace octa {
         typedef typename __OctaPtrType<T, D>::type pointer;
 
     private:
-        struct __OctaNAT { int x; };
+        struct __OctaNat { int x; };
 
         typedef RemoveReference<D> &D_ref;
         typedef const RemoveReference<D> &D_cref;
@@ -325,24 +325,24 @@ namespace octa {
         }
 
         template<typename U> explicit Box(U p, EnableIf<
-            __OctaSameOrLessCVQualified<U, pointer>::value, __OctaNAT
-        > = __OctaNAT()): p_ptr(p), p_del() {
+            __OctaSameOrLessCvQualified<U, pointer>::value, __OctaNat
+        > = __OctaNat()): p_ptr(p), p_del() {
             static_assert(!IsPointer<D>::value,
                 "Box constructed with null fptr deleter");
         }
 
         template<typename U> Box(U p, Conditional<IsReference<D>::value,
             D, AddLvalueReference<const D>
-        > d, EnableIf<__OctaSameOrLessCVQualified<U, pointer>::value, __OctaNAT
-        > = __OctaNAT()): p_ptr(p), p_del(d) {}
+        > d, EnableIf<__OctaSameOrLessCvQualified<U, pointer>::value, __OctaNat
+        > = __OctaNat()): p_ptr(p), p_del(d) {}
 
         Box(nullptr_t, Conditional<IsReference<D>::value,
             D, AddLvalueReference<const D>
         > d): p_ptr(), p_del(d) {}
 
         template<typename U> Box(U p, RemoveReference<D> &&d, EnableIf<
-            __OctaSameOrLessCVQualified<U, pointer>::value, __OctaNAT
-        > = __OctaNAT()): p_ptr(p), p_del(move(d)) {
+            __OctaSameOrLessCvQualified<U, pointer>::value, __OctaNat
+        > = __OctaNat()): p_ptr(p), p_del(move(d)) {
             static_assert(!IsReference<D>::value,
                 "rvalue deleter cannot be a ref");
         }
@@ -356,10 +356,10 @@ namespace octa {
 
         template<typename TT, typename DD>
         Box(Box<TT, DD> &&u, EnableIf<IsArray<TT>::value
-            && __OctaSameOrLessCVQualified<typename Box<TT, DD>::pointer,
+            && __OctaSameOrLessCvQualified<typename Box<TT, DD>::pointer,
                                            pointer>::value
             && IsConvertible<DD, D>::value
-            && (!IsReference<D>::value || IsSame<D, DD>::value)> = __OctaNAT()
+            && (!IsReference<D>::value || IsSame<D, DD>::value)> = __OctaNat()
         ): p_ptr(u.release()), p_del(forward<DD>(u.get_deleter())) {}
 
         Box &operator=(Box &&u) {
@@ -370,7 +370,7 @@ namespace octa {
 
         template<typename TT, typename DD>
         EnableIf<IsArray<TT>::value
-            && __OctaSameOrLessCVQualified<typename Box<TT, DD>::pointer,
+            && __OctaSameOrLessCvQualified<typename Box<TT, DD>::pointer,
                                            pointer>::value
             && IsAssignable<D &, DD &&>::value,
             Box &
@@ -405,7 +405,7 @@ namespace octa {
         }
 
         template<typename U> EnableIf<
-            __OctaSameOrLessCVQualified<U, pointer>::value, void
+            __OctaSameOrLessCvQualified<U, pointer>::value, void
         > reset(U p) {
             pointer tmp = p_ptr;
             p_ptr = p;
diff --git a/octa/type_traits.h b/octa/type_traits.h
index 908429d..cb7f786 100644
--- a/octa/type_traits.h
+++ b/octa/type_traits.h
@@ -13,9 +13,9 @@
 namespace octa {
     /* forward declarations */
 
-    template<typename> struct __OctaRemoveCV;
-    template<typename> struct __OctaAddLR;
-    template<typename> struct __OctaAddRR;
+    template<typename> struct __OctaRemoveCv;
+    template<typename> struct __OctaAddLr;
+    template<typename> struct __OctaAddRr;
     template<typename> struct __OctaAddConst;
     template<typename> struct IsReference;
     template<typename> struct __OctaRemoveReference;
@@ -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 */
 
@@ -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 */
 
@@ -249,7 +249,7 @@ namespace octa {
 
     /* is POD */
 
-    template<typename T> struct IsPOD: IntegralConstant<bool, __is_pod(T)> {};
+    template<typename T> struct IsPod: IntegralConstant<bool, __is_pod(T)> {};
 
     /* is polymorphic */
 
@@ -399,13 +399,13 @@ 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 */
@@ -430,15 +430,15 @@ 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 */
@@ -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 */
@@ -747,7 +747,7 @@ namespace octa {
     struct __OctaRemoveVolatile<volatile T> { typedef T type; };
 
     template<typename T>
-    struct __OctaRemoveCV {
+    struct __OctaRemoveCv {
         typedef typename __OctaRemoveVolatile<
             typename __OctaRemoveConst<T>::type
         >::type type;
@@ -758,7 +758,7 @@ namespace octa {
     template<typename T>
     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 */
 
@@ -787,7 +787,7 @@ namespace octa {
     };
 
     template<typename T>
-    struct __OctaAddCV {
+    struct __OctaAddCv {
         typedef typename __OctaAddConst<
             typename __OctaAddVolatile<T>::type
         >::type type;
@@ -798,7 +798,7 @@ namespace octa {
     template<typename T>
     using AddVolatile = typename __OctaAddVolatile<T>::type;
     template<typename T>
-    using AddCV = typename __OctaAddCV<T>::type;
+    using AddCv = typename __OctaAddCv<T>::type;
 
     /* remove reference */
 
@@ -839,45 +839,45 @@ namespace octa {
 
     /* 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<> struct __OctaAddLR<void> {
+    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;
     };
-    template<> struct __OctaAddLR<const void> {
+    template<> struct __OctaAddLr<const void> {
         typedef const void type;
     };
-    template<> struct __OctaAddLR<volatile void> {
+    template<> struct __OctaAddLr<volatile void> {
         typedef volatile void type;
     };
-    template<> struct __OctaAddLR<const volatile void> {
+    template<> struct __OctaAddLr<const volatile void> {
         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<> struct __OctaAddRR<void> {
+    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;
     };
-    template<> struct __OctaAddRR<const void> {
+    template<> struct __OctaAddRr<const void> {
         typedef const void type;
     };
-    template<> struct __OctaAddRR<volatile void> {
+    template<> struct __OctaAddRr<volatile void> {
         typedef volatile void type;
     };
-    template<> struct __OctaAddRR<const volatile void> {
+    template<> struct __OctaAddRr<const volatile void> {
         typedef const volatile void type;
     };
 
     template<typename T>
-    using AddRvalueReference = typename __OctaAddRR<T>::type;
+    using AddRvalueReference = typename __OctaAddRr<T>::type;
 
     /* remove extent */
 
@@ -912,78 +912,78 @@ namespace octa {
      * shamelessly copied from graphitemaster @ neothyne
      */
 
-    template<typename T, typename U> struct __OctaTL {
+    template<typename T, typename U> struct __OctaTl {
         typedef T first;
         typedef U rest;
     };
 
     /* not a type */
-    struct __OctaNAT {
-        __OctaNAT() = delete;
-        __OctaNAT(const __OctaNAT &) = delete;
-        __OctaNAT &operator=(const __OctaNAT &) = delete;
-        ~__OctaNAT() = delete;
+    struct __OctaNat {
+        __OctaNat() = delete;
+        __OctaNat(const __OctaNat &) = delete;
+        __OctaNat &operator=(const __OctaNat &) = delete;
+        ~__OctaNat() = delete;
     };
 
-    typedef __OctaTL<schar,
-            __OctaTL<short,
-            __OctaTL<int,
-            __OctaTL<long,
-            __OctaTL<llong, __OctaNAT>>>>> stypes;
+    typedef __OctaTl<schar,
+            __OctaTl<short,
+            __OctaTl<int,
+            __OctaTl<long,
+            __OctaTl<llong, __OctaNat>>>>> stypes;
 
-    typedef __OctaTL<uchar,
-            __OctaTL<ushort,
-            __OctaTL<uint,
-            __OctaTL<ulong,
-            __OctaTL<ullong, __OctaNAT>>>>> utypes;
+    typedef __OctaTl<uchar,
+            __OctaTl<ushort,
+            __OctaTl<uint,
+            __OctaTl<ulong,
+            __OctaTl<ullong, __OctaNat>>>>> utypes;
 
     template<typename T, size_t N, bool = (N <= sizeof(typename T::first))>
     struct __OctaTypeFindFirst;
 
     template<typename T, typename U, size_t N>
-    struct __OctaTypeFindFirst<__OctaTL<T, U>, N, true> {
+    struct __OctaTypeFindFirst<__OctaTl<T, U>, N, true> {
         typedef T type;
     };
 
     template<typename T, typename U, size_t N>
-    struct __OctaTypeFindFirst<__OctaTL<T, U>, N, false> {
+    struct __OctaTypeFindFirst<__OctaTl<T, U>, N, false> {
         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
-    > struct __OctaApplyCV {
+    > struct __OctaApplyCv {
         typedef U type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T, U, true, false> { /* const */
+    struct __OctaApplyCv<T, U, true, false> { /* const */
         typedef const U type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T, U, false, true> { /* volatile */
+    struct __OctaApplyCv<T, U, false, true> { /* volatile */
         typedef volatile U type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T, U, true, true> { /* const volatile */
+    struct __OctaApplyCv<T, U, true, true> { /* const volatile */
         typedef const volatile U type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T &, U, true, false> { /* const */
+    struct __OctaApplyCv<T &, U, true, false> { /* const */
         typedef const U &type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T &, U, false, true> { /* volatile */
+    struct __OctaApplyCv<T &, U, false, true> { /* volatile */
         typedef volatile U &type;
     };
 
     template<typename T, typename U>
-    struct __OctaApplyCV<T &, U, true, true> { /* const volatile */
+    struct __OctaApplyCv<T &, U, true, true> { /* const volatile */
         typedef const volatile U &type;
     };
 
@@ -1028,17 +1028,17 @@ namespace octa {
     template<> struct __OctaMakeUnsigned<ullong, true> { typedef ullong type; };
 
     template<typename T> struct __OctaMakeSignedBase {
-        typedef typename __OctaApplyCV<T,
+        typedef typename __OctaApplyCv<T,
             typename __OctaMakeSigned<
-                typename __OctaRemoveCV<T>::type
+                typename __OctaRemoveCv<T>::type
             >::type
         >::type type;
     };
 
     template<typename T> struct __OctaMakeUnsignedBase {
-        typedef typename __OctaApplyCV<T,
+        typedef typename __OctaApplyCv<T,
             typename __OctaMakeUnsigned<
-                typename __OctaRemoveCV<T>::type
+                typename __OctaRemoveCv<T>::type
             >::type
         >::type type;
     };
@@ -1127,7 +1127,7 @@ namespace octa {
             typename __OctaRemoveExtent<U>::type *,
             typename __OctaConditional<IsFunction<U>::value,
                 typename __OctaAddPointer<U>::type,
-                typename __OctaRemoveCV<U>::type
+                typename __OctaRemoveCv<U>::type
             >::type
         >::type type;
     };
diff --git a/octa/vector.h b/octa/vector.h
index 9381e5a..0e27504 100644
--- a/octa/vector.h
+++ b/octa/vector.h
@@ -76,7 +76,7 @@ namespace octa {
 
         void clear() {
             if (p_cap > 0) {
-                if (!octa::IsPOD<T>()) {
+                if (!octa::IsPod<T>()) {
                     T *cur = p_buf, *last = p_buf + p_len;
                     while (cur != last) (*cur++).~T();
                 }
@@ -90,7 +90,7 @@ namespace octa {
             if (this == &v) return *this;
 
             if (p_cap >= v.p_cap) {
-                if (!octa::IsPOD<T>()) {
+                if (!octa::IsPod<T>()) {
                     T *cur = p_buf, *last = p_buf + p_len;
                     while (cur != last) (*cur++).~T();
                 }
@@ -102,7 +102,7 @@ namespace octa {
                 p_buf = (T *)new uchar[p_cap * sizeof(T)];
             }
 
-            if (octa::IsPOD<T>()) {
+            if (octa::IsPod<T>()) {
                 memcpy(p_buf, v.p_buf, p_len * sizeof(T));
             } else {
                 T *cur = p_buf, *last = p_buf + p_len;
@@ -127,7 +127,7 @@ namespace octa {
             size_t len = p_len;
             reserve(n);
             p_len = n;
-            if (octa::IsPOD<T>()) {
+            if (octa::IsPod<T>()) {
                 for (size_t i = len; i < p_len; ++i) {
                     p_buf[i] = T(v);
                 }
@@ -152,7 +152,7 @@ namespace octa {
             }
             T *tmp = (T *)new uchar[p_cap * sizeof(T)];
             if (oc > 0) {
-                if (octa::IsPOD<T>()) {
+                if (octa::IsPod<T>()) {
                     memcpy(tmp, p_buf, p_len * sizeof(T));
                 } else {
                     T *cur = p_buf, *tcur = tmp, *last = tmp + p_len;
@@ -193,7 +193,7 @@ namespace octa {
         }
 
         void pop() {
-            if (!octa::IsPOD<T>()) {
+            if (!octa::IsPod<T>()) {
                 p_buf[--p_len].~T();
             } else {
                 --p_len;