From f00c963459c5d90d60f7f8b97c7001dc63207a0d Mon Sep 17 00:00:00 2001
From: "Niall Douglas (s [underscore] sourceforge {at} nedprod [dot] com)"
 <spamtrap@nedprod.com>
Date: Thu, 27 Jul 2017 01:07:14 +0100
Subject: [PATCH] Make includes not Boost path based.

---
 example/static_map.hpp                        | 659 ++++++++----------
 include/boost/static_views/algorithm_base.hpp | 301 ++++----
 .../boost/static_views/detail/find_first.hpp  |  12 +-
 include/boost/static_views/detail/invoke.hpp  |  97 ++-
 include/boost/static_views/detail/utils.hpp   | 139 ++--
 include/boost/static_views/detail/wrapper.hpp | 235 +++----
 include/boost/static_views/drop.hpp           | 185 +++--
 include/boost/static_views/errors.hpp         |  39 +-
 include/boost/static_views/hashed.hpp         | 469 ++++++-------
 include/boost/static_views/lfold.hpp          |  31 +-
 include/boost/static_views/raw_view.hpp       | 263 ++++---
 .../boost/static_views/sequence_traits.hpp    | 236 +++----
 include/boost/static_views/slice.hpp          | 280 ++++----
 include/boost/static_views/take.hpp           | 182 +++--
 include/boost/static_views/through.hpp        | 200 +++---
 include/boost/static_views/view_base.hpp      | 553 +++++++--------
 16 files changed, 1768 insertions(+), 2113 deletions(-)

diff --git a/example/static_map.hpp b/example/static_map.hpp
index d5100a2..4f375e0 100644
--- a/example/static_map.hpp
+++ b/example/static_map.hpp
@@ -8,413 +8,354 @@
 
 #include <type_traits>
 
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/find_first.hpp>
-#include <boost/static_views/detail/invoke.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/hashed.hpp>
-
-
+#include "../include/boost/static_views/detail/config.hpp"
+#include "../include/boost/static_views/detail/find_first.hpp"
+#include "../include/boost/static_views/detail/invoke.hpp"
+#include "../include/boost/static_views/detail/utils.hpp"
+#include "../include/boost/static_views/hashed.hpp"
 
 #if __cplusplus > 201402L
 #if defined(__has_include)
-#   if __has_include(<string_view>)
-#       include <string_view>
-#       define BOOST_STATIC_VIEWS_HAVE_STRING_VIEW
-        BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
-        template <class CharT, class Traits = std::char_traits<CharT>>
-        using basic_string_view =
-            std::basic_string_view<CharT, Traits>;
-        using std::string_view;
-        using std::u16string_view;
-        using std::u32string_view;
-        using std::wstring_view;
-        BOOST_STATIC_VIEWS_END_NAMESPACE
-#   elif __has_include(<experimental/string_view>)
-#       include <experimental/string_view>
-#       define BOOST_STATIC_VIEWS_HAVE_STRING_VIEW
-        BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
-        template <class CharT, class Traits = std::char_traits<CharT>>
-        using basic_string_view =
-            std::experimental::basic_string_view<CharT, Traits>;
-        using std::experimental::string_view;
-        using std::experimental::u16string_view;
-        using std::experimental::u32string_view;
-        using std::experimental::wstring_view;
-        BOOST_STATIC_VIEWS_END_NAMESPACE
-#   endif
+#if __has_include(<string_view>)
+#include <string_view>
+#define BOOST_STATIC_VIEWS_HAVE_STRING_VIEW
+BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
+template <class CharT, class Traits = std::char_traits<CharT>>
+using basic_string_view = std::basic_string_view<CharT, Traits>;
+using std::string_view;
+using std::u16string_view;
+using std::u32string_view;
+using std::wstring_view;
+BOOST_STATIC_VIEWS_END_NAMESPACE
+#elif __has_include(<experimental / string_view>)
+#include <experimental/string_view>
+#define BOOST_STATIC_VIEWS_HAVE_STRING_VIEW
+BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
+template <class CharT, class Traits = std::char_traits<CharT>>
+using basic_string_view = std::experimental::basic_string_view<CharT, Traits>;
+using std::experimental::string_view;
+using std::experimental::u16string_view;
+using std::experimental::u32string_view;
+using std::experimental::wstring_view;
+BOOST_STATIC_VIEWS_END_NAMESPACE
+#endif
 #endif
 #endif
-
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace static_map {
 
 struct key_not_found_error : std::exception {
-    auto what() const noexcept -> char const* override
-    {
-        return _msg;
-    }
+  auto what() const noexcept -> char const * override { return _msg; }
 
-  private:
-    static constexpr char const* _msg = "Key not found.";
+private:
+  static constexpr char const *_msg = "Key not found.";
 };
-constexpr char const* key_not_found_error::_msg;
+constexpr char const *key_not_found_error::_msg;
 
 namespace detail {
 
-    template <class T>
-    using not_equal_t = decltype( std::declval<T>() != std::declval<T>() );
+template <class T>
+using not_equal_t = decltype(std::declval<T>() != std::declval<T>());
 
-    // clang-format off
+// clang-format off
     template <class Char>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto length_c(Char const* const str) noexcept -> std::size_t
-    // clang-format on
-    {
-        using boost::static_views::detail::is_detected;
-        static_assert(std::is_nothrow_default_constructible<Char>::value,
-            "`boost::static_views::static_map::detail::length_c<Char>` "
-            "requires `Char` to be nothrow default-constructible.");
-        static_assert(is_detected<not_equal_t, Char>::value,
-            "`boost::static_views::static_map::detail::length_c<Char>` "
-            "requires `Char` to define `operator!=`.");
-        static_assert(noexcept(std::declval<Char>() != std::declval<Char>()),
-            "`boost::static_views::static_map::detail::length_c<Char>` "
-            "requires `Char`'s `operator!=` to be noexcept.");
-
-        std::size_t i = 0;
-        while (str[i] != Char{}) {
-            ++i;
-        }
-        return (i == 0) ? 0 : (i - 1);
-    }
+// clang-format on
+{
+  using boost::static_views::detail::is_detected;
+  static_assert(std::is_nothrow_default_constructible<Char>::value,
+                "`boost::static_views::static_map::detail::length_c<Char>` "
+                "requires `Char` to be nothrow default-constructible.");
+  static_assert(is_detected<not_equal_t, Char>::value,
+                "`boost::static_views::static_map::detail::length_c<Char>` "
+                "requires `Char` to define `operator!=`.");
+  static_assert(noexcept(std::declval<Char>() != std::declval<Char>()),
+                "`boost::static_views::static_map::detail::length_c<Char>` "
+                "requires `Char`'s `operator!=` to be noexcept.");
+
+  std::size_t i = 0;
+  while (str[i] != Char{}) {
+    ++i;
+  }
+  return (i == 0) ? 0 : (i - 1);
+}
 
-    // This algorithm is "stolen" from the Internet.
-    // clang-format off
+// This algorithm is "stolen" from the Internet.
+// clang-format off
     template <class Char>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto crc32_hash(Char const* const str) noexcept -> std::uint32_t
-    // clang-format on
-    {
-        static_assert(std::is_integral<Char>::value,
-            "`boost::static_views::static_map::detail::crc32_hash` "
-            "requires `Char` to be an integral type.");
-        constexpr std::uint32_t INITXOR  = 0xFFFFFFFF;
-        constexpr std::uint32_t FINALXOR = 0xFFFFFFFF;
-        constexpr std::uint32_t CRCPOLY  = 0xEDB88320;
-
-        auto const l      = length_c(str);
-        auto       crcreg = INITXOR;
-
-        for (std::size_t j = 0; j < l; ++j) {
-            auto b = static_cast<std::make_unsigned_t<Char>>(str[j]);
-            for (std::size_t i = 0; i < 8 * sizeof(Char); ++i) {
-                if ((crcreg ^ b) & 1) {
-                    crcreg = (crcreg >> 1) ^ CRCPOLY;
-                }
-                else {
-                    crcreg >>= 1;
-                }
-                b >>= 1;
-            }
-        }
-
-        return crcreg ^ FINALXOR;
+// clang-format on
+{
+  static_assert(std::is_integral<Char>::value,
+                "`boost::static_views::static_map::detail::crc32_hash` "
+                "requires `Char` to be an integral type.");
+  constexpr std::uint32_t INITXOR = 0xFFFFFFFF;
+  constexpr std::uint32_t FINALXOR = 0xFFFFFFFF;
+  constexpr std::uint32_t CRCPOLY = 0xEDB88320;
+
+  auto const l = length_c(str);
+  auto crcreg = INITXOR;
+
+  for (std::size_t j = 0; j < l; ++j) {
+    auto b = static_cast<std::make_unsigned_t<Char>>(str[j]);
+    for (std::size_t i = 0; i < 8 * sizeof(Char); ++i) {
+      if ((crcreg ^ b) & 1) {
+        crcreg = (crcreg >> 1) ^ CRCPOLY;
+      } else {
+        crcreg >>= 1;
+      }
+      b >>= 1;
     }
+  }
+
+  return crcreg ^ FINALXOR;
+}
 
-    // clang-format off
+// clang-format off
     template <class Char>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto simple_hash(Char const* const str) noexcept
-    // clang-format on
-    {
-        using boost::static_views::detail::is_detected;
-        static_assert(
-            std::is_nothrow_default_constructible<Char>::value,
-            "`boost::static_views::static_map::detail::simple_hash<"
-            "Char>` requires `Char` to be nothrow "
-            "default-constructible.");
-        static_assert(is_detected<not_equal_t, Char>::value,
-            "`boost::static_views::static_map::detail::simple_hash<"
-            "Char>` requires `Char` to define `operator!=`.");
-        static_assert(
-            noexcept(std::declval<Char>() != std::declval<Char>()),
-            "`boost::static_views::static_map::detail::simple_hash<"
-            "Char>` requires `Char`'s `operator!=` to be noexcept.");
-        std::size_t hash = 0;
-        std::size_t i    = 0;
-        while (str[i] != Char{}) {
-            hash = 37 * hash
-                   + static_cast<std::make_unsigned_t<Char>>(str[i]);
-            ++i;
-        }
-        return hash;
-    }
+// clang-format on
+{
+  using boost::static_views::detail::is_detected;
+  static_assert(std::is_nothrow_default_constructible<Char>::value,
+                "`boost::static_views::static_map::detail::simple_hash<"
+                "Char>` requires `Char` to be nothrow "
+                "default-constructible.");
+  static_assert(is_detected<not_equal_t, Char>::value,
+                "`boost::static_views::static_map::detail::simple_hash<"
+                "Char>` requires `Char` to define `operator!=`.");
+  static_assert(noexcept(std::declval<Char>() != std::declval<Char>()),
+                "`boost::static_views::static_map::detail::simple_hash<"
+                "Char>` requires `Char`'s `operator!=` to be noexcept.");
+  std::size_t hash = 0;
+  std::size_t i = 0;
+  while (str[i] != Char{}) {
+    hash = 37 * hash + static_cast<std::make_unsigned_t<Char>>(str[i]);
+    ++i;
+  }
+  return hash;
+}
 
-    template <class T, class = void>
-    struct hash_impl;
+template <class T, class = void> struct hash_impl;
 
-    template <class T>
-    struct hash_impl<T,
-        std::enable_if_t<std::is_integral<T>::value>> {
+template <class T>
+struct hash_impl<T, std::enable_if_t<std::is_integral<T>::value>> {
 
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto operator()(T const x) const noexcept -> std::size_t
-        {
-            return static_cast<std::size_t>(x);
-        }
-    };
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto operator()(T const x) const noexcept -> std::size_t {
+    return static_cast<std::size_t>(x);
+  }
+};
 
-    template <class Char>
-    struct hash_impl<Char const*,
-        std::enable_if_t<std::is_integral<Char>::value>> {
+template <class Char>
+struct hash_impl<Char const *,
+                 std::enable_if_t<std::is_integral<Char>::value>> {
 
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto operator()(Char const* const x) const noexcept
-            -> std::size_t
-        {
-            return simple_hash(x);
-            // return static_cast<std::size_t>(crc32_hash(x));
-        }
-    };
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto operator()(Char const *const x) const noexcept -> std::size_t {
+    return simple_hash(x);
+    // return static_cast<std::size_t>(crc32_hash(x));
+  }
+};
 
 #if defined(BOOST_STATIC_VIEWS_HAVE_STRING_VIEW)
-    template <class Char>
-    struct hash_impl<basic_string_view<Char>> {
+template <class Char> struct hash_impl<basic_string_view<Char>> {
 
-        BOOST_STATIC_VIEWS_CONSTEXPR auto operator()(
-            basic_string_view<Char> const x) const noexcept
-            -> std::size_t
-        {
-            return hash_impl<Char const*>{}(x.data());
-        }
-    };
+  BOOST_STATIC_VIEWS_CONSTEXPR auto
+  operator()(basic_string_view<Char> const x) const noexcept -> std::size_t {
+    return hash_impl<Char const *>{}(x.data());
+  }
+};
 #endif
 
 } // namespace detail
 
 struct hash_c {
-    template <class T>
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    auto operator()(T&& x) const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
-            detail::hash_impl<std::decay_t<T>>{}(std::forward<T>(x))))
-        -> std::size_t
-    {
-        return detail::hash_impl<std::decay_t<T>>{}(std::forward<T>(x));
-    }
+  template <class T>
+  BOOST_STATIC_VIEWS_FORCEINLINE BOOST_STATIC_VIEWS_CONSTEXPR auto
+  operator()(T &&x) const BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+      noexcept(detail::hash_impl<std::decay_t<T>>{}(std::forward<T>(x))))
+      -> std::size_t {
+    return detail::hash_impl<std::decay_t<T>>{}(std::forward<T>(x));
+  }
 };
 
