diff --git a/include/aka_compatibilty_with_cpp_standard.hh b/include/aka_compatibilty_with_cpp_standard.hh
index b139159a6..40125f798 100644
--- a/include/aka_compatibilty_with_cpp_standard.hh
+++ b/include/aka_compatibilty_with_cpp_standard.hh
@@ -1,186 +1,186 @@
 /**
  * @file   aka_compatibilty_with_cpp_standard.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Jun 18 2010
  * @date last modification: Wed Jan 10 2018
  *
  * @brief  The content of this file is taken from the possible implementations
  * on
  * http://en.cppreference.com
  *
  * @section LICENSE
  *
  * Copyright (©)  2010-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the
- * terms  of the  GNU Lesser  General Public  License as published by  the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
+ * akantu-iterators is free  software: you can redistribute it and/or  modify it
+ * under the terms  of the  GNU Lesser  General Public  License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
- * details.
+ * akantu-iterators is  distributed in the  hope that it  will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public
+ * License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
- * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_static_if.hh"
 /* -------------------------------------------------------------------------- */
+#include <iterator>
 #include <tuple>
 #include <type_traits>
 #include <utility>
-#include <iterator>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH
 #define AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH
 
 namespace aka {
 
 /* -------------------------------------------------------------------------- */
 // Part taken from C++14
 #if __cplusplus < 201402L
 template <bool B, class T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 #else
 template <bool B, class T = void> using enable_if_t = std::enable_if_t<B, T>;
 #endif
 
 /* -------------------------------------------------------------------------- */
 // Part taken from C++17
 #if __cplusplus < 201703L
 
 /* -------------------------------------------------------------------------- */
 // bool_constant
 template <bool B> using bool_constant = std::integral_constant<bool, B>;
 namespace {
-template <bool B> constexpr bool bool_constant_v = bool_constant<B>::value;
+  template <bool B> constexpr bool bool_constant_v = bool_constant<B>::value;
 }
 
 /* -------------------------------------------------------------------------- */
 // conjunction
 template <class...> struct conjunction : std::true_type {};
 template <class B1> struct conjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct conjunction<B1, Bn...>
     : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
 /* -------------------------------------------------------------------------- */
 // disjunction
 template <class...> struct disjunction : std::false_type {};
 template <class B1> struct disjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct disjunction<B1, Bn...>
     : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
 
 /* -------------------------------------------------------------------------- */
 // negations
 template <class B> struct negation : bool_constant<!bool(B::value)> {};
 
 /* -------------------------------------------------------------------------- */
 // invoke
 namespace detail {
-template <class T> struct is_reference_wrapper : std::false_type {};
-template <class U>
-struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
-
-template <class T, class Type, class T1, class... Args>
-decltype(auto) INVOKE(Type T::*f, T1 &&t1, Args &&... args) {
-  static_if(std::is_member_function_pointer<decltype(f)>{})
-      .then_([&](auto &&f) {
-        static_if(std::is_base_of<T, std::decay_t<T1>>{})
-            .then_([&](auto &&f) {
-              return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
-            })
-            .elseif(is_reference_wrapper<std::decay_t<T1>>{})([&](auto &&f) {
-              return (t1.get().*f)(std::forward<Args>(args)...);
-            })
-            .else_([&](auto &&f) {
-              return ((*std::forward<T1>(t1)).*f)(std::forward<Args>(args)...);
-            })(std::forward<decltype(f)>(f));
-      })
-      .else_([&](auto &&f) {
-        static_assert(std::is_member_object_pointer<decltype(f)>::value,
-                      "f is not a member object");
-        static_assert(sizeof...(args) == 0, "f takes arguments");
-        static_if(std::is_base_of<T, std::decay_t<T1>>{})
-            .then_([&](auto &&f) { return std::forward<T1>(t1).*f; })
-            .elseif(std::is_base_of<T, std::decay_t<T1>>{})(
-                [&](auto &&f) { return t1.get().*f; })
-            .else_([&](auto &&f) { return (*std::forward<T1>(t1)).*f; })(
-                std::forward<decltype(f)>(f));
-      })(std::forward<decltype(f)>(f));
-}
+  template <class T> struct is_reference_wrapper : std::false_type {};
+  template <class U>
+  struct is_reference_wrapper<std::reference_wrapper<U>> : std::true_type {};
+
+  template <class T, class Type, class T1, class... Args>
+  decltype(auto) INVOKE(Type T::*f, T1 && t1, Args &&... args) {
+    static_if(std::is_member_function_pointer<decltype(f)>{})
+        .then_([&](auto && f) {
+          static_if(std::is_base_of<T, std::decay_t<T1>>{})
+              .then_([&](auto && f) {
+                return (std::forward<T1>(t1).*f)(std::forward<Args>(args)...);
+              })
+              .elseif(is_reference_wrapper<std::decay_t<T1>>{})([&](auto && f) {
+                return (t1.get().*f)(std::forward<Args>(args)...);
+              })
+              .else_([&](auto && f) {
+                return ((*std::forward<T1>(t1)).*
+                        f)(std::forward<Args>(args)...);
+              })(std::forward<decltype(f)>(f));
+        })
+        .else_([&](auto && f) {
+          static_assert(std::is_member_object_pointer<decltype(f)>::value,
+                        "f is not a member object");
+          static_assert(sizeof...(args) == 0, "f takes arguments");
+          static_if(std::is_base_of<T, std::decay_t<T1>>{})
+              .then_([&](auto && f) { return std::forward<T1>(t1).*f; })
+              .elseif(std::is_base_of<T, std::decay_t<T1>>{})(
+                  [&](auto && f) { return t1.get().*f; })
+              .else_([&](auto && f) { return (*std::forward<T1>(t1)).*f; })(
+                  std::forward<decltype(f)>(f));
+        })(std::forward<decltype(f)>(f));
+  }
 
-template <class F, class... Args>
-decltype(auto) INVOKE(F &&f, Args &&... args) {
-  return std::forward<F>(f)(std::forward<Args>(args)...);
-}
+  template <class F, class... Args>
+  decltype(auto) INVOKE(F && f, Args &&... args) {
+    return std::forward<F>(f)(std::forward<Args>(args)...);
+  }
 } // namespace detail
 
 template <class F, class... Args>
-decltype(auto) invoke(F &&f, Args &&... args) {
+decltype(auto) invoke(F && f, Args &&... args) {
   return detail::INVOKE(std::forward<F>(f), std::forward<Args>(args)...);
 }
 
 /* -------------------------------------------------------------------------- */
 // apply
 namespace detail {
   template <class F, class Tuple, std::size_t... Is>
   constexpr decltype(auto) apply_impl(F && f, Tuple && t,
                                       std::index_sequence<Is...> /*unused*/) {
     return invoke(std::forward<F>(f), std::get<Is>(std::forward<Tuple>(t))...);
   }
 } // namespace detail
 
 /* -------------------------------------------------------------------------- */
 template <class F, class Tuple>
-constexpr decltype(auto) apply(F &&f, Tuple &&t) {
+constexpr decltype(auto) apply(F && f, Tuple && t) {
   return detail::apply_impl(
       std::forward<F>(f), std::forward<Tuple>(t),
       std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
 }
 
 /* -------------------------------------------------------------------------- */
 // count_if
 template <class InputIt, class UnaryPredicate>
 typename std::iterator_traits<InputIt>::difference_type
 count_if(InputIt first, InputIt last, UnaryPredicate p) {
   typename std::iterator_traits<InputIt>::difference_type ret = 0;
   for (; first != last; ++first) {
     if (p(*first)) {
       ret++;
     }
   }
   return ret;
 }
 
 #else
 template <bool B> using bool_constant = std::bool_constant<B>;
 template <bool B> using bool_constant_v = std::bool_constant_v<B>;
 
 template <class... Args> using conjunction = std::conjunction<Args...>;
 template <class... Args> using disjunction = std::disjunction<Args...>;
 template <class B> using negation = std::negation<B>;
 
 using invoke = std::invoke;
 using apply = std::apply;
 
 using count_if = std::count_if;
 #endif
 
-
 template <typename cat1, typename cat2>
 using is_iterator_category_at_least =
-                  std::is_same<std::common_type_t<cat1, cat2>, cat2>;
+    std::is_same<std::common_type_t<cat1, cat2>, cat2>;
 
 } // namespace aka
 
 #endif /* AKANTU_AKA_COMPATIBILTY_WITH_CPP_STANDARD_HH */
diff --git a/include/aka_iterators.hh b/include/aka_iterators.hh
index b66fecd35..f843b32b0 100644
--- a/include/aka_iterators.hh
+++ b/include/aka_iterators.hh
@@ -1,37 +1,37 @@
 /**
  * @file   aka_iterators.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Aug 11 2017
  * @date last modification: Mon Jan 29 2018
  *
  * @brief  iterator interfaces
  *
  * @section LICENSE
  *
  * Copyright (©) 2016-2018 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the
- * terms  of the  GNU Lesser  General Public  License as published by  the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
+ * akantu-iterators is free  software: you can redistribute it and/or  modify it
+ * under the terms  of the  GNU Lesser  General Public  License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
- * details.
+ * akantu-iterators is  distributed in the  hope that it  will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public
+ * License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
- * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "iterators/aka_arange_iterator.hh"
 #include "iterators/aka_enumerate_iterator.hh"
 #include "iterators/aka_filter_iterator.hh"
 #include "iterators/aka_transform_iterator.hh"
 #include "iterators/aka_zip_iterator.hh"
 /* -------------------------------------------------------------------------- */
diff --git a/include/aka_tuple_tools.hh b/include/aka_tuple_tools.hh
index 44d017f33..8f0f14b38 100644
--- a/include/aka_tuple_tools.hh
+++ b/include/aka_tuple_tools.hh
@@ -1,336 +1,338 @@
 /**
  * @file   aka_tuple_tools.hh
  *
  * @author Nicolas Richart <nicolas.richart@epfl.ch>
  *
  * @date creation: Fri Aug 11 2017
  * @date last modification: Mon Jan 29 2018
  *
  * @brief  iterator interfaces
  *
  * @section LICENSE
  *
  * Copyright 2019 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
  * Akantu is free  software: you can redistribute it and/or  modify it under the
  * terms  of the  GNU Lesser  General Public  License as published by  the Free
  * Software Foundation, either version 3 of the License, or (at your option) any
  * later version.
  *
  * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  * A PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
  * details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
  * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 /* -------------------------------------------------------------------------- */
 #include "aka_compatibilty_with_cpp_standard.hh"
 #include "aka_str_hash.hh"
 /* -------------------------------------------------------------------------- */
 #include <tuple>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKANTU_AKA_TUPLE_TOOLS_HH
 #define AKANTU_AKA_TUPLE_TOOLS_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 namespace tuple {
   /* ---------------------------------------------------------------------- */
   template <typename tag, typename type> struct named_tag {
     using _tag = tag;   ///< key
     using _type = type; ///< value type
 
     template <
         typename T,
         std::enable_if_t<not std::is_same<named_tag, T>::value> * = nullptr>
     explicit named_tag(T && value) // NOLINT
         : _value(std::forward<T>(value)) {}
 
     type _value;
   };
 
   namespace details {
 /* ---------------------------------------------------------------------- */
 #if (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Weffc++"
 #endif
     template <typename tag> struct named_tag_proxy {
       using _tag = tag;
 
       template <typename T> decltype(auto) operator=(T && value) {
         return named_tag<_tag, T>{std::forward<T>(value)};
       }
     };
 #if (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic pop
 #endif
   } // namespace details
 
   /* ---------------------------------------------------------------------- */
   template <typename T> struct is_named_tag : public std::false_type {};
   template <typename tag>
   struct is_named_tag<details::named_tag_proxy<tag>> : public std::true_type {};
   template <typename tag, typename type>
   struct is_named_tag<named_tag<tag, type>> : public std::true_type {};
   /* ---------------------------------------------------------------------- */
 
   template <class... Params>
   struct named_tuple : public std::tuple<typename Params::_type...> {
     using Names_t = std::tuple<typename Params::_tag...>;
     using parent = std::tuple<typename Params::_type...>;
 
     named_tuple(Params &&... params)
         : parent(std::forward<typename Params::_type>(params._value)...) {}
 
     named_tuple(typename Params::_type &&... args)
         : parent(std::forward<typename Params::_type>(args)...) {}
 
   private:
     template <typename tag, std::size_t Idx,
               std::enable_if_t<Idx == sizeof...(Params)> * = nullptr>
     static constexpr std::size_t get_element_index() noexcept {
       return -1;
     }
 
     template <typename tag, std::size_t Idx,
               std::enable_if_t<(Idx < sizeof...(Params))> * = nullptr>
     static constexpr std::size_t get_element_index() noexcept {
       using _tag = std::tuple_element_t<Idx, Names_t>;
       return (std::is_same<_tag, tag>::value)
                  ? Idx
                  : get_element_index<tag, Idx + 1>();
     }
 
   public:
     template <typename NT,
               std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
     constexpr decltype(auto) get(NT && /*unused*/) noexcept {
       const auto index = get_element_index<typename NT::_tag, 0>();
       static_assert((index != -1), "wrong named_tag");
       return (std::get<index>(*this));
     }
 
     template <typename NT,
               std::enable_if_t<is_named_tag<NT>::value> * = nullptr>
     constexpr decltype(auto) get(NT && /*unused*/) const noexcept {
       const auto index = get_element_index<typename NT::_tag, 0>();
       static_assert((index != -1), "wrong named_tag");
       return std::get<index>(*this);
     }
   };
 
   /* ---------------------------------------------------------------------- */
   template <typename T> struct is_named_tuple : public std::false_type {};
   template <typename... Params>
   struct is_named_tuple<named_tuple<Params...>> : public std::true_type {};
   /* ---------------------------------------------------------------------- */
 
   template <typename... Params>
   constexpr decltype(auto) make_named_tuple(Params &&... params) noexcept {
     return named_tuple<Params...>(std::forward<Params>(params)...);
   }
 
   template <typename tag> constexpr decltype(auto) make_named_tag() noexcept {
     return details::named_tag_proxy<tag>{};
   }
 
   template <size_t HashCode> constexpr decltype(auto) get() {
     return make_named_tag<std::integral_constant<size_t, HashCode>>();
   }
 
   template <size_t HashCode, class Tuple>
   constexpr decltype(auto) get(Tuple && tuple) {
     return tuple.get(get<HashCode>());
   }
 
   template <typename Param, typename Tuple,
             std::enable_if_t<is_named_tag<Param>::value> * = nullptr>
   constexpr decltype(auto) get(Tuple && tuple) noexcept {
     return tuple.template get<typename Param::hash>();
   }
 
 #if defined(__INTEL_COMPILER)
 // intel warnings here
 #elif defined(__clang__)
 // clang warnings here
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
 #elif (defined(__GNUC__) || defined(__GNUG__))
 // gcc warnings here
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpedantic"
 #endif
   /// this is a GNU exstension
   /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3599.html
   template <class CharT, CharT... chars>
   constexpr decltype(auto) operator"" _n() {
     return make_named_tag<std::integral_constant<
         std::size_t, string_literal<CharT, chars...>::hash>>();
   }
 #if defined(__INTEL_COMPILER)
 #elif defined(__clang__)
 #pragma clang diagnostic pop
 #elif (defined(__GNUC__) || defined(__GNUG__))
 #pragma GCC diagnostic pop
 #endif
 
   /* ------------------------------------------------------------------------ */
   namespace details {
     template <std::size_t N> struct Foreach {
       template <class Tuple>
       static inline bool not_equal(Tuple && a, Tuple && b) {
         if (std::get<N - 1>(std::forward<Tuple>(a)) ==
             std::get<N - 1>(std::forward<Tuple>(b))) {
           return false;
         }
         return Foreach<N - 1>::not_equal(std::forward<Tuple>(a),
                                          std::forward<Tuple>(b));
       }
     };
 
     /* ---------------------------------------------------------------------- */
     template <> struct Foreach<0> {
       template <class Tuple>
       static inline bool not_equal(Tuple && a, Tuple && b) {
         return std::get<0>(std::forward<Tuple>(a)) !=
                std::get<0>(std::forward<Tuple>(b));
       }
     };
 
     template <typename... Ts>
     decltype(auto) make_tuple_no_decay(Ts &&... args) {
       return std::tuple<Ts...>(std::forward<Ts>(args)...);
     }
 
     template <typename... Names, typename... Ts>
-    decltype(auto) make_named_tuple_no_decay(std::tuple<Names...> /*unused*/, Ts &&... args) {
+    decltype(auto) make_named_tuple_no_decay(std::tuple<Names...> /*unused*/,
+                                             Ts &&... args) {
       return named_tuple<named_tag<Names, Ts>...>(std::forward<Ts>(args)...);
     }
 
     template <class F, class Tuple, std::size_t... Is>
     void foreach_impl(F && func, Tuple && tuple,
                       std::index_sequence<Is...> && /*unused*/) {
       (void)std::initializer_list<int>{
           (std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple))),
            0)...};
     }
 
     template <class F, class Tuple, std::size_t... Is>
     decltype(auto) transform_impl(F && func, Tuple && tuple,
                                   std::index_sequence<Is...> && /*unused*/) {
       return make_tuple_no_decay(
           std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple)))...);
     }
 
     template <class F, class Tuple, std::size_t... Is>
     decltype(auto)
     transform_named_impl(F && func, Tuple && tuple,
                          std::index_sequence<Is...> && /*unused*/) {
-      return make_named_tuple_no_decay(typename std::decay_t<Tuple>::Names_t{},
+      return make_named_tuple_no_decay(
+          typename std::decay_t<Tuple>::Names_t{},
           std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple)))...);
     }
 
   } // namespace details
 
   /* ------------------------------------------------------------------------ */
   template <class Tuple,
             std::enable_if_t<not is_named_tuple<std::decay_t<Tuple>>::value> * =
                 nullptr>
   bool are_not_equal(Tuple && a, Tuple && b) {
     return details::Foreach<std::tuple_size<std::decay_t<Tuple>>::value>::
         not_equal(std::forward<Tuple>(a), std::forward<Tuple>(b));
   }
 
   template <
       class Tuple,
       std::enable_if_t<is_named_tuple<std::decay_t<Tuple>>::value> * = nullptr>
   bool are_not_equal(Tuple && a, Tuple && b) {
     return details::Foreach<
         std::tuple_size<typename std::decay_t<Tuple>::parent>::value>::
         not_equal(std::forward<Tuple>(a), std::forward<Tuple>(b));
   }
 
   template <class F, class Tuple,
             std::enable_if_t<not is_named_tuple<std::decay_t<Tuple>>::value> * =
                 nullptr>
   void foreach (F && func, Tuple && tuple) {
     return details::foreach_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<std::decay_t<Tuple>>::value>{});
   }
 
   template <
       class F, class Tuple,
       std::enable_if_t<is_named_tuple<std::decay_t<Tuple>>::value> * = nullptr>
   void foreach (F && func, Tuple && tuple) {
     return details::foreach_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<typename std::decay_t<Tuple>::parent>::value>{});
   }
 
   template <class F, class Tuple,
             std::enable_if_t<not is_named_tuple<std::decay_t<Tuple>>::value> * =
                 nullptr>
   decltype(auto) transform(F && func, Tuple && tuple) {
     return details::transform_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<std::decay_t<Tuple>>::value>{});
   }
 
   template <
       class F, class Tuple,
       std::enable_if_t<is_named_tuple<std::decay_t<Tuple>>::value> * = nullptr>
   decltype(auto) transform(F && func, Tuple && tuple) {
     return details::transform_named_impl(
         std::forward<F>(func), std::forward<Tuple>(tuple),
         std::make_index_sequence<
             std::tuple_size<typename std::decay_t<Tuple>::parent>::value>{});
   }
 
   namespace details {
     template <class Tuple, std::size_t... Is>
     decltype(auto) flatten(Tuple && tuples,
                            std::index_sequence<Is...> /*unused*/) {
       return std::tuple_cat(std::get<Is>(tuples)...);
     }
   } // namespace details
 
   template <class Tuple> decltype(auto) flatten(Tuple && tuples) {
     return details::flatten(std::forward<Tuple>(tuples),
                             std::make_index_sequence<
                                 std::tuple_size<std::decay_t<Tuple>>::value>());
   }
 } // namespace tuple
 
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 /* -------------------------------------------------------------------------- */
 #include <iterator>
 /* -------------------------------------------------------------------------- */
 
 namespace std {
 template <typename tag, typename type>
 struct iterator_traits<
     ::AKANTU_ITERATORS_NAMESPACE::tuple::named_tag<tag, type>> {
   using iterator_category = typename type::iterator_category;
   using value_type = typename type::value_type;
   using difference_type = typename type::difference_type;
   using pointer = typename type::pointer;
   using reference = typename type::reference;
 };
 } // namespace std
 #endif /* AKANTU_AKA_TUPLE_TOOLS_HH */
