diff --git a/cmake/ProjectGlobalMacros.cmake b/cmake/ProjectGlobalMacros.cmake
index 315d51d..3cbce7d 100644
--- a/cmake/ProjectGlobalMacros.cmake
+++ b/cmake/ProjectGlobalMacros.cmake
@@ -131,7 +131,7 @@ macro(project_enable_clang_format)
 if (NOT ${CLANG_FORMAT_EXE} STREQUAL "CLANG_FORMAT_EXE-NOTFOUND")
   message("-- clang-format found, whole source formatting enabled through 'format' target.")
   add_custom_target(format
-    COMMAND find ./src -type f -regex .*\\.h\\\|.*\\.hpp\\\|.*\\.hxx\\\|.*\\.c\\\|.*\\.cpp\\\|.*\\.cxx\\\|.*\\.cc -exec clang-format -i {} \;
+    COMMAND find ./includes -type f -regex .*\\.h\\\|.*\\.hpp\\\|.*\\.hxx\\\|.*\\.c\\\|.*\\.cpp\\\|.*\\.cxx\\\|.*\\.cc -exec clang-format -i {} \;
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
     VERBATIM
   )
diff --git a/cmake/ProjectTestFunctions.cmake b/cmake/ProjectTestFunctions.cmake
index 68a735b..8f22865 100644
--- a/cmake/ProjectTestFunctions.cmake
+++ b/cmake/ProjectTestFunctions.cmake
@@ -1,4 +1,4 @@
-# This file provides function to add tests tp ctest
+# This file prmvides function to add tests tp ctest
 # with additional tooling
 
 ##