-
 namespace detail {
 
+template <class HashedView, class Pred, class GetKey, class GetMapped>
+class static_map : private HashedView {
+
+  // Make sure HashedView is actually a View.
+  static_assert(boost::static_views::detail::concepts::is_View<HashedView>(),
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure Pred is not a strange reference or something.
+  static_assert(std::is_same<Pred, std::decay_t<Pred>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure Pred is a wrapper.
+  static_assert(boost::static_views::detail::is_wrapper<Pred>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure GetKey is not a strange reference or something.
+  static_assert(std::is_same<GetKey, std::decay_t<GetKey>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure GetKey is a wrapper.
+  static_assert(boost::static_views::detail::is_wrapper<GetKey>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure GetMapped is not a strange reference or something.
+  static_assert(std::is_same<GetMapped, std::decay_t<GetMapped>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+  // Make sure GetMapped is a wrapper.
+  static_assert(boost::static_views::detail::is_wrapper<GetMapped>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+private:
+  using bucket_type = std::decay_t<decltype(
+      std::declval<HashedView>()[std::declval<std::size_t>()])>;
+
+  // Make sure buckets are actually Views.
+  static_assert(boost::static_views::detail::concepts::is_View<bucket_type>(),
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+public:
+  using type = static_map<HashedView, Pred, GetKey, GetMapped>;
+  using value_type = std::remove_reference_t<decltype(
+      std::declval<bucket_type>()[std::declval<std::size_t>()])>;
+  using key_getter = typename GetKey::type;
+  using value_getter = typename GetMapped::type;
+
+private:
+  template <class T>
+  using callable_with_value_t = decltype(boost::static_views::invoke(
+      std::declval<T const &>(), std::declval<value_type>()));
+
+  static_assert(boost::static_views::detail::is_detected<callable_with_value_t,
+                                                         key_getter>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(boost::static_views::detail::is_detected<callable_with_value_t,
+                                                         value_getter>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+public:
+  using key_type = std::remove_reference_t<decltype(boost::static_views::invoke(
+      std::declval<key_getter const &>(), std::declval<value_type &>()))>;
+  using mapped_type =
+      std::remove_reference_t<decltype(boost::static_views::invoke(
+          std::declval<value_getter const &>(), std::declval<value_type &>()))>;
+  using key_equal = typename Pred::type;
+
+private:
+  template <class T>
+  using callable_with_key_t = decltype(boost::static_views::invoke(
+      std::declval<T const &>(), std::declval<key_type const &>()));
+
+  template <class T>
+  using callable_with_2_key_t =
+      decltype(boost::static_views::invoke(std::declval<T const &>(),
+                                           std::declval<key_type const &>(),
+                                           std::declval<key_type const &>()));
+
+  static_assert(boost::static_views::detail::is_detected<callable_with_2_key_t,
+                                                         key_equal>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+
+public:
+  using hasher = std::decay_t<decltype(
+      std::declval<HashedView const &>().hash_function()._hf.get())>;
+  static_assert(
+      std::is_convertible<
+          boost::static_views::detail::detected_t<callable_with_key_t, hasher>,
+          std::size_t>::value,
+      BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  using difference_type = std::ptrdiff_t;
+  using size_type = std::size_t;
+
+private:
+  using view_type = HashedView;
+
+  Pred _eq;
+  GetKey _get_key;
+  GetMapped _get_mapped;
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO _hash_function() const {
+    return this->hash_function()._hf.get();
+  }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto _lookup(key_type const &k) const -> value_type const * {
+    struct pred_equal {
+      key_getter const &get_key;
+      key_equal const &equal;
+      key_type const &x;
+
+      BOOST_STATIC_VIEWS_CONSTEXPR
+      auto operator()(value_type const &y) -> bool {
+        return boost::static_views::invoke(
+            equal, x, boost::static_views::invoke(get_key, y));
+      }
+    };
 
-    template <class HashedView, class Pred, class GetKey, class GetMapped>
-    class static_map : private HashedView {
-
-        // Make sure HashedView is actually a View.
-        static_assert(boost::static_views::detail::concepts::is_View<
-                          HashedView>(),
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure Pred is not a strange reference or something.
-        static_assert(std::is_same<Pred, std::decay_t<Pred>>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure Pred is a wrapper.
-        static_assert(
-            boost::static_views::detail::is_wrapper<Pred>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure GetKey is not a strange reference or something.
-        static_assert(
-            std::is_same<GetKey, std::decay_t<GetKey>>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure GetKey is a wrapper.
-        static_assert(
-            boost::static_views::detail::is_wrapper<GetKey>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure GetMapped is not a strange reference or something.
-        static_assert(
-            std::is_same<GetMapped, std::decay_t<GetMapped>>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-        // Make sure GetMapped is a wrapper.
-        static_assert(
-            boost::static_views::detail::is_wrapper<GetMapped>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-      private:
-        using bucket_type = std::decay_t<decltype(
-            std::declval<HashedView>()[std::declval<std::size_t>()])>;
-
-        // Make sure buckets are actually Views.
-        static_assert(boost::static_views::detail::concepts::is_View<
-                          bucket_type>(),
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-
-      public:
-        using type = static_map<HashedView, Pred, GetKey, GetMapped>;
-        using value_type =
-            std::remove_reference_t<decltype(std::declval<
-                bucket_type>()[std::declval<std::size_t>()])>;
-        using key_getter   = typename GetKey::type;
-        using value_getter = typename GetMapped::type;
-
-      private:
-        template <class T>
-        using callable_with_value_t = decltype(
-            boost::static_views::invoke(std::declval<T const&>(),
-                std::declval<value_type>()));
-
-        static_assert(boost::static_views::detail::is_detected<
-                          callable_with_value_t, key_getter>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-        static_assert(boost::static_views::detail::is_detected<
-                          callable_with_value_t, value_getter>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-      public:
-        using key_type    = std::remove_reference_t<decltype(
-            boost::static_views::invoke(
-                std::declval<key_getter const&>(),
-                std::declval<value_type&>()))>;
-        using mapped_type = std::remove_reference_t<decltype(
-            boost::static_views::invoke(
-                std::declval<value_getter const&>(),
-                std::declval<value_type&>()))>;
-        using key_equal   = typename Pred::type;
-
-      private:
-        template <class T>
-        using callable_with_key_t = decltype(
-            boost::static_views::invoke(std::declval<T const&>(),
-                std::declval<key_type const&>()));
-
-        template <class T>
-        using callable_with_2_key_t = decltype(
-            boost::static_views::invoke(std::declval<T const&>(),
-                std::declval<key_type const&>(),
-                std::declval<key_type const&>()));
-
-        static_assert(boost::static_views::detail::is_detected<
-                          callable_with_2_key_t, key_equal>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-
-      public:
-        using hasher =
-            std::decay_t<decltype(std::declval<HashedView const&>()
-                                      .hash_function()
-                                      ._hf.get())>;
-        static_assert(std::is_convertible<
-                          boost::static_views::detail::detected_t<
-                              callable_with_key_t, hasher>,
-                          std::size_t>::value,
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-        using difference_type = std::ptrdiff_t;
-        using size_type       = std::size_t;
-
-      private:
-        using view_type = HashedView;
-
-        Pred      _eq;
-        GetKey    _get_key;
-        GetMapped _get_mapped;
-
-
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        BOOST_STATIC_VIEWS_DECLTYPE_AUTO _hash_function() const
-        {
-            return this->hash_function()._hf.get();
-        }
-
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto _lookup(key_type const& k) const -> value_type const*
-        {
-            struct pred_equal {
-                key_getter const& get_key;
-                key_equal const&  equal;
-                key_type const&   x;
-
-                BOOST_STATIC_VIEWS_CONSTEXPR
-                auto operator()(value_type const& y) -> bool
-                {
-                    return boost::static_views::invoke(
-                        equal, x, boost::static_views::invoke(get_key, y));
-                }
-            };
-
-            // get all elements matching key k
-            auto const ys =
-                static_cast<view_type const*>(this)->operator[](
-                    boost::static_views::invoke(_hash_function(), k));
-            // search for the one that compares equal to k
-            auto const i = boost::static_views::find_first_i(
-                ys, pred_equal{_get_key.get(), _eq.get(), k});
-
-            return (i < ys.size()) ? &(ys[i]) : nullptr;
-        }
-
-      public:
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        static_map(view_type&& xs, Pred&& eq, GetKey&& get_key,
-            GetMapped&& get_mapped)
-            : view_type{std::move(xs)}
-            , _eq{std::move(eq)}
-            , _get_key{std::move(get_key)}
-            , _get_mapped{std::move(get_mapped)}
-        {
-        }
-
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto size() const -> size_type
-        {
-            return static_cast<view_type const*>(this)->size();
-        }
-
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto find(key_type const& k) const -> value_type*
-        {
-            return _lookup(k);
-        }
-
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        auto count(key_type const& k) const -> size_type
-        {
-            return _lookup(k) == nullptr ? 0 : 1;
-        }
-
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        decltype(auto) at(key_type const& k) const
-        {
-            auto* x = _lookup(k);
-            if (x == nullptr) {
-                throw key_not_found_error{};
-            }
-            return invoke(_get_mapped.get(), *x);
-        }
+    // get all elements matching key k
+    auto const ys = static_cast<view_type const *>(this)->operator[](
+        boost::static_views::invoke(_hash_function(), k));
+    // search for the one that compares equal to k
+    auto const i = boost::static_views::find_first_i(
+        ys, pred_equal{_get_key.get(), _eq.get(), k});
+
+    return (i < ys.size()) ? &(ys[i]) : nullptr;
+  }
+
+public:
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  static_map(view_type &&xs, Pred &&eq, GetKey &&get_key,
+             GetMapped &&get_mapped)
+      : view_type{std::move(xs)}, _eq{std::move(eq)},
+        _get_key{std::move(get_key)}, _get_mapped{std::move(get_mapped)} {}
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto size() const -> size_type {
+    return static_cast<view_type const *>(this)->size();
+  }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto find(key_type const &k) const -> value_type * { return _lookup(k); }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto count(key_type const &k) const -> size_type {
+    return _lookup(k) == nullptr ? 0 : 1;
+  }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  decltype(auto) at(key_type const &k) const {
+    auto *x = _lookup(k);
+    if (x == nullptr) {
+      throw key_not_found_error{};
+    }
+    return invoke(_get_mapped.get(), *x);
+  }
 
-        BOOST_STATIC_VIEWS_FORCEINLINE
-        BOOST_STATIC_VIEWS_CONSTEXPR
-        decltype(auto) operator[](key_type const& k) const
-        {
-            return at(k);
-        }
-    };
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  decltype(auto) operator[](key_type const &k) const { return at(k); }
+};
 
 } // namespace detail
 
@@ -469,10 +410,4 @@ auto make_static_map(View&& xs, GetKey&& get_key, GetMapped&& get_mapped,
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
-
-
-
-
-
-
 #endif // BOOST_STATIC_VIEWS_STATIC_MAP_HPP
diff --git a/include/boost/static_views/algorithm_base.hpp b/include/boost/static_views/algorithm_base.hpp
index ee80812..2472f6d 100644
--- a/include/boost/static_views/algorithm_base.hpp
+++ b/include/boost/static_views/algorithm_base.hpp
@@ -6,13 +6,14 @@
 #ifndef BOOST_STATIC_VIEWS_ALGORITHM_BASE_HPP
 #define BOOST_STATIC_VIEWS_ALGORITHM_BASE_HPP
 
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
+#include "detail/wrapper.hpp"
+#include "view_base.hpp"
+
 #include <tuple>
 #include <type_traits>
 #include <utility>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/detail/wrapper.hpp>
-#include <boost/static_views/view_base.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -22,8 +23,7 @@ BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 /// By deriving from :cpp:class:`algorithm_base`, you tell StaticView
 /// that the derived class models the :ref:`view <algorithm-concept>`
 /// concept. \endverbatim
-struct algorithm_base {
-};
+struct algorithm_base {};
 
 /// \brief Checks whether `T` models the Algorithm concept.
 
@@ -38,35 +38,31 @@ struct algorithm_base {
 ///   {};
 ///
 /// \endverbatim
-template <class V>
-struct is_algorithm : std::is_base_of<algorithm_base, V> {
-};
+template <class V> struct is_algorithm : std::is_base_of<algorithm_base, V> {};
 
 namespace detail {
 template <class Function, class... Args>
 struct algorithm_impl : algorithm_base {
 
-  private:
-    Function                     _func;
-    std::tuple<wrapper<Args>...> _args;
-
-    template <class View>
-    static constexpr auto is_noexcept_call_cref() noexcept -> bool
-    {
-        return noexcept(invoke(std::declval<Function const&>(),
-            make_wrapper(std::declval<View&&>()),
-            std::declval<Args const&>()...));
-    }
-
-    template <class View>
-    static constexpr auto is_noexcept_call_move() noexcept -> bool
-    {
-        return noexcept(invoke(std::declval<Function&&>(),
-            make_wrapper(std::declval<View&&>()),
-            std::declval<Args&&>()...));
-    }
-
-    // clang-format off
+private:
+  Function _func;
+  std::tuple<wrapper<Args>...> _args;
+
+  template <class View>
+  static constexpr auto is_noexcept_call_cref() noexcept -> bool {
+    return noexcept(invoke(std::declval<Function const &>(),
+                           make_wrapper(std::declval<View &&>()),
+                           std::declval<Args const &>()...));
+  }
+
+  template <class View>
+  static constexpr auto is_noexcept_call_move() noexcept -> bool {
+    return noexcept(invoke(std::declval<Function &&>(),
+                           make_wrapper(std::declval<View &&>()),
+                           std::declval<Args &&>()...));
+  }
+
+  // clang-format off
     template <class View, std::size_t... Is>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -78,21 +74,21 @@ struct algorithm_impl : algorithm_base {
         return invoke(_func, make_wrapper(std::forward<View>(xs)),
             std::get<Is>(_args).get()...);
     }
-    // clang-format on
-
-    /* // I think that this overload makes little sense
-    template <class View, std::size_t... Is>
-    BOOST_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO call_impl(View&& xs,
-        std::index_sequence<Is...>) &
-    {
-        return invoke(_func, make_wrapper(std::forward<View>(xs)),
-            std::get<Is>(_args).get()...);
-    }
-    */
-
-    // clang-format off
+  // clang-format on
+
+  /* // I think that this overload makes little sense
+  template <class View, std::size_t... Is>
+  BOOST_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO call_impl(View&& xs,
+      std::index_sequence<Is...>) &
+  {
+      return invoke(_func, make_wrapper(std::forward<View>(xs)),
+          std::get<Is>(_args).get()...);
+  }
+  */
+
+  // clang-format off
     template <class View, std::size_t... Is>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -105,39 +101,35 @@ struct algorithm_impl : algorithm_base {
             make_wrapper(std::forward<View>(xs)),
             std::get<Is>(std::move(_args)).get()...);
     }
-    // clang-format on
+  // clang-format on
 
-  public:
-
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR algorithm_impl(
-        Function&& f, wrapper<Args>&&... args)
+public:
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR algorithm_impl(Function &&f,
+                                                       wrapper<Args> &&... args)
 #if defined(BOOST_STATIC_VIEWS_NEGLECT_STD_TUPLE)
-        // std::tuple's constructor is not marked noexcept in most of
-        // the implementations. We "know", however, that the only
-        // thing std::tuple's move constructor needs is for each Args
-        // to be nothrow move constructible. Hence, we can "neglect"
-        // the fact that std::tuple's move constructor is not
-        // noexcept.
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            utils::all(std::is_nothrow_move_constructible<
-                           wrapper<Args>>::value...,
-                std::is_nothrow_move_constructible<Function>::value))
+      // std::tuple's constructor is not marked noexcept in most of
+      // the implementations. We "know", however, that the only
+      // thing std::tuple's move constructor needs is for each Args
+      // to be nothrow move constructible. Hence, we can "neglect"
+      // the fact that std::tuple's move constructor is not
+      // noexcept.
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_move_constructible<wrapper<Args>>::value...,
+          std::is_nothrow_move_constructible<Function>::value))
 #else
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            utils::all(std::is_nothrow_move_constructible<
-                           std::tuple<wrapper<Args>...>>::value,
-                std::is_nothrow_move_constructible<Function>::value))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_move_constructible<
+                         std::tuple<wrapper<Args>...>>::value,
+                     std::is_nothrow_move_constructible<Function>::value))
 #endif
-        : _func{std::move(f)}, _args{std::move(args)...}
-    {
-    }
+      : _func{std::move(f)}, _args{std::move(args)...} {
+  }
 
-#define FAKE_CALL_IMPL(qualifiers)                                   \
-    std::declval<algorithm_impl qualifiers>().call_impl(             \
-        std::forward<View>(xs),                                      \
-        std::make_index_sequence<sizeof...(Args)>{})
+#define FAKE_CALL_IMPL(qualifiers)                                             \
+  std::declval<algorithm_impl qualifiers>().call_impl(                         \
+      std::forward<View>(xs), std::make_index_sequence<sizeof...(Args)>{})
 
-    // clang-format off
+  // clang-format off
     template <class View>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -148,23 +140,23 @@ struct algorithm_impl : algorithm_base {
         return call_impl(std::forward<View>(xs),
             std::make_index_sequence<sizeof...(Args)>{});
     }
-    // clang-format on
-
-    /*
-    template <class View>
-    BOOST_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator()(View&& xs) &
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(FAKE_CALL_IMPL(&)))
-    {
-        static_assert(is_view<std::decay_t<View>>::value,
-            "`View` must model the View concept.");
-        return call_impl(std::forward<View>(xs),
-            std::make_index_sequence<sizeof...(Args)>{});
-    }
-    */
-
-    // clang-format off
+  // clang-format on
+
+  /*
+  template <class View>
+  BOOST_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator()(View&& xs) &
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(FAKE_CALL_IMPL(&)))
+  {
+      static_assert(is_view<std::decay_t<View>>::value,
+          "`View` must model the View concept.");
+      return call_impl(std::forward<View>(xs),
+          std::make_index_sequence<sizeof...(Args)>{});
+  }
+  */
+
+  // clang-format off
     template <class View>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -176,87 +168,79 @@ struct algorithm_impl : algorithm_base {
             std::forward<View>(xs),
             std::make_index_sequence<sizeof...(Args)>{});
     }
-    // clang-format on
+// clang-format on
 
 #undef FAKE_CALL_IMPL
 
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    algorithm_impl(algorithm_impl const& other)
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  algorithm_impl(algorithm_impl const &other)
 #if defined(BOOST_STATIC_VIEWS_NEGLECT_STD_TUPLE)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_copy_constructible<Function>::value,
-            std::is_nothrow_copy_constructible<
-                wrapper<Args>>::value...))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_copy_constructible<Function>::value,
+          std::is_nothrow_copy_constructible<wrapper<Args>>::value...))
 #else
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_copy_constructible<Function>::value,
-            std::is_nothrow_copy_constructible<
-                std::tuple<wrapper<Args>...>>::value))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_copy_constructible<Function>::value,
+                     std::is_nothrow_copy_constructible<
+                         std::tuple<wrapper<Args>...>>::value))
 #endif
-        : _func{other._func}, _args{other._args}
-    {
-    }
+      : _func{other._func}, _args{other._args} {
+  }
 
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    algorithm_impl(algorithm_impl&& other)
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  algorithm_impl(algorithm_impl &&other)
 #if defined(BOOST_STATIC_VIEWS_NEGLECT_STD_TUPLE)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_move_constructible<Function>::value,
-            std::is_nothrow_move_constructible<
-                wrapper<Args>>::value...))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_move_constructible<Function>::value,
+          std::is_nothrow_move_constructible<wrapper<Args>>::value...))
 #else
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_move_constructible<Function>::value,
-            std::is_nothrow_move_constructible<
-                std::tuple<wrapper<Args>...>>::value))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_move_constructible<Function>::value,
+                     std::is_nothrow_move_constructible<
+                         std::tuple<wrapper<Args>...>>::value))
 #endif
-        : _func{std::move(other._func)}, _args{std::move(other._args)}
-    {
-    }
+      : _func{std::move(other._func)}, _args{std::move(other._args)} {
+  }
 
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    algorithm_impl& operator=(algorithm_impl const& other)
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  algorithm_impl &operator=(algorithm_impl const &other)
 #if defined(BOOST_STATIC_VIEWS_NEGLECT_STD_TUPLE)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_copy_assignable<Function>::value,
-            std::is_nothrow_copy_assignable<wrapper<Args>>::value...))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_copy_assignable<Function>::value,
+                     std::is_nothrow_copy_assignable<wrapper<Args>>::value...))
 #else
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_copy_assignable<Function>::value,
-            std::is_nothrow_copy_assignable<
-                std::tuple<wrapper<Args>...>>::value))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_copy_assignable<Function>::value,
+          std::is_nothrow_copy_assignable<std::tuple<wrapper<Args>...>>::value))
 #endif
-    {
-        _func = other._func;
-        _args = other._args;
-        return *this;
-    }
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    algorithm_impl& operator=(algorithm_impl&& other)
+  {
+    _func = other._func;
+    _args = other._args;
+    return *this;
+  }
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  algorithm_impl &operator=(algorithm_impl &&other)
 #if defined(BOOST_STATIC_VIEWS_NEGLECT_STD_TUPLE)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_move_assignable<Function>::value,
-            std::is_nothrow_move_assignable<wrapper<Args>>::value...))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_move_assignable<Function>::value,
+                     std::is_nothrow_move_assignable<wrapper<Args>>::value...))
 #else
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_move_assignable<Function>::value,
-            std::is_nothrow_move_assignable<
-                std::tuple<wrapper<Args>...>>::value))
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_move_assignable<Function>::value,
+          std::is_nothrow_move_assignable<std::tuple<wrapper<Args>...>>::value))
 #endif
-    {
-        _func = std::move(other._func);
-        _args = std::move(other._args);
-        return *this;
-    }
-
-    ~algorithm_impl() = default;
+  {
+    _func = std::move(other._func);
+    _args = std::move(other._args);
+    return *this;
+  }
 
+  ~algorithm_impl() = default;
 };
 
-template <class Function>
-struct make_algorithm_impl {
-    // clang-format off
+template <class Function> struct make_algorithm_impl {
+  // clang-format off
     template <class... Args>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -274,19 +258,18 @@ struct make_algorithm_impl {
         return algorithm_impl<Function, Args&&...>(
             Function{}, make_wrapper(std::forward<Args>(args))...);
     }
-    // clang-format on
+  // clang-format on
 };
 
 } // namespace detail
 
-#define BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(type, name)          \
-    inline namespace {                                               \
-        BOOST_STATIC_VIEWS_CONSTEXPR auto const& name =              \
-            ::BOOST_STATIC_VIEWS_NAMESPACE::_static_const<           \
-                ::BOOST_STATIC_VIEWS_NAMESPACE::detail::             \
-                    make_algorithm_impl<type>>;                      \
-    }                                                                \
-    /**/
+#define BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(type, name)                    \
+  inline namespace {                                                           \
+  BOOST_STATIC_VIEWS_CONSTEXPR auto const &name =                              \
+      ::BOOST_STATIC_VIEWS_NAMESPACE::_static_const<                           \
+          ::BOOST_STATIC_VIEWS_NAMESPACE::detail::make_algorithm_impl<type>>;  \
+  } \
+/**/
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
diff --git a/include/boost/static_views/detail/find_first.hpp b/include/boost/static_views/detail/find_first.hpp
index cfda644..f17bdbb 100644
--- a/include/boost/static_views/detail/find_first.hpp
+++ b/include/boost/static_views/detail/find_first.hpp
@@ -8,15 +8,16 @@
 
 #include <functional>
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
+
+#include "config.hpp"
+#include "utils.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
 struct find_first_i_impl {
-    // clang-format off
+  // clang-format off
     template <class View, class Predicate>
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto operator()(View&& xs, Predicate&& p = Predicate{}) const
@@ -34,13 +35,12 @@ struct find_first_i_impl {
         }
         return i;
     }
-    // clang-format on
+  // clang-format on
 };
 
 } // namespace detail
 
-BOOST_STATIC_VIEWS_INLINE_VARIABLE(
-    detail::find_first_i_impl, find_first_i)
+BOOST_STATIC_VIEWS_INLINE_VARIABLE(detail::find_first_i_impl, find_first_i)
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
diff --git a/include/boost/static_views/detail/invoke.hpp b/include/boost/static_views/detail/invoke.hpp
index 62090f7..2a14d60 100644
--- a/include/boost/static_views/detail/invoke.hpp
+++ b/include/boost/static_views/detail/invoke.hpp
@@ -9,24 +9,21 @@
 #ifndef BOOST_STATIC_VIEWS_DETAIL_INVOKE_HPP
 #define BOOST_STATIC_VIEWS_DETAIL_INVOKE_HPP
 
+#include "config.hpp"
+
 #include <functional>
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
 /// \brief Trait that determines whether `T` is a reference_wrapper.
-template <class T>
-struct is_reference_wrapper : std::false_type {
-};
+template <class T> struct is_reference_wrapper : std::false_type {};
 
 /// \cond
 template <class T>
-struct is_reference_wrapper<std::reference_wrapper<T>>
-    : std::true_type {
-};
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 /// \endcond
 
 #if 0 // Current implementations of invoke are not constexpr.