diff --git a/include/iterators/aka_arange_iterator.hh b/include/iterators/aka_arange_iterator.hh
index fc02ecbbd..a2b2ec16c 100644
--- a/include/iterators/aka_arange_iterator.hh
+++ b/include/iterators/aka_arange_iterator.hh
@@ -1,177 +1,177 @@
 /**
  * @file   aka_arange_iterator.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  jeu déc 12 2019
  *
  * @brief implementation of arange
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the
- * terms  of the  GNU Lesser  General Public  License as  published by  the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
+ * akantu-iterators is free  software: you can redistribute it and/or  modify it
+ * under the terms  of the  GNU Lesser  General Public  License as  published by
+ * the Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
- * details.
+ * akantu-iterators is  distributed in the  hope that it  will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public
+ * License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
- * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include <cstddef>
 #include <iterator>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKA_ARANGE_ITERATOR_HH
 #define AKA_ARANGE_ITERATOR_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 namespace containers {
 
   template <class Iterator> class Range {
   public:
     using iterator = Iterator;
     // ugly trick
     using const_iterator = Iterator;
 
     explicit Range(Iterator && it1, Iterator && it2)
         : iterators(std::forward<Iterator>(it1), std::forward<Iterator>(it2)) {}
 
     decltype(auto) begin() const { return std::get<0>(iterators); }
     decltype(auto) begin() { return std::get<0>(iterators); }
 
     decltype(auto) end() const { return std::get<1>(iterators); }
     decltype(auto) end() { return std::get<1>(iterators); }
 
   private:
     std::tuple<Iterator, Iterator> iterators;
   };
 } // namespace containers
 
 template <class Iterator>
 decltype(auto) range(Iterator && it1, Iterator && it2) {
   return containers::Range<Iterator>(std::forward<Iterator>(it1),
                                      std::forward<Iterator>(it2));
 }
 /* -------------------------------------------------------------------------- */
 /* Arange                                                                     */
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class T> class ArangeIterator {
   public:
     using value_type = T;
     using pointer = T *;
     using reference = T &;
     using difference_type = size_t;
     using iterator_category = std::forward_iterator_tag;
 
     constexpr ArangeIterator(T value, T step) : value(value), step(step) {}
     constexpr ArangeIterator(const ArangeIterator &) = default;
 
     constexpr ArangeIterator & operator++() {
       value += step;
       return *this;
     }
 
     constexpr T operator*() const { return value; }
 
     constexpr bool operator==(const ArangeIterator & other) const {
       return (value == other.value) and (step == other.step);
     }
 
     constexpr bool operator!=(const ArangeIterator & other) const {
       return not operator==(other);
     }
 
   private:
     T value{0};
     const T step{1};
   };
 } // namespace iterators
 
 namespace containers {
   template <class T> class ArangeContainer {
   public:
     using iterator = iterators::ArangeIterator<T>;
     using const_iterator = iterators::ArangeIterator<T>;
 
     constexpr ArangeContainer(T start, T stop, T step = 1)
         : start(start), stop((stop - start) % step == 0
                                  ? stop
                                  : start + (1 + (stop - start) / step) * step),
           step(step) {}
     explicit constexpr ArangeContainer(T stop) : ArangeContainer(0, stop, 1) {}
 
     constexpr T operator[](std::size_t i) {
       T val = start + i * step;
       assert(val < stop && "i is out of range");
       return val;
     }
 
     constexpr T size() { return (stop - start) / step; }
 
     constexpr iterator begin() { return iterator(start, step); }
     constexpr iterator end() { return iterator(stop, step); }
 
   private:
     const T start{0}, stop{0}, step{1};
   };
 } // namespace containers
 
 template <class T,
           typename = std::enable_if_t<std::is_integral<std::decay_t<T>>::value>>
 inline decltype(auto) arange(const T & stop) {
   return containers::ArangeContainer<T>(stop);
 }
 
 template <class T1, class T2,
           typename = std::enable_if_t<
               std::is_integral<std::common_type_t<T1, T2>>::value>>
 inline constexpr decltype(auto) arange(const T1 & start, const T2 & stop) {
   return containers::ArangeContainer<std::common_type_t<T1, T2>>(start, stop);
 }
 
 template <class T1, class T2, class T3,
           typename = std::enable_if_t<
               std::is_integral<std::common_type_t<T1, T2, T3>>::value>>
 inline constexpr decltype(auto) arange(const T1 & start, const T2 & stop,
                                        const T3 & step) {
   return containers::ArangeContainer<std::common_type_t<T1, T2, T3>>(
       start, stop, step);
 }
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 namespace std {
 template <class T>
 struct iterator_traits<
     ::AKANTU_ITERATORS_NAMESPACE::iterators::ArangeIterator<T>> {
 private:
   using iterator_type =
       typename ::AKANTU_ITERATORS_NAMESPACE::iterators::ArangeIterator<T>;
 
 public:
   using iterator_category = typename iterator_type::iterator_category;
   using value_type = typename iterator_type::value_type;
   using difference_type = typename iterator_type::difference_type;
   using pointer = typename iterator_type::pointer;
   using reference = typename iterator_type::reference;
 };
 
 } // namespace std
 
 #endif /* AKA_ARANGE_ITERATOR_HH */