diff --git a/includes/named_types/extensions/factory.hpp b/includes/named_types/extensions/factory.hpp
index ede19f2..b494ca0 100644
--- a/includes/named_types/extensions/factory.hpp
+++ b/includes/named_types/extensions/factory.hpp
@@ -8,8 +8,8 @@ namespace extensions {
 namespace __factory_impl {
 template <class T, class Base, class... Args>
 std::function<Base*(Args...)> make_builder() {
-  return ([](Args... args) -> Base *
-          { return new T(std::forward<Args>(args)...); });
+  return (
+      [](Args... args) -> Base* { return new T(std::forward<Args>(args)...); });
 }
 } // namespace __factory_impl
 
@@ -25,8 +25,7 @@ template <class BaseClass, class... T> class factory {
         named_tuple<typename id<std::function<BaseClass*(BuildArgs...)>(
             __ntuple_tag_spec_t<T>)>::type...>;
     static builder_tuple_type const builders_{
-        __factory_impl::make_builder<__ntuple_tag_elem_t<T>,
-                                     BaseClass,
+        __factory_impl::make_builder<__ntuple_tag_elem_t<T>, BaseClass,
                                      BuildArgs...>()...};
     static const_rt_view<builder_tuple_type> const rt_view_(builders_);
     auto builder =
diff --git a/includes/named_types/extensions/generation_tools.hpp b/includes/named_types/extensions/generation_tools.hpp
index 2624b60..5ea9044 100644
--- a/includes/named_types/extensions/generation_tools.hpp
+++ b/includes/named_types/extensions/generation_tools.hpp
@@ -1,9 +1,9 @@
 #pragma once
-#include <type_traits>
-#include <cstdint>
+#include "named_types/extensions/type_traits.hpp"
 #include "named_types/named_tuple.hpp"
 #include "named_types/rt_named_tuple.hpp"
-#include "named_types/extensions/type_traits.hpp"
+#include <cstdint>
+#include <type_traits>
 
 namespace named_types {
 namespace extensions {
@@ -11,7 +11,7 @@ namespace generation {
 
 template <class T> struct printf_sequence {
   using type = void;
-  static T evaluate(T value){ return value; };
+  static T evaluate(T value) { return value; };
 };
 
 template <> struct printf_sequence<char const*> {
@@ -61,7 +61,7 @@ template <> struct printf_sequence<double> {
   static inline double evaluate(double data) { return data; };
 };
 
-//template <typename ... T> forward_as_flattened_tuple(
+// template <typename ... T> forward_as_flattened_tuple(
 
 } // namespace generation
 } // namespace extensions
diff --git a/includes/named_types/extensions/parsing_tools.hpp b/includes/named_types/extensions/parsing_tools.hpp
index f41cd56..205ad09 100644
--- a/includes/named_types/extensions/parsing_tools.hpp
+++ b/includes/named_types/extensions/parsing_tools.hpp
@@ -1,13 +1,13 @@
 #pragma once
-#include <type_traits>
+#include "named_types/extensions/type_traits.hpp"
+#include "named_types/named_tuple.hpp"
+#include "named_types/rt_named_tuple.hpp"
 #include <cstdint>
-#include <vector>
 #include <list>
 #include <map>
+#include <type_traits>
 #include <unordered_map>
-#include "named_types/named_tuple.hpp"
-#include "named_types/rt_named_tuple.hpp"
-#include "named_types/extensions/type_traits.hpp"
+#include <vector>
 
 namespace named_types {
 namespace extensions {
@@ -20,9 +20,9 @@ inline std::enable_if_t<std::is_arithmetic<From>::value &&
                             is_std_basic_string<To>::value,
                         To>
 lexical_cast(From const& value) {
-  std::basic_ostringstream<typename To::value_type,
-                           typename To::traits_type,
-                           typename To::allocator_type> output;
+  std::basic_ostringstream<typename To::value_type, typename To::traits_type,
+                           typename To::allocator_type>
+      output;
   output << value;
   return output.str();
 }
@@ -49,10 +49,9 @@ lexical_cast(From const& value) {
 }
 
 template <class To, class From>
-inline std::enable_if_t<is_raw_string<From>::value &&
-                            std::is_arithmetic<To>::value,
-                        To>
-lexical_cast(From const& value) {
+inline std::
+    enable_if_t<is_raw_string<From>::value && std::is_arithmetic<To>::value, To>
+    lexical_cast(From const& value) {
   To result{};
   std::istringstream(value) >> result;
   return result;
@@ -63,8 +62,9 @@ template <class Source, class Tuple, size_t Index>
 inline std::enable_if_t<tuple_member_assignable<Source, Tuple, Index>::value,
                         std::function<void(Tuple&, Source&&)>>
 make_setter() {
-  return [](Tuple& tuple, Source&& source)
-      -> void { std::get<Index>(tuple) = std::move(source); };
+  return [](Tuple& tuple, Source&& source) -> void {
+    std::get<Index>(tuple) = std::move(source);
+  };
 }
 
 template <class Source, class Tuple, size_t Index>
@@ -144,11 +144,9 @@ inline std::enable_if_t<
     std::function<
         value_setter_interface<KeyCharT, ValueCharT, SizeType>*(Tuple&)>>
 make_creator() {
-  return [](Tuple & tuple)
-      -> value_setter_interface<KeyCharT, ValueCharT, SizeType> * {
-    return new value_setter<KeyCharT,
-                            ValueCharT,
-                            SizeType,
+  return [](Tuple& tuple)
+             -> value_setter_interface<KeyCharT, ValueCharT, SizeType>* {
+    return new value_setter<KeyCharT, ValueCharT, SizeType,
                             std::tuple_element_t<Index, Tuple>>(
         std::get<Index>(tuple));
   };
@@ -177,11 +175,9 @@ inline std::enable_if_t<
     std::function<
         sequence_pusher_interface<KeyCharT, ValueCharT, SizeType>*(Tuple&)>>
 make_sequence_creator() {
-  return [](Tuple & tuple)
-      -> sequence_pusher_interface<KeyCharT, ValueCharT, SizeType> * {
-    return new sequence_pusher<KeyCharT,
-                               ValueCharT,
-                               SizeType,
+  return [](Tuple& tuple)
+             -> sequence_pusher_interface<KeyCharT, ValueCharT, SizeType>* {
+    return new sequence_pusher<KeyCharT, ValueCharT, SizeType,
                                std::tuple_element_t<Index, Tuple>>(
         std::get<Index>(tuple));
   };
@@ -346,12 +342,11 @@ class value_setter<KeyCharT, ValueCharT, SizeType, named_tuple<Tags...>>
   rt_view<Tuple> rt_root_;
 
   template <class T> bool setFrom(size_t field_index, T&& value) {
-    static std::array<std::function<void(Tuple&, T && )>, Tuple::size> setters =
+    static std::array<std::function<void(Tuple&, T &&)>, Tuple::size> setters =
         {make_setter<
-            T,
-            Tuple,
+            T, Tuple,
             Tuple::template tag_index<__ntuple_tag_spec_t<Tags>>::value>()...};
-    std::function<void(Tuple&, T && )> setter(
+    std::function<void(Tuple&, T &&)> setter(
         field_index < setters.size() ? setters[field_index] : nullptr);
     if (setter) {
       setter(root_, std::move(value));
@@ -409,20 +404,17 @@ class value_setter<KeyCharT, ValueCharT, SizeType, named_tuple<Tags...>>
 
   virtual value_setter_interface<KeyCharT, ValueCharT, SizeType>*
   createChildNode(std::basic_string<KeyCharT> const& key) override {
-    static std::array<
-        std::function<
-            value_setter_interface<KeyCharT, ValueCharT, SizeType>*(Tuple&)>,
-        Tuple::size> creators = {
-        make_creator<
-            KeyCharT,
-            ValueCharT,
-            SizeType,
-            Tuple,
+    static std::array<std::function<value_setter_interface<KeyCharT, ValueCharT,
+                                                           SizeType>*(Tuple&)>,
+                      Tuple::size>
+        creators = {make_creator<
+            KeyCharT, ValueCharT, SizeType, Tuple,
             Tuple::template tag_index<__ntuple_tag_spec_t<Tags>>::value>()...};
     size_t field_index = rt_root_.index_of(key);
     if (field_index < creators.size()) {
       std::function<value_setter_interface<KeyCharT, ValueCharT, SizeType>*(
-          Tuple&)> creator = creators[field_index];
+          Tuple&)>
+          creator = creators[field_index];
       if (creator)
         return creator(root_);
     }
@@ -431,20 +423,17 @@ class value_setter<KeyCharT, ValueCharT, SizeType, named_tuple<Tags...>>
 
   virtual sequence_pusher_interface<KeyCharT, ValueCharT, SizeType>*
   createChildSequence(std::basic_string<KeyCharT> const& key) override {
-    static std::array<
-        std::function<
-            sequence_pusher_interface<KeyCharT, ValueCharT, SizeType>*(Tuple&)>,
-        Tuple::size> creators = {
-        make_sequence_creator<
-            KeyCharT,
-            ValueCharT,
-            SizeType,
-            Tuple,
+    static std::array<std::function<sequence_pusher_interface<
+                          KeyCharT, ValueCharT, SizeType>*(Tuple&)>,
+                      Tuple::size>
+        creators = {make_sequence_creator<
+            KeyCharT, ValueCharT, SizeType, Tuple,
             Tuple::template tag_index<__ntuple_tag_spec_t<Tags>>::value>()...};
     size_t field_index = rt_root_.index_of(key);
     if (field_index < creators.size()) {
       std::function<sequence_pusher_interface<KeyCharT, ValueCharT, SizeType>*(
-          Tuple&)> creator = creators[field_index];
+          Tuple&)>
+          creator = creators[field_index];
       if (creator)
         return creator(root_);
     }
diff --git a/includes/named_types/extensions/rapidjson.hpp b/includes/named_types/extensions/rapidjson.hpp
index 38c0a7b..ffaba63 100644
--- a/includes/named_types/extensions/rapidjson.hpp
+++ b/includes/named_types/extensions/rapidjson.hpp
@@ -1,12 +1,12 @@
 #pragma once
+#include "named_types/extensions/type_traits.hpp"
+#include "named_types/named_tuple.hpp"
+#include "named_types/rt_named_tuple.hpp"
 #include <array>
-#include <stack>
 #include <iterator>
-#include <rapidjson/reader.h>
-#include "named_types/named_tuple.hpp"
-#include "named_types/extensions/type_traits.hpp"
 #include <named_types/extensions/parsing_tools.hpp>
-#include "named_types/rt_named_tuple.hpp"
+#include <rapidjson/reader.h>
+#include <stack>
 
 namespace named_types {
 namespace extensions {
@@ -15,9 +15,9 @@ namespace rapidjson {
 template <class RootType, class Encoding> class reader_handler;
 
 template <class RootType, class Encoding>
-class reader_handler : public ::rapidjson::BaseReaderHandler<
-                           Encoding,
-                           reader_handler<RootType, Encoding>> {
+class reader_handler
+    : public ::rapidjson::
+          BaseReaderHandler<Encoding, reader_handler<RootType, Encoding>> {
   static_assert(is_sub_object<RootType>::value ||
                     is_sequence_container<RootType>::value,
                 "Root type of a handler must either be a named_tuple, an "
diff --git a/includes/named_types/extensions/type_traits.hpp b/includes/named_types/extensions/type_traits.hpp
index d3bec4a..55a3e07 100644
--- a/includes/named_types/extensions/type_traits.hpp
+++ b/includes/named_types/extensions/type_traits.hpp
@@ -1,13 +1,13 @@
 #pragma once
-#include <type_traits>
+#include "named_types/named_tuple.hpp"
+#include "named_types/rt_named_tuple.hpp"
 #include <cstdint>
-#include <vector>
 #include <list>
 #include <map>
-#include <unordered_map>
 #include <memory>
-#include "named_types/named_tuple.hpp"
-#include "named_types/rt_named_tuple.hpp"
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
 
 namespace named_types {
 
@@ -114,7 +114,7 @@ struct is_static_cast_assignable
               !std::is_assignable<Target,
                                   Source>::
                   value> //&& !std::is_convertible<Source,Target>::value;
-      {};
+{};
 
 template <class Source, class Tuple, size_t Index>
 struct tuple_member_assignable
@@ -184,90 +184,111 @@ struct __array_to_tuple_impl<T, N, std::index_sequence<Indexes...>> {
 };
 
 template <class T, std::size_t N> struct array_to_tuple<std::array<T, N>> {
-  using l_value_reference_forwarded_type = typename __array_to_tuple_impl<T&, N, std::make_index_sequence<N>>::type;
-  using const_l_value_reference_forwarded_type = typename __array_to_tuple_impl<T const&, N, std::make_index_sequence<N>>::type;
-  using r_value_reference_forwarded_type = typename __array_to_tuple_impl<T, N, std::make_index_sequence<N>>::type;
+  using l_value_reference_forwarded_type =
+      typename __array_to_tuple_impl<T&, N, std::make_index_sequence<N>>::type;
+  using const_l_value_reference_forwarded_type =
+      typename __array_to_tuple_impl<T const&, N, std::make_index_sequence<N>>::
+          type;
+  using r_value_reference_forwarded_type =
+      typename __array_to_tuple_impl<T, N, std::make_index_sequence<N>>::type;
 
  private:
-   template <std::size_t ... Indexes> static l_value_reference_forwarded_type forward_impl(std::array<T, N>& value, std::index_sequence<Indexes...>) {
-     return l_value_reference_forwarded_type(value[Indexes]... );
-   }
-   template <std::size_t ... Indexes> static constexpr const_l_value_reference_forwarded_type forward_impl(std::array<T, N> const& value, std::index_sequence<Indexes...>) {
-     return const_l_value_reference_forwarded_type(value[Indexes]...);
-   }
-   template <std::size_t ... Indexes> static constexpr r_value_reference_forwarded_type forward_impl(std::array<T, N>&& value, std::index_sequence<Indexes...>) {
-     return r_value_reference_forwarded_type(std::move(value[Indexes])... );
-   }
+  template <std::size_t... Indexes>
+  static l_value_reference_forwarded_type
+  forward_impl(std::array<T, N>& value, std::index_sequence<Indexes...>) {
+    return l_value_reference_forwarded_type(value[Indexes]...);
+  }
+  template <std::size_t... Indexes>
+  static constexpr const_l_value_reference_forwarded_type
+  forward_impl(std::array<T, N> const& value, std::index_sequence<Indexes...>) {
+    return const_l_value_reference_forwarded_type(value[Indexes]...);
+  }
+  template <std::size_t... Indexes>
+  static constexpr r_value_reference_forwarded_type
+  forward_impl(std::array<T, N>&& value, std::index_sequence<Indexes...>) {
+    return r_value_reference_forwarded_type(std::move(value[Indexes])...);
+  }
+
  public:
-   using type =
+  using type =
       typename __array_to_tuple_impl<T, N, std::make_index_sequence<N>>::type;
 
-  static constexpr l_value_reference_forwarded_type forward(std::array<T, N>& value) {
+  static constexpr l_value_reference_forwarded_type
+  forward(std::array<T, N>& value) {
     return forward_impl(value, std::make_index_sequence<N>());
   }
-  static constexpr const_l_value_reference_forwarded_type forward(std::array<T, N> const& value) {
+  static constexpr const_l_value_reference_forwarded_type
+  forward(std::array<T, N> const& value) {
     return forward_impl(value, std::make_index_sequence<N>());
   }
-  static constexpr l_value_reference_forwarded_type forward(std::array<T, N>&& value) {
+  static constexpr l_value_reference_forwarded_type
+  forward(std::array<T, N>&& value) {
     return forward_impl(std::move(value), std::make_index_sequence<N>());
   }
 };
 
 template <class T> using array_to_tuple_t = typename array_to_tuple<T>::type;
 
-template <class ... T> struct tuple_cat_type; 
+template <class... T> struct tuple_cat_type;
 
-template <class Head, class ... Tail> struct tuple_cat_type<Head,Tail...> {
-  using type = typename tuple_cat_type<Head, typename tuple_cat_type<Tail...>::type>::type;
+template <class Head, class... Tail> struct tuple_cat_type<Head, Tail...> {
+  using type =
+      typename tuple_cat_type<Head,
+                              typename tuple_cat_type<Tail...>::type>::type;
 };
 
-template <class ... T1, class ... T2> struct tuple_cat_type<std::tuple<T1...>, std::tuple<T2...>> {
-  using type = std::tuple<T1...,T2...>;
+template <class... T1, class... T2>
+struct tuple_cat_type<std::tuple<T1...>, std::tuple<T2...>> {
+  using type = std::tuple<T1..., T2...>;
 };
 
-template <class ... T> struct tuple_cat_type<std::tuple<T...>> {
+template <class... T> struct tuple_cat_type<std::tuple<T...>> {
   using type = std::tuple<T...>;
 };
 
-template <> struct tuple_cat_type<> {
-  using type = std::tuple<>;
-};
+template <> struct tuple_cat_type<> { using type = std::tuple<>; };
 
 // Forward as concatenated tuple
 template <class T>
 inline constexpr auto forward_as_reference_tuple(T const& value)
-    -> std::enable_if_t<!is_tuple<T>::value && !is_array<T>::value, std::tuple<T const&>> {
+    -> std::enable_if_t<!is_tuple<T>::value && !is_array<T>::value,
+                        std::tuple<T const&>> {
   return std::tuple<T const&>(value);
 }
 
 template <class... T, std::size_t... Indexes>
-inline constexpr auto forward_as_reference_tuple(std::tuple<T...> const& value,
-                                          std::index_sequence<Indexes...>)
+inline constexpr auto
+forward_as_reference_tuple(std::tuple<T...> const& value,
+                           std::index_sequence<Indexes...>)
     -> decltype(std::tuple_cat(
         forward_as_reference_tuple(std::get<Indexes>(value))...));
 
 template <class... T>
 inline constexpr auto forward_as_reference_tuple(std::tuple<T...> const& value)
     -> decltype(forward_as_reference_tuple(value,
-                                              std::index_sequence_for<T...>()));
+                                           std::index_sequence_for<T...>()));
 
 template <class T, std::size_t N, std::size_t... Indexes>
-inline constexpr auto forward_as_reference_tuple(std::array<T, N> const& value,
-  std::index_sequence<Indexes...>)
-  -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...));
+inline constexpr auto
+forward_as_reference_tuple(std::array<T, N> const& value,
+                           std::index_sequence<Indexes...>)
+    -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...));
 //    -> decltype(
 //        std::tuple_cat(forward_as_reference_tuple(value[Indexes])...));
 
 template <class T, std::size_t N, std::size_t... Indexes>
 inline constexpr auto forward_as_reference_tuple(std::array<T, N> const& value)
--> decltype(forward_as_reference_tuple(value, std::make_index_sequence<N>()));
+    -> decltype(forward_as_reference_tuple(value,
+                                           std::make_index_sequence<N>()));
 /*template <class T, std::size_t N, std::size_t... Indexes>
 inline auto forward_as_reference_tuple(std::array<T, N> const& value)
-    -> decltype(forward_as_reference_tuple(typename array_to_tuple<std::array<T, N>>::const_l_value_reference_forwarded_type));*/
+    -> decltype(forward_as_reference_tuple(typename array_to_tuple<std::array<T,
+N>>::const_l_value_reference_forwarded_type));*/
 
 template <class... T, std::size_t... Indexes>
-inline constexpr auto forward_as_reference_tuple(std::tuple<T...> const& value,
-                                          std::index_sequence<Indexes...>)
+inline constexpr auto
+forward_as_reference_tuple(std::tuple<T...> const& value,
+                           std::index_sequence<Indexes...>)
     -> decltype(std::tuple_cat(
         forward_as_reference_tuple(std::get<Indexes>(value))...)) {
   return std::tuple_cat(
@@ -276,32 +297,35 @@ inline constexpr auto forward_as_reference_tuple(std::tuple<T...> const& value,
 
 template <class... T>
 inline constexpr auto forward_as_reference_tuple(std::tuple<T...> const& value)
-    -> decltype(forward_as_reference_tuple(
-        value, std::index_sequence_for<T...>())) {
+    -> decltype(forward_as_reference_tuple(value,
+                                           std::index_sequence_for<T...>())) {
   return forward_as_reference_tuple(value, std::index_sequence_for<T...>());
 }
 
 template <class T, std::size_t N, std::size_t... Indexes>
-inline constexpr auto forward_as_reference_tuple(std::array<T, N> const& value,
-                                          std::index_sequence<Indexes...>)
-  -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...))
-{
+inline constexpr auto
+forward_as_reference_tuple(std::array<T, N> const& value,
+                           std::index_sequence<Indexes...>)
+    -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...)) {
   return std::tuple_cat(forward_as_reference_tuple(value[Indexes])...);
 }
-//    -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...)) {
+//    -> decltype(std::tuple_cat(forward_as_reference_tuple(value[Indexes])...))
+//    {
 //  return std::tuple_cat(forward_as_reference_tuple(value[Indexes])...);
 //}
 
 template <class T, std::size_t N, std::size_t... Indexes>
 inline constexpr auto forward_as_reference_tuple(std::array<T, N> const& value)
--> decltype(forward_as_reference_tuple(value, std::make_index_sequence<N>())) {
+    -> decltype(forward_as_reference_tuple(value,
+                                           std::make_index_sequence<N>())) {
   return forward_as_reference_tuple(value, std::make_index_sequence<N>());
 }
 
 /*template <class T, std::size_t N, std::size_t... Indexes>
 inline auto forward_as_reference_tuple(std::array<T, N> const& value)
-    -> decltype(forward_as_reference_tuple(typename array_to_tuple<std::array<T, N>>::const_l_value_reference_forwarded_type)) {
-  return forward_as_reference_tuple(array_to_tuple<std::array<T, N>>::forward(value));
+    -> decltype(forward_as_reference_tuple(typename array_to_tuple<std::array<T,
+N>>::const_l_value_reference_forwarded_type)) { return
+forward_as_reference_tuple(array_to_tuple<std::array<T, N>>::forward(value));
 }*/
 
 } // namespace named_types
diff --git a/includes/named_types/literals/integral_string_literal.hpp b/includes/named_types/literals/integral_string_literal.hpp
index 7f75378..8646b7c 100644
--- a/includes/named_types/literals/integral_string_literal.hpp
+++ b/includes/named_types/literals/integral_string_literal.hpp
@@ -1,16 +1,15 @@
 #pragma once
 #include "string_literal.hpp"
-#include <type_traits>
-#include <limits>
 #include <cstdint>
+#include <limits>
+#include <type_traits>
 
 namespace named_types {
 
 namespace arithmetic {
 
-
 template <class T> constexpr T pow(T value, size_t power) {
-  static_assert(std::is_unsigned<T>::value,"Type used must be unsigned");
+  static_assert(std::is_unsigned<T>::value, "Type used must be unsigned");
   T current_value = 1;
   for (size_t index = 0; index < power; ++index)
     current_value *= value;
@@ -18,7 +17,7 @@ template <class T> constexpr T pow(T value, size_t power) {
 }
 
 template <class T> constexpr size_t max_pow_holdable(T base, T value) {
-  static_assert(std::is_unsigned<T>::value,"Type used must be unsigned");
+  static_assert(std::is_unsigned<T>::value, "Type used must be unsigned");
   T current_value = value;
   size_t current_pow = 0;
   while (base <= current_value) {
@@ -30,122 +29,146 @@ template <class T> constexpr size_t max_pow_holdable(T base, T value) {
   return current_pow;
 }
 
-}  // namespace arithmetic
-
+} // namespace arithmetic
 
 /**
  * This class represents
  */
-template <class Storage, class Char, Char ... charset> class integral_string_format {
+template <class Storage, class Char, Char... charset>
+class integral_string_format {
   // Compute size storable - init part
   static constexpr size_t max_size_storable() {
-    return arithmetic::max_pow_holdable<size_t>(sizeof ... (charset), std::numeric_limits<Storage>::max());
+    return arithmetic::max_pow_holdable<size_t>(
+        sizeof...(charset), std::numeric_limits<Storage>::max());
   }
 
-# ifndef _MSC_VER
-  template <size_t Size> static constexpr size_t index_of(Char const (&input)[Size], size_t index, Char value) {
-    return (Size <= index) ? Size : ((input[index] == value) ? index : index_of(input,index+1,value));
+#ifndef _MSC_VER
+  template <size_t Size>
+  static constexpr size_t
+  index_of(Char const (&input)[Size], size_t index, Char value) {
+    return (Size <= index)
+               ? Size
+               : ((input[index] == value) ? index
+                                          : index_of(input, index + 1, value));
   }
-# else
+#else
   // MSVC does not support arrays in constexpr
   static constexpr size_t index_of(Char value, size_t index, size_t size) {
     return size;
   }
 
-  template <class Head, class ... Tail> static constexpr size_t index_of(Char value, size_t index, size_t size, Head current,  Tail ... tail) {
-    return (index < size && value == current) ? index : index_of(value,index+1,size, tail...);
+  template <class Head, class... Tail>
+  static constexpr size_t
+  index_of(Char value, size_t index, size_t size, Head current, Tail... tail) {
+    return (index < size && value == current)
+               ? index
+               : index_of(value, index + 1, size, tail...);
   }
-# endif
+#endif
 
   // Returns the index of the given char into the charset
   static constexpr size_t index_of(Char value) {
-#   ifndef _MSC_VER
-    return index_of<sizeof ... (charset)>({charset...},0u,value);
-#   else
+#ifndef _MSC_VER
+    return index_of<sizeof...(charset)>({charset...}, 0u, value);
+#else
     // MSVC does not support arrays in constexpr
-    return index_of(value, 0u, sizeof ... (charset), charset ...);
-#   endif
+    return index_of(value, 0u, sizeof...(charset), charset...);
+#endif
   }
 
   // Return true if the given char is included in the charset
   static constexpr bool contains(Char value) {
-    return index_of(value) < sizeof ... (charset);
+    return index_of(value) < sizeof...(charset);
   }
 
-  static constexpr Storage encode_impl(Char const* input, size_t current_index, size_t input_size) {
+  static constexpr Storage
+  encode_impl(Char const* input, size_t current_index, size_t input_size) {
     size_t value = 0;
     for (size_t index = 0; index < input_size; ++index) {
-      value += index_of(input[index])*arithmetic::pow(sizeof ... (charset), index);
+      value +=
+          index_of(input[index]) * arithmetic::pow(sizeof...(charset), index);
     }
     return value;
   }
 
   static constexpr size_t decode_size(Storage input) {
     size_t index = 0;
-    for(;arithmetic::pow<size_t>(sizeof ... (charset),index) < input; ++index);
+    for (; arithmetic::pow<size_t>(sizeof...(charset), index) < input; ++index)
+      ;
     return index;
   }
 
-# ifndef _MSC_VER
-  template <size_t Size> static constexpr Char char_at_impl(Char const (&input)[Size], size_t index) {
+#ifndef _MSC_VER
+  template <size_t Size>
+  static constexpr Char char_at_impl(Char const (&input)[Size], size_t index) {
     return index < Size ? input[index] : 0u;
   }
-# else
+#else
   // MSVC does not support arrays in constexpr
   static constexpr Char char_at_impl(size_t current_index, size_t index) {
     return 0u;
   }
 
-  template <class Head, class ... Tail> static constexpr Char char_at_impl(size_t current_index, size_t index, Head current,  Tail ... tail) {
-    return current_index == index ? current : char_at_impl(current_index+1u, index, tail...);
+  template <class Head, class... Tail>
+  static constexpr Char
+  char_at_impl(size_t current_index, size_t index, Head current, Tail... tail) {
+    return current_index == index
+               ? current
+               : char_at_impl(current_index + 1u, index, tail...);
   }
-# endif
+#endif
 
   // Returns the char at position "index" in the charset
   static constexpr Char char_at(size_t index) {
-#   ifndef _MSC_VER
-    return char_at_impl<sizeof ... (charset)>({charset...},index);
-#   else
+#ifndef _MSC_VER
+    return char_at_impl<sizeof...(charset)>({charset...}, index);
+#else
     // MSVC does not support arrays in constexpr
     return char_at_impl(0u, index, charset...);
-#   endif
+#endif
   }
 
-  // Returns the charset index of the char encoded at pose "index" in the input encoded string
+  // Returns the charset index of the char encoded at pose "index" in the input
+  // encoded string
   static constexpr size_t decode_char_index_at(Storage input, size_t index) {
-    return 0u < input ? ((input-1u) / arithmetic::pow(sizeof ... (charset),index)) % sizeof ... (charset): sizeof ... (charset);
+    return 0u < input
+               ? ((input - 1u) / arithmetic::pow(sizeof...(charset), index)) %
+                     sizeof...(charset)
+               : sizeof...(charset);
   }
 
   // Returns the char encoded at position "index" in the input encoded string
   static constexpr Char decode_char_at(Storage input, size_t index) {
-    return char_at(decode_char_index_at(input,index));
+    return char_at(decode_char_index_at(input, index));
   }
-  
+
   template <class IntegerSequence, Storage value> struct decode_impl;
-  template <Storage value, size_t ... indexes> struct decode_impl<std::integer_sequence<size_t,indexes...>,value> {
-    using type = string_literal<Char, decode_char_at(value,indexes)...>;
+  template <Storage value, size_t... indexes>
+  struct decode_impl<std::integer_sequence<size_t, indexes...>, value> {
+    using type = string_literal<Char, decode_char_at(value, indexes)...>;
   };
 
  public:
-  using string_literal_type = string_literal<Char, charset ...>;
+  using string_literal_type = string_literal<Char, charset...>;
 
-# ifdef _MSC_VER
-# pragma warning(disable:4307)
-# endif 
+#ifdef _MSC_VER
+#pragma warning(disable : 4307)
+#endif
   static constexpr size_t max_length_value = max_size_storable();
-# ifdef _MSC_VER
-# pragma warning(default:4307)
-# endif 
+#ifdef _MSC_VER
+#pragma warning(default : 4307)
+#endif
 
   // Encodes a string
-# ifndef _MSC_VER
-  template <size_t Size> static constexpr Storage encode(Char const (&input)[Size]) {
-    return encode(input,Size-1); // Be careful to exclude '\0'
+#ifndef _MSC_VER
+  template <size_t Size>
+  static constexpr Storage encode(Char const (&input)[Size]) {
+    return encode(input, Size - 1); // Be careful to exclude '\0'
   }
-# endif
+#endif
 
   static constexpr Storage encode(Char const* input, size_t input_size) {
-    return 0u == input_size ? 0u : encode_impl(input,0,input_size)+1;
+    return 0u == input_size ? 0u : encode_impl(input, 0, input_size) + 1;
   }
 
   static constexpr Storage encode(Char const* input) {
@@ -154,24 +177,223 @@ template <class Storage, class Char, Char ... charset> class integral_string_for
 
   // Decode an encoded string
   template <Storage value> struct decode {
-    using type = typename decode_impl<std::make_integer_sequence<size_t, decode_size(value)>, value>::type;
+    using type = typename decode_impl<
+        std::make_integer_sequence<size_t, decode_size(value)>,
+        value>::type;
   };
 };
 
 // Providing built-in charsets
-template <class Storage> using basic_charset = integral_string_format<Storage, char, '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_','-'>;
-template <class Storage> using basic_lowcase_charset = integral_string_format<Storage, char, '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','_','-'>;
-template <class Storage> using ascii_charset = integral_string_format<Storage, char
-    ,'\x20','\x21','\x22','\x23','\x24','\x25','\x26','\x27','\x28','\x29','\x2a','\x2b','\x2c','\x2d','\x2e','\x2f'
-    ,'\x30','\x31','\x32','\x33','\x34','\x35','\x36','\x37','\x38','\x39','\x3a','\x3b','\x3c','\x3d','\x3e','\x3f'
-    ,'\x40','\x41','\x42','\x43','\x44','\x45','\x46','\x47','\x48','\x49','\x4a','\x4b','\x4c','\x4d','\x4e','\x4f'
-    ,'\x50','\x51','\x52','\x53','\x54','\x55','\x56','\x57','\x58','\x59','\x5a','\x5b','\x5c','\x5d','\x5e','\x5f'
-    ,'\x60','\x61','\x62','\x63','\x64','\x65','\x66','\x67','\x68','\x69','\x6a','\x6b','\x6c','\x6d','\x6e','\x6f'
-    ,'\x70','\x71','\x72','\x73','\x74','\x75','\x76','\x77','\x78','\x79','\x7a','\x7b','\x7c','\x7d','\x7e'>;
+template <class Storage>
+using basic_charset = integral_string_format<Storage,
+                                             char,
+                                             '0',
+                                             '1',
+                                             '2',
+                                             '3',
+                                             '4',
+                                             '5',
+                                             '6',
+                                             '7',
+                                             '8',
+                                             '9',
+                                             'a',
+                                             'b',
+                                             'c',
+                                             'd',
+                                             'e',
+                                             'f',
+                                             'g',
+                                             'h',
+                                             'i',
+                                             'j',
+                                             'k',
+                                             'l',
+                                             'm',
+                                             'n',
+                                             'o',
+                                             'p',
+                                             'q',
+                                             'r',
+                                             's',
+                                             't',
+                                             'u',
+                                             'v',
+                                             'w',
+                                             'x',
+                                             'y',
+                                             'z',
+                                             'A',
+                                             'B',
+                                             'C',
+                                             'D',
+                                             'E',
+                                             'F',
+                                             'G',
+                                             'H',
+                                             'I',
+                                             'J',
+                                             'K',
+                                             'L',
+                                             'M',
+                                             'N',
+                                             'O',
+                                             'P',
+                                             'Q',
+                                             'R',
+                                             'S',
+                                             'T',
+                                             'U',
+                                             'V',
+                                             'W',
+                                             'X',
+                                             'Y',
+                                             'Z',
+                                             '_',
+                                             '-'>;
+template <class Storage>
+using basic_lowcase_charset = integral_string_format<Storage,
+                                                     char,
+                                                     '0',
+                                                     '1',
+                                                     '2',
+                                                     '3',
+                                                     '4',
+                                                     '5',
+                                                     '6',
+                                                     '7',
+                                                     '8',
+                                                     '9',
+                                                     'a',
+                                                     'b',
+                                                     'c',
+                                                     'd',
+                                                     'e',
+                                                     'f',
+                                                     'g',
+                                                     'h',
+                                                     'i',
+                                                     'j',
+                                                     'k',
+                                                     'l',
+                                                     'm',
+                                                     'n',
+                                                     'o',
+                                                     'p',
+                                                     'q',
+                                                     'r',
+                                                     's',
+                                                     't',
+                                                     'u',
+                                                     'v',
+                                                     'w',
+                                                     'x',
+                                                     'y',
+                                                     'z',
+                                                     '_',
+                                                     '-'>;
+template <class Storage>
+using ascii_charset = integral_string_format<Storage,
+                                             char,
+                                             '\x20',
+                                             '\x21',
+                                             '\x22',
+                                             '\x23',
+                                             '\x24',
+                                             '\x25',
+                                             '\x26',
+                                             '\x27',
+                                             '\x28',
+                                             '\x29',
+                                             '\x2a',
+                                             '\x2b',
+                                             '\x2c',
+                                             '\x2d',
+                                             '\x2e',
+                                             '\x2f',
+                                             '\x30',
+                                             '\x31',
+                                             '\x32',
+                                             '\x33',
+                                             '\x34',
+                                             '\x35',
+                                             '\x36',
+                                             '\x37',
+                                             '\x38',
+                                             '\x39',
+                                             '\x3a',
+                                             '\x3b',
+                                             '\x3c',
+                                             '\x3d',
+                                             '\x3e',
+                                             '\x3f',
+                                             '\x40',
+                                             '\x41',
+                                             '\x42',
+                                             '\x43',
+                                             '\x44',
+                                             '\x45',
+                                             '\x46',
+                                             '\x47',
+                                             '\x48',
+                                             '\x49',
+                                             '\x4a',
+                                             '\x4b',
+                                             '\x4c',
+                                             '\x4d',
+                                             '\x4e',
+                                             '\x4f',
+                                             '\x50',
+                                             '\x51',
+                                             '\x52',
+                                             '\x53',
+                                             '\x54',
+                                             '\x55',
+                                             '\x56',
+                                             '\x57',
+                                             '\x58',
+                                             '\x59',
+                                             '\x5a',
+                                             '\x5b',
+                                             '\x5c',
+                                             '\x5d',
+                                             '\x5e',
+                                             '\x5f',
+                                             '\x60',
+                                             '\x61',
+                                             '\x62',
+                                             '\x63',
+                                             '\x64',
+                                             '\x65',
+                                             '\x66',
+                                             '\x67',
+                                             '\x68',
+                                             '\x69',
+                                             '\x6a',
+                                             '\x6b',
+                                             '\x6c',
+                                             '\x6d',
+                                             '\x6e',
+                                             '\x6f',
+                                             '\x70',
+                                             '\x71',
+                                             '\x72',
+                                             '\x73',
+                                             '\x74',
+                                             '\x75',
+                                             '\x76',
+                                             '\x77',
+                                             '\x78',
+                                             '\x79',
+                                             '\x7a',
+                                             '\x7b',
+                                             '\x7c',
+                                             '\x7d',
+                                             '\x7e'>;
 
 // Providing standard compliant formats
 using basic_charset_format = basic_charset<uint64_t>;
 using basic_lowcase_charset_format = basic_lowcase_charset<uint64_t>;
 using ascii_charset_format = ascii_charset<uint64_t>;
 
-};  // namespace named_types
+}; // namespace named_types
diff --git a/includes/named_types/literals/string_literal.hpp b/includes/named_types/literals/string_literal.hpp
index b0150a3..4303ebb 100644
--- a/includes/named_types/literals/string_literal.hpp
+++ b/includes/named_types/literals/string_literal.hpp
@@ -1,7 +1,9 @@
 #pragma once
+#include "string_literal.hpp"
 #include <type_traits>
 #include <utility>
-#include "string_literal.hpp"
+#include <cstring>
+#include <cstdio>
 
 namespace named_types {
 
@@ -12,10 +14,9 @@ unsigned long long constexpr const_size(Char const* input) {
 
 template <class Char>
 unsigned long long constexpr const_hash(Char const* input) {
-  return *input
-             ? static_cast<unsigned long long>(*input) +
-                   33llu * const_hash(input + 1llu)
-             : 5381llu;
+  return *input ? static_cast<unsigned long long>(*input) +
+                      33llu * const_hash(input + 1llu)
+                : 5381llu;
 }
 
 #ifndef _MSC_VER
@@ -29,19 +30,18 @@ unsigned long long constexpr array_const_hash() { return 5381llu; }
 
 template <class Head, class... Tail>
 unsigned long long constexpr array_const_hash(Head current, Tail... tail) {
-  return 0u != current
-             ? static_cast<unsigned long long>(current) +
-                   33llu * array_const_hash(tail...)
-             : 5381llu;
+  return 0u != current ? static_cast<unsigned long long>(current) +
+                             33llu * array_const_hash(tail...)
+                       : 5381llu;
 }
 #endif
 
 template <class T, T... chars> struct string_literal {
-  static const char data[sizeof...(chars)+1u];
+  static const char data[sizeof...(chars) + 1u];
   static const size_t data_size = sizeof...(chars);
 #ifndef _MSC_VER
   static const unsigned long long hash_value =
-      array_const_hash<T, sizeof...(chars)+1>({chars..., '\0'});
+      array_const_hash<T, sizeof...(chars) + 1>({chars..., '\0'});
 #else
 #pragma warning(disable : 4307)
   static const unsigned long long hash_value = array_const_hash(chars..., '\0');
@@ -70,8 +70,8 @@ template <class T, T... chars> struct string_literal {
 };
 
 template <class T, T... chars>
-const char string_literal<T, chars...>::data[sizeof...(chars)+1u] = {chars...,
-                                                                     '\0'};
+const char string_literal<T, chars...>::data[sizeof...(chars) + 1u] = {chars...,
+                                                                       '\0'};
 
 // concatenate
 
@@ -140,8 +140,9 @@ struct repeat_string<0u, string_literal<CharT, chars...>> {
 
 template <std::size_t Size, class CharT, CharT... chars>
 struct repeat_string<Size, string_literal<CharT, chars...>> {
-  using type = concatenate_t < string_literal<CharT, chars...>,
-        typename repeat_string<Size - 1, string_literal<CharT, chars...>>::type>;
+  using type = concatenate_t<
+      string_literal<CharT, chars...>,
+      typename repeat_string<Size - 1, string_literal<CharT, chars...>>::type>;
 };
 
 template <std::size_t Size, class StringLiteral>
@@ -149,8 +150,8 @@ using repeat_string_t = typename repeat_string<Size, StringLiteral>::type;
 
 // join_repeat
 
-template <std::size_t Size, class CharT, CharT Glue, class StringLiteral> struct join_repeat_string;
-
+template <std::size_t Size, class CharT, CharT Glue, class StringLiteral>
+struct join_repeat_string;
 
 template <class CharT, CharT Glue, CharT... chars>
 struct join_repeat_string<0u, CharT, Glue, string_literal<CharT, chars...>> {
@@ -159,16 +160,21 @@ struct join_repeat_string<0u, CharT, Glue, string_literal<CharT, chars...>> {
 
 template <class CharT, CharT Glue, CharT... chars>
 struct join_repeat_string<1u, CharT, Glue, string_literal<CharT, chars...>> {
-  using type = string_literal<CharT,chars...>;
+  using type = string_literal<CharT, chars...>;
 };
 
 template <std::size_t Size, class CharT, CharT Glue, CharT... chars>
 struct join_repeat_string<Size, CharT, Glue, string_literal<CharT, chars...>> {
-  using type = concatenate_t <string_literal<CharT, chars..., Glue>,
-        typename join_repeat_string<Size - 1, CharT, Glue, string_literal<CharT, chars...>>::type>;
+  using type = concatenate_t<
+      string_literal<CharT, chars..., Glue>,
+      typename join_repeat_string<Size - 1,
+                                  CharT,
+                                  Glue,
+                                  string_literal<CharT, chars...>>::type>;
 };
 
 template <std::size_t Size, class CharT, CharT Glue, class StringLiteral>
-using join_repeat_string_t = typename join_repeat_string<Size, CharT, Glue, StringLiteral>::type;
+using join_repeat_string_t =
+    typename join_repeat_string<Size, CharT, Glue, StringLiteral>::type;
 
-} // namespace string_literal
+} // namespace named_types
diff --git a/includes/named_types/named_tag.hpp b/includes/named_types/named_tag.hpp
index 73b8362..2dfa0c9 100644
--- a/includes/named_types/named_tag.hpp
+++ b/includes/named_types/named_tag.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "literals/string_literal.hpp"
-#include <type_traits>
 #include <std/experimental/tagged.hpp>
+#include <type_traits>
 
 namespace named_types {
 
diff --git a/includes/named_types/named_tuple.hpp b/includes/named_types/named_tuple.hpp
index 9166d1a..f5f54e4 100644
--- a/includes/named_types/named_tuple.hpp
+++ b/includes/named_types/named_tuple.hpp
@@ -1,8 +1,8 @@
 #pragma once
-#include <type_traits>
-#include <stdexcept>
-#include <std/experimental/tagged.hpp>
 #include "named_tag.hpp"
+#include <std/experimental/tagged.hpp>
+#include <stdexcept>
+#include <type_traits>
 
 namespace named_types {
 
@@ -27,10 +27,58 @@ template <class Spec, class Arg> struct __ntuple_tag_notation<Arg(Spec)> {
 template <class T>
 using __ntuple_tag_notation_t = typename __ntuple_tag_notation<T>::type;
 
+// forward declaration
+template <class... Types> struct named_tuple;
+
+} // namespace named_types
+
+// Standard specialization
+
+namespace std {
+
+template <size_t Index, class... Tags>
+struct tuple_element<Index, named_types::named_tuple<Tags...>> {
+  using type =
+      tuple_element_t<Index, tuple<named_types::__ntuple_tag_elem_t<Tags>...>>;
+};
+
+template <size_t Index, class... Tags>
+inline constexpr
+    typename tuple_element<Index, named_types::named_tuple<Tags...>>::type&
+    get(named_types::named_tuple<Tags...>& in) {
+  return get<Index>(
+      static_cast<typename named_types::named_tuple<Tags...>::tuple_type&>(in));
+}
+
+template <size_t Index, class... Tags>
+inline constexpr const typename tuple_element<
+    Index,
+    named_types::named_tuple<Tags...>>::type&
+get(const named_types::named_tuple<Tags...>& in) {
+  return get<Index>(
+      static_cast<
+          const typename named_types::named_tuple<Tags...>::tuple_type&>(in));
+}
+
+template <size_t Index, class... Tags>
+inline constexpr
+    typename tuple_element<Index, named_types::named_tuple<Tags...>>::type&&
+    get(named_types::named_tuple<Tags...>&& in) {
+  return move(get<Index>(
+      static_cast<typename named_types::named_tuple<Tags...>::tuple_type&&>(
+          in)));
+}
+
+} // namespace std
+
+// end Standard specialization
+
+namespace named_types {
+
 template <class... Types>
 struct named_tuple : public std::tagged_tuple<__ntuple_tag_notation_t<Types>...>
-                     // struct named_tuple : std::tagged_tuple< Types ...
-                     {
+// struct named_tuple : std::tagged_tuple< Types ...
+{
   // Type aliases
   using tuple_type = std::tuple<__ntuple_tag_elem_t<Types>...>;
   using tagged_type = std::tagged_tuple<__ntuple_tag_notation_t<Types>...>;
@@ -73,10 +121,9 @@ struct named_tuple : public std::tagged_tuple<__ntuple_tag_notation_t<Types>...>
   }
 
   template <typename Tag, typename Value, class ForeignTuple>
-  inline typename std::enable_if_t<
-      tag_not_assignable_from<ForeignTuple, Tag>::value,
-      Value>
-  ctor_assign_from(ForeignTuple const& from) {
+  inline typename std::
+      enable_if_t<tag_not_assignable_from<ForeignTuple, Tag>::value, Value>
+      ctor_assign_from(ForeignTuple const& from) {
     return {};
   }
 
@@ -166,7 +213,7 @@ struct named_tuple : public std::tagged_tuple<__ntuple_tag_notation_t<Types>...>
   // Member operator []
 
   template <class Tag>
-  inline decltype(auto) operator[](named_tag<Tag> const&)& {
+  inline decltype(auto) operator[](named_tag<Tag> const&) & {
     return std::get<
         named_tuple::template tag_index<typename named_tag<Tag>::type>::value>(
         *this);
@@ -180,7 +227,7 @@ struct named_tuple : public std::tagged_tuple<__ntuple_tag_notation_t<Types>...>
   }
 
   template <class Tag>
-  inline decltype(auto) operator[](named_tag<Tag> const&)&& {
+  inline decltype(auto) operator[](named_tag<Tag> const&) && {
     return std::get<
         named_tuple::template tag_index<typename named_tag<Tag>::type>::value>(
         std::move(*this));
@@ -200,27 +247,17 @@ inline constexpr decltype(auto) make_named_tuple(Types&&... args) {
 template <class Func, class... Types>
 inline constexpr void for_each(Func&& f, named_tuple<Types...> const& in) {
   using swallow = int[];
-  (void)swallow{
-      int{},
-      (f(__ntuple_tag_spec_t<Types>{}, get<__ntuple_tag_spec_t<Types>>(in)),
-       int{})...};
+  (void)swallow{int{}, (f(__ntuple_tag_spec_t<Types>{},
+                          get<__ntuple_tag_spec_t<Types>>(in)),
+                        int{})...};
 }
 
 // apply : should be replaceable by std::experimental::apply
 
 template <class Func, class... Types>
-inline constexpr auto apply(Func&& f, named_tuple<Types...> const& in) -> decltype(auto) {
+inline constexpr auto apply(Func&& f, named_tuple<Types...> const& in)
+    -> decltype(auto) {
   return f(get<__ntuple_tag_spec_t<Types>>(in)...);
 }
 
 } // namespace named_types
-
-// Standard specialization
-
-namespace std {
-template <size_t Index, class... Tags>
-struct tuple_element<Index, named_types::named_tuple<Tags...>> {
-  using type =
-      tuple_element_t<Index, tuple<named_types::__ntuple_tag_elem_t<Tags>...>>;
-};
-} // namespace std
diff --git a/includes/named_types/rt_named_tag.hpp b/includes/named_types/rt_named_tag.hpp
index a12830c..0286d03 100644
--- a/includes/named_types/rt_named_tag.hpp
+++ b/includes/named_types/rt_named_tag.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include <typeinfo>
 #include "named_tag.hpp"
+#include <typeinfo>
 
 namespace named_types {
 // Named extraction for runtime default naming
@@ -21,7 +21,7 @@ template <typename T> class type_name {
   static inline auto extract(int) -> decltype(TT::name()) {
     return TT::name();
   }
-  template <typename TT> static inline auto extract(...) -> char const * {
+  template <typename TT> static inline auto extract(...) -> char const* {
     return typeid(TT).name();
   }
 #endif // _MSC_VER
diff --git a/includes/named_types/rt_named_tuple.hpp b/includes/named_types/rt_named_tuple.hpp
index 2b524d7..21c39c2 100644
--- a/includes/named_types/rt_named_tuple.hpp
+++ b/includes/named_types/rt_named_tuple.hpp
@@ -1,8 +1,8 @@
 #pragma once
 #include "named_tuple.hpp"
 #include "rt_named_tag.hpp"
-#include <array>
 #include <algorithm>
+#include <array>
 
 namespace named_types {
 
@@ -80,10 +80,11 @@ std::array<std::type_info const*, sizeof...(Types)> const
         {&typeid(__ntuple_tag_elem_t<Types>)...}};
 
 template <class Parent, class... Types>
-std::array<std::string const, sizeof...(Types)> const
-    const_rt_view_impl<Parent, named_tuple<Types...>>::attributes = {
-        {std::string(type_name<
-            typename __ntuple_tag_spec_t<Types>::value_type>::value)...}};
+std::array<std::string const, sizeof...(Types)> const const_rt_view_impl<
+    Parent,
+    named_tuple<Types...>>::attributes = {
+    {std::string(
+        type_name<typename __ntuple_tag_spec_t<Types>::value_type>::value)...}};
 
 // Non-const version
 template <class... Types>
diff --git a/includes/std/experimental/tagged.hpp b/includes/std/experimental/tagged.hpp
index cb70bdf..33f465e 100644
--- a/includes/std/experimental/tagged.hpp
+++ b/includes/std/experimental/tagged.hpp
@@ -16,10 +16,10 @@
 #ifndef SDT_EXPERIMENTAL_TAGGED_HEADER
 #define SDT_EXPERIMENTAL_TAGGED_HEADER
 
-#include <utility>
 #include <functional>
 #include <tuple>
 #include <type_traits>
+#include <utility>
 
 namespace std {
 template <class Base, class... Tags> struct tagged;
@@ -56,6 +56,7 @@ struct __getters {
 template <class Base, class... Tags>
 struct tagged : Base, __getters::collect<tagged<Base, Tags...>, Tags...> {
   using Base::Base;
+  using base_tuple = Base;
   tagged() = default;
   tagged(tagged&&) = default;
   tagged(const tagged&) = default;
@@ -119,9 +120,7 @@ struct __indexes {
 
   template <class Type, std::size_t... Is, class... Types>
   struct collect_<Type, index_sequence<Is...>, Types...>
-      : tag_indexer_<__tag_spec_t<Types>,
-                     __tag_elem_t<Types>,
-                     Is>... {
+      : tag_indexer_<__tag_spec_t<Types>, __tag_elem_t<Types>, Is>... {
     constexpr collect_(){};
     ~collect_() = default;
     constexpr collect_(const collect_&) = default;
@@ -161,8 +160,9 @@ struct __indexes {
     }
 
     template <class Tag>
-    static constexpr typename tag_indexer_<Tag, void, sizeof...(Types)>::
-        tag_index permissive_get_tag_index(...) {
+    static constexpr
+        typename tag_indexer_<Tag, void, sizeof...(Types)>::tag_index
+        permissive_get_tag_index(...) {
       return {};
     }
 
@@ -191,7 +191,7 @@ struct __indexes {
 
     template <class Tag>
     static constexpr tag_indexer_<Tag, void, sizeof...(Types)>
-        permissive_get_tag_indexer(...) {
+    permissive_get_tag_indexer(...) {
       return {};
     }
 
@@ -211,14 +211,13 @@ struct indexed_tagged
 };
 
 template <class F, class S>
-using tagged_pair =
-    tagged<pair<__tag_elem_t<F>, __tag_elem_t<S>>,
-           __tag_spec_t<F>,
-           __tag_spec_t<S>>;
+using tagged_pair = tagged<pair<__tag_elem_t<F>, __tag_elem_t<S>>,
+                           __tag_spec_t<F>,
+                           __tag_spec_t<S>>;
 
 template <class... Types>
 using __tagged_tuple =
-    indexed_tagged<tuple<typename __tag_elem<Types>::type ... >, Types...>;
+    indexed_tagged<tuple<typename __tag_elem<Types>::type...>, Types...>;
 
 /**
  * Making tagged_tuple a new type is mandatory to make
@@ -231,20 +230,22 @@ template <class... Types> struct tagged_tuple : __tagged_tuple<Types...> {
 template <class Tag, class... Types>
 typename tagged_tuple<Types...>::template type_at<Tag>::raw_type const&
 get(tagged_tuple<Types...> const& input) {
-  return get<tagged_tuple<Types...>::template tag_index<Tag>::value>(input);
+  return get<tagged_tuple<Types...>::template tag_index<Tag>::value>(
+      static_cast<typename tagged_tuple<Types...>::base_tuple const&>(input));
 };
 
 template <class Tag, class... Types>
 typename tagged_tuple<Types...>::template type_at<Tag>::raw_type&
 get(tagged_tuple<Types...>& input) {
-  return get<tagged_tuple<Types...>::template tag_index<Tag>::value>(input);
+  return get<tagged_tuple<Types...>::template tag_index<Tag>::value>(
+      static_cast<typename tagged_tuple<Types...>::base_tuple&>(input));
 };
 
 template <class Tag, class... Types>
 typename tagged_tuple<Types...>::template type_at<Tag>::raw_type&&
 get(tagged_tuple<Types...>&& input) {
-  return move(get<tagged_tuple<Types...>::template tag_index<Tag>::value>(
-      std::forward<tagged_tuple<Types...>>(input)));
+  return get<tagged_tuple<Types...>::template tag_index<Tag>::value>(
+      static_cast<typename tagged_tuple<Types...>::base_tuple&&>(input));
 };
 
 namespace tag {
@@ -260,12 +261,12 @@ struct basic_tag {
     ~getter() = default;
 
    private:
-    friend struct __getters;
+    friend struct std::__getters;
   };
 
-  friend struct __getters;
+  friend struct std::__getters;
 };
-}
-}
+} // namespace tag
+} // namespace std
 
 #endif // SDT_EXPERIMENTAL_TAGGED_HEADER