@@ -195,52 +192,46 @@ constexpr decltype(auto) invoke_nonmember
 // clang-format on
 
 struct invoke_impl {
-  private:
-    template <class Function, class T, class Object,
-        class = std::enable_if_t<
-            std::is_member_object_pointer<Function(T::*)>::value>>
-    BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
-    call_impl(Function(T::*f), Object&& obj)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
-            invoke_member_data(f, std::forward<Object>(obj))))
-    {
-        return invoke_member_data(f, std::forward<Object>(obj));
-    }
-
-    template <class Function, class T, class Object, class... Args,
-        class = std::enable_if_t<
-            std::is_member_function_pointer<Function(T::*)>::value>>
-    BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
-    call_impl(Function(T::*f), Object&& obj, Args&&... args)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke_member_func(f,
-            std::forward<Object>(obj), std::forward<Args>(args)...)))
-    {
-        return invoke_member_func(f, std::forward<Object>(obj),
-            std::forward<Args>(args)...);
-    }
-
-    template <class Function, class... Args,
-        class = std::enable_if_t<
-            !std::is_member_pointer<std::decay_t<Function>>::value>>
-    BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
-    call_impl(Function&& f, Args&&... args)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke_nonmember(
-            std::forward<Function>(f), std::forward<Args>(args)...)))
-    {
-        return invoke_nonmember(
-            std::forward<Function>(f), std::forward<Args>(args)...);
-    }
-
-  public:
-    template <class Function, class... Args>
-    BOOST_STATIC_VIEWS_FORCEINLINE constexpr decltype(auto)
-    operator()(Function&& f, Args&&... args) const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(call_impl(
-            std::forward<Function>(f), std::forward<Args>(args)...)))
-    {
-        return call_impl(
-            std::forward<Function>(f), std::forward<Args>(args)...);
-    }
+private:
+  template <class Function, class T, class Object,
+            class = std::enable_if_t<
+                std::is_member_object_pointer<Function(T::*)>::value>>
+  BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
+  call_impl(Function(T::*f), Object &&obj) BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+      noexcept(invoke_member_data(f, std::forward<Object>(obj)))) {
+    return invoke_member_data(f, std::forward<Object>(obj));
+  }
+
+  template <class Function, class T, class Object, class... Args,
+            class = std::enable_if_t<
+                std::is_member_function_pointer<Function(T::*)>::value>>
+  BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
+  call_impl(Function(T::*f), Object &&obj, Args &&... args)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke_member_func(
+          f, std::forward<Object>(obj), std::forward<Args>(args)...))) {
+    return invoke_member_func(f, std::forward<Object>(obj),
+                              std::forward<Args>(args)...);
+  }
+
+  template <class Function, class... Args,
+            class = std::enable_if_t<
+                !std::is_member_pointer<std::decay_t<Function>>::value>>
+  BOOST_STATIC_VIEWS_FORCEINLINE static constexpr decltype(auto)
+  call_impl(Function &&f, Args &&... args)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke_nonmember(
+          std::forward<Function>(f), std::forward<Args>(args)...))) {
+    return invoke_nonmember(std::forward<Function>(f),
+                            std::forward<Args>(args)...);
+  }
+
+public:
+  template <class Function, class... Args>
+  BOOST_STATIC_VIEWS_FORCEINLINE constexpr decltype(auto)
+  operator()(Function &&f, Args &&... args) const
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
+          call_impl(std::forward<Function>(f), std::forward<Args>(args)...))) {
+    return call_impl(std::forward<Function>(f), std::forward<Args>(args)...);
+  }
 };
 
 #endif // if C++17
diff --git a/include/boost/static_views/detail/utils.hpp b/include/boost/static_views/detail/utils.hpp
index 3193760..ab01d22 100644
--- a/include/boost/static_views/detail/utils.hpp
+++ b/include/boost/static_views/detail/utils.hpp
@@ -6,43 +6,42 @@
 #ifndef BOOST_STATIC_VIEWS_DETAIL_UTILS_HPP
 #define BOOST_STATIC_VIEWS_DETAIL_UTILS_HPP
 
+#include "config.hpp"
+
 #include <tuple>
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 namespace utils {
 
-    constexpr auto all() noexcept -> bool { return true; }
+constexpr auto all() noexcept -> bool { return true; }
 
-    template <class... Bools>
-    constexpr auto all(bool const x, Bools... xs) noexcept -> bool
-    {
-        return x && all(xs...);
-    }
+template <class... Bools>
+constexpr auto all(bool const x, Bools... xs) noexcept -> bool {
+  return x && all(xs...);
+}
 
 } // namespace utils
 
 #if defined(__cpp_lib_void_t) && __cpp_lib_void_t >= 201411
-    using std::void_t;
+using std::void_t;
 #else