diff --git a/include/iterators/aka_enumerate_iterator.hh b/include/iterators/aka_enumerate_iterator.hh
index d4ca5b94b..55789f28b 100644
--- a/include/iterators/aka_enumerate_iterator.hh
+++ b/include/iterators/aka_enumerate_iterator.hh
@@ -1,155 +1,155 @@
 /**
  * @file   aka_enumerate_iterator.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  jeu déc 12 2019
  *
  * @brief implementation of enumerate.
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the
- * terms  of the  GNU Lesser  General Public  License as  published by  the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
+ * akantu-iterators is free  software: you can redistribute it and/or  modify it
+ * under the terms  of the  GNU Lesser  General Public  License as  published by
+ * the Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
- * details.
+ * akantu-iterators is  distributed in the  hope that it  will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public
+ * License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
- * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "iterators/aka_zip_iterator.hh"
 /* -------------------------------------------------------------------------- */
 #include <iterator>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKA_ENUMERATE_ITERATOR_HH
 #define AKA_ENUMERATE_ITERATOR_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   template <class Iterator> class EnumerateIterator {
   public:
     using value_type =
         std::tuple<std::size_t,
                    typename std::iterator_traits<Iterator>::value_type>;
     using difference_type = std::size_t;
     using pointer =
         std::tuple<std::size_t,
                    typename std::iterator_traits<Iterator>::pointer>;
     using reference =
         std::tuple<std::size_t,
                    typename std::iterator_traits<Iterator>::reference>;
     using iterator_category = std::input_iterator_tag;
 
   public:
     explicit EnumerateIterator(Iterator && iterator) : iterator(iterator) {}
 
     // input iterator ++it
     EnumerateIterator & operator++() {
       ++iterator;
       ++index;
       return *this;
     }
 
     // input iterator it++
     EnumerateIterator operator++(int) {
       auto cpy = *this;
       this->operator++();
       return cpy;
     }
 
     // input iterator it != other_it
     bool operator!=(const EnumerateIterator & other) const {
       return iterator != other.iterator;
     }
 
     // input iterator dereference *it
     decltype(auto) operator*() {
       return std::tuple_cat(std::make_tuple(index), *iterator);
     }
 
     bool operator==(const EnumerateIterator & other) const {
       return not this->operator!=(other);
     }
 
   private:
     Iterator iterator;
     size_t index{0};
   };
 
   template <class Iterator>
   inline constexpr decltype(auto) enumerate(Iterator && iterator) {
     return EnumerateIterator<Iterator>(std::forward<Iterator>(iterator));
   }
 
 } // namespace iterators
 
 namespace containers {
   template <class... Containers> class EnumerateContainer {
   public:
     explicit EnumerateContainer(Containers &&... containers)
         : zip_container(std::forward<Containers>(containers)...) {}
 
     decltype(auto) begin() {
       return iterators::enumerate(zip_container.begin());
     }
 
     decltype(auto) begin() const {
       return iterators::enumerate(zip_container.begin());
     }
 
     decltype(auto) end() { return iterators::enumerate(zip_container.end()); }
 
     decltype(auto) end() const {
       return iterators::enumerate(zip_container.end());
     }
 
   private:
     ZipContainer<Containers...> zip_container;
   };
 } // namespace containers
 
 template <class... Container>
 inline constexpr decltype(auto) enumerate(Container &&... container) {
   return containers::EnumerateContainer<Container...>(
       std::forward<Container>(container)...);
 }
 
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 namespace std {
 template <class Iterator>
 struct iterator_traits<
     ::AKANTU_ITERATORS_NAMESPACE::iterators::EnumerateIterator<Iterator>> {
 private:
   using iterator_type =
       typename ::AKANTU_ITERATORS_NAMESPACE::iterators::EnumerateIterator<
           Iterator>;
 
 public:
   using iterator_category = typename iterator_type::iterator_category;
   using value_type = typename iterator_type::value_type;
   using difference_type = typename iterator_type::difference_type;
   using pointer = typename iterator_type::pointer;
   using reference = typename iterator_type::reference;
 };
 } // namespace std
 
 #endif /* AKA_ENUMERATE_ITERATOR_HH */
diff --git a/include/iterators/aka_zip_iterator.hh b/include/iterators/aka_zip_iterator.hh
index 9b8e7b589..95c78c007 100644
--- a/include/iterators/aka_zip_iterator.hh
+++ b/include/iterators/aka_zip_iterator.hh
@@ -1,304 +1,304 @@
 /**
  * @file   aka_zip_iterator.hh
  *
  * @author Nicolas Richart
  *
  * @date creation  jeu déc 12 2019
  *
  * @brief A Documented file.
  *
  * @section LICENSE
  *
  * Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne)
  * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
  *
- * Akantu is free  software: you can redistribute it and/or  modify it under the
- * terms  of the  GNU Lesser  General Public  License as  published by  the Free
- * Software Foundation, either version 3 of the License, or (at your option) any
- * later version.
+ * akantu-iterators is free  software: you can redistribute it and/or  modify it
+ * under the terms  of the  GNU Lesser  General Public  License as  published by
+ * the Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
  *
- * Akantu is  distributed in the  hope that it  will be useful, but  WITHOUT ANY
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public License  for more
- * details.
+ * akantu-iterators is  distributed in the  hope that it  will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A  PARTICULAR PURPOSE. See  the GNU  Lesser General  Public
+ * License  for more details.
  *
  * You should  have received  a copy  of the GNU  Lesser General  Public License
- * along with Akantu. If not, see <http://www.gnu.org/licenses/>.
+ * along with akantu-iterators. If not, see <http://www.gnu.org/licenses/>.
  *
  */
 /* -------------------------------------------------------------------------- */
 #include "aka_compatibilty_with_cpp_standard.hh"
 #include "aka_tuple_tools.hh"
 /* -------------------------------------------------------------------------- */
 #include <iterator>
 #include <tuple>
 #include <utility>
 /* -------------------------------------------------------------------------- */
 
 #ifndef AKA_ZIP_ITERATOR_HH
 #define AKA_ZIP_ITERATOR_HH
 
 #ifndef AKANTU_ITERATORS_NAMESPACE
 #define AKANTU_ITERATORS_NAMESPACE akantu
 #endif
 
 namespace AKANTU_ITERATORS_NAMESPACE {
 
 /* -------------------------------------------------------------------------- */
 namespace iterators {
   namespace details {
     template <bool enable> struct CopyAssignmentEnabler {};
     template <> struct CopyAssignmentEnabler<false> {
       CopyAssignmentEnabler() = default;
       CopyAssignmentEnabler(const CopyAssignmentEnabler &) = default;
       CopyAssignmentEnabler(CopyAssignmentEnabler &&) = default;
       CopyAssignmentEnabler & operator=(const CopyAssignmentEnabler &) = delete;
       CopyAssignmentEnabler & operator=(CopyAssignmentEnabler &&) = default;
     };
 
     template <bool enable> struct MoveAssignmentEnabler {};
     template <> struct MoveAssignmentEnabler<false> {
       MoveAssignmentEnabler() = default;
       MoveAssignmentEnabler(const MoveAssignmentEnabler &) = default;
       MoveAssignmentEnabler(MoveAssignmentEnabler &&) = default;
       MoveAssignmentEnabler & operator=(const MoveAssignmentEnabler &) = delete;
       MoveAssignmentEnabler & operator=(MoveAssignmentEnabler &&) = default;
     };
 
   } // namespace details
 
   /* ------------------------------------------------------------------------ */
   template <template <class...> class Tuple, class... Iterators>
   class ZipIterator_
       : public details::CopyAssignmentEnabler<
             aka::conjunction<std::is_copy_assignable<Iterators>...,
                              std::is_copy_constructible<Iterators>...>::value>,
         public details::MoveAssignmentEnabler<
             aka::conjunction<std::is_move_assignable<Iterators>...,
                              std::is_move_constructible<Iterators>...>::value> {
   private:
     using tuple_t = Tuple<Iterators...>;
 
   public:
     using value_type =
         Tuple<typename std::iterator_traits<Iterators>::value_type...>;
     using difference_type = std::common_type_t<
         typename std::iterator_traits<Iterators>::difference_type...>;
-    using pointer =
-        Tuple<typename std::iterator_traits<Iterators>::pointer...>;
+    using pointer = Tuple<typename std::iterator_traits<Iterators>::pointer...>;
     using reference =
         Tuple<typename std::iterator_traits<Iterators>::reference...>;
     using iterator_category = // std::input_iterator_tag;
         std::common_type_t<
             typename std::iterator_traits<Iterators>::iterator_category...>;
 
-//    using nb_iterators = sizeof...(Iterators);
+    //    using nb_iterators = sizeof...(Iterators);
 
   public:
     explicit ZipIterator_(tuple_t iterators)
         : iterators(std::move(iterators)) {}
 
     /* ---------------------------------------------------------------------- */
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::bidirectional_iterator_tag>::value> * = nullptr>
     ZipIterator_ & operator--() {
       tuple::foreach ([](auto && it) { --it; }, iterators);
       return *this;
     }
 
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::bidirectional_iterator_tag>::value> * = nullptr>
     ZipIterator_ operator--(int) {
       auto cpy = *this;
       this->operator--();
       return cpy;
     }
 
     // input iterator ++it
     ZipIterator_ & operator++() {
       tuple::foreach ([](auto && it) { ++it; }, iterators);
       return *this;
     }
 
     // input iterator it++
     ZipIterator_ operator++(int) {
       auto cpy = *this;
       this->operator++();
       return cpy;
     }
 
     // input iterator it != other_it
     bool operator!=(const ZipIterator_ & other) const {
       // return tuple::are_not_equal(iterators, other.iterators);
       return std::get<0>(iterators) !=
              std::get<0>(other.iterators); // helps the compiler to optimize
     }
 
     // input iterator dereference *it
     decltype(auto) operator*() {
       return tuple::transform([](auto && it) -> decltype(auto) { return *it; },
                               iterators);
     }
 
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     difference_type operator-(const ZipIterator_ & other) {
       return std::get<0>(this->iterators) - std::get<0>(other.iterators);
     }
 
     // random iterator it[idx]
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator[](std::size_t idx) {
       return tuple::transform(
           [idx](auto && it) -> decltype(auto) { return it[idx]; }, iterators);
     }
 
     // random iterator it + n
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator+(std::size_t n) {
       return ZipIterator_(std::forward<tuple_t>(tuple::transform(
           [n](auto && it) -> decltype(auto) { return it + n; }, iterators)));
     }
 
     // random iterator it - n
     template <class iterator_category_ = iterator_category,
               std::enable_if_t<aka::is_iterator_category_at_least<
                   iterator_category_,
                   std::random_access_iterator_tag>::value> * = nullptr>
     decltype(auto) operator-(std::size_t n) {
       return ZipIterator_(std::forward<tuple_t>(tuple::transform(
           [n](auto && it) -> decltype(auto) { return it - n; }, iterators)));
     }
 
     template <
         class iterator_category_ = iterator_category,
         std::enable_if_t<aka::is_iterator_category_at_least<
             iterator_category_, std::forward_iterator_tag>::value> * = nullptr>
     bool operator==(const ZipIterator_ & other) const {
       return not tuple::are_not_equal(iterators, other.iterators);
     }
 
   private:
     tuple_t iterators;
   };
 
   template <class... Iterators>
   using ZipIterator = ZipIterator_<std::tuple, Iterators...>;
 
   template <class... Iterators>
   using NamedZipIterator = ZipIterator_<tuple::named_tuple, Iterators...>;
 } // namespace iterators
 
 /* -------------------------------------------------------------------------- */
 template <class... Iterators>
 decltype(auto) zip_iterator(std::tuple<Iterators...> && iterators_tuple) {
   auto zip = iterators::ZipIterator<Iterators...>(
       std::forward<decltype(iterators_tuple)>(iterators_tuple));
   return zip;
 }
 
 template <class... Iterators>
 decltype(auto)
 zip_iterator(tuple::named_tuple<Iterators...> && iterators_tuple) {
   auto zip = iterators::NamedZipIterator<Iterators...>(
       std::forward<decltype(iterators_tuple)>(iterators_tuple));
   return zip;
 }
 
 /* -------------------------------------------------------------------------- */
 namespace containers {
   template <template <class...> class Tuple, class... Containers>
   class ZipContainer_ {
     using containers_t = Tuple<Containers...>;
 
   public:
     explicit ZipContainer_(Containers &&... containers)
         : containers(std::forward<Containers>(containers)...) {}
 
     decltype(auto) begin() const {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.begin(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) end() const {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.end(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) begin() {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.begin(); },
                            std::forward<containers_t>(containers)));
     }
 
     decltype(auto) end() {
       return zip_iterator(
           tuple::transform([](auto && c) { return c.end(); },
                            std::forward<containers_t>(containers)));
     }
 
   private:
     containers_t containers;
   };
 
   template <class... Containers>
   using ZipContainer = ZipContainer_<std::tuple, Containers...>;
 
   template <class... Containers>
   using NamedZipContainer = ZipContainer_<tuple::named_tuple, Containers...>;
 } // namespace containers
 
 /* -------------------------------------------------------------------------- */
 template <class... Containers> decltype(auto) zip(Containers &&... conts) {
   return containers::ZipContainer<Containers...>(
       std::forward<Containers>(conts)...);
 }
 
 template <class... NamedContainers>
 decltype(auto) named_zip(NamedContainers &&... conts) {
   return containers::NamedZipContainer<NamedContainers...>(
       std::forward<NamedContainers>(conts)...);
 }
 
 /* -------------------------------------------------------------------------- */
 template <class... zip_container_t>
 decltype(auto) make_zip_cat(zip_container_t &&... cont) {
   return make_transform_adaptor(
       zip(std::forward<zip_container_t>(cont)...),
       [](auto && value) { return tuple::flatten(value); });
 }
 
 } // namespace AKANTU_ITERATORS_NAMESPACE
 
 namespace std {
-template <template <class ...> class Tuple, typename... Its>
+template <template <class...> class Tuple, typename... Its>
 struct iterator_traits<
     ::AKANTU_ITERATORS_NAMESPACE::iterators::ZipIterator_<Tuple, Its...>> {
 private:
   using iterator_type =
-      typename ::AKANTU_ITERATORS_NAMESPACE::iterators::ZipIterator_<Tuple, Its...>;
+      typename ::AKANTU_ITERATORS_NAMESPACE::iterators::ZipIterator_<Tuple,
+                                                                     Its...>;
 
 public:
   using iterator_category = typename iterator_type::iterator_category;
   using value_type = typename iterator_type::value_type;
   using difference_type = typename iterator_type::difference_type;
   using pointer = typename iterator_type::pointer;
   using reference = typename iterator_type::reference;
 };
 } // namespace std
 
 #endif /* AKA_ZIP_ITERATOR_HH */