-    template <class...>
-    using void_t = void;
+template <class...> using void_t = void;
 #endif
 
 struct nonesuch {
-    nonesuch()                = delete;
-    ~nonesuch()               = delete;
-    nonesuch(nonesuch const&) = delete;
-    nonesuch(nonesuch&&)      = delete;
-    nonesuch& operator=(nonesuch const&) = delete;
-    nonesuch& operator=(nonesuch&&) = delete;
+  nonesuch() = delete;
+  ~nonesuch() = delete;
+  nonesuch(nonesuch const &) = delete;
+  nonesuch(nonesuch &&) = delete;
+  nonesuch &operator=(nonesuch const &) = delete;
+  nonesuch &operator=(nonesuch &&) = delete;
 };
 
 struct not_copy_constructible {
-    // clang-format off
+  // clang-format off
     not_copy_constructible(not_copy_constructible const&) = delete;
 
     constexpr not_copy_constructible()
@@ -53,11 +52,11 @@ struct not_copy_constructible {
         noexcept = default;
     constexpr not_copy_constructible& operator=(not_copy_constructible&&)
         noexcept = default;
-    // clang-format on
+  // clang-format on
 };
 
 struct not_move_constructible {
-    // clang-format off
+  // clang-format off
     not_move_constructible(not_move_constructible&&) = delete;
 
     constexpr not_move_constructible()
@@ -68,11 +67,11 @@ struct not_move_constructible {
         noexcept = default;
     constexpr not_move_constructible& operator=(not_move_constructible&&)
         noexcept = default;
-    // clang-format on
+  // clang-format on
 };
 
 struct not_copy_assignable {
-    // clang-format off
+  // clang-format off
     not_copy_assignable& operator=(not_copy_assignable const&) = delete;
 
     constexpr not_copy_assignable()
@@ -83,11 +82,11 @@ struct not_copy_assignable {
         noexcept = default;
     constexpr not_copy_assignable& operator=(not_copy_assignable&&)
         noexcept = default;
-    // clang-format on
+  // clang-format on
 };
 
 struct not_move_assignable {
-    // clang-format off
+  // clang-format off
     not_move_assignable& operator=(not_move_assignable&&) = delete;
 
     constexpr not_move_assignable()
@@ -98,71 +97,62 @@ struct not_move_assignable {
         noexcept = default;
     constexpr not_move_assignable& operator=(not_move_assignable const&)
         noexcept = default;
-    // clang-format on
+  // clang-format on
 };
 
-template <class T, class List>
-struct push_front;
+template <class T, class List> struct push_front;
 
 template <template <class...> class List, class T, class... Args>
 struct push_front<T, List<Args...>> {
-    using type = List<T, Args...>;
+  using type = List<T, Args...>;
 };
 
 template <class T, class List>
 using push_front_t = typename push_front<T, List>::type;
 
-template <class List>
-struct filter_out_void;
+template <class List> struct filter_out_void;
 
-template <template <class...> class List>
-struct filter_out_void<List<>> {
-    using type = List<>;
+template <template <class...> class List> struct filter_out_void<List<>> {
+  using type = List<>;
 };
 
 template <template <class...> class List, class Arg, class... Args>
 struct filter_out_void<List<Arg, Args...>> {
-    using type = std::conditional_t < std::is_same<Arg, void>::value,
-          typename filter_out_void<List<Args...>>::type,
-          push_front_t<Arg,
-              typename filter_out_void<List<Args...>>::type>>;
+  using type = std::conditional_t<
+      std::is_same<Arg, void>::value,
+      typename filter_out_void<List<Args...>>::type,
+      push_front_t<Arg, typename filter_out_void<List<Args...>>::type>>;
 };
 
 template <class List>
 using filter_out_void_t = typename filter_out_void<List>::type;
 
-template <class T>
-struct conditional_copy_and_move_impl;
+template <class T> struct conditional_copy_and_move_impl;
 
 template <template <class...> class List, class... Ts>
 struct conditional_copy_and_move_impl<List<Ts...>> : Ts... {
-    constexpr conditional_copy_and_move_impl()
-        = default;
-    constexpr conditional_copy_and_move_impl(conditional_copy_and_move_impl const&)
-        = default;
-    constexpr conditional_copy_and_move_impl(conditional_copy_and_move_impl&&)
-        = default;
-    constexpr conditional_copy_and_move_impl& operator=(
-        conditional_copy_and_move_impl const&) = default;
-    constexpr conditional_copy_and_move_impl& operator=(
-        conditional_copy_and_move_impl&&) = default;
+  constexpr conditional_copy_and_move_impl() = default;
+  constexpr conditional_copy_and_move_impl(
+      conditional_copy_and_move_impl const &) = default;
+  constexpr conditional_copy_and_move_impl(conditional_copy_and_move_impl &&) =
+      default;
+  constexpr conditional_copy_and_move_impl &
+  operator=(conditional_copy_and_move_impl const &) = default;
+  constexpr conditional_copy_and_move_impl &
+  operator=(conditional_copy_and_move_impl &&) = default;
 };
 
 template <class T>
-using conditional_copy_and_move = conditional_copy_and_move_impl<
-    filter_out_void_t<std::tuple<
-        std::conditional_t<!std::is_copy_constructible<T>::value,
-            not_copy_constructible, void>,
-        std::conditional_t<!std::is_move_constructible<T>::value,
-            not_move_constructible, void>,
-        std::conditional_t<!std::is_copy_assignable<T>::value,
-            not_copy_assignable, void>,
-        std::conditional_t<!std::is_move_assignable<T>::value,
-            not_move_assignable, void>
-    >>
-    >;
-
-
+using conditional_copy_and_move =
+    conditional_copy_and_move_impl<filter_out_void_t<
+        std::tuple<std::conditional_t<!std::is_copy_constructible<T>::value,
+                                      not_copy_constructible, void>,
+                   std::conditional_t<!std::is_move_constructible<T>::value,
+                                      not_move_constructible, void>,
+                   std::conditional_t<!std::is_copy_assignable<T>::value,
+                                      not_copy_assignable, void>,
+                   std::conditional_t<!std::is_move_assignable<T>::value,
+                                      not_move_assignable, void>>>>;
 
 // clang-format off
 template < class Default
@@ -185,41 +175,24 @@ struct detector<Default, void_t<Op<Args...>>, Op, Args...> {
 };
 // clang-format on
 
-
-
 template <template <class...> class Op, class... Args>
 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
 
 template <template <class...> class Op, class... Args>
 using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
 
-
 namespace concepts {
 
-constexpr auto check() noexcept -> bool
-{
-    return true;
-}
+constexpr auto check() noexcept -> bool { return true; }
 
 template <class Check, class... Checks>
-constexpr auto check(Check&& head, Checks&&... tail) noexcept -> bool
-{
-    bool const passed = std::forward<Check>(head)();
-    return passed
-        ? check(std::forward<Checks>(tail)...)
-        : false;
+constexpr auto check(Check &&head, Checks &&... tail) noexcept -> bool {
+  bool const passed = std::forward<Check>(head)();
+  return passed ? check(std::forward<Checks>(tail)...) : false;
 }
 
 } // namespace concepts
 
-
-
-
-
-
-
-
-
 } // namespace detail
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
diff --git a/include/boost/static_views/detail/wrapper.hpp b/include/boost/static_views/detail/wrapper.hpp
index 8c60b88..88dc7f5 100644
--- a/include/boost/static_views/detail/wrapper.hpp
+++ b/include/boost/static_views/detail/wrapper.hpp
@@ -8,9 +8,10 @@
 #ifndef BOOST_STATIC_VIEWS_DETAIL_WRAPPER_HPP
 #define BOOST_STATIC_VIEWS_DETAIL_WRAPPER_HPP
 
+#include "config.hpp"
+#include "invoke.hpp"
+
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/invoke.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -38,101 +39,86 @@ namespace detail {
 ///
 /// Constructors are intentionally not listed. Use make_wrapper(T&&)
 /// to create wrappers.
-template <class T>
-struct wrapper;
+template <class T> struct wrapper;
 
-template <class T>
-struct is_wrapper : std::false_type {
-};
+template <class T> struct is_wrapper : std::false_type {};
 
-template <class T>
-struct is_wrapper<wrapper<T>> : std::true_type {
-};
+template <class T> struct is_wrapper<wrapper<T>> : std::true_type {};
 
 /// \cond
-template <class T>
-struct wrapper<T&> {
-    using type = T;
-
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR wrapper(type& x) noexcept
-        : _payload{&x}
-    {
-    }
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    wrapper(wrapper const& other) noexcept = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    wrapper(wrapper&&) noexcept = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    wrapper& operator=(wrapper const& other) noexcept = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    wrapper& operator=(wrapper&&) noexcept = default;
-
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto get() const noexcept
-        -> type const&
-    {
-        return *_payload;
-    }
-
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto get() noexcept -> type&
-    {
-        return *_payload;
-    }
-
-    /*
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR operator type&() const noexcept
-    {
-        return get();
-    }
-    */
-
-    /*
-    template <class... Args>
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    decltype(auto) operator()(Args&&... args) const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke(
-            std::declval<T const&>(), std::declval<Args&&>()...)))
-    {
-        return invoke(*_payload, std::forward<Args>(args)...);
-    }
-    */
-
-  private:
-    T* _payload;
+template <class T> struct wrapper<T &> {
+  using type = T;
+
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR wrapper(type &x) noexcept
+      : _payload{&x} {}
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  wrapper(wrapper const &other) noexcept = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  wrapper(wrapper &&) noexcept = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  wrapper &operator=(wrapper const &other) noexcept = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  wrapper &operator=(wrapper &&) noexcept = default;
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto get() const noexcept -> type const & {
+    return *_payload;
+  }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto get() noexcept -> type & {
+    return *_payload;
+  }
+
+  /*
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR operator type&() const noexcept
+  {
+      return get();
+  }
+  */
+
+  /*
+  template <class... Args>
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  decltype(auto) operator()(Args&&... args) const
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(invoke(
+          std::declval<T const&>(), std::declval<Args&&>()...)))
+  {
+      return invoke(*_payload, std::forward<Args>(args)...);
+  }
+  */
+
+private:
+  T *_payload;
 };
 /// \endcond
 
 /// \cond
-template <class T>
-struct wrapper<T&&> {
-    using type = T;
+template <class T> struct wrapper<T &&> {
+  using type = T;
 
-    static_assert(std::is_move_constructible<T>::value,
-        "wrapper<T&&>: I'm refusing to work with non-movable types. "
-        "If you have problems with that, submit an issue here "
-        "https://github.com/BoostGSoC17/static-views/issues.");
+  static_assert(std::is_move_constructible<T>::value,
+                "wrapper<T&&>: I'm refusing to work with non-movable types. "
+                "If you have problems with that, submit an issue here "
+                "https://github.com/BoostGSoC17/static-views/issues.");
 
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR wrapper(type&& x)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            std::is_nothrow_move_constructible<type>::value)
-        : _payload{std::move(x)}
-    {
-    }
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR wrapper(type &&x)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          std::is_nothrow_move_constructible<type>::value)
+      : _payload{std::move(x)} {}
 
-    // clang-format off
+  // clang-format off
     BOOST_STATIC_VIEWS_CONSTEXPR wrapper(wrapper const&)            = default;
     BOOST_STATIC_VIEWS_CONSTEXPR wrapper(wrapper &&)                = default;
     BOOST_STATIC_VIEWS_CONSTEXPR wrapper& operator=(wrapper const&) = default;
     BOOST_STATIC_VIEWS_CONSTEXPR wrapper& operator=(wrapper &&)     = default;
-    // clang-format on
-
+// clang-format on
 
 #if 0 // defined(BOOST_STATIC_VIEWS_GCC)
     BOOST_STATIC_VIEWS_FORCEINLINE
@@ -143,16 +129,16 @@ struct wrapper<T&&> {
         return _payload;
     }
 #else
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    auto get() & noexcept -> type& { return _payload; }
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto get() & noexcept -> type & { return _payload; }
 
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    auto get() const & noexcept -> type const& { return _payload; }
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto get() const & noexcept -> type const & { return _payload; }
 #endif
 
-    // clang-format off
+  // clang-format off
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto get() &&
@@ -161,21 +147,21 @@ struct wrapper<T&&> {
     {
         return std::move(_payload);
     }
-    // clang-format on
+  // clang-format on
 
-    /*
-    BOOST_STATIC_VIEWS_CONSTEXPR operator type() const noexcept
-    {
-        return get();
-    }
+  /*
+  BOOST_STATIC_VIEWS_CONSTEXPR operator type() const noexcept
+  {
+      return get();
+  }
 
-    BOOST_STATIC_VIEWS_CONSTEXPR operator type() noexcept
-    {
-        return get();
-    }
-    */
+  BOOST_STATIC_VIEWS_CONSTEXPR operator type() noexcept
+  {
+      return get();
+  }
+  */
 
-    // clang-format off
+  // clang-format off
     /*
     template <class... Args>
     BOOST_STATIC_VIEWS_FORCEINLINE
@@ -189,9 +175,9 @@ struct wrapper<T&&> {
             std::forward<Args>(args)...);
     }
     */
-    // clang-format on
+  // clang-format on
 
-    // clang-format off
+  // clang-format off
     /*
     template <class... Args>
     BOOST_STATIC_VIEWS_FORCEINLINE
@@ -205,9 +191,9 @@ struct wrapper<T&&> {
             std::forward<Args>(args)...);
     }
     */
-    // clang-format on
+  // clang-format on
 
-    // clang-format off
+  // clang-format off
     /*
     template <class... Args>
     BOOST_STATIC_VIEWS_FORCEINLINE
@@ -221,27 +207,24 @@ struct wrapper<T&&> {
             std::forward<Args>(args)...);
     }
     */
-    // clang-format on
+  // clang-format on
 
-
-  private:
-    T _payload;
+private:
+  T _payload;
 };
 /// \endcond
 
-
 struct make_wrapper_impl {
 
-  private:
-    // If an rvalue of type T is passed to make_wrapper, require T to
-    // be move-constructible.
-    template <class T>
-    using reference_or_move_constructible = std::integral_constant<
-        bool,
-        std::is_lvalue_reference<T>::value
-            || std::is_move_constructible<std::decay_t<T>>::value>;
+private:
+  // If an rvalue of type T is passed to make_wrapper, require T to
+  // be move-constructible.
+  template <class T>
+  using reference_or_move_constructible = std::integral_constant<
+      bool, std::is_lvalue_reference<T>::value ||
+                std::is_move_constructible<std::decay_t<T>>::value>;
 
-    // clang-format off
+  // clang-format off
     template <class T>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR auto call_impl(T&& /*unused*/,
@@ -256,9 +239,9 @@ struct make_wrapper_impl {
             "`boost::static_views::make_wrapper(T&&)` requires `T` "
             "to be move constructible.");
     }
-    // clang-format on
+  // clang-format on
 
-    // clang-format off
+  // clang-format off
     template <class T>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR auto call_impl(T&& x,
@@ -268,10 +251,10 @@ struct make_wrapper_impl {
     {
         return detail::wrapper<decltype(x)>{std::forward<T>(x)};
     }
-    // clang-format on
+  // clang-format on
 
-  public:
-    // clang-format off
+public:
+  // clang-format off
     template <class T>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -285,11 +268,9 @@ struct make_wrapper_impl {
         return call_impl(std::forward<T>(x),
             reference_or_move_constructible<decltype(x)>{});
     }
-    // clang-format on
+  // clang-format on
 };
 
-
-
 } // end namespace detail
 
 /// \brief Makes a wrapper around an rvalue or lvalue reference.
diff --git a/include/boost/static_views/drop.hpp b/include/boost/static_views/drop.hpp
index 64299f8..b18418d 100644
--- a/include/boost/static_views/drop.hpp
+++ b/include/boost/static_views/drop.hpp
@@ -13,11 +13,11 @@
 #include <algorithm>
 #include <type_traits>
 
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/algorithm_base.hpp>
-#include <boost/static_views/errors.hpp>
-#include <boost/static_views/view_base.hpp>
+#include "algorithm_base.hpp"
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
+#include "errors.hpp"
+#include "view_base.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -25,99 +25,92 @@ namespace detail {
 template <class View>
 struct drop_impl : view_adaptor_base<drop_impl<View>, View> {
 
-    static_assert(std::is_same<View, std::decay_t<View>>::value,
-        BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    static_assert(
-        is_wrapper<View>::value, BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    static_assert(detail::concepts::is_View<typename View::type>(),
-        "[INTERNAL] invalid use of drop_impl.");
-
-    /// \brief Constructs a view of \p xs with the first \p b elements
-    /// dropped.
-
-    /// \tparam View
-    /// \verbatim embed:rst:leading-slashes
-    /// Wrapper around a view, i.e. ``typename View::type`` is a view
-    /// and
-    /// must model the :ref:`view <view-concept>` concept.
-    /// \endverbatim
-    /// \param xs Rvalue reference to a wrapper around a view.
-    /// \param b  Number of elements to drop. The resulting view will
-    ///           contain \f$ max(\text{xs.get().size()} - \text{b},
-    ///           0)\f$
-    ///           elements.
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   It's annoying to have to specify the View template parameter
-    ///   all the time. For this reason a :cpp:var:`drop` factory
-    ///   function is provided. Use it instead to construct drop
-    ///   views.
-    /// \endverbatim
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR drop_impl(
-        View&& xs, std::size_t const b)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_constructible<
-                typename drop_impl::view_adaptor_base_type,
-                View&&>::value
-            // This is formally wrong, but come on, std::min(size_t,
-            // size_t)
-            // _should_ be noexcept.
-            // noexcept(std::min(std::declval<std::size_t>(),
-            //    std::declval<std::size_t>())),
-            ))
-        : drop_impl::view_adaptor_base_type{std::move(xs)}
-        , _b{std::min(this->parent().size(), b)}
-    {
-    }
-
-    /// \brief Returns the number of elements viewed.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It never fails unless a call to ``parent().size()``
-    /// fails.
-    /// \endverbatim
-    BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept
-    {
-        static_assert(noexcept(this->parent()),
-            "[INTERNAL] Why is parent() not noexcept?");
-        static_assert(
-            noexcept(std::declval<decltype(this->parent())>().size()),
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-        return this->parent().size() - _b;
-    }
-
-    /// \brief "Maps" index \p i to the corresponding index in the
-    /// parent
-    /// view.
-
-    /// Let `xs` be of type #drop_impl. The following relation then
-    /// holds
-    /// \f[
-    /// \text{xs}[i] = \text{xs.parent}()[\text{xs.map}(i)]\;,
-    ///     \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}.
-    /// \f]
-    ///
-    /// If the condition `i < size()` is not satisfied, this function
-    /// throws an #out_of_bound exception.
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const
-    {
-        return i < size() ? (_b + i)
-                          : ((void)make_out_of_bound_error(
-                                 "`i < size()` not satisfied."),
-                                _b + i);
-    }
-
-  private:
-    // friend struct
-    // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
-    std::size_t _b;
+  static_assert(std::is_same<View, std::decay_t<View>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(is_wrapper<View>::value, BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(detail::concepts::is_View<typename View::type>(),
+                "[INTERNAL] invalid use of drop_impl.");
+
+  /// \brief Constructs a view of \p xs with the first \p b elements
+  /// dropped.
+
+  /// \tparam View
+  /// \verbatim embed:rst:leading-slashes
+  /// Wrapper around a view, i.e. ``typename View::type`` is a view
+  /// and
+  /// must model the :ref:`view <view-concept>` concept.
+  /// \endverbatim
+  /// \param xs Rvalue reference to a wrapper around a view.
+  /// \param b  Number of elements to drop. The resulting view will
+  ///           contain \f$ max(\text{xs.get().size()} - \text{b},
+  ///           0)\f$
+  ///           elements.
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   It's annoying to have to specify the View template parameter
+  ///   all the time. For this reason a :cpp:var:`drop` factory
+  ///   function is provided. Use it instead to construct drop
+  ///   views.
+  /// \endverbatim
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR drop_impl(View &&xs,
+                                                  std::size_t const b)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_constructible<
+                     typename drop_impl::view_adaptor_base_type, View &&>::value
+                     // This is formally wrong, but come on, std::min(size_t,
+                     // size_t)
+                     // _should_ be noexcept.
+                     // noexcept(std::min(std::declval<std::size_t>(),
+                     //    std::declval<std::size_t>())),
+                     ))
+      : drop_impl::view_adaptor_base_type{std::move(xs)},
+        _b{std::min(this->parent().size(), b)} {}
+
+  /// \brief Returns the number of elements viewed.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It never fails unless a call to ``parent().size()``
+  /// fails.
+  /// \endverbatim
+  BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept {
+    static_assert(noexcept(this->parent()),
+                  "[INTERNAL] Why is parent() not noexcept?");
+    static_assert(noexcept(std::declval<decltype(this->parent())>().size()),
+                  BOOST_STATIC_VIEWS_BUG_MESSAGE);
+    return this->parent().size() - _b;
+  }
+
+  /// \brief "Maps" index \p i to the corresponding index in the
+  /// parent
+  /// view.
+
+  /// Let `xs` be of type #drop_impl. The following relation then
+  /// holds
+  /// \f[
+  /// \text{xs}[i] = \text{xs.parent}()[\text{xs.map}(i)]\;,
+  ///     \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}.
+  /// \f]
+  ///
+  /// If the condition `i < size()` is not satisfied, this function
+  /// throws an #out_of_bound exception.
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const {
+    return i < size()
+               ? (_b + i)
+               : ((void)make_out_of_bound_error("`i < size()` not satisfied."),
+                  _b + i);
+  }
+
+private:
+  // friend struct
+  // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
+  std::size_t _b;
 };
 
 struct make_drop_impl {
-    // clang-format off
+  // clang-format off
     template <class View>
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto operator()(View&& xs, std::size_t const b) const
@@ -130,7 +123,7 @@ struct make_drop_impl {
         return drop_impl<std::decay_t<View>>{
             std::forward<View>(xs), b};
     }
-    // clang-format on
+  // clang-format on
 };
 } // end namespace detail
 
diff --git a/include/boost/static_views/errors.hpp b/include/boost/static_views/errors.hpp
index 8cef715..f614689 100644
--- a/include/boost/static_views/errors.hpp
+++ b/include/boost/static_views/errors.hpp
@@ -6,24 +6,22 @@
 #ifndef BOOST_STATIC_VIEWS_ERRORS_HPP
 #define BOOST_STATIC_VIEWS_ERRORS_HPP
 
+#include "detail/config.hpp"
+
 #include <exception>
-#include <boost/static_views/detail/config.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 /// \brief Exception that is thrown when an "index out of bounds
 /// error" is encountered.
 class out_of_bound : std::exception {
-    char const* _msg;
+  char const *_msg;
 
-  public:
-    out_of_bound() noexcept : _msg{"Index out of bounds."} {}
-    explicit out_of_bound(char const* msg) noexcept : _msg{msg} {}
+public:
+  out_of_bound() noexcept : _msg{"Index out of bounds."} {}
+  explicit out_of_bound(char const *msg) noexcept : _msg{msg} {}
 
-    auto what() const noexcept -> char const* override
-    {
-        return _msg;
-    }
+  auto what() const noexcept -> char const * override { return _msg; }
 };
 
 /*
@@ -41,24 +39,18 @@ class invalid_range : std::exception {
 /// \brief Exception that is thrown when an insert into a full bucket
 /// is attempted.
 class full_bucket : std::exception {
-    char const* _msg;
+  char const *_msg;
 
-  public:
-    full_bucket() noexcept : _msg{"Bucket is full."} {}
-    explicit full_bucket(char const* msg) noexcept : _msg{msg} {}
+public:
+  full_bucket() noexcept : _msg{"Bucket is full."} {}
+  explicit full_bucket(char const *msg) noexcept : _msg{msg} {}
 
-    auto what() const noexcept -> char const* override
-    {
-        return _msg;
-    }
+  auto what() const noexcept -> char const * override { return _msg; }
 };
 
 namespace detail {
 BOOST_STATIC_VIEWS_NORETURN
-auto make_out_of_bound(char const* msg) -> void
-{
-    throw out_of_bound{msg};
-}
+auto make_out_of_bound(char const *msg) -> void { throw out_of_bound{msg}; }
 
 /*
 BOOST_STATIC_VIEWS_NORETURN
@@ -69,10 +61,7 @@ auto make_invalid_range(char const* msg) -> void
 */
 
 BOOST_STATIC_VIEWS_NORETURN
-auto make_full_bucket(char const* msg) -> void
-{
-    throw full_bucket{msg};
-}
+auto make_full_bucket(char const *msg) -> void { throw full_bucket{msg}; }
 } // end namespace detail
 
 // clang-format off
diff --git a/include/boost/static_views/hashed.hpp b/include/boost/static_views/hashed.hpp
index 13a3b05..360b8ca 100644
--- a/include/boost/static_views/hashed.hpp
+++ b/include/boost/static_views/hashed.hpp
@@ -6,52 +6,47 @@
 #ifndef BOOST_STATIC_VIEWS_HASHED_HPP
 #define BOOST_STATIC_VIEWS_HASHED_HPP
 
-#include <type_traits>
 #include <limits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/find_first.hpp>
-#include <boost/static_views/detail/invoke.hpp>
-#include <boost/static_views/algorithm_base.hpp>
-#include <boost/static_views/raw_view.hpp>
-#include <boost/static_views/slice.hpp>
-#include <boost/static_views/through.hpp>
-#include <boost/static_views/view_base.hpp>
+#include <type_traits>
+
+#include "algorithm_base.hpp"
+#include "detail/config.hpp"
+#include "detail/find_first.hpp"
+#include "detail/invoke.hpp"
+#include "raw_view.hpp"
+#include "slice.hpp"
+#include "through.hpp"
+#include "view_base.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <class View>
-struct hasher_compat_checker {
-    template <class Hasher>
-    using call_t = decltype( invoke(
-        std::declval<Hasher const&>(),
-        std::declval<View const&>()[std::declval<std::size_t>()]) );
-
-    template <class Hasher>
-    static constexpr auto is_compatible() noexcept -> bool
-    {
-        return concepts::is_View<View>()
-               && std::is_convertible<detected_t<call_t, Hasher>,
-                      std::size_t>::value;
-    }
-
-    template <class Hasher>
-    static constexpr auto assert_compatible() noexcept -> bool
-    {
-        constexpr bool x = is_compatible<Hasher>();
-        static_assert(x,
-            "`Hasher` must be a function that takes an element of "
-            "`View` and returns a type convertible to size_t.");
-        return x;
-    }
+template <class View> struct hasher_compat_checker {
+  template <class Hasher>
+  using call_t = decltype(
+      invoke(std::declval<Hasher const &>(),
+             std::declval<View const &>()[std::declval<std::size_t>()]));
+
+  template <class Hasher>
+  static constexpr auto is_compatible() noexcept -> bool {
+    return concepts::is_View<View>() &&
+           std::is_convertible<detected_t<call_t, Hasher>, std::size_t>::value;
+  }
+
+  template <class Hasher>
+  static constexpr auto assert_compatible() noexcept -> bool {
+    constexpr bool x = is_compatible<Hasher>();
+    static_assert(x, "`Hasher` must be a function that takes an element of "
+                     "`View` and returns a type convertible to size_t.");
+    return x;
+  }
 };
 
-template <std::size_t BucketSize, std::size_t... Is>
-struct hashed_init_impl {
-    std::size_t storage[sizeof...(Is)];
+template <std::size_t BucketSize, std::size_t... Is> struct hashed_init_impl {
+  std::size_t storage[sizeof...(Is)];
 
-    // clang-format off
+  // clang-format off
     template <class View, class Hasher>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -67,245 +62,211 @@ struct hashed_init_impl {
             insert(i, bucket_size() * (invoke(h, xs[i]) % bucket_count()));
         }
     }
-    // clang-format on
-
-  private:
-    static constexpr auto capacity() noexcept -> std::size_t
-    {
-        static_assert(sizeof...(Is) > 0,
-            "[INTERNAL] Invalid use of hashed_init_impl.");
-        return sizeof...(Is);
-    }
-
-    static constexpr auto bucket_size() noexcept -> std::size_t
-    {
-        static_assert(BucketSize > 0,
-            "[INTERNAL] Invalid use of hashed_init_impl.");
-        return BucketSize;
-    }
-
-    static constexpr auto bucket_count() noexcept -> std::size_t
-    {
-        static_assert(sizeof...(Is) % bucket_size() == 0,
-            "[INTERNAL] Invalid use of hashed_init_impl.");
-        return capacity() / bucket_size();
-    }
-
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    auto insert(std::size_t const i, std::size_t const guess) -> void
-    {
+  // clang-format on
+
+private:
+  static constexpr auto capacity() noexcept -> std::size_t {
+    static_assert(sizeof...(Is) > 0,
+                  "[INTERNAL] Invalid use of hashed_init_impl.");
+    return sizeof...(Is);
+  }
+
+  static constexpr auto bucket_size() noexcept -> std::size_t {
+    static_assert(BucketSize > 0,
+                  "[INTERNAL] Invalid use of hashed_init_impl.");
+    return BucketSize;
+  }
+
+  static constexpr auto bucket_count() noexcept -> std::size_t {
+    static_assert(sizeof...(Is) % bucket_size() == 0,
+                  "[INTERNAL] Invalid use of hashed_init_impl.");
+    return capacity() / bucket_size();
+  }
+
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto insert(std::size_t const i, std::size_t const guess) -> void {
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 201603
-        // We have C++17 constexpr lambdas
-        constexpr auto is_empty = [](auto const x) noexcept
-        {
-            return x == hashed_init_impl::capacity();
-        };
+    // We have C++17 constexpr lambdas
+    constexpr auto is_empty = [](auto const x) noexcept {
+      return x == hashed_init_impl::capacity();
+    };
 #else
-        struct is_empty_impl {
-            BOOST_STATIC_VIEWS_CONSTEXPR
-            auto operator()(std::size_t const x) const noexcept
-            {
-                return x == hashed_init_impl::capacity();
-            }
-        };
-        constexpr is_empty_impl is_empty{};
+    struct is_empty_impl {
+      BOOST_STATIC_VIEWS_CONSTEXPR
+      auto operator()(std::size_t const x) const noexcept {
+        return x == hashed_init_impl::capacity();
+      }
+    };
+    constexpr is_empty_impl is_empty{};
 #endif
 
-        auto const bucket =
-            slice(guess, guess + bucket_size())(raw_view(storage));
-        auto const p = find_first_i(bucket, is_empty);
+    auto const bucket = slice(guess, guess + bucket_size())(raw_view(storage));
+    auto const p = find_first_i(bucket, is_empty);
 
-        if (p != bucket_size()) {
-            storage[guess + p] = i;
-        }
-        else {
-            make_full_bucket_error("Bucket is full.");
-        }
+    if (p != bucket_size()) {
+      storage[guess + p] = i;
+    } else {
+      make_full_bucket_error("Bucket is full.");
     }
+  }
 };
 
 template <std::size_t BucketSize, class V, class H, std::size_t... Is>
-BOOST_STATIC_VIEWS_CONSTEXPR auto make_hashed_init_impl(
-    V const& xs, H const& h, std::index_sequence<Is...> /*unused*/)
-{
-    return hashed_init_impl<BucketSize, Is...>{xs, h};
+BOOST_STATIC_VIEWS_CONSTEXPR auto
+make_hashed_init_impl(V const &xs, H const &h,
+                      std::index_sequence<Is...> /*unused*/) {
+  return hashed_init_impl<BucketSize, Is...>{xs, h};
 }
 
-template <std::size_t BucketCount, std::size_t BucketSize, class V,
-    class H>
-BOOST_STATIC_VIEWS_CONSTEXPR auto make_hashed_init_impl(
-    V const& xs, H const& h)
-{
-    static_assert(
-        std::numeric_limits<std::size_t>::max() / BucketCount
-            >= BucketSize,
-        "[INTERNAL] Overflow detected.");
-    return make_hashed_init_impl<BucketSize>(
-        xs, h, std::make_index_sequence<BucketCount * BucketSize>{});
+template <std::size_t BucketCount, std::size_t BucketSize, class V, class H>
+BOOST_STATIC_VIEWS_CONSTEXPR auto make_hashed_init_impl(V const &xs,
+                                                        H const &h) {
+  static_assert(std::numeric_limits<std::size_t>::max() / BucketCount >=
+                    BucketSize,
+                "[INTERNAL] Overflow detected.");
+  return make_hashed_init_impl<BucketSize>(
+      xs, h, std::make_index_sequence<BucketCount * BucketSize>{});
 }
 
 template <std::size_t BucketCount, std::size_t BucketSize, class View,
-    class Hasher>
+          class Hasher>
 struct hashed_impl
-    : view_adaptor_base<
-          hashed_impl<BucketCount, BucketSize, View, Hasher>, View> {
-
-  private:
-    static_assert(
-        BucketCount > 0, "[INTERNAL] Invalid use of hashed_impl.");
-    static_assert(
-        BucketSize > 0, "[INTERNAL] Invalid use of hashed_impl.");
-    static_assert(
-        is_wrapper<View>(), "[INTERNAL] Invalid use of hashed_impl.");
-
-    using view_type = typename View::type;
-
-    static_assert(concepts::is_View<view_type>(),
-        "[INTERNAL] Invalid use of hashed_impl.");
-    static_assert(is_wrapper<Hasher>(),
-        "[INTERNAL] Invalid use of hashed_impl.");
-
-    using hasher_type = typename Hasher::type;
-
-    static_assert(
-        hasher_compat_checker<view_type>::template is_compatible<
-            hasher_type>(),
-        "[INTERNAL] Invalid use of hashed_impl.");
-
-  public:
-    /// \brief Returns the number buckets.
-    static constexpr auto bucket_count() noexcept
-    {
-        return BucketCount;
-    }
-
-    /// \brief Returns the capacity of each bucket.
-    static constexpr auto bucket_size() noexcept
-    {
-        return BucketSize;
-    }
-
-    /// \brief Constructs a hashed view of \p xs using \p hf as a hash
-    /// function.
-
-    /// \tparam BucketCount
-    /// Number of buckets.
-    /// \tparam BucketSize
-    /// Capacity of each bucket.
-    /// \tparam View
-    /// \verbatim embed:rst:leading-slashes
-    /// Wrapper around a view, i.e. ``typename View::type`` is a view
-    /// and
-    /// must model the :ref:`view <view-concept>` concept.
-    /// \endverbatim
-    /// \param xs      Rvalue reference to a wrapper around a view.
-    /// \param hf      Hash function to use.
-    /// \param storage Array of indices initialised by
-    /// #hashed_init_impl.
-    ///
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   This function requires an initialiser storage as an argument
-    ///   which
-    ///   is an implementation detail. This constructor is thus not
-    ///   meant to
-    ///   be used explicitly, use the :cpp:var:`hashed` factory
-    ///   function instead.
-    /// \endverbatim
-    template <std::size_t... Is>
-    BOOST_STATIC_VIEWS_CONSTEXPR hashed_impl(View&& xs, Hasher&& hf,
-        std::size_t (&storage)[hashed_impl::bucket_count()
-                               * hashed_impl::bucket_size()],
-        std::index_sequence<Is...> /*unused*/)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_constructible<
-                typename hashed_impl::view_adaptor_base_type,
-                View&&>::value,
-            std::is_nothrow_move_constructible<
-                std::decay_t<Hasher>>::value))
-        : hashed_impl::view_adaptor_base_type{std::move(xs)}
-        , _hf{std::move(hf)}
-        , _storage{storage[Is]...}
-    {
-    }
-
-    /// \brief Returns the capacity of the view.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. Hashed view is a view of buckets rather than
-    /// individual elements. This function is thus equivalent to
-    /// :cpp:func:`bucket_count()
-    /// <detail::hashed_impl::bucket_count()>`.
-    /// \endverbatim
-    static constexpr auto capacity() noexcept
-    {
-        return bucket_count();
-    }
-
-    /// \brief Returns a reference to the hash function.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO hash_function() const noexcept
-    {
-        static_assert(noexcept(_hf.get()),
-            "[INTERNAL] hashed_impl assumes that _hf has a noexcept "
-            "get().");
-        return _hf.get();
-    }
-
-    /// \brief Returns the bucket corresponding to \p hash.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It returns a view of elements that have hash
-    /// ``hash``. If there are no such elements, the returned view
-    /// will have size zero. \endverbatim
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    auto operator[](std::size_t const hash) const
-    // noexcept /* TODO add specifiers */
-    {
+    : view_adaptor_base<hashed_impl<BucketCount, BucketSize, View, Hasher>,
+                        View> {
+
+private:
+  static_assert(BucketCount > 0, "[INTERNAL] Invalid use of hashed_impl.");
+  static_assert(BucketSize > 0, "[INTERNAL] Invalid use of hashed_impl.");
+  static_assert(is_wrapper<View>(), "[INTERNAL] Invalid use of hashed_impl.");
+
+  using view_type = typename View::type;
+
+  static_assert(concepts::is_View<view_type>(),
+                "[INTERNAL] Invalid use of hashed_impl.");
+  static_assert(is_wrapper<Hasher>(), "[INTERNAL] Invalid use of hashed_impl.");
+
+  using hasher_type = typename Hasher::type;
+
+  static_assert(
+      hasher_compat_checker<view_type>::template is_compatible<hasher_type>(),
+      "[INTERNAL] Invalid use of hashed_impl.");
+
+public:
+  /// \brief Returns the number buckets.
+  static constexpr size_t bucket_count() noexcept { return BucketCount; }
+
+  /// \brief Returns the capacity of each bucket.
+  static constexpr size_t bucket_size() noexcept { return BucketSize; }
+
+  /// \brief Constructs a hashed view of \p xs using \p hf as a hash
+  /// function.
+
+  /// \tparam BucketCount
+  /// Number of buckets.
+  /// \tparam BucketSize
+  /// Capacity of each bucket.
+  /// \tparam View
+  /// \verbatim embed:rst:leading-slashes
+  /// Wrapper around a view, i.e. ``typename View::type`` is a view
+  /// and
+  /// must model the :ref:`view <view-concept>` concept.
+  /// \endverbatim
+  /// \param xs      Rvalue reference to a wrapper around a view.
+  /// \param hf      Hash function to use.
+  /// \param storage Array of indices initialised by
+  /// #hashed_init_impl.
+  ///
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   This function requires an initialiser storage as an argument
+  ///   which
+  ///   is an implementation detail. This constructor is thus not
+  ///   meant to
+  ///   be used explicitly, use the :cpp:var:`hashed` factory
+  ///   function instead.
+  /// \endverbatim
+  template <std::size_t... Is>
+  BOOST_STATIC_VIEWS_CONSTEXPR hashed_impl(
+      View &&xs, Hasher &&hf,
+      std::size_t (
+          &storage)[hashed_impl::bucket_count() * hashed_impl::bucket_size()],
+      std::index_sequence<Is...> /*unused*/)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_constructible<
+              typename hashed_impl::view_adaptor_base_type, View &&>::value,
+          std::is_nothrow_move_constructible<std::decay_t<Hasher>>::value))
+      : hashed_impl::view_adaptor_base_type{std::move(xs)}, _hf{std::move(hf)},
+        _storage{storage[Is]...} {}
+
+  /// \brief Returns the capacity of the view.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. Hashed view is a view of buckets rather than
+  /// individual elements. This function is thus equivalent to
+  /// :cpp:func:`bucket_count()
+  /// <detail::hashed_impl::bucket_count()>`.
+  /// \endverbatim
+  static constexpr auto capacity() noexcept { return bucket_count(); }
+
+  /// \brief Returns a reference to the hash function.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO hash_function() const noexcept {
+    static_assert(noexcept(_hf.get()),
+                  "[INTERNAL] hashed_impl assumes that _hf has a noexcept "
+                  "get().");
+    return _hf.get();
+  }
+
+  /// \brief Returns the bucket corresponding to \p hash.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It returns a view of elements that have hash
+  /// ``hash``. If there are no such elements, the returned view
+  /// will have size zero. \endverbatim
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  auto operator[](std::size_t const hash) const
+  // noexcept /* TODO add specifiers */
+  {
 #if defined(__cpp_constexpr) && __cpp_constexpr >= 201603
-        constexpr auto is_empty = [](auto const x) noexcept
-        {
-            return x == bucket_count() * bucket_size();
-        };
+    constexpr auto is_empty = [](auto const x) noexcept {
+      return x == bucket_count() * bucket_size();
+    };
 #else
-        struct is_empty_impl {
-            BOOST_STATIC_VIEWS_CONSTEXPR
-            auto operator()(std::size_t const x) const noexcept
-            {
-                return x == bucket_count() * bucket_size();
-            }
-        };
-        constexpr is_empty_impl is_empty{};
+    struct is_empty_impl {
+      BOOST_STATIC_VIEWS_CONSTEXPR
+      auto operator()(std::size_t const x) const noexcept {
+        return x == bucket_count() * bucket_size();
+      }
+    };
+    constexpr is_empty_impl is_empty{};
 #endif
-        auto const i = bucket_size() * (hash % bucket_count());
-        auto const n = find_first_i(
-            slice(i, i + bucket_size())(raw_view(_storage)),
-            is_empty);
-        return through(slice(i, i + n)(raw_view(_storage)))(
-            this->parent());
-    }
-
-  private:
-    Hasher      _hf;
-    std::size_t _storage[bucket_count() * bucket_size()];
+    auto const i = bucket_size() * (hash % bucket_count());
+    auto const n =
+        find_first_i(slice(i, i + bucket_size())(raw_view(_storage)), is_empty);
+    return through(slice(i, i + n)(raw_view(_storage)))(this->parent());
+  }
+
+private:
+  Hasher _hf;
+  std::size_t _storage[bucket_count() * bucket_size()];
 };
 
 template <std::size_t BucketCount, std::size_t BucketSize>
 struct make_hashed_impl {
 
-    static_assert(BucketCount > 0,
-        "`boost::static_views::hashed<BucketCount, BucketSize>` "
-        "requires BucketCount to be greater than zero.");
-    static_assert(BucketCount > 0,
-        "`boost::static_views::hashed<BucketCount, BucketSize>` "
-        "requires BucketSize to be greater than zero.");
+  static_assert(BucketCount > 0,
+                "`boost::static_views::hashed<BucketCount, BucketSize>` "
+                "requires BucketCount to be greater than zero.");
+  static_assert(BucketCount > 0,
+                "`boost::static_views::hashed<BucketCount, BucketSize>` "
+                "requires BucketSize to be greater than zero.");
 
-    // clang-format off
+  // clang-format off
     template <class View, class Hasher>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -327,7 +288,7 @@ struct make_hashed_impl {
             init.storage,
             std::make_index_sequence<BucketCount * BucketSize>{}};
     }
-    // clang-format on
+  // clang-format on
 };
 } // end namespace detail
 
@@ -362,7 +323,7 @@ constexpr auto hashed = implementation detail;
 #else
 inline namespace {
 template <std::size_t BucketCount, std::size_t BucketSize>
-BOOST_STATIC_VIEWS_CONSTEXPR auto const& hashed =
+BOOST_STATIC_VIEWS_CONSTEXPR auto const &hashed =
     ::BOOST_STATIC_VIEWS_NAMESPACE::_static_const<
         ::BOOST_STATIC_VIEWS_NAMESPACE::detail::make_algorithm_impl<
             detail::make_hashed_impl<BucketCount, BucketSize>>>;
diff --git a/include/boost/static_views/lfold.hpp b/include/boost/static_views/lfold.hpp
index dfbc764..22a5ccb 100644
--- a/include/boost/static_views/lfold.hpp
+++ b/include/boost/static_views/lfold.hpp
@@ -6,31 +6,30 @@
 #ifndef BOOST_STATIC_VIEWS_LFOLD_HPP
 #define BOOST_STATIC_VIEWS_LFOLD_HPP
 
+#include "detail/config.hpp"
+
 #include <functional>
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
 struct left_fold_impl {
-    template <class View, class T,
-        class BinaryOperation = std::plus<T>>
-    constexpr auto operator()(View&& xs, T init,
-        BinaryOperation&& op = BinaryOperation{}) const
-        noexcept /* TODO add specifier */
-        -> T
-    {
-        std::size_t const n = xs.size();
-        std::size_t       i = 0;
-
-        while (i < n) {
-            init = op(init, std::forward<View>(xs)[i]);
-            ++i;
-        }
-        return init;
+  template <class View, class T, class BinaryOperation = std::plus<T>>
+  constexpr auto operator()(View &&xs, T init,
+                            BinaryOperation &&op = BinaryOperation{}) const
+      noexcept /* TODO add specifier */
+      -> T {
+    std::size_t const n = xs.size();
+    std::size_t i = 0;
+
+    while (i < n) {
+      init = op(init, std::forward<View>(xs)[i]);
+      ++i;
     }
+    return init;
+  }
 };
 
 } // end namespace detail
diff --git a/include/boost/static_views/raw_view.hpp b/include/boost/static_views/raw_view.hpp
index d678acd..9fc6090 100644
--- a/include/boost/static_views/raw_view.hpp
+++ b/include/boost/static_views/raw_view.hpp
@@ -11,153 +11,142 @@
 #define BOOST_STATIC_VIEWS_RAW_VIEW_HPP
 
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/errors.hpp>
-#include <boost/static_views/sequence_traits.hpp>
-#include <boost/static_views/view_base.hpp>
+
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
+#include "errors.hpp"
+#include "sequence_traits.hpp"
+#include "view_base.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
-
-
-template <class Sequence>
-struct raw_view_impl : view_base {
-
-    /// \brief Constructs a view of \p xs.
-
-    /// \tparam Sequence
-    /// \verbatim embed:rst:leading-slashes
-    /// Must model the :ref:`sequence <sequence-concept>` concept.
-    /// \endverbatim
-    /// \param xs Reference to the sequence.
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   It's annoying to have to specify Sequence template parameter
-    ///   all the time. For this reason a :cpp:var:`raw_view` factory
-    ///   function is provided. Use it instead to construct raw views
-    ///   of data.
-    /// \endverbatim
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR raw_view_impl(
-        Sequence& xs) noexcept
-        : _xs{&xs}
-    {
-    }
-
-    /// \brief Copy constructor.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    raw_view_impl(raw_view_impl const&) noexcept = default;
-
-    /// \brief Move constructor.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    raw_view_impl(raw_view_impl&&) noexcept = default;
-
-    /// \brief Copy assignment operator.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    raw_view_impl& operator=(raw_view_impl const&) noexcept = default;
-
-    /// \brief Move assignment operator.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    raw_view_impl& operator=(raw_view_impl&&) noexcept = default;
-
-    ~raw_view_impl() = default;
-
-    /// \brief Returns the size of the sequence.
-
-    /// \snippet raw_view.hpp raw_view_impl::capacity() implementation
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It returns the maximum possible number of elements
-    /// this view can have. In this case, just the number of elements
-    /// in the sequence.
-    ///
-    /// .. note::
-    ///   This function is marked `static constexpr` and may thus be
-    ///   freely used in constant expressions.
-    /// \endverbatim
-    static constexpr auto capacity() noexcept
-    {
-        //! [raw_view_impl::capacity() implementation]
-        return sequence_traits<sequence_type>::size();
-        //! [raw_view_impl::capacity() implementation]
-    }
-
-    /// \brief Returns the size of the sequence.
-
-    /// \snippet raw_view.hpp raw_view_impl::size() implementation
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It's behavior is equivalent to :cpp:func:`capacity()
-    /// <detail::raw_view_impl::capacity()>` function, i.e. it returns
-    /// the number of elements in the sequence.
-    /// \endverbatim
-    constexpr auto size() const noexcept
-    {
-        //! [raw_view_impl::size() implementation]
-        return sequence_traits<sequence_type>::size();
-        //! [raw_view_impl::size() implementation]
-    }
-
-    /// \brief Element access
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It provides access to element at index `i`. Return
-    /// type is determined by the corresponding specialisation of
-    /// :cpp:class:`sequence_traits`. It may be a reference to
-    /// element, or a value, or something else. Behavior of this
-    /// function is well-described by the following code snippet:
-    ///
-    /// .. code-block:: python
-    ///
-    ///   if i < sequence.size():
-    ///       return sequence[i]
-    ///   else:
-    ///       raise out_of_bound
-    ///
-    /// \endverbatim
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator[](
-        std::size_t const i) const
-    {
-        return i < size()
-                   ? sequence_traits<sequence_type>::at(*_xs, i)
-                   : (make_out_of_bound_error(
-                          "Index `i` exceeds size of sequence."),
+template <class Sequence> struct raw_view_impl : view_base {
+
+  /// \brief Constructs a view of \p xs.
+
+  /// \tparam Sequence
+  /// \verbatim embed:rst:leading-slashes
+  /// Must model the :ref:`sequence <sequence-concept>` concept.
+  /// \endverbatim
+  /// \param xs Reference to the sequence.
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   It's annoying to have to specify Sequence template parameter
+  ///   all the time. For this reason a :cpp:var:`raw_view` factory
+  ///   function is provided. Use it instead to construct raw views
+  ///   of data.
+  /// \endverbatim
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR raw_view_impl(Sequence &xs) noexcept
+      : _xs{&xs} {}
+
+  /// \brief Copy constructor.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  raw_view_impl(raw_view_impl const &) noexcept = default;
+
+  /// \brief Move constructor.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  raw_view_impl(raw_view_impl &&) noexcept = default;
+
+  /// \brief Copy assignment operator.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  raw_view_impl &operator=(raw_view_impl const &) noexcept = default;
+
+  /// \brief Move assignment operator.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  raw_view_impl &operator=(raw_view_impl &&) noexcept = default;
+
+  ~raw_view_impl() = default;
+
+  /// \brief Returns the size of the sequence.
+
+  /// \snippet raw_view.hpp raw_view_impl::capacity() implementation
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It returns the maximum possible number of elements
+  /// this view can have. In this case, just the number of elements
+  /// in the sequence.
+  ///
+  /// .. note::
+  ///   This function is marked `static constexpr` and may thus be
+  ///   freely used in constant expressions.
+  /// \endverbatim
+  static constexpr auto capacity() noexcept {
+    //! [raw_view_impl::capacity() implementation]
+    return sequence_traits<sequence_type>::size();
+    //! [raw_view_impl::capacity() implementation]
+  }
+
+  /// \brief Returns the size of the sequence.
+
+  /// \snippet raw_view.hpp raw_view_impl::size() implementation
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It's behavior is equivalent to :cpp:func:`capacity()
+  /// <detail::raw_view_impl::capacity()>` function, i.e. it returns
+  /// the number of elements in the sequence.
+  /// \endverbatim
+  constexpr auto size() const noexcept {
+    //! [raw_view_impl::size() implementation]
+    return sequence_traits<sequence_type>::size();
+    //! [raw_view_impl::size() implementation]
+  }
+
+  /// \brief Element access
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It provides access to element at index `i`. Return
+  /// type is determined by the corresponding specialisation of
+  /// :cpp:class:`sequence_traits`. It may be a reference to
+  /// element, or a value, or something else. Behavior of this
+  /// function is well-described by the following code snippet:
+  ///
+  /// .. code-block:: python
+  ///
+  ///   if i < sequence.size():
+  ///       return sequence[i]
+  ///   else:
+  ///       raise out_of_bound
+  ///
+  /// \endverbatim
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator[](std::size_t const i) const {
+    return i < size() ? sequence_traits<sequence_type>::at(*_xs, i)
+                      : (make_out_of_bound_error(
+                             "Index `i` exceeds size of sequence."),
                          sequence_traits<sequence_type>::at(*_xs, i));
-    }
+  }
+
+  /*
+  #if defined(DOXYGEN_IN_HOUSE)
+          constexpr element_type& operator[](std::size_t const i)
+  #else
+          BOOST_STATIC_VIEWS_FORCEINLINE
+          constexpr decltype(auto) operator[](std::size_t const i)
+  #endif
+          {
+              return BOOST_LIKELY(i < size())
+                  ? sequence_traits<sequence_type>::at(_xs, i)
+                  : ( make_out_of_bound_error( \
+                          "Index `i` exceeds size of sequence."),
+                      sequence_traits<sequence_type>::at(_xs, i) );
+          }
+  */
 
-    /*
-    #if defined(DOXYGEN_IN_HOUSE)
-            constexpr element_type& operator[](std::size_t const i)
-    #else
-            BOOST_STATIC_VIEWS_FORCEINLINE
-            constexpr decltype(auto) operator[](std::size_t const i)
-    #endif
-            {
-                return BOOST_LIKELY(i < size())
-                    ? sequence_traits<sequence_type>::at(_xs, i)
-                    : ( make_out_of_bound_error( \
-                            "Index `i` exceeds size of sequence."),
-                        sequence_traits<sequence_type>::at(_xs, i) );
-            }
-    */
-
-  private:
-    using sequence_type =
-        std::remove_const_t<std::remove_reference_t<Sequence>>;
-    Sequence* _xs;
+private:
+  using sequence_type = std::remove_const_t<std::remove_reference_t<Sequence>>;
+  Sequence *_xs;
 };
 
 /// \cond
 struct make_raw_view {
-    // clang-format off
+  // clang-format off
     template <class Sequence>
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto operator()(Sequence& sequence) const
@@ -168,7 +157,7 @@ struct make_raw_view {
             std::remove_cv_t<Sequence>>>();
         return raw_view_impl<Sequence>(sequence);
     }
-    // clang-format on
+  // clang-format on
 };
 /// \endcond
 
diff --git a/include/boost/static_views/sequence_traits.hpp b/include/boost/static_views/sequence_traits.hpp
index 1b38fa4..6509008 100644
--- a/include/boost/static_views/sequence_traits.hpp
+++ b/include/boost/static_views/sequence_traits.hpp
@@ -10,8 +10,9 @@
 #define BOOST_STATIC_VIEWS_SEQUENCE_TRAITS_HPP
 
 #include <array>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
+
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -28,36 +29,31 @@ BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 ///     static constexpr reference at(S&& xs, std::size_t i) noexcept;
 /// };
 /// \endcode
-template <class Sequence>
-struct sequence_traits;
+template <class Sequence> struct sequence_traits;
 
 /// \cond
-template <class T, std::size_t N>
-struct sequence_traits<T[N]> {
-    using type = T[N];
+template <class T, std::size_t N> struct sequence_traits<T[N]> {
+  using type = T[N];
 
-    static constexpr auto size() noexcept { return N; }
+  static constexpr auto size() noexcept { return N; }
 
-    template <class S>
-    static constexpr decltype(auto) at(S&& xs, std::size_t i) noexcept
-    {
-        return std::forward<S>(xs)[i];
-    }
+  template <class S>
+  static constexpr decltype(auto) at(S &&xs, std::size_t i) noexcept {
+    return std::forward<S>(xs)[i];
+  }
 };
 /// \endcond
 
 /// \cond
-template <class T, std::size_t N>
-struct sequence_traits<std::array<T, N>> {
-    using type = std::array<T, N>;
+template <class T, std::size_t N> struct sequence_traits<std::array<T, N>> {
+  using type = std::array<T, N>;
 
-    static constexpr auto size() noexcept { return N; }
+  static constexpr auto size() noexcept { return N; }
 
-    template <class S>
-    static constexpr decltype(auto) at(S&& xs, std::size_t i) noexcept
-    {
-        return std::forward<S>(xs)[i];
-    }
+  template <class S>
+  static constexpr decltype(auto) at(S &&xs, std::size_t i) noexcept {
+    return std::forward<S>(xs)[i];
+  }
 };
 /// \endcond
 
@@ -65,125 +61,95 @@ namespace detail {
 namespace concepts {
 namespace sequence {
 
-    /// \brief Trait that determines whether a specialisation of
-    /// #sequence_traits for `T` exists.
-    template <class T>
-    using has_sequence_traits_spec_t =
-        decltype(sequence_traits<T>{});
-
-    /// \brief Trait that determines whether a specialisation of
-    /// #sequence_traits for `T` exists _and_ has a `type` typedef.
-    template <class T>
-    using has_type_typedef_t = typename sequence_traits<T>::type;
-
-    /// \brief Trait that determines whether a specialisation of
-    /// #sequence_traits for `T` exists _and_ has a static member
-    /// function `size()`.
-    template <class T>
-    using sequence_traits_size_t = decltype(sequence_traits<T>::size());
-
-    /// \brief Trait that determines whether a specialisation of
-    /// #sequence_traits for `T` exists _and_ has a static member
-    /// function `at(T, size_t)` taking a `T` and `size_t` as
-    /// arguments.
-    template <class T>
-    using sequence_traits_at_t = decltype(sequence_traits<T>::at(
-        std::declval<T>(), std::declval<std::size_t>()));
-
-    template <class T>
-    constexpr auto check_specialisation() noexcept -> bool
-    {
-        return is_detected<has_sequence_traits_spec_t, T>::value;
-    }
-
-    template <class T>
-    constexpr auto assert_specialisation() noexcept -> bool
-    {
-        constexpr bool x = check_specialisation<T>();
-        static_assert(x,
-            "There exists no specialisation of "
-            "`boost::static_views::sequence_traits` for type `T`. "
-            "Availability of it is, unfortunately, required "
-            "by the Sequence concept.");
-        return x;
-    }
-
-    template <class T>
-    constexpr auto check_type_typedef() noexcept -> bool
-    {
-        return is_detected<has_type_typedef_t, T>::value;
-    }
-
-    template <class T>
-    constexpr auto assert_type_typedef() noexcept -> bool
-    {
-        constexpr bool x = check_type_typedef<T>();
-        static_assert(x,
-            "`boost::static_views::sequence_traits<T>` has no "
-            "`type` typedef. Availability of it is, unfortunately, "
-            "required by the Sequence concept.");
-        return x;
-    }
-
-    template <class T>
-    constexpr auto check_static_size() noexcept -> bool
-    {
-        return std::is_convertible<
-            detected_t<sequence_traits_size_t, T>,
-            std::size_t>::value;
-    }
-
-    template <class T>
-    constexpr auto assert_static_size() noexcept -> bool
-    {
-        constexpr bool x = check_static_size<T>();
-        static_assert(x,
-            "`boost::static_views::sequence_traits<T>` has no "
-            "static constexpr member function `size()` with "
-            "return type convertible to size_t. Availability of "
-            "it is, unfortunately, required by the Sequence "
-            "concept.");
-        return x;
-    }
-
-    template <class T>
-    constexpr auto check_static_at() noexcept -> bool
-    {
-        return is_detected<sequence_traits_at_t, T>::value;
-    }
-
-    template <class T>
-    constexpr auto assert_static_at() noexcept -> bool
-    {
-        constexpr bool x = check_static_at<T>();
-        static_assert(x,
-            "`boost::static_views::sequence_traits<T>` has no "
-            "static constexpr member function `at(T, size_t)` "
-            "taking a sequence and an index as arguments. "
-            "Availability of it is, unfortunately, required "
-            "by the Sequence concept.");
-        return x;
-    }
+/// \brief Trait that determines whether a specialisation of
+/// #sequence_traits for `T` exists.
+template <class T>
+using has_sequence_traits_spec_t = decltype(sequence_traits<T>{});
 
-} // namespace sequence
+/// \brief Trait that determines whether a specialisation of
+/// #sequence_traits for `T` exists _and_ has a `type` typedef.
+template <class T> using has_type_typedef_t = typename sequence_traits<T>::type;
 
+/// \brief Trait that determines whether a specialisation of
+/// #sequence_traits for `T` exists _and_ has a static member
+/// function `size()`.
+template <class T>
+using sequence_traits_size_t = decltype(sequence_traits<T>::size());
 
+/// \brief Trait that determines whether a specialisation of
+/// #sequence_traits for `T` exists _and_ has a static member
+/// function `at(T, size_t)` taking a `T` and `size_t` as
+/// arguments.
 template <class T>
-constexpr auto is_Sequence() noexcept -> bool
-{
-    return check(&sequence::check_specialisation<T>,
-        &sequence::check_type_typedef<T>,
-        &sequence::check_static_size<T>,
-        &sequence::check_static_at<T>);
+using sequence_traits_at_t = decltype(
+    sequence_traits<T>::at(std::declval<T>(), std::declval<std::size_t>()));
+
+template <class T> constexpr auto check_specialisation() noexcept -> bool {
+  return is_detected<has_sequence_traits_spec_t, T>::value;
 }
 
-template <class T>
-constexpr auto assert_Sequence() noexcept -> bool
-{
-    return check(&sequence::assert_specialisation<T>,
-        &sequence::assert_type_typedef<T>,
-        &sequence::assert_static_size<T>,
-        &sequence::assert_static_at<T>);
+template <class T> constexpr auto assert_specialisation() noexcept -> bool {
+  constexpr bool x = check_specialisation<T>();
+  static_assert(x, "There exists no specialisation of "
+                   "`boost::static_views::sequence_traits` for type `T`. "
+                   "Availability of it is, unfortunately, required "
+                   "by the Sequence concept.");
+  return x;
+}
+
+template <class T> constexpr auto check_type_typedef() noexcept -> bool {
+  return is_detected<has_type_typedef_t, T>::value;
+}
+
+template <class T> constexpr auto assert_type_typedef() noexcept -> bool {
+  constexpr bool x = check_type_typedef<T>();
+  static_assert(x, "`boost::static_views::sequence_traits<T>` has no "
+                   "`type` typedef. Availability of it is, unfortunately, "
+                   "required by the Sequence concept.");
+  return x;
+}
+
+template <class T> constexpr auto check_static_size() noexcept -> bool {
+  return std::is_convertible<detected_t<sequence_traits_size_t, T>,
+                             std::size_t>::value;
+}
+
+template <class T> constexpr auto assert_static_size() noexcept -> bool {
+  constexpr bool x = check_static_size<T>();
+  static_assert(x, "`boost::static_views::sequence_traits<T>` has no "
+                   "static constexpr member function `size()` with "
+                   "return type convertible to size_t. Availability of "
+                   "it is, unfortunately, required by the Sequence "
+                   "concept.");
+  return x;
+}
+
+template <class T> constexpr auto check_static_at() noexcept -> bool {
+  return is_detected<sequence_traits_at_t, T>::value;
+}
+
+template <class T> constexpr auto assert_static_at() noexcept -> bool {
+  constexpr bool x = check_static_at<T>();
+  static_assert(x, "`boost::static_views::sequence_traits<T>` has no "
+                   "static constexpr member function `at(T, size_t)` "
+                   "taking a sequence and an index as arguments. "
+                   "Availability of it is, unfortunately, required "
+                   "by the Sequence concept.");
+  return x;
+}
+
+} // namespace sequence
+
+template <class T> constexpr auto is_Sequence() noexcept -> bool {
+  return check(&sequence::check_specialisation<T>,
+               &sequence::check_type_typedef<T>,
+               &sequence::check_static_size<T>, &sequence::check_static_at<T>);
+}
+
+template <class T> constexpr auto assert_Sequence() noexcept -> bool {
+  return check(
+      &sequence::assert_specialisation<T>, &sequence::assert_type_typedef<T>,
+      &sequence::assert_static_size<T>, &sequence::assert_static_at<T>);
 }
 
 } // namespace concepts
diff --git a/include/boost/static_views/slice.hpp b/include/boost/static_views/slice.hpp
index cb71c80..2c97a0b 100644
--- a/include/boost/static_views/slice.hpp
+++ b/include/boost/static_views/slice.hpp
@@ -7,163 +7,142 @@
 #define BOOST_STATIC_VIEWS_SLICE_HPP
 
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/drop.hpp>
-#include <boost/static_views/take.hpp>
+
+#include "detail/config.hpp"
+#include "drop.hpp"
+#include "take.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <class DropTake>
-struct slice_impl : DropTake {
-
-    static_assert(
-        std::is_same<DropTake, std::decay_t<DropTake>>::value,
-        BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    static_assert(detail::concepts::is_View<DropTake>(),
-        "[INTERNAL] invalid use of drop_impl.");
-
-  private:
-
-    template <class T>
-    using call_parent_t = decltype( std::declval<T const&>().parent() );
-
-    template <class T>
-    static constexpr auto check_has_parent() noexcept -> bool
-    {
-        return is_detected<call_parent_t, T>::value;
-    }
-
-    template <class T,
-        class = std::enable_if_t<check_has_parent<T>()>, class = void>
-    static constexpr auto check_parent_returns_view() noexcept -> bool
-    {
-        return concepts::is_View<
-            std::decay_t<detected_t<call_parent_t, T>>>();
-    }
-
-    template <class T,
-        class = std::enable_if_t<!check_has_parent<T>()>>
-    static constexpr auto check_parent_returns_view() noexcept -> bool
-    {
-        return false;
-    }
-
-    template <class T>
-    static constexpr auto check_parent() noexcept -> bool
-    {
-        return utils::all(
-            check_has_parent<T>(),
-            check_parent_returns_view<T>());
-    }
-
-    template <class T>
-    static constexpr auto assert_parent() noexcept -> bool
-    {
-        constexpr bool x = check_parent<T>();
-        static_assert(x,
-            "[INTERNAL] `T` is required to have a `parent()` member "
-            "function with return type modeling the View concept.");
-        return x;
-    }
-
-  public:
-    /// \brief Converts \p xs to "slice view".
-
-    /// \tparam View
-    /// \verbatim embed:rst:leading-slashes
-    /// Wrapper around a view, i.e. ``typename View::type`` is a view
-    /// and
-    /// must model the :ref:`view <view-concept>` concept. It is
-    /// furthermore
-    /// assumed that ``View`` is of the form
-    /// ``wrapper<drop_impl<wrapper<take_impl<wrapper<V&(&)>&&>>>&&>``
-    /// for
-    /// some view ``V``.
-    /// \endverbatim
-    /// \param xs Rvalue reference to a wrapper around a take view of
-    /// a drop view of a view.
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   It's pretty impossible to specify ``DropTake`` and ``View``
-    ///   template parameters correctly. For this reason a
-    ///   :cpp:var:`slice`
-    ///   factory function is provided. Use it instead to construct
-    ///   slice
-    ///   views.
-    /// \endverbatim
-    template <class View,
-        // avoid clashes with copy/move constructors
-        class = std::enable_if_t<!std::is_same<std::decay_t<View>,
-            slice_impl<DropTake>>::value>>
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR slice_impl(View&& xs)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            std::is_nothrow_constructible<DropTake, View&&>::value)
-        : DropTake{std::forward<View>(xs)}
-    {
-        assert_parent<DropTake>();
-    }
-
-    /// \brief "Maps" index \p i to the corresponding index in the
-    /// parent
-    /// view.
-
-    /// Let `xs` be of type #slice_impl. The following relation then
-    /// holds
-    ///
-    /// `xs[i] = xs.` #parent `()[xs.` #map `(i)]`
-    /// \f$ \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}\f$.
-    ///
-    /// This function and the #parent() member function are what
-    /// distinguish
-    /// slice view from the "drop view of take view of view". Although
-    /// slice
-    /// is implemented in terms of the latter, this function goes two
-    /// steps
-    /// up and thus makes the rest of the library think that slice is
-    /// a single view.
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            noexcept(std::declval<DropTake const&>().parent().map(
-                std::declval<DropTake const&>().map(
-                    std::declval<std::size_t>()))))
-    {
-        static_assert(
-            noexcept(std::declval<DropTake const&>().parent()),
-            "[INTERNAL] Why is parent() not noexcept?");
-        auto const* p = static_cast<DropTake const*>(this);
-        return p->parent().map(p->map(i));
-    }
-
-    /// \brief Returns the "parent" view.
-
-    /// Let `xs_ptr` be of a pointer to some view. The following
-    /// relation
-    /// then holds
-    ///
-    /// `xs_ptr = &` #slice `(b, e)(*xs_ptr).` #parent `(),`
-    ///     \f$\forall \text{b},\text{e} \in \mathbb{N}\f$.
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO parent() const noexcept
-    {
-        static_assert(
-            noexcept(std::declval<DropTake const&>().parent()),
-            "[INTERNAL] Why is parent() not noexcept?");
-        using parent_type = std::decay_t<decltype(
-            std::declval<DropTake const&>().parent())>;
-        assert_parent<parent_type>();
-        static_assert(noexcept(std::declval<parent_type>().parent()),
-            "[INTERNAL] Why is parent() not noexcept?");
-        return static_cast<DropTake const*>(this)->parent().parent();
-    }
+template <class DropTake> struct slice_impl : DropTake {
+
+  static_assert(std::is_same<DropTake, std::decay_t<DropTake>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(detail::concepts::is_View<DropTake>(),
+                "[INTERNAL] invalid use of drop_impl.");
+
+private:
+  template <class T>
+  using call_parent_t = decltype(std::declval<T const &>().parent());
+
+  template <class T> static constexpr auto check_has_parent() noexcept -> bool {
+    return is_detected<call_parent_t, T>::value;
+  }
+
+  template <class T, class = std::enable_if_t<check_has_parent<T>()>,
+            class = void>
+  static constexpr auto check_parent_returns_view() noexcept -> bool {
+    return concepts::is_View<std::decay_t<detected_t<call_parent_t, T>>>();
+  }
+
+  template <class T, class = std::enable_if_t<!check_has_parent<T>()>>
+  static constexpr auto check_parent_returns_view() noexcept -> bool {
+    return false;
+  }
+
+  template <class T> static constexpr auto check_parent() noexcept -> bool {
+    return utils::all(check_has_parent<T>(), check_parent_returns_view<T>());
+  }
+
+  template <class T> static constexpr auto assert_parent() noexcept -> bool {
+    constexpr bool x = check_parent<T>();
+    static_assert(x, "[INTERNAL] `T` is required to have a `parent()` member "
+                     "function with return type modeling the View concept.");
+    return x;
+  }
+
+public:
+  /// \brief Converts \p xs to "slice view".
+
+  /// \tparam View
+  /// \verbatim embed:rst:leading-slashes
+  /// Wrapper around a view, i.e. ``typename View::type`` is a view
+  /// and
+  /// must model the :ref:`view <view-concept>` concept. It is
+  /// furthermore
+  /// assumed that ``View`` is of the form
+  /// ``wrapper<drop_impl<wrapper<take_impl<wrapper<V&(&)>&&>>>&&>``
+  /// for
+  /// some view ``V``.
+  /// \endverbatim
+  /// \param xs Rvalue reference to a wrapper around a take view of
+  /// a drop view of a view.
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   It's pretty impossible to specify ``DropTake`` and ``View``
+  ///   template parameters correctly. For this reason a
+  ///   :cpp:var:`slice`
+  ///   factory function is provided. Use it instead to construct
+  ///   slice
+  ///   views.
+  /// \endverbatim
+  template <class View,
+            // avoid clashes with copy/move constructors
+            class = std::enable_if_t<
+                !std::is_same<std::decay_t<View>, slice_impl<DropTake>>::value>>
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR slice_impl(View &&xs)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          std::is_nothrow_constructible<DropTake, View &&>::value)
+      : DropTake{std::forward<View>(xs)} {
+    assert_parent<DropTake>();
+  }
+
+  /// \brief "Maps" index \p i to the corresponding index in the
+  /// parent
+  /// view.
+
+  /// Let `xs` be of type #slice_impl. The following relation then
+  /// holds
+  ///
+  /// `xs[i] = xs.` #parent `()[xs.` #map `(i)]`
+  /// \f$ \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}\f$.
+  ///
+  /// This function and the #parent() member function are what
+  /// distinguish
+  /// slice view from the "drop view of take view of view". Although
+  /// slice
+  /// is implemented in terms of the latter, this function goes two
+  /// steps
+  /// up and thus makes the rest of the library think that slice is
+  /// a single view.
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto
+  map(std::size_t const i) const BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+      noexcept(std::declval<DropTake const &>().parent().map(
+          std::declval<DropTake const &>().map(std::declval<std::size_t>())))) {
+    static_assert(noexcept(std::declval<DropTake const &>().parent()),
+                  "[INTERNAL] Why is parent() not noexcept?");
+    auto const *p = static_cast<DropTake const *>(this);
+    return p->parent().map(p->map(i));
+  }
+
+  /// \brief Returns the "parent" view.
+
+  /// Let `xs_ptr` be of a pointer to some view. The following
+  /// relation
+  /// then holds
+  ///
+  /// `xs_ptr = &` #slice `(b, e)(*xs_ptr).` #parent `(),`
+  ///     \f$\forall \text{b},\text{e} \in \mathbb{N}\f$.
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO parent() const noexcept {
+    static_assert(noexcept(std::declval<DropTake const &>().parent()),
+                  "[INTERNAL] Why is parent() not noexcept?");
+    using parent_type =
+        std::decay_t<decltype(std::declval<DropTake const &>().parent())>;
+    assert_parent<parent_type>();
+    static_assert(noexcept(std::declval<parent_type>().parent()),
+                  "[INTERNAL] Why is parent() not noexcept?");
+    return static_cast<DropTake const *>(this)->parent().parent();
+  }
 };
 
 struct make_slice_impl {
 
-    // clang-format off
+  // clang-format off
     template <class View>
     BOOST_STATIC_VIEWS_FORCEINLINE
     BOOST_STATIC_VIEWS_CONSTEXPR
@@ -177,7 +156,7 @@ struct make_slice_impl {
             drop(b)(take(e)(std::forward<View>(xs).get())))>>{
             drop(b)(take(e)(std::forward<View>(xs).get()))};
     }
-    // clang-format on
+  // clang-format on
 };
 } // end namespace detail
 
@@ -209,8 +188,7 @@ struct make_slice_impl {
 ///   the :ref:`algorithm <algorithm-concept>` concept.
 ///
 /// \endverbatim
-BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(
-    detail::make_slice_impl, slice)
+BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(detail::make_slice_impl, slice)
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
diff --git a/include/boost/static_views/take.hpp b/include/boost/static_views/take.hpp
index 6695ee4..d67786c 100644
--- a/include/boost/static_views/take.hpp
+++ b/include/boost/static_views/take.hpp
@@ -13,11 +13,11 @@
 #include <algorithm>
 #include <type_traits>
 
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/algorithm_base.hpp>
-#include <boost/static_views/errors.hpp>
-#include <boost/static_views/view_base.hpp>
+#include "algorithm_base.hpp"
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
+#include "errors.hpp"
+#include "view_base.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -25,98 +25,90 @@ namespace detail {
 template <class View>
 struct take_impl : view_adaptor_base<take_impl<View>, View> {
 
-    static_assert(std::is_same<View, std::decay_t<View>>::value,
-        BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    static_assert(
-        is_wrapper<View>::value, BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    static_assert(detail::concepts::is_View<typename View::type>(),
-        "[INTERNAL] invalid use of take_impl.");
-
-    /// \brief Constructs a view of \p xs consisting of at most \p e
-    /// elements of \p xs.
-
-    /// \tparam View
-    /// \verbatim embed:rst:leading-slashes
-    /// Wrapper around a view, i.e. ``typename View::type`` is a view
-    /// and
-    /// must model the :ref:`view <view-concept>` concept.
-    /// \endverbatim
-    /// \param xs Rvalue reference to a wrapper around a view.
-    /// \param e  Number of elements to take. The resulting view will
-    ///           contain \f$min(\text{xs.get}()\text{.size}(),
-    ///           \text{e})\f$
-    ///           elements.
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   It's annoying to have to specify the View template parameter
-    ///   all the time. For this reason a :cpp:var:`take` factory
-    ///   function is provided. Use it instead to construct take
-    ///   views.
-    /// \endverbatim
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR take_impl(
-        View&& xs, std::size_t const n)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_constructible<
-                typename take_impl::view_adaptor_base_type,
-                View&&>::value
-            // This is formally wrong, but come on, std::min(size_t,
-            // size_t)
-            // _should_ be noexcept.
-            // noexcept(std::min(std::declval<std::size_t>(),
-            //    std::declval<std::size_t>())),
-            ))
-        : take_impl::view_adaptor_base_type{std::move(xs)}
-        , _n{std::min(this->parent().size(), n)}
-    {
-        static_assert(noexcept(this->parent()),
-            "[INTERNAL] Why is parent() not noexcept?");
-        static_assert(
-            noexcept(std::declval<decltype(this->parent())>().size()),
-            BOOST_STATIC_VIEWS_BUG_MESSAGE);
-    }
-
-    /// \brief Returns the number of elements viewed.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It never throws.
-    /// \endverbatim
-    BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept
-    {
-        return _n;
-    }
-
-    /// \brief "Maps" index \p i to the corresponding index in the
-    /// parent
-    /// view.
-
-    /// Let `xs` be of type #take_impl. The following relation then
-    /// holds
-    /// \f[
-    /// \text{xs}[i] = \text{xs.parent}()[\text{xs.map}(i)]\;,
-    ///     \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}.
-    /// \f]
-    ///
-    /// If the condition `i < size()` is not satisfied, this function
-    /// throws an #out_of_bound exception.
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const
-    {
-        return i < size() ? i
-                          : ((void)make_out_of_bound_error(
-                                 "`i < size()` not satisfied."),
-                                i);
-    }
-
-  private:
-    // friend struct
-    // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
-    std::size_t _n;
+  static_assert(std::is_same<View, std::decay_t<View>>::value,
+                BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(is_wrapper<View>::value, BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  static_assert(detail::concepts::is_View<typename View::type>(),
+                "[INTERNAL] invalid use of take_impl.");
+
+  /// \brief Constructs a view of \p xs consisting of at most \p e
+  /// elements of \p xs.
+
+  /// \tparam View
+  /// \verbatim embed:rst:leading-slashes
+  /// Wrapper around a view, i.e. ``typename View::type`` is a view
+  /// and
+  /// must model the :ref:`view <view-concept>` concept.
+  /// \endverbatim
+  /// \param xs Rvalue reference to a wrapper around a view.
+  /// \param e  Number of elements to take. The resulting view will
+  ///           contain \f$min(\text{xs.get}()\text{.size}(),
+  ///           \text{e})\f$
+  ///           elements.
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   It's annoying to have to specify the View template parameter
+  ///   all the time. For this reason a :cpp:var:`take` factory
+  ///   function is provided. Use it instead to construct take
+  ///   views.
+  /// \endverbatim
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR take_impl(View &&xs,
+                                                  std::size_t const n)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          utils::all(std::is_nothrow_constructible<
+                     typename take_impl::view_adaptor_base_type, View &&>::value
+                     // This is formally wrong, but come on, std::min(size_t,
+                     // size_t)
+                     // _should_ be noexcept.
+                     // noexcept(std::min(std::declval<std::size_t>(),
+                     //    std::declval<std::size_t>())),
+                     ))
+      : take_impl::view_adaptor_base_type{std::move(xs)},
+        _n{std::min(this->parent().size(), n)} {
+    static_assert(noexcept(this->parent()),
+                  "[INTERNAL] Why is parent() not noexcept?");
+    static_assert(noexcept(std::declval<decltype(this->parent())>().size()),
+                  BOOST_STATIC_VIEWS_BUG_MESSAGE);
+  }
+
+  /// \brief Returns the number of elements viewed.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It never throws.
+  /// \endverbatim
+  BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept { return _n; }
+
+  /// \brief "Maps" index \p i to the corresponding index in the
+  /// parent
+  /// view.
+
+  /// Let `xs` be of type #take_impl. The following relation then
+  /// holds
+  /// \f[
+  /// \text{xs}[i] = \text{xs.parent}()[\text{xs.map}(i)]\;,
+  ///     \forall i \in \{0, 1, \dots, \text{xs.size}()-1\}.
+  /// \f]
+  ///
+  /// If the condition `i < size()` is not satisfied, this function
+  /// throws an #out_of_bound exception.
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const {
+    return i < size()
+               ? i
+               : ((void)make_out_of_bound_error("`i < size()` not satisfied."),
+                  i);
+  }
+
+private:
+  // friend struct
+  // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
+  std::size_t _n;
 };
 
 struct make_take_impl {
-    // clang-format off
+  // clang-format off
     template <class View>
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto operator()(View&& xs, std::size_t const n) const
@@ -129,7 +121,7 @@ struct make_take_impl {
         return take_impl<std::decay_t<View>>{
             std::forward<View>(xs), n};
     }
-    // clang-format on
+  // clang-format on
 };
 } // end namespace detail
 
diff --git a/include/boost/static_views/through.hpp b/include/boost/static_views/through.hpp
index 671cdbd..4aae5a3 100644
--- a/include/boost/static_views/through.hpp
+++ b/include/boost/static_views/through.hpp
@@ -8,117 +8,106 @@
 
 #include <type_traits>
 
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/algorithm_base.hpp>
-#include <boost/static_views/view_base.hpp>
+#include "algorithm_base.hpp"
+#include "detail/config.hpp"
+#include "view_base.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
 namespace detail {
 template <class View, class Proxy>
-struct through_impl
-    : view_adaptor_base<through_impl<View, Proxy>, View> {
-
-    /// \brief Constructs a view of \p xs through \p proxy.
-
-    /// \tparam View
-    /// \verbatim embed:rst:leading-slashes
-    /// Wrapper around a view, i.e. ``typename View::type`` is a view
-    /// and
-    /// must model the :ref:`view <view-concept>` concept.
-    /// \endverbatim
-    /// \tparam Proxy
-    /// \verbatim embed:rst:leading-slashes
-    /// Just like ``View``, a wrapper around a view, i.e.
-    /// ``typename Proxy::type`` must be a view. Furthermore, viewed
-    /// elements must be of type ``std::size_t``.
-    /// \endverbatim
-    /// \param xs    Rvalue reference to a wrapper around a view.
-    /// \param proxy Rvalue reference to a wrapper around a view. It
-    /// is
-    ///              used as a proxy to access elements of \p xs, i.e.
-    ///              if `ys = through_impl{xs, proxy}`, then
-    ///              \f[
-    ///                 \text{ys}[i] = \text{xs.get}()\!\left[
-    ///                     \text{proxy.get}()[i]\right]\;,
-    ///                 \forall i \in \{0,1,\dots,\text{xs.size}() -
-    ///                 1\}.
-    ///              \f]
-    ///
-    /// \verbatim embed:rst:leading-slashes
-    /// .. note::
-    ///   It's annoying to have to specify the ``View`` and ``Proxy``
-    ///   template parameters all the time. For this reason a
-    ///   :cpp:var:`through` factory function is provided. Use it
-    ///   instead
-    ///   to construct views through other views.
-    /// \endverbatim
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR through_impl(
-        View&& xs, Proxy&& proxy)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
-            std::is_nothrow_constructible<
-                typename through_impl::view_adaptor_base_type,
-                View&&>::value,
-            std::is_nothrow_move_constructible<Proxy>::value))
-        : through_impl::view_adaptor_base_type{std::move(xs)}
-        , _proxy{std::move(proxy)}
-    {
-    }
-
-    /// \brief Returns the capacity of this view.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It just calls ``capacity()`` on the proxy view. This
-    /// function never fails.
-    /// \endverbatim
-    static constexpr auto capacity() noexcept
-    {
-        return Proxy::type::capacity();
-    }
-
-    /// \brief Returns the number of elements viewed.
-
-    /// \verbatim embed:rst:leading-slashes
-    /// This function is required by the :ref:`view <view-concept>`
-    /// concept. It just calls ``size()`` on the proxy view. This
-    /// function never fails unless a call to ``proxy.size()``
-    /// fails.
-    /// \endverbatim
-    BOOST_STATIC_VIEWS_CONSTEXPR auto size() const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            noexcept(std::declval<Proxy const&>().get().size()))
-    {
-        return _proxy.get().size();
-    }
-
-    /// \brief "Maps" index \p i to the corresponding index in the
-    /// parent
-    /// view. Actually, it just calls ``operator[]`` on the proxy
-    /// view.
-
-    /// Let `ys` be of type #through_impl, i.e. `ys = ` #through
-    /// `(proxy)(xs)`. The following relation then holds
-    ///
-    /// `ys.` #map `(i) = proxy[i],`
-    ///     \f$\forall i \in \{0, 1, \dots,
-    ///     \text{proxy.size}()-1\}.\f$
-    BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
-            std::declval<Proxy const&>()
-                .get()[std::declval<std::size_t>()])) -> std::size_t
-    {
-        return _proxy.get()[i];
-    }
-
-  private:
-    // friend struct
-    // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
-    Proxy _proxy;
+struct through_impl : view_adaptor_base<through_impl<View, Proxy>, View> {
+
+  /// \brief Constructs a view of \p xs through \p proxy.
+
+  /// \tparam View
+  /// \verbatim embed:rst:leading-slashes
+  /// Wrapper around a view, i.e. ``typename View::type`` is a view
+  /// and
+  /// must model the :ref:`view <view-concept>` concept.
+  /// \endverbatim
+  /// \tparam Proxy
+  /// \verbatim embed:rst:leading-slashes
+  /// Just like ``View``, a wrapper around a view, i.e.
+  /// ``typename Proxy::type`` must be a view. Furthermore, viewed
+  /// elements must be of type ``std::size_t``.
+  /// \endverbatim
+  /// \param xs    Rvalue reference to a wrapper around a view.
+  /// \param proxy Rvalue reference to a wrapper around a view. It
+  /// is
+  ///              used as a proxy to access elements of \p xs, i.e.
+  ///              if `ys = through_impl{xs, proxy}`, then
+  ///              \f[
+  ///                 \text{ys}[i] = \text{xs.get}()\!\left[
+  ///                     \text{proxy.get}()[i]\right]\;,
+  ///                 \forall i \in \{0,1,\dots,\text{xs.size}() -
+  ///                 1\}.
+  ///              \f]
+  ///
+  /// \verbatim embed:rst:leading-slashes
+  /// .. note::
+  ///   It's annoying to have to specify the ``View`` and ``Proxy``
+  ///   template parameters all the time. For this reason a
+  ///   :cpp:var:`through` factory function is provided. Use it
+  ///   instead
+  ///   to construct views through other views.
+  /// \endverbatim
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR through_impl(View &&xs, Proxy &&proxy)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(utils::all(
+          std::is_nothrow_constructible<
+              typename through_impl::view_adaptor_base_type, View &&>::value,
+          std::is_nothrow_move_constructible<Proxy>::value))
+      : through_impl::view_adaptor_base_type{std::move(xs)},
+        _proxy{std::move(proxy)} {}
+
+  /// \brief Returns the capacity of this view.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It just calls ``capacity()`` on the proxy view. This
+  /// function never fails.
+  /// \endverbatim
+  static constexpr auto capacity() noexcept { return Proxy::type::capacity(); }
+
+  /// \brief Returns the number of elements viewed.
+
+  /// \verbatim embed:rst:leading-slashes
+  /// This function is required by the :ref:`view <view-concept>`
+  /// concept. It just calls ``size()`` on the proxy view. This
+  /// function never fails unless a call to ``proxy.size()``
+  /// fails.
+  /// \endverbatim
+  BOOST_STATIC_VIEWS_CONSTEXPR auto size() const BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+      noexcept(std::declval<Proxy const &>().get().size())) {
+    return _proxy.get().size();
+  }
+
+  /// \brief "Maps" index \p i to the corresponding index in the
+  /// parent
+  /// view. Actually, it just calls ``operator[]`` on the proxy
+  /// view.
+
+  /// Let `ys` be of type #through_impl, i.e. `ys = ` #through
+  /// `(proxy)(xs)`. The following relation then holds
+  ///
+  /// `ys.` #map `(i) = proxy[i],`
+  ///     \f$\forall i \in \{0, 1, \dots,
+  ///     \text{proxy.size}()-1\}.\f$
+  BOOST_STATIC_VIEWS_CONSTEXPR auto map(std::size_t const i) const
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
+          std::declval<Proxy const &>().get()[std::declval<std::size_t>()]))
+          -> std::size_t {
+    return _proxy.get()[i];
+  }
+
+private:
+  // friend struct
+  // BOOST_STATIC_VIEWS_NAMESPACE::view_adaptor_core_access;
+  Proxy _proxy;
 };
 
 struct make_through_impl {
-    // clang-format off
+  // clang-format off
     template <class View, class Proxy>
     BOOST_STATIC_VIEWS_CONSTEXPR
     auto operator()(View&& xs, Proxy&& proxy) const
@@ -135,7 +124,7 @@ struct make_through_impl {
                     std::forward<View>(xs),
                     make_wrapper(std::forward<Proxy>(proxy))};
     }
-    // clang-format on
+  // clang-format on
 };
 } // end namespace detail
 
@@ -161,8 +150,7 @@ struct make_through_impl {
 ///   concept.
 ///
 /// \endverbatim
-BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(
-    detail::make_through_impl, through)
+BOOST_STATIC_VIEWS_INLINE_ALGO_VARIABLE(detail::make_through_impl, through)
 
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
diff --git a/include/boost/static_views/view_base.hpp b/include/boost/static_views/view_base.hpp
index 7b68b48..c7e0356 100644
--- a/include/boost/static_views/view_base.hpp
+++ b/include/boost/static_views/view_base.hpp
@@ -12,9 +12,10 @@
 #define BOOST_STATIC_VIEWS_VIEW_BASE_HPP
 
 #include <type_traits>
-#include <boost/static_views/detail/config.hpp>
-#include <boost/static_views/detail/utils.hpp>
-#include <boost/static_views/detail/wrapper.hpp>
+
+#include "detail/config.hpp"
+#include "detail/utils.hpp"
+#include "detail/wrapper.hpp"
 
 BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 
@@ -24,12 +25,9 @@ BOOST_STATIC_VIEWS_BEGIN_NAMESPACE
 /// By deriving from :cpp:class:`view_base`, you tell StaticView that
 /// the derived class models the :ref:`view <view-concept>` concept.
 /// \endverbatim
-struct view_base {
-};
-
+struct view_base {};
 
-template <class Derived, class View>
-struct view_adaptor_base;
+template <class Derived, class View> struct view_adaptor_base;
 
 /// \brief Checks whether `V` models the View concept.
 
@@ -63,190 +61,141 @@ struct view_adaptor_base;
 /// but nothing else. The very same technique is used in
 /// [Boost.Iterator](http://www.boost.org/doc/libs/1_64_0/libs/iterator/doc/iterator_facade.html#iterator-core-access).
 struct view_adaptor_core_access {
-    template <class T, class V>
-    friend struct view_adaptor_base;
-
-  private:
-    template <class View>
-    static BOOST_STATIC_VIEWS_CONSTEXPR auto map(
-        View const& xs, std::size_t const i)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(xs.map(i)))
-    {
-        return xs.map(i);
-    }
+  template <class T, class V> friend struct view_adaptor_base;
+
+private:
+  template <class View>
+  static BOOST_STATIC_VIEWS_CONSTEXPR auto map(View const &xs,
+                                               std::size_t const i)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(xs.map(i))) {
+    return xs.map(i);
+  }
 };
 
 namespace detail {
 namespace concepts {
 namespace view {
 
+template <class T>
+using operator_access_t =
+    decltype(std::declval<T>()[std::declval<std::size_t>()]);
 
-    template <class T>
-    using operator_access_t =
-        decltype(std::declval<T>()[std::declval<std::size_t>()]);
-
-    template <class T>
-    constexpr auto check_copy_or_move() noexcept -> bool
-    {
-        return std::is_move_constructible<std::remove_cv_t<T>>::value
-            || std::is_copy_constructible<std::remove_cv_t<T>>::value;
-    }
+template <class T> constexpr auto check_copy_or_move() noexcept -> bool {
+  return std::is_move_constructible<std::remove_cv_t<T>>::value ||
+         std::is_copy_constructible<std::remove_cv_t<T>>::value;
+}
 
-    template <class T>
-    constexpr auto assert_copy_or_move() noexcept -> bool
-    {
-        constexpr bool x = check_copy_or_move<T>();
-        static_assert(x,
-            "`T` is neither move nor copy constructible. "
-            "It is, however, required by the View concept that "
-            "`T` be either copy or move constructible");
-        return x;
-    }
+template <class T> constexpr auto assert_copy_or_move() noexcept -> bool {
+  constexpr bool x = check_copy_or_move<T>();
+  static_assert(x, "`T` is neither move nor copy constructible. "
+                   "It is, however, required by the View concept that "
+                   "`T` be either copy or move constructible");
+  return x;
+}
 
-    template <class T>
-    constexpr auto check_derive() noexcept -> bool
-    {
-        return std::is_base_of<view_base, std::remove_cv_t<T>>::value;
-    }
+template <class T> constexpr auto check_derive() noexcept -> bool {
+  return std::is_base_of<view_base, std::remove_cv_t<T>>::value;
+}
 
-    template <class T>
-    constexpr auto assert_derive() noexcept -> bool
-    {
-        constexpr bool x = check_derive<T>();
-        static_assert(x,
-            "It is required by the View concept that `T` derive "
-            "from boost::static_views::view_base.");
-        return x;
-    }
+template <class T> constexpr auto assert_derive() noexcept -> bool {
+  constexpr bool x = check_derive<T>();
+  static_assert(x, "It is required by the View concept that `T` derive "
+                   "from boost::static_views::view_base.");
+  return x;
+}
 
-    template <class T>
-    using static_capacity_t = decltype(T::capacity());
+template <class T> using static_capacity_t = decltype(T::capacity());
 
-    template <class T>
-    constexpr auto check_exists_static_capacity() noexcept -> bool
-    {
-        return std::is_convertible<detected_t<static_capacity_t, T>,
-            std::size_t>::value;
-    }
+template <class T>
+constexpr auto check_exists_static_capacity() noexcept -> bool {
+  return std::is_convertible<detected_t<static_capacity_t, T>,
+                             std::size_t>::value;
+}
 
-    template <class T,
-        class = std::enable_if_t<check_exists_static_capacity<T>()>,
-        class = void>
-    constexpr auto check_noexcept_static_capacity() noexcept -> bool
-    {
-        return noexcept(T::capacity());
-    }
+template <class T, class = std::enable_if_t<check_exists_static_capacity<T>()>,
+          class = void>
+constexpr auto check_noexcept_static_capacity() noexcept -> bool {
+  return noexcept(T::capacity());
+}
 
-    template <class T,
-        class = std::enable_if_t<!check_exists_static_capacity<T>()>>
-    constexpr auto check_noexcept_static_capacity() noexcept -> bool
-    {
-        return false;
-    }
+template <class T, class = std::enable_if_t<!check_exists_static_capacity<T>()>>
+constexpr auto check_noexcept_static_capacity() noexcept -> bool {
+  return false;
+}
 
-    template <class T>
-    constexpr auto check_static_capacity() noexcept -> bool
-    {
-        return utils::all(
-            check_exists_static_capacity<T>(),
-            check_noexcept_static_capacity<T>());
-    }
+template <class T> constexpr auto check_static_capacity() noexcept -> bool {
+  return utils::all(check_exists_static_capacity<T>(),
+                    check_noexcept_static_capacity<T>());
+}
 
-    template <class T>
-    constexpr auto assert_static_capacity() noexcept -> bool
-    {
-        constexpr bool x = check_static_capacity<T>();
-        static_assert(x,
-            "It is required by the View concept for `T` to have a "
-            "static constexpr non-throwing member function "
-            "`capacity()` with return type convertible to size_t.");
-        return x;
-    }
+template <class T> constexpr auto assert_static_capacity() noexcept -> bool {
+  constexpr bool x = check_static_capacity<T>();
+  static_assert(x, "It is required by the View concept for `T` to have a "
+                   "static constexpr non-throwing member function "
+                   "`capacity()` with return type convertible to size_t.");
+  return x;
+}
 
-    template <class T>
-    using member_size_t = decltype(std::declval<T const&>().size());
+template <class T>
+using member_size_t = decltype(std::declval<T const &>().size());
 
-    template <class T>
-    constexpr auto check_exists_member_size() noexcept -> bool
-    {
-        return std::is_convertible<detected_t<member_size_t, T>,
-            std::size_t>::value;
-    }
+template <class T> constexpr auto check_exists_member_size() noexcept -> bool {
+  return std::is_convertible<detected_t<member_size_t, T>, std::size_t>::value;
+}
 
-    template <class T,
-        class = std::enable_if_t<check_exists_member_size<T>()>,
-        class = void>
-    constexpr auto check_noexcept_member_size() noexcept -> bool
-    {
-        return noexcept(std::declval<T const&>().size());
-    }
+template <class T, class = std::enable_if_t<check_exists_member_size<T>()>,
+          class = void>
+constexpr auto check_noexcept_member_size() noexcept -> bool {
+  return noexcept(std::declval<T const &>().size());
+}
 
-    template <class T,
-        class = std::enable_if_t<!check_exists_member_size<T>()>>
-    constexpr auto check_noexcept_member_size() noexcept -> bool
-    {
-        return false;
-    }
+template <class T, class = std::enable_if_t<!check_exists_member_size<T>()>>
+constexpr auto check_noexcept_member_size() noexcept -> bool {
+  return false;
+}
 
-    template <class T>
-    constexpr auto check_member_size() noexcept -> bool
-    {
-        return utils::all(
-            check_exists_member_size<T>(),
-            check_noexcept_member_size<T>());
-    }
+template <class T> constexpr auto check_member_size() noexcept -> bool {
+  return utils::all(check_exists_member_size<T>(),
+                    check_noexcept_member_size<T>());
+}
 
-    template <class T>
-    constexpr auto assert_member_size() noexcept -> bool
-    {
-        constexpr bool x = check_member_size<T>();
-        static_assert(x,
-            "It is required by the View concept for `T` to have a "
-            "constexpr non-throwing member function `size() const` "
-            "with return type convertible to size_t.");
-        return x;
-    }
+template <class T> constexpr auto assert_member_size() noexcept -> bool {
+  constexpr bool x = check_member_size<T>();
+  static_assert(x, "It is required by the View concept for `T` to have a "
+                   "constexpr non-throwing member function `size() const` "
+                   "with return type convertible to size_t.");
+  return x;
+}
 
-    template <class T>
-    constexpr auto check_operator_access() noexcept -> bool
-    {
-        return is_detected<operator_access_t, T>::value;
-    }
+template <class T> constexpr auto check_operator_access() noexcept -> bool {
+  return is_detected<operator_access_t, T>::value;
+}
 
-    template <class T>
-    constexpr auto assert_operator_access() noexcept -> bool
-    {
-        constexpr bool x = check_operator_access<T>();
-        static_assert(x,
-            "It is required by the View concept for `T` to have a "
-            "constexpr `operator[](size_t)` taking an index as "
-            "argument.");
-        return x;
-    }
+template <class T> constexpr auto assert_operator_access() noexcept -> bool {
+  constexpr bool x = check_operator_access<T>();
+  static_assert(x, "It is required by the View concept for `T` to have a "
+                   "constexpr `operator[](size_t)` taking an index as "
+                   "argument.");
+  return x;
+}
 } // namespace view
 
-template <class T>
-constexpr auto is_View() noexcept -> bool
-{
-    constexpr bool x = check(&view::check_derive<T>,
-        &view::check_copy_or_move<T>,
-        &view::check_static_capacity<T>,
-        &view::check_member_size<T>,
-        &view::check_operator_access<T>);
-    return x;
+template <class T> constexpr auto is_View() noexcept -> bool {
+  constexpr bool x =
+      check(&view::check_derive<T>, &view::check_copy_or_move<T>,
+            &view::check_static_capacity<T>, &view::check_member_size<T>,
+            &view::check_operator_access<T>);
+  return x;
 }
 
-template <class T>
-constexpr auto assert_View() noexcept -> bool
-{
-    static_assert(is_View<T>(),
-        "I'm sorry, but `T` needs to model the View concept.");
-    constexpr bool x = check(&view::assert_derive<T>,
-        &view::assert_copy_or_move<T>,
-        &view::assert_static_capacity<T>,
-        &view::assert_member_size<T>,
-        &view::assert_operator_access<T>);
-    return x;
+template <class T> constexpr auto assert_View() noexcept -> bool {
+  static_assert(is_View<T>(),
+                "I'm sorry, but `T` needs to model the View concept.");
+  constexpr bool x =
+      check(&view::assert_derive<T>, &view::assert_copy_or_move<T>,
+            &view::assert_static_capacity<T>, &view::assert_member_size<T>,
+            &view::assert_operator_access<T>);
+  return x;
 }
 
 } // namespace concepts
@@ -256,130 +205,120 @@ constexpr auto assert_View() noexcept -> bool
 /// \verbatim embed:rst:leading-slashes
 /// Base class to that helps with modeling the :ref:`View
 /// <view-concept>` concept. \endverbatim
-template <class Derived, class View>
-struct view_adaptor_base : view_base {
-
-    // Make sure Derived is not some strange reference or something.
-    static_assert(std::is_same<Derived, std::decay_t<Derived>>::value,
-        "`boost::static_views::view_adaptor_base<Derived, View>` "
-        "requires the `Derived` template argument to be an "
-        "unqualified type.");
-    // Make sure View is not some strange reference or something.
-    static_assert(std::is_same<View, std::decay_t<View>>::value,
-        "`boost::static_views::view_adaptor_base<Derived, View>` "
-        "requires the `View` template argument to be an "
-        "unqualified type.");
-    // Make sure View is actually a wrapper.
-    static_assert(detail::is_wrapper<View>::value,
-        "`boost::static_views::view_adaptor_base<Derived, View>` "
-        "requires the `View` template argument to be a wrapper "
-        "type (i.e. `View = wrapper<T>` for some type `T`).");
-    // View is stored as a member variable, so we need at least
-    // move-constructor
-    static_assert(detail::concepts::is_View<
-        typename View::type>(),
-        "`boost::static_views::view_adaptor_base<Derived, View>`, "
-        "mind the __View__! In other words, `View::type` must "
-        "model the View concept.");
-
-  private:
-    using derived_type = Derived;
-    using wrapper_type = View;
-    using view_type    = typename View::type;
-
-  protected:
-    using view_adaptor_base_type = view_adaptor_base<Derived, View>;
-
-  public:
-    /// \name Constructors
-    ///
-    /// \brief Constructs an adaptor of \p view.
-    /// \details Here, \p view is a wrapper around the actual view
-    /// created with #make_wrapper(T&&) function.
-    explicit BOOST_STATIC_VIEWS_CONSTEXPR view_adaptor_base(
-        wrapper_type&& view)
-        BOOST_STATIC_VIEWS_NOEXCEPT_IF(
-            std::is_nothrow_move_constructible<wrapper_type>::value)
-        : _xs{std::move(view)}
-    {
-    }
-
-    /// \name Copy and move constructors/assignments
-    ///
-    /// Defines default copy and move constructors and assignments,
-    /// i.e. is copy/move-constructible/assignable if \p View is.
-    /// \{
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    view_adaptor_base(view_adaptor_base const&) = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    view_adaptor_base(view_adaptor_base&&) = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    view_adaptor_base& operator=(view_adaptor_base const&) = default;
-
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    view_adaptor_base& operator=(view_adaptor_base&&) = default;
-    /// \}
-
-    /// \brief
-    /// \verbatim embed:rst:leading-slashes
-    /// Default implementation of the ``capacity`` function required
-    /// by the :ref:`view concept <view-concept>`. \endverbatim
-
-    /// Just calls `capacity()` on the underlying view.
-    static constexpr auto capacity() noexcept
-    {
-        static_assert(noexcept(view_type::capacity()),
-            "view_adaptor_base<> assumes that view_type::capacity() "
-            "never throws.");
-        return view_type::capacity();
-    }
-
-    /// \brief
-    /// \verbatim embed:rst:leading-slashes
-    /// Default implementation of the ``size`` function required by
-    /// the :ref:`view concept <view-concept>`. \endverbatim
-
-    /// Just calls `size()` on the underlying view.
-    BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept
-    {
-        static_assert(noexcept(this->parent()),
-            "view_adaptor_base<> assumes that its own parent() "
-            "member function does not throw.");
-        static_assert(
-            noexcept(std::declval<decltype(this->parent())>().size()),
-            "view_adaptor_base<> assumes that its parent has a "
-            "non-throwing size() member function.");
-        return parent().size();
-    }
-
-    /// \brief Returns the underlying view.
-    /// \{
-    BOOST_STATIC_VIEWS_CONSTEXPR
-    BOOST_STATIC_VIEWS_DECLTYPE_AUTO parent() const & noexcept
-    {
-        static_assert(noexcept(_xs.get()),
-            "view_adaptor_base<> assumes that "
-            "`wrapper::get() const&` is noexcept.");
-        return _xs.get();
-    }
-
-    /*
-    #if defined(DOXYGEN_IN_HOUSE)
-        BOOST_STATIC_VIEWS_CONSTEXPR underlying_view_type& parent() &
-    #else
-        BOOST_STATIC_VIEWS_CONSTEXPR decltype(auto) parent() &
-    #endif
-            BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
-                std::declval<wrapper_type &>().get()
-            ))
-        {
-            return _xs.get();
-        }
-    */
-
-    // clang-format off
+template <class Derived, class View> struct view_adaptor_base : view_base {
+
+  // Make sure Derived is not some strange reference or something.
+  static_assert(std::is_same<Derived, std::decay_t<Derived>>::value,
+                "`boost::static_views::view_adaptor_base<Derived, View>` "
+                "requires the `Derived` template argument to be an "
+                "unqualified type.");
+  // Make sure View is not some strange reference or something.
+  static_assert(std::is_same<View, std::decay_t<View>>::value,
+                "`boost::static_views::view_adaptor_base<Derived, View>` "
+                "requires the `View` template argument to be an "
+                "unqualified type.");
+  // Make sure View is actually a wrapper.
+  static_assert(detail::is_wrapper<View>::value,
+                "`boost::static_views::view_adaptor_base<Derived, View>` "
+                "requires the `View` template argument to be a wrapper "
+                "type (i.e. `View = wrapper<T>` for some type `T`).");
+  // View is stored as a member variable, so we need at least
+  // move-constructor
+  static_assert(detail::concepts::is_View<typename View::type>(),
+                "`boost::static_views::view_adaptor_base<Derived, View>`, "
+                "mind the __View__! In other words, `View::type` must "
+                "model the View concept.");
+
+private:
+  using derived_type = Derived;
+  using wrapper_type = View;
+  using view_type = typename View::type;
+
+protected:
+  using view_adaptor_base_type = view_adaptor_base<Derived, View>;
+
+public:
+  /// \name Constructors
+  ///
+  /// \brief Constructs an adaptor of \p view.
+  /// \details Here, \p view is a wrapper around the actual view
+  /// created with #make_wrapper(T&&) function.
+  explicit BOOST_STATIC_VIEWS_CONSTEXPR view_adaptor_base(wrapper_type &&view)
+      BOOST_STATIC_VIEWS_NOEXCEPT_IF(
+          std::is_nothrow_move_constructible<wrapper_type>::value)
+      : _xs{std::move(view)} {}
+
+  /// \name Copy and move constructors/assignments
+  ///
+  /// Defines default copy and move constructors and assignments,
+  /// i.e. is copy/move-constructible/assignable if \p View is.
+  /// \{
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  view_adaptor_base(view_adaptor_base const &) = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  view_adaptor_base(view_adaptor_base &&) = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  view_adaptor_base &operator=(view_adaptor_base const &) = default;
+
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  view_adaptor_base &operator=(view_adaptor_base &&) = default;
+  /// \}
+
+  /// \brief
+  /// \verbatim embed:rst:leading-slashes
+  /// Default implementation of the ``capacity`` function required
+  /// by the :ref:`view concept <view-concept>`. \endverbatim
+
+  /// Just calls `capacity()` on the underlying view.
+  static constexpr auto capacity() noexcept {
+    static_assert(noexcept(view_type::capacity()),
+                  "view_adaptor_base<> assumes that view_type::capacity() "
+                  "never throws.");
+    return view_type::capacity();
+  }
+
+  /// \brief
+  /// \verbatim embed:rst:leading-slashes
+  /// Default implementation of the ``size`` function required by
+  /// the :ref:`view concept <view-concept>`. \endverbatim
+
+  /// Just calls `size()` on the underlying view.
+  BOOST_STATIC_VIEWS_CONSTEXPR auto size() const noexcept {
+    static_assert(noexcept(this->parent()),
+                  "view_adaptor_base<> assumes that its own parent() "
+                  "member function does not throw.");
+    static_assert(noexcept(std::declval<decltype(this->parent())>().size()),
+                  "view_adaptor_base<> assumes that its parent has a "
+                  "non-throwing size() member function.");
+    return parent().size();
+  }
+
+  /// \brief Returns the underlying view.
+  /// \{
+  BOOST_STATIC_VIEWS_CONSTEXPR
+  BOOST_STATIC_VIEWS_DECLTYPE_AUTO parent() const &noexcept {
+    static_assert(noexcept(_xs.get()), "view_adaptor_base<> assumes that "
+                                       "`wrapper::get() const&` is noexcept.");
+    return _xs.get();
+  }
+
+  /*
+  #if defined(DOXYGEN_IN_HOUSE)
+      BOOST_STATIC_VIEWS_CONSTEXPR underlying_view_type& parent() &
+  #else
+      BOOST_STATIC_VIEWS_CONSTEXPR decltype(auto) parent() &
+  #endif
+          BOOST_STATIC_VIEWS_NOEXCEPT_IF(noexcept(
+              std::declval<wrapper_type &>().get()
+          ))
+      {
+          return _xs.get();
+      }
+  */
+
+  // clang-format off
     BOOST_STATIC_VIEWS_CONSTEXPR
     BOOST_STATIC_VIEWS_DECLTYPE_AUTO parent() &&
         BOOST_STATIC_VIEWS_NOEXCEPT_IF(
@@ -387,12 +326,12 @@ struct view_adaptor_base : view_base {
     {
         return std::move(_xs).get();
     }
-    // clang-format on
-    /// \}
+  // clang-format on
+  /// \}
 
-    /// \name Element access
-    /// \{
-    // clang-format off
+  /// \name Element access
+  /// \{
+  // clang-format off
     BOOST_STATIC_VIEWS_CONSTEXPR
     BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator[](std::size_t const i) const&
         BOOST_STATIC_VIEWS_NOEXCEPT_IF(
@@ -403,9 +342,9 @@ struct view_adaptor_base : view_base {
     {
         return parent()[view_adaptor_core_access::map(derived(), i)];
     }
-    // clang-format on
+  // clang-format on
 
-    // clang-format off
+  // clang-format off
     BOOST_STATIC_VIEWS_CONSTEXPR
     BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator[](std::size_t const i) &
         BOOST_STATIC_VIEWS_NOEXCEPT_IF(
@@ -416,9 +355,9 @@ struct view_adaptor_base : view_base {
     {
         return parent()[view_adaptor_core_access::map(derived(), i)];
     }
-    // clang-format on
+  // clang-format on
 
-    // clang-format off
+  // clang-format off
     BOOST_STATIC_VIEWS_CONSTEXPR
     BOOST_STATIC_VIEWS_DECLTYPE_AUTO operator[](std::size_t const i) &&
         BOOST_STATIC_VIEWS_NOEXCEPT_IF(
@@ -430,21 +369,19 @@ struct view_adaptor_base : view_base {
         return std::forward<view_adaptor_base>(*this).parent()[
             view_adaptor_core_access::map(derived(), i)];
     }
-    // clang-format on
-    /// \}
+  // clang-format on
+  /// \}
 
-  private:
-    View _xs;
+private:
+  View _xs;
 
-    BOOST_STATIC_VIEWS_FORCEINLINE
-    BOOST_STATIC_VIEWS_CONSTEXPR auto derived() const noexcept
-        -> derived_type const&
-    {
-        return *static_cast<derived_type const*>(this);
-    }
+  BOOST_STATIC_VIEWS_FORCEINLINE
+  BOOST_STATIC_VIEWS_CONSTEXPR auto derived() const noexcept
+      -> derived_type const & {
+    return *static_cast<derived_type const *>(this);
+  }
 };
 
-
 BOOST_STATIC_VIEWS_END_NAMESPACE
 
 #endif // BOOST_STATIC_VIEWS_VIEW_BASE_HPP