diff --git a/include/boost/parser/detail/stl_interfaces/iterator_interface.hpp b/include/boost/parser/detail/stl_interfaces/iterator_interface.hpp
index 9591e756..919b7070 100644
--- a/include/boost/parser/detail/stl_interfaces/iterator_interface.hpp
+++ b/include/boost/parser/detail/stl_interfaces/iterator_interface.hpp
@@ -47,11 +47,9 @@ namespace boost::parser::detail { namespace stl_interfaces {
         `T`. */
     template<typename T>
 #if defined(BOOST_STL_INTERFACES_DOXYGEN) || BOOST_PARSER_USE_CONCEPTS
-    // clang-format off
         requires std::is_object_v<T>
 #endif
     struct proxy_arrow_result
-    // clang-format on
     {
         constexpr proxy_arrow_result(T const & value) noexcept(
             noexcept(T(value))) :
@@ -619,33 +617,25 @@ namespace boost::parser::detail { namespace stl_interfaces { BOOST_PARSER_DETAIL
         using iter_concept_t = typename iter_concept<Iterator>::type;
 
         template<typename D, typename DifferenceType>
-        // clang-format off
-        concept plus_eq = requires (D d) { d += DifferenceType(1); };
-        // clang-format on
+        concept plus_eq = requires(D d) { d += DifferenceType(1); };
 
         template<typename D, typename D2 = D>
-        // clang-format off
         concept base_3way =
 #if defined(__cpp_impl_three_way_comparison)
-            requires (D d, D2 d2) { access::base(d) <=> access::base(d2); };
+            requires(D d, D2 d2) { access::base(d) <=> access::base(d2); };
 #else
             false;
 #endif
-        // clang-format on
 
         template<typename D1, typename D2 = D1>
-        // clang-format off
         concept base_eq =
-            requires (D1 d1, D2 d2) { access::base(d1) == access::base(d2); };
-        // clang-format on
+            requires(D1 d1, D2 d2) { access::base(d1) == access::base(d2); };
 
         template<typename D, typename D2 = D>
-        // clang-format off
-        concept iter_sub = requires (D d, D2 d2) {
+        concept iter_sub = requires(D d, D2 d2) {
             typename D::difference_type;
-            {d - d2} -> std::convertible_to<typename D::difference_type>;
+            { d - d2 } -> std::convertible_to<typename D::difference_type>;
         };
-        // clang-format on
 
         // This iterator concept -> category mapping scheme follows the one
         // from zip_transform_view; see
diff --git a/include/boost/parser/detail/stl_interfaces/view_adaptor.hpp b/include/boost/parser/detail/stl_interfaces/view_adaptor.hpp
index 7a73cdbf..ee63fe76 100644
--- a/include/boost/parser/detail/stl_interfaces/view_adaptor.hpp
+++ b/include/boost/parser/detail/stl_interfaces/view_adaptor.hpp
@@ -328,23 +328,20 @@ namespace boost::parser::detail { namespace stl_interfaces {
     {
         constexpr adaptor(F f) : f_(f) {}
 
-        // clang-format off
         template<typename... Args>
         constexpr auto operator()(Args &&... args) const
-        // clang-format on
         {
 #if BOOST_PARSER_DETAIL_STL_INTERFACES_USE_CONCEPTS
             if constexpr (std::is_invocable_v<F const &, Args...>) {
-                return f_((Args &&) args...);
+                return f_((Args &&)args...);
             } else {
-                return closure(
-                    stl_interfaces::bind_back(f_, (Args &&) args...));
+                return closure(stl_interfaces::bind_back(f_, (Args &&)args...));
             }
 #else
             return detail::adaptor_impl<
                 F const &,
                 detail::is_invocable_v<F const &, Args...>,
-                Args...>::call(f_, (Args &&) args...);
+                Args...>::call(f_, (Args &&)args...);
 #endif
         }
 
diff --git a/include/boost/parser/detail/text/concepts.hpp b/include/boost/parser/detail/text/concepts.hpp
index 26cbc20a..2913dda4 100644
--- a/include/boost/parser/detail/text/concepts.hpp
+++ b/include/boost/parser/detail/text/concepts.hpp
@@ -97,17 +97,14 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
 
     template<typename T>
     concept grapheme_iter =
-        // clang-format off
-        std::input_iterator<T> &&
-        code_point_range<std::iter_reference_t<T>> &&
+        std::input_iterator<T> && code_point_range<std::iter_reference_t<T>> &&
         requires(T t) {
-        { t.base() } -> code_point_iter;
-        // clang-format on
-    };
+            { t.base() } -> code_point_iter;
+        };
 
     template<typename T>
     concept grapheme_range = std::ranges::input_range<T> &&
-        grapheme_iter<std::ranges::iterator_t<T>>;
+                             grapheme_iter<std::ranges::iterator_t<T>>;
 
     template<typename R>
     using code_point_iterator_t = decltype(std::declval<R>().begin().base());
@@ -116,75 +113,63 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     using code_point_sentinel_t = decltype(std::declval<R>().end().base());
 
     template<typename T, format F>
-    concept grapheme_iter_code_unit =
-        // clang-format off
-        grapheme_iter<T> &&
-        requires(T t) {
+    concept grapheme_iter_code_unit = grapheme_iter<T> && requires(T t) {
         { t.base().base() } -> code_unit_iter<F>;
-        // clang-format on
     };
 
     template<typename T, format F>
-    concept grapheme_range_code_unit = grapheme_range<T> &&
+    concept grapheme_range_code_unit =
+        grapheme_range<T> &&
         grapheme_iter_code_unit<std::ranges::iterator_t<T>, F>;
 
 
     namespace dtl {
         template<typename T, class CodeUnit>
         concept eraseable_insertable_sized_bidi_range =
-            // clang-format off
-            std::ranges::sized_range<T> &&
-            std::ranges::input_range<T> &&
+            std::ranges::sized_range<T> && std::ranges::input_range<T> &&
             requires(T t, CodeUnit const * it) {
-                { t.erase(t.begin(), t.end()) } ->
-                    std::same_as<std::ranges::iterator_t<T>>;
-                { t.insert(t.end(), it, it) } ->
-                    std::same_as<std::ranges::iterator_t<T>>;
+                {
+                    t.erase(t.begin(), t.end())
+                } -> std::same_as<std::ranges::iterator_t<T>>;
+                {
+                    t.insert(t.end(), it, it)
+                } -> std::same_as<std::ranges::iterator_t<T>>;
             };
-        // clang-format on
     }
 
     template<typename T>
-    concept utf8_string =
-        // clang-format off
-        utf8_code_unit<std::ranges::range_value_t<T>> &&
-        dtl::eraseable_insertable_sized_bidi_range<
-            T, std::ranges::range_value_t<T>>;
-        // clang-format on
+    concept utf8_string = utf8_code_unit<std::ranges::range_value_t<T>> &&
+                          dtl::eraseable_insertable_sized_bidi_range<
+                              T,
+                              std::ranges::range_value_t<T>>;
 
     template<typename T>
-    concept utf16_string =
-        // clang-format off
-        utf16_code_unit<std::ranges::range_value_t<T>> &&
-        dtl::eraseable_insertable_sized_bidi_range<
-            T, std::ranges::range_value_t<T>>;
-        // clang-format on
+    concept utf16_string = utf16_code_unit<std::ranges::range_value_t<T>> &&
+                           dtl::eraseable_insertable_sized_bidi_range<
+                               T,
+                               std::ranges::range_value_t<T>>;
 
     template<typename T>
     concept utf_string = utf8_string<T> || utf16_string<T>;
 
     template<typename T>
-    // clang-format off
-        concept transcoding_error_handler = requires(T t, std::string_view msg) {
+    concept transcoding_error_handler = requires(T t, std::string_view msg) {
         { t(msg) } -> std::same_as<char32_t>;
-        // clang-format on
     };
     //]
 
     // Clang 13 defines __cpp_lib_concepts but not std::indirectly copyable.
 #if defined(__clang_major__) && __clang_major__ <= 13
     template<typename In, typename Out>
-    // clang-format off
     concept indirectly_copyable =
         std::indirectly_readable<In> &&
         std::indirectly_writable<Out, std::iter_reference_t<In>>;
-    // clang-format on
 #else
     template<typename In, typename Out>
     concept indirectly_copyable = std::indirectly_copyable<In, Out>;
 #endif
-
-}}}
+    }
+}}
 
 #endif
 
diff --git a/include/boost/parser/detail/text/detail/algorithm.hpp b/include/boost/parser/detail/text/detail/algorithm.hpp
index e43ea73b..8bda0ccd 100644
--- a/include/boost/parser/detail/text/detail/algorithm.hpp
+++ b/include/boost/parser/detail/text/detail/algorithm.hpp
@@ -51,13 +51,10 @@ namespace boost::parser::detail { namespace text { namespace detail {
     // that is comparable with T's interator type.
     template<typename T>
     concept cp_sentinel_gr_rng =
-        // clang-format off
-        grapheme_range<T> &&
-        !grapheme_iter<sentinel_t<T>> &&
+        grapheme_range<T> && !grapheme_iter<sentinel_t<T>> &&
         requires(iterator_t<T> first, sentinel_t<T> last) {
-        { first.base() == last } -> std::convertible_to<bool>;
-        // clang-format on
-    };
+            { first.base() == last } -> std::convertible_to<bool>;
+        };
 
     template<typename T>
     using gr_rng_cp_iter_t = decltype(std::declval<iterator_t<T>>().base());
diff --git a/include/boost/parser/detail/text/transcode_iterator.hpp b/include/boost/parser/detail/text/transcode_iterator.hpp
index 09e8f7ec..f979b5a4 100644
--- a/include/boost/parser/detail/text/transcode_iterator.hpp
+++ b/include/boost/parser/detail/text/transcode_iterator.hpp
@@ -2350,11 +2350,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf8_inserter(Cont & c, typename Cont::iterator it)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return std::insert_iterator<Cont>(c, it);
@@ -2366,11 +2364,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf16_inserter(Cont & c, typename Cont::iterator it)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_16_to_8_insert_iterator<Cont>(c, it);
@@ -2382,11 +2378,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf32_inserter(Cont & c, typename Cont::iterator it)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_32_to_8_insert_iterator<Cont>(c, it);
@@ -2398,11 +2392,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf8_back_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return std::back_insert_iterator<Cont>(c);
@@ -2414,11 +2406,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf16_back_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_16_to_8_back_insert_iterator<Cont>(c);
@@ -2430,11 +2420,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf32_back_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_32_to_8_back_insert_iterator<Cont>(c);
@@ -2446,11 +2434,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf8_front_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return std::front_insert_iterator<Cont>(c);
@@ -2462,11 +2448,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf16_front_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_16_to_8_front_insert_iterator<Cont>(c);
@@ -2478,11 +2462,9 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
     }
 
     template<typename Cont>
-    // clang-format off
         requires requires { typename Cont::value_type; } &&
-        utf_code_unit<typename Cont::value_type>
+                 utf_code_unit<typename Cont::value_type>
     constexpr auto from_utf32_front_inserter(Cont & c)
-    // clang-format on
     {
         if constexpr (sizeof(typename Cont::value_type) == 1) {
             return utf_32_to_8_front_insert_iterator<Cont>(c);
@@ -2492,7 +2474,6 @@ namespace boost::parser::detail { namespace text { BOOST_PARSER_DETAIL_TEXT_NAME
             return std::front_insert_iterator<Cont>(c);
         }
     }
-
 }}}
 
 #endif
diff --git a/include/boost/parser/detail/text/transcode_view.hpp b/include/boost/parser/detail/text/transcode_view.hpp
index a52a28ad..d5cff552 100644
--- a/include/boost/parser/detail/text/transcode_view.hpp
+++ b/include/boost/parser/detail/text/transcode_view.hpp
@@ -423,49 +423,57 @@ namespace boost::parser::detail { namespace text {
 #if defined(__cpp_char8_t)
     inline constexpr detail::as_charn_impl<char8_view, format::utf8> as_char8_t;
 #endif
-    inline constexpr detail::as_charn_impl<char16_view, format::utf16> as_char16_t;
-    inline constexpr detail::as_charn_impl<char32_view, format::utf32> as_char32_t;
+    inline constexpr detail::as_charn_impl<char16_view, format::utf16>
+        as_char16_t;
+    inline constexpr detail::as_charn_impl<char32_view, format::utf32>
+        as_char32_t;
 
-    // clang-format off
 #if BOOST_PARSER_DETAIL_TEXT_USE_CONCEPTS
     template<utf_range V>
-    requires std::ranges::view<V> && std::ranges::forward_range<V>
+        requires std::ranges::view<V> && std::ranges::forward_range<V>
 #else
     template<typename V>
 #endif
-    class unpacking_view : public stl_interfaces::view_interface<unpacking_view<V>> {
-      V base_ = V();
+    class unpacking_view
+        : public stl_interfaces::view_interface<unpacking_view<V>>
+    {
+        V base_ = V();
 
     public:
-      constexpr unpacking_view()
+        constexpr unpacking_view()
 #if BOOST_PARSER_DETAIL_TEXT_USE_CONCEPTS
-          requires std::default_initializable<V>
+            requires std::default_initializable<V>
 #endif
-      = default;
-      constexpr unpacking_view(V base) : base_(std::move(base)) {}
+        = default;
+        constexpr unpacking_view(V base) : base_(std::move(base)) {}
 
-      constexpr V base() const &
+        constexpr V base() const &
 #if BOOST_PARSER_DETAIL_TEXT_USE_CONCEPTS
-          requires std::copy_constructible<V>
+            requires std::copy_constructible<V>
 #endif
-      { return base_; }
-      constexpr V base() && { return std::move(base_); }
+        {
+            return base_;
+        }
+        constexpr V base() && { return std::move(base_); }
 
-      constexpr auto code_units() const noexcept {
-        auto unpacked = boost::parser::detail::text::unpack_iterator_and_sentinel(detail::begin(base_), detail::end(base_));
-        return BOOST_PARSER_DETAIL_TEXT_SUBRANGE(unpacked.first, unpacked.last);
-      }
+        constexpr auto code_units() const noexcept
+        {
+            auto unpacked =
+                boost::parser::detail::text::unpack_iterator_and_sentinel(
+                    detail::begin(base_), detail::end(base_));
+            return BOOST_PARSER_DETAIL_TEXT_SUBRANGE(
+                unpacked.first, unpacked.last);
+        }
 
-      constexpr auto begin() { return code_units().begin(); }
-      constexpr auto begin() const { return code_units().begin(); }
+        constexpr auto begin() { return code_units().begin(); }
+        constexpr auto begin() const { return code_units().begin(); }
 
-      constexpr auto end() { return code_units().end(); }
-      constexpr auto end() const { return code_units().end(); }
+        constexpr auto end() { return code_units().end(); }
+        constexpr auto end() const { return code_units().end(); }
     };
 
     template<class R>
     unpacking_view(R &&) -> unpacking_view<detail::all_t<R>>;
-    // clang-format on
 
 #if BOOST_PARSER_DETAIL_TEXT_USE_CONCEPTS
     template<format Format, utf_range V>
diff --git a/include/boost/parser/parser.hpp b/include/boost/parser/parser.hpp
index de03a343..d350222d 100644
--- a/include/boost/parser/parser.hpp
+++ b/include/boost/parser/parser.hpp
@@ -4434,22 +4434,18 @@ namespace boost { namespace parser {
 #endif
 
     namespace detail {
-        // clang-format off
         template<typename Action, typename Attribute>
         using action_direct_call_expr =
             decltype(std::declval<Action>()(std::declval<Attribute>()));
         template<typename Action, typename Attribute>
-        using action_apply_call_expr =
-            decltype(hl::apply(std::declval<Action>(), std::declval<Attribute>()));
+        using action_apply_call_expr = decltype(hl::apply(
+            std::declval<Action>(), std::declval<Attribute>()));
         template<typename Action, typename Attribute, typename Context>
         using action_assignable_to_val_direct_expr =
-            decltype(_val(std::declval<Context>()) =
-                     std::declval<Action>()(std::declval<Attribute>()));
+            decltype(_val(std::declval<Context>()) = std::declval<Action>()(std::declval<Attribute>()));
         template<typename Action, typename Attribute, typename Context>
         using action_assignable_to_val_apply_expr =
-            decltype(_val(std::declval<Context>()) =
-                     hl::apply(std::declval<Action>(), std::declval<Attribute>()));
-        // clang-format on
+            decltype(_val(std::declval<Context>()) = hl::apply(std::declval<Action>(), std::declval<Attribute>()));
 
         template<typename Action, typename Attribute, typename Context>
         constexpr auto action_assignable_to_val_direct()
@@ -6684,8 +6680,7 @@ namespace boost { namespace parser {
             \tparam T Constrained by `!parsable_range_like<T>`. */
 #if BOOST_PARSER_USE_CONCEPTS
         template<typename T>
-        // clang-format off
-        requires (!parsable_range_like<T>)
+            requires(!parsable_range_like<T>)
 #else
         template<
             typename T,
@@ -6693,7 +6688,6 @@ namespace boost { namespace parser {
                 std::enable_if_t<!detail::is_parsable_range_like_v<T>>>
 #endif
         constexpr auto operator()(T x) const noexcept
-        // clang-format on
         {
             BOOST_PARSER_ASSERT(
                 (detail::is_nope_v<Expected> &&
@@ -6758,10 +6752,9 @@ namespace boost { namespace parser {
 
             \tparam R Additionally constrained by
             `std::same_as<std::ranges::range_value_t<R>, char32_t>`. */
-        // clang-format off
 #if BOOST_PARSER_USE_CONCEPTS
         template<parsable_range_like R>
-        requires std::same_as<std::ranges::range_value_t<R>, char32_t>
+            requires std::same_as<std::ranges::range_value_t<R>, char32_t>
 #else
         template<
             typename R,
@@ -6770,14 +6763,13 @@ namespace boost { namespace parser {
                 std::is_same_v<detail::range_value_t<R>, char32_t>>>
 #endif
         constexpr auto operator()(sorted_t, R && r) const noexcept
-        // clang-format on
         {
             BOOST_PARSER_ASSERT(
                 ((!std::is_rvalue_reference_v<R &&> ||
                   !detail::is_range<detail::remove_cv_ref_t<R>>) &&
-                     "It looks like you tried to pass an rvalue range to "
-                     "char_().  Don't do that, or you'll end up with dangling "
-                     "references."));
+                 "It looks like you tried to pass an rvalue range to "
+                 "char_().  Don't do that, or you'll end up with dangling "
+                 "references."));
             BOOST_PARSER_ASSERT(
                 (detail::is_nope_v<Expected> &&
                  "If you're seeing this, you tried to chain calls on char_, "
@@ -7411,8 +7403,7 @@ namespace boost { namespace parser {
             that uses `x` as its quotation marks. */
 #if BOOST_PARSER_USE_CONCEPTS
         template<typename T>
-        // clang-format off
-        requires (!parsable_range_like<T>)
+            requires(!parsable_range_like<T>)
 #else
         template<
             typename T,
@@ -7420,7 +7411,6 @@ namespace boost { namespace parser {
                 std::enable_if_t<!detail::is_parsable_range_like_v<T>>>
 #endif
         constexpr auto operator()(T x) const noexcept
-        // clang-format on
         {
             if constexpr (!detail::is_nope_v<Quotes>) {
                 BOOST_PARSER_ASSERT(
@@ -7476,8 +7466,7 @@ namespace boost { namespace parser {
             Note that `"\\"` and `"\ch"` are always valid escape sequences. */
 #if BOOST_PARSER_USE_CONCEPTS
         template<typename T, typename U>
-        // clang-format off
-        requires (!parsable_range_like<T>)
+            requires(!parsable_range_like<T>)
 #else
         template<
             typename T,
@@ -7486,7 +7475,6 @@ namespace boost { namespace parser {
                 std::enable_if_t<!detail::is_parsable_range_like_v<T>>>
 #endif
         auto operator()(T x, symbols<U> const & escapes) const noexcept
-        // clang-format on
         {
             if constexpr (!detail::is_nope_v<Quotes>) {
                 BOOST_PARSER_ASSERT(
@@ -7496,9 +7484,8 @@ namespace boost { namespace parser {
                      "it!'"));
             }
             auto symbols = symbol_parser(escapes.parser_);
-            auto parser =
-                quoted_string_parser<detail::nope, decltype(symbols)>(
-                    char32_t(x), symbols);
+            auto parser = quoted_string_parser<detail::nope, decltype(symbols)>(
+                char32_t(x), symbols);
             return parser_interface(parser);
         }
 
@@ -8638,10 +8625,8 @@ namespace boost { namespace parser {
         Attr & attr,
         trace trace_mode = trace::off)
 #if BOOST_PARSER_USE_CONCEPTS
-        // clang-format off
-        requires (
+        requires(
             !detail::derived_from_parser_interface_v<std::remove_cvref_t<Attr>>)
-    // clang-format on
 #endif
     {
         detail::attr_reset reset(attr);
diff --git a/include/boost/parser/replace.hpp b/include/boost/parser/replace.hpp
index e9905ab3..58bcf916 100644
--- a/include/boost/parser/replace.hpp
+++ b/include/boost/parser/replace.hpp
@@ -77,22 +77,16 @@ namespace boost::parser {
             range_rvalue_reference_t<V2>>;
 
 #if BOOST_PARSER_USE_CONCEPTS
-        // clang-format off
         template<typename ReplacementV, typename V>
         concept concatable = requires {
             typename detail::concat_reference_t<ReplacementV, V>;
             typename detail::concat_value_t<ReplacementV, V>;
             typename detail::concat_rvalue_reference_t<ReplacementV, V>;
         };
-        // clang-format on
 #else
         template<typename ReplacementV, typename V>
-        // clang-format off
-        using concatable_expr = decltype(
-            std::declval<concat_reference_t<ReplacementV, V>>(),
-            std::declval<concat_value_t<ReplacementV, V>>(),
-            std::declval<concat_rvalue_reference_t<ReplacementV, V>>());
-        // clang-format on
+        using concatable_expr =
+            decltype(std::declval<concat_reference_t<ReplacementV, V>>(), std::declval<concat_value_t<ReplacementV, V>>(), std::declval<concat_rvalue_reference_t<ReplacementV, V>>());
         template<typename ReplacementV, typename V>
         constexpr bool concatable =
             is_detected_v<concatable_expr, ReplacementV, V>;
@@ -107,7 +101,7 @@ namespace boost::parser {
 #endif
             >
 #if BOOST_PARSER_USE_CONCEPTS
-        requires concatable<V1, V2>
+            requires concatable<V1, V2>
 #endif
         struct either_iterator_impl
             : detail::stl_interfaces::iterator_interface<
@@ -169,14 +163,12 @@ namespace boost::parser {
             either_iterator_impl<V1, V2>>;
 
 #if BOOST_PARSER_USE_CONCEPTS
-        // clang-format off
         template<typename ReplacementV, typename V>
-        concept replacement_for = requires (ReplacementV replacement, V base) {
+        concept replacement_for = requires(ReplacementV replacement, V base) {
             { either_iterator<V, ReplacementV>(replacement.begin()) };
             { either_iterator<V, ReplacementV>(replacement.end()) };
             { either_iterator<V, ReplacementV>(base.begin()) };
         };
-        // clang-format on
 #else
         template<typename ReplacementV, typename V>
         using replacement_for_expr = decltype(
@@ -528,23 +520,19 @@ namespace boost::parser {
                 typename GlobalState,
                 typename ErrorHandler,
                 typename SkipParser>
-            requires
-                // clang-format off
-                std::ranges::viewable_range<R> &&
-                std::ranges::viewable_range<ReplacementR> &&
-                // clang-format on
-                can_replace_view<
-                    to_range_t<R>,
-                    decltype(to_range<
-                             ReplacementR,
-                             true,
-                             detail::range_utf_format_v<R>>::
-                                 call(std::declval<ReplacementR>())),
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    SkipParser>
-                // clang-format off
+                requires std::ranges::viewable_range<R> &&
+                         std::ranges::viewable_range<ReplacementR> &&
+                         can_replace_view<
+                             to_range_t<R>,
+                             decltype(to_range<
+                                      ReplacementR,
+                                      true,
+                                      detail::range_utf_format_v<R>>::
+                                          call(std::declval<ReplacementR>())),
+                             Parser,
+                             GlobalState,
+                             ErrorHandler,
+                             SkipParser>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -552,10 +540,9 @@ namespace boost::parser {
                 parser_interface<SkipParser> const & skip,
                 ReplacementR && replacement,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return replace_view(
-                    to_range<R>::call((R &&) r),
+                    to_range<R>::call((R &&)r),
                     parser,
                     skip,
                     to_range<
@@ -572,36 +559,31 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler>
-            requires
-                // clang-format off
-                std::ranges::viewable_range<R> &&
-                std::ranges::viewable_range<ReplacementR> &&
-                // clang-format on
-                can_replace_view<
-                    to_range_t<R>,
-                    decltype(to_range<
-                             ReplacementR,
-                             true,
-                             detail::range_utf_format_v<R>>::
-                                 call(std::declval<ReplacementR>())),
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    parser_interface<eps_parser<detail::phony>>>
-                // clang-format off
+                requires std::ranges::viewable_range<R> &&
+                         std::ranges::viewable_range<ReplacementR> &&
+                         can_replace_view<
+                             to_range_t<R>,
+                             decltype(to_range<
+                                      ReplacementR,
+                                      true,
+                                      detail::range_utf_format_v<R>>::
+                                          call(std::declval<ReplacementR>())),
+                             Parser,
+                             GlobalState,
+                             ErrorHandler,
+                             parser_interface<eps_parser<detail::phony>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 ReplacementR && replacement,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return (*this)(
-                    (R &&) r,
+                    (R &&)r,
                     parser,
                     parser_interface<eps_parser<detail::phony>>{},
-                    (ReplacementR &&) replacement,
+                    (ReplacementR &&)replacement,
                     trace_mode);
             }
 
diff --git a/include/boost/parser/search.hpp b/include/boost/parser/search.hpp
index c1209d0c..ef54c945 100644
--- a/include/boost/parser/search.hpp
+++ b/include/boost/parser/search.hpp
@@ -541,25 +541,21 @@ namespace boost::parser {
                 typename GlobalState,
                 typename ErrorHandler,
                 typename SkipParser>
-            requires(
-                std::ranges::viewable_range<R>) &&
-                can_search_all_view<
-                    to_range_t<R>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    SkipParser>
-                // clang-format off
+                requires(std::ranges::viewable_range<R>) && can_search_all_view<
+                                                                to_range_t<R>,
+                                                                Parser,
+                                                                GlobalState,
+                                                                ErrorHandler,
+                                                                SkipParser>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 parser_interface<SkipParser> const & skip,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return search_all_view(
-                    to_range<R>::call((R &&) r), parser, skip, trace_mode);
+                    to_range<R>::call((R &&)r), parser, skip, trace_mode);
             }
 
             template<
@@ -567,24 +563,21 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler>
-            requires(
-                std::ranges::viewable_range<R>) &&
-                can_search_all_view<
-                    to_range_t<R>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    parser_interface<eps_parser<detail::phony>>>
-                // clang-format off
+                requires(std::ranges::viewable_range<R>) &&
+                        can_search_all_view<
+                            to_range_t<R>,
+                            Parser,
+                            GlobalState,
+                            ErrorHandler,
+                            parser_interface<eps_parser<detail::phony>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return (*this)(
-                    (R &&) r,
+                    (R &&)r,
                     parser,
                     parser_interface<eps_parser<detail::phony>>{},
                     trace_mode);
diff --git a/include/boost/parser/split.hpp b/include/boost/parser/split.hpp
index d47ec906..6b554763 100644
--- a/include/boost/parser/split.hpp
+++ b/include/boost/parser/split.hpp
@@ -258,25 +258,21 @@ namespace boost::parser {
                 typename GlobalState,
                 typename ErrorHandler,
                 typename SkipParser>
-            requires(
-                std::ranges::viewable_range<R>) &&
-                can_split_view<
-                    to_range_t<R>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    SkipParser>
-                // clang-format off
+                requires(std::ranges::viewable_range<R>) && can_split_view<
+                                                                to_range_t<R>,
+                                                                Parser,
+                                                                GlobalState,
+                                                                ErrorHandler,
+                                                                SkipParser>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 parser_interface<SkipParser> const & skip,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return split_view(
-                    to_range<R>::call((R &&) r), parser, skip, trace_mode);
+                    to_range<R>::call((R &&)r), parser, skip, trace_mode);
             }
 
             template<
@@ -284,24 +280,21 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler>
-            requires(
-                std::ranges::viewable_range<R>) &&
-                can_split_view<
-                    to_range_t<R>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    parser_interface<eps_parser<detail::phony>>>
-                // clang-format off
+                requires(std::ranges::viewable_range<R>) &&
+                        can_split_view<
+                            to_range_t<R>,
+                            Parser,
+                            GlobalState,
+                            ErrorHandler,
+                            parser_interface<eps_parser<detail::phony>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return (*this)(
-                    (R &&) r,
+                    (R &&)r,
                     parser,
                     parser_interface<eps_parser<detail::phony>>{},
                     trace_mode);
diff --git a/include/boost/parser/transform_replace.hpp b/include/boost/parser/transform_replace.hpp
index 17adb36b..51e2d6b3 100644
--- a/include/boost/parser/transform_replace.hpp
+++ b/include/boost/parser/transform_replace.hpp
@@ -28,16 +28,15 @@ namespace boost::parser {
         using range_attr_t = attr_type<iterator_t<R>, sentinel_t<R>, Parser>;
 
 #if BOOST_PARSER_USE_CONCEPTS
-        // clang-format off
         template<typename F, typename V, typename Parser>
         concept transform_replacement_for =
             std::regular_invocable<F &, range_attr_t<V, Parser>> &&
             detail::replacement_for<
-                std::invoke_result_t<F &, range_attr_t<V, Parser>>, V> &&
+                std::invoke_result_t<F &, range_attr_t<V, Parser>>,
+                V> &&
             (detail::range_utf_format_v<V> ==
              detail::range_utf_format_v<
                  std::invoke_result_t<F &, range_attr_t<V, Parser>>>);
-        // clang-format on
 #else
         template<typename F, typename V, typename Parser>
         using transform_replacement_for_expr = decltype(std::declval<F &>()(
@@ -646,24 +645,20 @@ namespace boost::parser {
                 typename GlobalState,
                 typename ErrorHandler,
                 typename SkipParser>
-            requires
-                // clang-format off
-                std::ranges::viewable_range<R> &&
-                std::regular_invocable<
-                    F &,
-                    range_attr_t<to_range_t<R>, Parser>> &&
-                // clang-format on
-                can_transform_replace_view<
-                    to_range_t<R>,
-                    utf_rvalue_shim<
-                        to_range_t<R>,
-                        std::remove_cvref_t<F>,
-                        range_attr_t<to_range_t<R>, Parser>>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    SkipParser>
-                // clang-format off
+                requires std::ranges::viewable_range<R> &&
+                         std::regular_invocable<
+                             F &,
+                             range_attr_t<to_range_t<R>, Parser>> &&
+                         can_transform_replace_view<
+                             to_range_t<R>,
+                             utf_rvalue_shim<
+                                 to_range_t<R>,
+                                 std::remove_cvref_t<F>,
+                                 range_attr_t<to_range_t<R>, Parser>>,
+                             Parser,
+                             GlobalState,
+                             ErrorHandler,
+                             SkipParser>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
@@ -671,16 +666,15 @@ namespace boost::parser {
                 parser_interface<SkipParser> const & skip,
                 F && f,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return transform_replace_view(
-                    to_range<R>::call((R &&) r),
+                    to_range<R>::call((R &&)r),
                     parser,
                     skip,
                     utf_rvalue_shim<
                         to_range_t<R>,
                         std::remove_cvref_t<F>,
-                        range_attr_t<to_range_t<R>, Parser>>((F &&) f),
+                        range_attr_t<to_range_t<R>, Parser>>((F &&)f),
                     trace_mode);
             }
 
@@ -690,37 +684,32 @@ namespace boost::parser {
                 typename Parser,
                 typename GlobalState,
                 typename ErrorHandler>
-            requires
-                // clang-format off
-                std::ranges::viewable_range<R> &&
-                std::regular_invocable<
-                    F &,
-                    range_attr_t<to_range_t<R>, Parser>> &&
-                // clang-format on
-                can_transform_replace_view<
-                    to_range_t<R>,
-                    utf_rvalue_shim<
-                        to_range_t<R>,
-                        std::remove_cvref_t<F>,
-                        range_attr_t<to_range_t<R>, Parser>>,
-                    Parser,
-                    GlobalState,
-                    ErrorHandler,
-                    parser_interface<eps_parser<detail::phony>>>
-                // clang-format off
+                requires std::ranges::viewable_range<R> &&
+                         std::regular_invocable<
+                             F &,
+                             range_attr_t<to_range_t<R>, Parser>> &&
+                         can_transform_replace_view<
+                             to_range_t<R>,
+                             utf_rvalue_shim<
+                                 to_range_t<R>,
+                                 std::remove_cvref_t<F>,
+                                 range_attr_t<to_range_t<R>, Parser>>,
+                             Parser,
+                             GlobalState,
+                             ErrorHandler,
+                             parser_interface<eps_parser<detail::phony>>>
             [[nodiscard]] constexpr auto operator()(
                 R && r,
                 parser_interface<Parser, GlobalState, ErrorHandler> const &
                     parser,
                 F && f,
                 trace trace_mode = trace::off) const
-            // clang-format on
             {
                 return (*this)(
-                    (R &&) r,
+                    (R &&)r,
                     parser,
                     parser_interface<eps_parser<detail::phony>>{},
-                    (F &&) f,
+                    (F &&)f,
                     trace_mode);
             }
 
diff --git a/test/parser.cpp b/test/parser.cpp
index 4d8616fe..e928e914 100644
--- a/test/parser.cpp
+++ b/test/parser.cpp
@@ -417,7 +417,6 @@ int main()
     }
 
     // int_uint
-    // clang-format off
     {
         {
             std::string str = "-42";
@@ -425,7 +424,6 @@ int main()
             BOOST_TEST(parse(str, int_, i));
             BOOST_TEST(i == -42);
         }
-        // clang-format on
         {
             std::string str = "42";
             int i = 0;
@@ -458,12 +456,14 @@ int main()
             BOOST_TEST(parse(str, uint4, i));
             BOOST_TEST(i == 42u);
         }
-        }
+    }
 
-        // bool_
-        {{std::string str = "";
-        bool b = false;
-        BOOST_TEST(!parse(str, bool_, b));
+    // bool_
+    {
+        {
+            std::string str = "";
+            bool b = false;
+            BOOST_TEST(!parse(str, bool_, b));
         }
         {
             std::string str = "true";
@@ -503,28 +503,30 @@ int main()
             BOOST_TEST(prefix_parse(first, last, bool_, b));
             BOOST_TEST(b == false);
         }
-        }
+    }
 
-        // star
-        {{constexpr auto parser = *char_;
+    // star
+    {
         {
-            std::string str = "";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>());
-        }
-        {
-            std::string str = "a";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'a'}));
-        }
-        {
-            std::string str = "ba";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'b', 'a'}));
-        }
+            constexpr auto parser = *char_;
+            {
+                std::string str = "";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>());
+            }
+            {
+                std::string str = "a";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'a'}));
+            }
+            {
+                std::string str = "ba";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'b', 'a'}));
+            }
         }
 
         {
@@ -548,28 +550,30 @@ int main()
                 BOOST_TEST(chars == std::vector<char>({'b', 'b'}));
             }
         }
-        }
+    }
 
-        // plus
-        {{constexpr auto parser = +char_;
+    // plus
+    {
+        {
+            constexpr auto parser = +char_;
 
-        {
-            std::string str = "";
-            std::vector<char> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-        }
-        {
-            std::string str = "a";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'a'}));
-        }
-        {
-            std::string str = "ba";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'b', 'a'}));
-        }
+            {
+                std::string str = "";
+                std::vector<char> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+            }
+            {
+                std::string str = "a";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'a'}));
+            }
+            {
+                std::string str = "ba";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'b', 'a'}));
+            }
         }
 
         {
@@ -593,28 +597,30 @@ int main()
                 BOOST_TEST(chars == std::vector<char>({'b', 'b'}));
             }
         }
-        }
+    }
 
-        // star_and_plus_collapsing
-        {{constexpr auto parser = +(+char_('b'));
+    // star_and_plus_collapsing
+    {
+        {
+            constexpr auto parser = +(+char_('b'));
 
-        {
-            std::string str = "";
-            std::vector<char> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-        }
-        {
-            std::string str = "b";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'b'}));
-        }
-        {
-            std::string str = "bb";
-            std::vector<char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<char>({'b', 'b'}));
-        }
+            {
+                std::string str = "";
+                std::vector<char> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+            }
+            {
+                std::string str = "b";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'b'}));
+            }
+            {
+                std::string str = "bb";
+                std::vector<char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<char>({'b', 'b'}));
+            }
         }
 
         {
@@ -685,34 +691,36 @@ int main()
                 BOOST_TEST(chars == std::vector<char>({'z', 'z'}));
             }
         }
-        }
+    }
 
-        // action_
-        {{std::string str = "";
+    // action_
+    {
         {
-            std::stringstream ss;
-            auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
-            auto parser = *char_('b')[action];
-            BOOST_TEST(parse(str, parser));
-            BOOST_TEST(ss.str() == "");
-        }
-        {
-            str = "b";
-            std::stringstream ss;
-            auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
-            auto parser = *char_('b')[action];
-            BOOST_TEST(parse(str, parser));
-            BOOST_TEST(ss.str() == "b");
-        }
-        {
-            str = "bb";
-            std::stringstream ss;
-            auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
-            auto parser = *char_('b')[action];
-            BOOST_TEST(parse(str, parser));
-            BOOST_TEST(parse(str, parser));
-            BOOST_TEST(ss.str() == "bbbb");
-        }
+            std::string str = "";
+            {
+                std::stringstream ss;
+                auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
+                auto parser = *char_('b')[action];
+                BOOST_TEST(parse(str, parser));
+                BOOST_TEST(ss.str() == "");
+            }
+            {
+                str = "b";
+                std::stringstream ss;
+                auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
+                auto parser = *char_('b')[action];
+                BOOST_TEST(parse(str, parser));
+                BOOST_TEST(ss.str() == "b");
+            }
+            {
+                str = "bb";
+                std::stringstream ss;
+                auto action = [&ss](auto & ctx) { ss << _attr(ctx); };
+                auto parser = *char_('b')[action];
+                BOOST_TEST(parse(str, parser));
+                BOOST_TEST(parse(str, parser));
+                BOOST_TEST(ss.str() == "bbbb");
+            }
         }
 
         {
@@ -742,29 +750,31 @@ int main()
                 BOOST_TEST(ss.str() == "bbbb");
             }
         }
-        }
+    }
 
-        // star_as_string_or_vector
-        {{constexpr auto parser = *char_('z');
+    // star_as_string_or_vector
+    {
+        {
+            constexpr auto parser = *char_('z');
 
-        {
-            std::string str = "";
-            std::string chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == "");
-        }
-        {
-            std::string str = "z";
-            std::string chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == "z");
-        }
-        {
-            std::string str = "zz";
-            std::string chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == "zz");
-        }
+            {
+                std::string str = "";
+                std::string chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == "");
+            }
+            {
+                std::string str = "z";
+                std::string chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == "z");
+            }
+            {
+                std::string str = "zz";
+                std::string chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == "zz");
+            }
         }
 
         {
@@ -906,141 +916,141 @@ int main()
                 BOOST_TEST(chars == std::vector<std::string>({"zs", "zs"}));
             }
         }
-        }
+    }
 
-        // transform
-        {
-            int calls = 0;
-            auto by_value_str_sum = [&](std::string s) {
-                ++calls;
-                std::transform(s.begin(), s.end(), s.begin(), [](auto ch) {
-                    return ch - '0';
-                });
-                return std::accumulate(s.begin(), s.end(), 0);
-            };
-            auto cref_str_sum = [&](std::string const & s) {
-                ++calls;
-                int retval = 0;
-                for (auto ch : s) {
-                    retval += ch - '0';
-                }
-                return retval;
-            };
-            auto rv_ref_str_sum = [&](std::string && s) {
-                ++calls;
-                std::transform(s.begin(), s.end(), s.begin(), [](auto ch) {
-                    return ch - '0';
-                });
-                return std::accumulate(s.begin(), s.end(), 0);
-            };
-            {
-                constexpr auto parser = +char_;
-                std::string str = "012345";
-                {
-                    auto result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == "012345");
-                }
-                {
-                    calls = 0;
-                    auto result =
-                        parse(str, transform(by_value_str_sum)[parser]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == 15);
-                    BOOST_TEST(calls == 1);
-                }
-                {
-                    calls = 0;
-                    auto result = parse(str, transform(cref_str_sum)[parser]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == 15);
-                    BOOST_TEST(calls == 1);
-                }
-                {
-                    calls = 0;
-                    auto result = parse(str, transform(rv_ref_str_sum)[parser]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == 15);
-                    BOOST_TEST(calls == 1);
-                }
+    // transform
+    {
+        int calls = 0;
+        auto by_value_str_sum = [&](std::string s) {
+            ++calls;
+            std::transform(s.begin(), s.end(), s.begin(), [](auto ch) {
+                return ch - '0';
+            });
+            return std::accumulate(s.begin(), s.end(), 0);
+        };
+        auto cref_str_sum = [&](std::string const & s) {
+            ++calls;
+            int retval = 0;
+            for (auto ch : s) {
+                retval += ch - '0';
             }
-            {
-                constexpr auto parser = +char_;
-                std::string str = "012345";
-                {
-                    calls = 0;
-                    auto result =
-                        parse(str, omit[transform(by_value_str_sum)[parser]]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(calls == 0);
-                }
-                {
-                    calls = 0;
-                    auto result =
-                        parse(str, omit[transform(cref_str_sum)[parser]]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(calls == 0);
-                }
-                {
-                    calls = 0;
-                    auto result =
-                        parse(str, omit[transform(rv_ref_str_sum)[parser]]);
-                    BOOST_TEST(result);
-                    BOOST_TEST(calls == 0);
-                }
-            }
-        }
-
-        // transform_doc_example
+            return retval;
+        };
+        auto rv_ref_str_sum = [&](std::string && s) {
+            ++calls;
+            std::transform(s.begin(), s.end(), s.begin(), [](auto ch) {
+                return ch - '0';
+            });
+            return std::accumulate(s.begin(), s.end(), 0);
+        };
         {
-            //[ transform_directive_example
-            auto str_sum = [&](std::string const & s) {
-                int retval = 0;
-                for (auto ch : s) {
-                    retval += ch - '0';
-                }
-                return retval;
-            };
-
-            namespace bp = boost::parser;
-            constexpr auto parser = +bp::char_;
+            constexpr auto parser = +char_;
             std::string str = "012345";
+            {
+                auto result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == "012345");
+            }
+            {
+                calls = 0;
+                auto result = parse(str, transform(by_value_str_sum)[parser]);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == 15);
+                BOOST_TEST(calls == 1);
+            }
+            {
+                calls = 0;
+                auto result = parse(str, transform(cref_str_sum)[parser]);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == 15);
+                BOOST_TEST(calls == 1);
+            }
+            {
+                calls = 0;
+                auto result = parse(str, transform(rv_ref_str_sum)[parser]);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == 15);
+                BOOST_TEST(calls == 1);
+            }
+        }
+        {
+            constexpr auto parser = +char_;
+            std::string str = "012345";
+            {
+                calls = 0;
+                auto result =
+                    parse(str, omit[transform(by_value_str_sum)[parser]]);
+                BOOST_TEST(result);
+                BOOST_TEST(calls == 0);
+            }
+            {
+                calls = 0;
+                auto result = parse(str, omit[transform(cref_str_sum)[parser]]);
+                BOOST_TEST(result);
+                BOOST_TEST(calls == 0);
+            }
+            {
+                calls = 0;
+                auto result =
+                    parse(str, omit[transform(rv_ref_str_sum)[parser]]);
+                BOOST_TEST(result);
+                BOOST_TEST(calls == 0);
+            }
+        }
+    }
 
-            auto result = bp::parse(str, bp::transform(str_sum)[parser]);
-            assert(result);
-            assert(*result == 15);
-            static_assert(std::is_same_v<decltype(result), std::optional<int>>);
-            //]
-            (void)result;
-        }
+    // transform_doc_example
+    {
+        //[ transform_directive_example
+        auto str_sum = [&](std::string const & s) {
+            int retval = 0;
+            for (auto ch : s) {
+                retval += ch - '0';
+            }
+            return retval;
+        };
 
-        // omit
-        {{constexpr auto parser = omit[*+char_('z')];
+        namespace bp = boost::parser;
+        constexpr auto parser = +bp::char_;
+        std::string str = "012345";
 
+        auto result = bp::parse(str, bp::transform(str_sum)[parser]);
+        assert(result);
+        assert(*result == 15);
+        static_assert(std::is_same_v<decltype(result), std::optional<int>>);
+        //]
+        (void)result;
+    }
+
+    // omit
+    {
         {
-            std::string str = "";
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string str = "z";
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string str = "zz";
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string str = "";
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string str = "z";
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string str = "zz";
-            BOOST_TEST(parse(str, parser));
-        }
+            constexpr auto parser = omit[*+char_('z')];
+
+            {
+                std::string str = "";
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string str = "z";
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string str = "zz";
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string str = "";
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string str = "z";
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string str = "zz";
+                BOOST_TEST(parse(str, parser));
+            }
         }
 
         {
@@ -1069,60 +1079,63 @@ int main()
                 BOOST_TEST(parse(str, parser));
             }
         }
-        }
-
-        // repeat
-        {{constexpr auto parser = repeat(2, 3)[string("zs")];
+    }
 
+    // repeat
+    {
         {
-            std::string str = "";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
+            constexpr auto parser = repeat(2, 3)[string("zs")];
 
             {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
-            }
-        }
-        {
-            std::string str = "z";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
+                std::string str = "";
+                std::vector<std::string> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>{});
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
             }
-        }
-        {
-            std::string str = "zs";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
+            {
+                std::string str = "z";
+                std::vector<std::string> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>{});
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
             }
-        }
-        {
-            std::string str = "zszs";
-            std::vector<std::string> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>({"zs", "zs"}));
+            {
+                std::string str = "zs";
+                std::vector<std::string> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>{});
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"zs", "zs"}));
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
+            }
+            {
+                std::string str = "zszs";
+                std::vector<std::string> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>({"zs", "zs"}));
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(chars);
+                    BOOST_TEST(
+                        *chars == std::vector<std::string>({"zs", "zs"}));
+                }
             }
-        }
         }
         {
             constexpr auto parser = *char_ >> eps >> *string("str");
@@ -1137,374 +1150,377 @@ int main()
             BOOST_TEST(
                 *result == std::vector<std::string>({"abcdefg", "str", "str"}));
         }
-        }
+    }
 
-        // raw
+    // raw
+    {
         {
-            {
-                constexpr auto parser = raw[*string("zs")];
-                using range_t = BOOST_PARSER_DETAIL_TEXT_SUBRANGE<
-                    std::string::const_iterator>;
+            constexpr auto parser = raw[*string("zs")];
+            using range_t =
+                BOOST_PARSER_DETAIL_TEXT_SUBRANGE<std::string::const_iterator>;
 
-                {
-                    std::string const str = "";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r.begin() == str.begin());
-                    BOOST_TEST(r.end() == str.begin());
-                }
-                {
-                    std::string const str = "z";
-                    range_t r;
-                    BOOST_TEST(!parse(str, parser, r));
-                    BOOST_TEST(r.begin() == r.end());
-                }
-                {
-                    std::string const str = "z";
-                    range_t r;
-                    auto first = str.begin();
-                    BOOST_TEST(prefix_parse(first, str.end(), parser, r));
-                    BOOST_TEST(r.begin() == str.begin());
-                    BOOST_TEST(r.end() == str.begin());
-                }
-                {
-                    std::string const str = "zs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r.begin() == str.begin());
-                    BOOST_TEST(r.end() == str.end());
-                }
-                {
-                    std::string const str = "zszs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r.begin() == str.begin());
-                    BOOST_TEST(r.end() == str.end());
-                }
-                {
-                    std::string const str = "";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(result->begin() == str.begin());
-                    BOOST_TEST(result->end() == str.begin());
-                }
-                {
-                    std::string const str = "z";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(!result);
-                }
-                {
-                    std::string const str = "z";
-                    auto first = str.begin();
-                    std::optional<range_t> result =
-                        prefix_parse(first, str.end(), parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(result->begin() == str.begin());
-                    BOOST_TEST(result->end() == str.begin());
-                }
-                {
-                    std::string const str = "zs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(result->begin() == str.begin());
-                    BOOST_TEST(result->end() == str.end());
-                }
-                {
-                    std::string const str = "zszs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(result->begin() == str.begin());
-                    BOOST_TEST(result->end() == str.end());
-                }
+            {
+                std::string const str = "";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r.begin() == str.begin());
+                BOOST_TEST(r.end() == str.begin());
+            }
+            {
+                std::string const str = "z";
+                range_t r;
+                BOOST_TEST(!parse(str, parser, r));
+                BOOST_TEST(r.begin() == r.end());
+            }
+            {
+                std::string const str = "z";
+                range_t r;
+                auto first = str.begin();
+                BOOST_TEST(prefix_parse(first, str.end(), parser, r));
+                BOOST_TEST(r.begin() == str.begin());
+                BOOST_TEST(r.end() == str.begin());
+            }
+            {
+                std::string const str = "zs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r.begin() == str.begin());
+                BOOST_TEST(r.end() == str.end());
+            }
+            {
+                std::string const str = "zszs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r.begin() == str.begin());
+                BOOST_TEST(r.end() == str.end());
+            }
+            {
+                std::string const str = "";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(result->begin() == str.begin());
+                BOOST_TEST(result->end() == str.begin());
+            }
+            {
+                std::string const str = "z";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(!result);
+            }
+            {
+                std::string const str = "z";
+                auto first = str.begin();
+                std::optional<range_t> result =
+                    prefix_parse(first, str.end(), parser);
+                BOOST_TEST(result);
+                BOOST_TEST(result->begin() == str.begin());
+                BOOST_TEST(result->end() == str.begin());
+            }
+            {
+                std::string const str = "zs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(result->begin() == str.begin());
+                BOOST_TEST(result->end() == str.end());
+            }
+            {
+                std::string const str = "zszs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(result->begin() == str.begin());
+                BOOST_TEST(result->end() == str.end());
             }
         }
+    }
 
 #if BOOST_PARSER_USE_CONCEPTS
-        // string_view
+    // string_view
+    {
         {
-            {
-                constexpr auto parser = string_view[*string("zs")];
-                using range_t = std::string_view;
+            constexpr auto parser = string_view[*string("zs")];
+            using range_t = std::string_view;
 
-                {
-                    std::string const str = "";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == "");
-                }
-                {
-                    std::string const str = "z";
-                    range_t r;
-                    BOOST_TEST(!parse(str, parser, r));
-                    BOOST_TEST(r == "");
-                }
-                {
-                    std::string const str = "z";
-                    range_t r;
-                    auto first = str.begin();
-                    BOOST_TEST(prefix_parse(first, str.end(), parser, r));
-                    BOOST_TEST(r == "");
-                }
-                {
-                    std::string const str = "zs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == "zs");
-                }
-                {
-                    std::string const str = "zszs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == "zszs");
-                }
-                {
-                    std::string const str = "";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == "");
-                }
-                {
-                    std::string const str = "z";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(!result);
-                }
-                {
-                    std::string const str = "z";
-                    auto first = str.begin();
-                    std::optional<range_t> result =
-                        prefix_parse(first, str.end(), parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == "");
-                }
-                {
-                    std::string const str = "zs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == "zs");
-                }
-                {
-                    std::string const str = "zszs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == "zszs");
-                }
+            {
+                std::string const str = "";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == "");
             }
             {
-                constexpr auto parser = string_view[*string("zs")];
-                using range_t = std::u32string_view;
-
-                {
-                    std::u32string const str = U"";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == U"");
-                }
-                {
-                    std::u32string const str = U"z";
-                    range_t r;
-                    BOOST_TEST(!parse(str, parser, r));
-                    BOOST_TEST(r == U"");
-                }
-                {
-                    std::u32string const str = U"z";
-                    range_t r;
-                    auto first = str.begin();
-                    BOOST_TEST(prefix_parse(first, str.end(), parser, r));
-                    BOOST_TEST(r == U"");
-                }
-                {
-                    std::u32string const str = U"zs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == U"zs");
-                }
-                {
-                    std::u32string const str = U"zszs";
-                    range_t r;
-                    BOOST_TEST(parse(str, parser, r));
-                    BOOST_TEST(r == U"zszs");
-                }
-                {
-                    std::u32string const str = U"";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == U"");
-                }
-                {
-                    std::u32string const str = U"z";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(!result);
-                }
-                {
-                    std::u32string const str = U"z";
-                    auto first = str.begin();
-                    std::optional<range_t> result =
-                        prefix_parse(first, str.end(), parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == U"");
-                }
-                {
-                    std::u32string const str = U"zs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == U"zs");
-                }
-                {
-                    std::u32string const str = U"zszs";
-                    std::optional<range_t> result = parse(str, parser);
-                    BOOST_TEST(result);
-                    BOOST_TEST(*result == U"zszs");
-                }
+                std::string const str = "z";
+                range_t r;
+                BOOST_TEST(!parse(str, parser, r));
+                BOOST_TEST(r == "");
+            }
+            {
+                std::string const str = "z";
+                range_t r;
+                auto first = str.begin();
+                BOOST_TEST(prefix_parse(first, str.end(), parser, r));
+                BOOST_TEST(r == "");
+            }
+            {
+                std::string const str = "zs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == "zs");
+            }
+            {
+                std::string const str = "zszs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == "zszs");
+            }
+            {
+                std::string const str = "";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == "");
+            }
+            {
+                std::string const str = "z";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(!result);
+            }
+            {
+                std::string const str = "z";
+                auto first = str.begin();
+                std::optional<range_t> result =
+                    prefix_parse(first, str.end(), parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == "");
+            }
+            {
+                std::string const str = "zs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == "zs");
+            }
+            {
+                std::string const str = "zszs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == "zszs");
             }
         }
+        {
+            constexpr auto parser = string_view[*string("zs")];
+            using range_t = std::u32string_view;
+
+            {
+                std::u32string const str = U"";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == U"");
+            }
+            {
+                std::u32string const str = U"z";
+                range_t r;
+                BOOST_TEST(!parse(str, parser, r));
+                BOOST_TEST(r == U"");
+            }
+            {
+                std::u32string const str = U"z";
+                range_t r;
+                auto first = str.begin();
+                BOOST_TEST(prefix_parse(first, str.end(), parser, r));
+                BOOST_TEST(r == U"");
+            }
+            {
+                std::u32string const str = U"zs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == U"zs");
+            }
+            {
+                std::u32string const str = U"zszs";
+                range_t r;
+                BOOST_TEST(parse(str, parser, r));
+                BOOST_TEST(r == U"zszs");
+            }
+            {
+                std::u32string const str = U"";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == U"");
+            }
+            {
+                std::u32string const str = U"z";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(!result);
+            }
+            {
+                std::u32string const str = U"z";
+                auto first = str.begin();
+                std::optional<range_t> result =
+                    prefix_parse(first, str.end(), parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == U"");
+            }
+            {
+                std::u32string const str = U"zs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == U"zs");
+            }
+            {
+                std::u32string const str = U"zszs";
+                std::optional<range_t> result = parse(str, parser);
+                BOOST_TEST(result);
+                BOOST_TEST(*result == U"zszs");
+            }
+        }
+    }
 #endif
 
-        // delimited
-        {{constexpr auto parser = string("yay") % ',';
-
+    // delimited
+    {
         {
-            std::string str = "";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
+            constexpr auto parser = string("yay") % ',';
 
             {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
-            }
-        }
-        {
-            std::string str = "z";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
-
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
-            }
-        }
-        {
-            std::string str = ",";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
-
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
-            }
-        }
-        {
-            std::string str = ",yay";
-            std::vector<std::string> chars;
-            BOOST_TEST(!parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>{});
-
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
-            }
-        }
-        {
-            std::string str = "yay";
-            std::vector<std::string> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == std::vector<std::string>({"yay"}));
-
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
-            }
-        }
-        {
-            std::string str = "yayyay";
-            {
+                std::string str = "";
                 std::vector<std::string> chars;
                 BOOST_TEST(!parse(str, parser, chars));
                 BOOST_TEST(chars == std::vector<std::string>{});
-            }
-            {
-                std::vector<std::string> chars;
-                auto first = str.c_str();
-                BOOST_TEST(prefix_parse(
-                    first,
-                    boost::parser::detail::text::null_sentinel,
-                    parser,
-                    chars));
-                BOOST_TEST(chars == std::vector<std::string>({"yay"}));
-            }
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
             }
             {
-                auto first = str.c_str();
-                std::optional<std::vector<std::string>> const chars =
-                    prefix_parse(
-                        first,
-                        boost::parser::detail::text::null_sentinel,
-                        parser);
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
-            }
-        }
-        {
-            std::string str = "yay,";
-            {
+                std::string str = "z";
                 std::vector<std::string> chars;
                 BOOST_TEST(!parse(str, parser, chars));
-            }
-            {
-                std::vector<std::string> chars;
-                auto first = str.c_str();
-                BOOST_TEST(prefix_parse(
-                    first,
-                    boost::parser::detail::text::null_sentinel,
-                    parser,
-                    chars));
-                BOOST_TEST(chars == std::vector<std::string>({"yay"}));
-            }
+                BOOST_TEST(chars == std::vector<std::string>{});
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(!chars);
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
             }
             {
-                auto first = str.c_str();
-                std::optional<std::vector<std::string>> const chars =
-                    prefix_parse(
+                std::string str = ",";
+                std::vector<std::string> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>{});
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
+            }
+            {
+                std::string str = ",yay";
+                std::vector<std::string> chars;
+                BOOST_TEST(!parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>{});
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
+            }
+            {
+                std::string str = "yay";
+                std::vector<std::string> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == std::vector<std::string>({"yay"}));
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(chars);
+                    BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                }
+            }
+            {
+                std::string str = "yayyay";
+                {
+                    std::vector<std::string> chars;
+                    BOOST_TEST(!parse(str, parser, chars));
+                    BOOST_TEST(chars == std::vector<std::string>{});
+                }
+                {
+                    std::vector<std::string> chars;
+                    auto first = str.c_str();
+                    BOOST_TEST(prefix_parse(
                         first,
                         boost::parser::detail::text::null_sentinel,
-                        parser);
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
-            }
-        }
-        {
-            std::string str = "yay,yay,yay";
-            std::vector<std::string> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(
-                chars == std::vector<std::string>({"yay", "yay", "yay"}));
+                        parser,
+                        chars));
+                    BOOST_TEST(chars == std::vector<std::string>({"yay"}));
+                }
 
-            {
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser);
-                BOOST_TEST(chars);
-                BOOST_TEST(
-                    *chars == std::vector<std::string>({"yay", "yay", "yay"}));
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
+                {
+                    auto first = str.c_str();
+                    std::optional<std::vector<std::string>> const chars =
+                        prefix_parse(
+                            first,
+                            boost::parser::detail::text::null_sentinel,
+                            parser);
+                    BOOST_TEST(chars);
+                    BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                }
+            }
+            {
+                std::string str = "yay,";
+                {
+                    std::vector<std::string> chars;
+                    BOOST_TEST(!parse(str, parser, chars));
+                }
+                {
+                    std::vector<std::string> chars;
+                    auto first = str.c_str();
+                    BOOST_TEST(prefix_parse(
+                        first,
+                        boost::parser::detail::text::null_sentinel,
+                        parser,
+                        chars));
+                    BOOST_TEST(chars == std::vector<std::string>({"yay"}));
+                }
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(!chars);
+                }
+                {
+                    auto first = str.c_str();
+                    std::optional<std::vector<std::string>> const chars =
+                        prefix_parse(
+                            first,
+                            boost::parser::detail::text::null_sentinel,
+                            parser);
+                    BOOST_TEST(chars);
+                    BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                }
+            }
+            {
+                std::string str = "yay,yay,yay";
+                std::vector<std::string> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(
+                    chars == std::vector<std::string>({"yay", "yay", "yay"}));
+
+                {
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser);
+                    BOOST_TEST(chars);
+                    BOOST_TEST(
+                        *chars ==
+                        std::vector<std::string>({"yay", "yay", "yay"}));
+                }
             }
-        }
         }
 
         {
@@ -1918,86 +1934,88 @@ int main()
                 BOOST_TEST(subrange_1.end() == str.begin() + 21);
             }
         }
-        }
-
-        // lexeme
-        {{constexpr auto parser = lexeme[string("yay") % ','];
+    }
 
+    // lexeme
+    {
         {
-            std::string str = "yay, yay, yay";
-            {
-                std::vector<std::string> chars;
-                BOOST_TEST(!parse(str, parser, char_(' '), chars));
-            }
-            {
-                std::vector<std::string> chars;
-                auto first = str.c_str();
-                BOOST_TEST(prefix_parse(
-                    first,
-                    boost::parser::detail::text::null_sentinel,
-                    parser,
-                    char_(' '),
-                    chars));
-                BOOST_TEST(chars == std::vector<std::string>({"yay"}));
-            }
+            constexpr auto parser = lexeme[string("yay") % ','];
 
             {
                 std::string str = "yay, yay, yay";
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser, char_(' '));
-                BOOST_TEST(!chars);
-            }
-            {
-                std::string str = "yay, yay, yay";
-                auto first = str.c_str();
-                std::optional<std::vector<std::string>> const chars =
-                    prefix_parse(
+                {
+                    std::vector<std::string> chars;
+                    BOOST_TEST(!parse(str, parser, char_(' '), chars));
+                }
+                {
+                    std::vector<std::string> chars;
+                    auto first = str.c_str();
+                    BOOST_TEST(prefix_parse(
                         first,
                         boost::parser::detail::text::null_sentinel,
                         parser,
-                        char_(' '));
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
-            }
-        }
-        {
-            std::string str = " yay, yay, yay";
-            {
-                std::vector<std::string> chars;
-                BOOST_TEST(!parse(str, parser, char_(' '), chars));
-            }
-            {
-                std::vector<std::string> chars;
-                auto first = str.c_str();
-                BOOST_TEST(prefix_parse(
-                    first,
-                    boost::parser::detail::text::null_sentinel,
-                    parser,
-                    char_(' '),
-                    chars));
-                BOOST_TEST(chars == std::vector<std::string>({"yay"}));
-            }
+                        char_(' '),
+                        chars));
+                    BOOST_TEST(chars == std::vector<std::string>({"yay"}));
+                }
 
-            {
-                std::string str = " yay, yay, yay";
-                std::optional<std::vector<std::string>> const chars =
-                    parse(str, parser, char_(' '));
-                BOOST_TEST(!chars);
+                {
+                    std::string str = "yay, yay, yay";
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser, char_(' '));
+                    BOOST_TEST(!chars);
+                }
+                {
+                    std::string str = "yay, yay, yay";
+                    auto first = str.c_str();
+                    std::optional<std::vector<std::string>> const chars =
+                        prefix_parse(
+                            first,
+                            boost::parser::detail::text::null_sentinel,
+                            parser,
+                            char_(' '));
+                    BOOST_TEST(chars);
+                    BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                }
             }
             {
                 std::string str = " yay, yay, yay";
-                auto first = str.c_str();
-                std::optional<std::vector<std::string>> const chars =
-                    prefix_parse(
+                {
+                    std::vector<std::string> chars;
+                    BOOST_TEST(!parse(str, parser, char_(' '), chars));
+                }
+                {
+                    std::vector<std::string> chars;
+                    auto first = str.c_str();
+                    BOOST_TEST(prefix_parse(
                         first,
                         boost::parser::detail::text::null_sentinel,
                         parser,
-                        char_(' '));
-                BOOST_TEST(chars);
-                BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                        char_(' '),
+                        chars));
+                    BOOST_TEST(chars == std::vector<std::string>({"yay"}));
+                }
+
+                {
+                    std::string str = " yay, yay, yay";
+                    std::optional<std::vector<std::string>> const chars =
+                        parse(str, parser, char_(' '));
+                    BOOST_TEST(!chars);
+                }
+                {
+                    std::string str = " yay, yay, yay";
+                    auto first = str.c_str();
+                    std::optional<std::vector<std::string>> const chars =
+                        prefix_parse(
+                            first,
+                            boost::parser::detail::text::null_sentinel,
+                            parser,
+                            char_(' '));
+                    BOOST_TEST(chars);
+                    BOOST_TEST(*chars == std::vector<std::string>({"yay"}));
+                }
             }
         }
-        }
 
         {
             constexpr auto parser = lexeme[skip[string("yay") % ',']];
@@ -2132,69 +2150,73 @@ int main()
                 }
             }
         }
-        }
+    }
 
-        // skip
-        {{constexpr auto parser = skip(char_(' '))[string("yay") % ','];
+    // skip
+    {
+        {
+            constexpr auto parser = skip(char_(' '))[string("yay") % ','];
 
-        {
-            std::string str = "yay, yay, yay";
-            std::vector<std::string> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(
-                chars == std::vector<std::string>({"yay", "yay", "yay"}));
-        }
-        {
-            std::string str = "yay, yay, yay";
-            std::optional<std::vector<std::string>> const chars =
-                parse(str, parser);
-            BOOST_TEST(chars);
-            BOOST_TEST(
-                *chars == std::vector<std::string>({"yay", "yay", "yay"}));
-        }
-        {
-            std::string str = " yay, yay, yay";
-            std::vector<std::string> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(
-                chars == std::vector<std::string>({"yay", "yay", "yay"}));
-        }
-        {
-            std::string str = " yay, yay, yay";
-            std::optional<std::vector<std::string>> const chars =
-                parse(str, parser);
-            BOOST_TEST(chars);
-            BOOST_TEST(
-                *chars == std::vector<std::string>({"yay", "yay", "yay"}));
-        }
-        }
+            {
+                std::string str = "yay, yay, yay";
+                std::vector<std::string> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(
+                    chars == std::vector<std::string>({"yay", "yay", "yay"}));
+            }
+            {
+                std::string str = "yay, yay, yay";
+                std::optional<std::vector<std::string>> const chars =
+                    parse(str, parser);
+                BOOST_TEST(chars);
+                BOOST_TEST(
+                    *chars == std::vector<std::string>({"yay", "yay", "yay"}));
+            }
+            {
+                std::string str = " yay, yay, yay";
+                std::vector<std::string> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(
+                    chars == std::vector<std::string>({"yay", "yay", "yay"}));
+            }
+            {
+                std::string str = " yay, yay, yay";
+                std::optional<std::vector<std::string>> const chars =
+                    parse(str, parser);
+                BOOST_TEST(chars);
+                BOOST_TEST(
+                    *chars == std::vector<std::string>({"yay", "yay", "yay"}));
+            }
         }
+    }
 
-        // combined_seq_and_or
-        {{constexpr auto parser = char_('a') >> char_('b') >> char_('c') |
-                                  char_('x') >> char_('y') >> char_('z');
-        using tup = tuple<char, char, char>;
-
+    // combined_seq_and_or
+    {
         {
-            std::string str = "abc";
-            tuple<char, char, char> chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == tup('c', '\0', '\0'));
-        }
+            constexpr auto parser = char_('a') >> char_('b') >> char_('c') |
+                                    char_('x') >> char_('y') >> char_('z');
+            using tup = tuple<char, char, char>;
 
-        {
-            std::string str = "abc";
-            std::optional<std::string> const chars = parse(str, parser);
-            BOOST_TEST(chars);
-            BOOST_TEST(*chars == "abc");
-        }
+            {
+                std::string str = "abc";
+                tuple<char, char, char> chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == tup('c', '\0', '\0'));
+            }
 
-        {
-            std::string str = "xyz";
-            tup chars;
-            BOOST_TEST(parse(str, parser, chars));
-            BOOST_TEST(chars == tup('z', '\0', '\0'));
-        }
+            {
+                std::string str = "abc";
+                std::optional<std::string> const chars = parse(str, parser);
+                BOOST_TEST(chars);
+                BOOST_TEST(*chars == "abc");
+            }
+
+            {
+                std::string str = "xyz";
+                tup chars;
+                BOOST_TEST(parse(str, parser, chars));
+                BOOST_TEST(chars == tup('z', '\0', '\0'));
+            }
         }
 
         {
@@ -2359,570 +2381,573 @@ int main()
             BOOST_TEST(result);
             BOOST_TEST(*result == 34);
         }
-        }
+    }
 
-        // eol_
-        {{constexpr auto parser = eol;
+    // eol_
+    {
+        {
+            constexpr auto parser = eol;
 
-        {
-            std::string str = "y";
-            BOOST_TEST(!parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000b";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000c";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u0085";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2028";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2029";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        }
+            {
+                std::string str = "y";
+                BOOST_TEST(!parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000b";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000c";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u0085";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2028";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2029";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
         }
+    }
 
-        // ws_
-        {{constexpr auto parser = ws;
+    // ws_
+    {
+        {
+            constexpr auto parser = ws;
 
-        {
-            std::string str = "y";
-            BOOST_TEST(!parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u0009";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000b";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000c";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u0085";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u00a0";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u1680";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2000";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2001";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2002";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2003";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2004";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2005";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2006";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2007";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2008";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2009";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u200a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2028";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2029";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u202F";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u205F";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u3000";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser));
-        }
-        }
+            {
+                std::string str = "y";
+                BOOST_TEST(!parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u0009";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000b";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000c";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u0085";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u00a0";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u1680";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2000";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2001";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2002";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2003";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2004";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2005";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2006";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2007";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2008";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2009";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u200a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2028";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2029";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u202F";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u205F";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u3000";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser));
+            }
         }
+    }
 
-        // blank_
-        {{constexpr auto parser = blank;
-        constexpr auto alt_parser = ws - eol;
+    // blank_
+    {
+        {
+            constexpr auto parser = blank;
+            constexpr auto alt_parser = ws - eol;
 
-        {
-            std::string str = "y";
-            BOOST_TEST(!parse(str, parser));
-        }
-        {
-            std::string s = (char const *)u8"\u0009";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d\u000a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000b";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000c";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u000d";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u0085";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u00a0";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u1680";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2000";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2001";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2002";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2003";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2004";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2005";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2006";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2007";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2008";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2009";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u200a";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2028";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u2029";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u202F";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u205F";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        {
-            std::string s = (char const *)u8"\u3000";
-            auto str = boost::parser::detail::text::as_utf8(s);
-            BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
-        }
-        }
+            {
+                std::string str = "y";
+                BOOST_TEST(!parse(str, parser));
+            }
+            {
+                std::string s = (char const *)u8"\u0009";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d\u000a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000b";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000c";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u000d";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u0085";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u00a0";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u1680";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2000";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2001";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2002";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2003";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2004";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2005";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2006";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2007";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2008";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2009";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u200a";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2028";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u2029";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u202F";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u205F";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
+            {
+                std::string s = (char const *)u8"\u3000";
+                auto str = boost::parser::detail::text::as_utf8(s);
+                BOOST_TEST(parse(str, parser) == parse(str, alt_parser));
+            }
         }
+    }
 
-        // digit_
-        {
-            constexpr auto parser = +digit;
+    // digit_
+    {
+        constexpr auto parser = +digit;
 
-            std::u32string str = U"a/09:\x0659\x0660\x0669\x066a";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - digit, result));
-            BOOST_TEST(
-                result == std::vector<uint32_t>({'0', '9', 0x0660, 0x0669}));
-        }
+        std::u32string str = U"a/09:\x0659\x0660\x0669\x066a";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - digit, result));
+        BOOST_TEST(result == std::vector<uint32_t>({'0', '9', 0x0660, 0x0669}));
+    }
 
-        // hex_digit_
-        {
-            constexpr auto parser = +hex_digit;
+    // hex_digit_
+    {
+        constexpr auto parser = +hex_digit;
 
-            std::u32string str = U"a/09:A\uff0f\uff10\uff19\uff1a";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - hex_digit, result));
-            BOOST_TEST(
-                result == std::vector<uint32_t>(
-                              {'a', '0', '9', 'A', U'\uff10', U'\uff19'}));
-        }
+        std::u32string str = U"a/09:A\uff0f\uff10\uff19\uff1a";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - hex_digit, result));
+        BOOST_TEST(
+            result ==
+            std::vector<uint32_t>({'a', '0', '9', 'A', U'\uff10', U'\uff19'}));
+    }
 
-        // control_
-        {
-            constexpr auto parser = +control;
+    // control_
+    {
+        constexpr auto parser = +control;
 
-            std::u32string str = U"\u0001\u001f\u0020\u007e\u007f\u009f\u00a0";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - control, result));
-            BOOST_TEST(
-                result == std::vector<uint32_t>({1, 0x001f, 0x007f, 0x009f}));
-        }
+        std::u32string str = U"\u0001\u001f\u0020\u007e\u007f\u009f\u00a0";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - control, result));
+        BOOST_TEST(
+            result == std::vector<uint32_t>({1, 0x001f, 0x007f, 0x009f}));
+    }
 
-        // punct_
-        {
-            auto parser = +punct;
+    // punct_
+    {
+        auto parser = +punct;
 
-            std::u32string str = U"\u0020\u0021\u0fda\u0fdb";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - punct, result));
-            BOOST_TEST(result == std::vector<uint32_t>({0x21, 0xfda}));
-        }
+        std::u32string str = U"\u0020\u0021\u0fda\u0fdb";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - punct, result));
+        BOOST_TEST(result == std::vector<uint32_t>({0x21, 0xfda}));
+    }
 
-        // lower_
-        {
-            auto parser = +lower;
+    // lower_
+    {
+        auto parser = +lower;
 
-            std::u32string str = U"aA\u016F\u0170";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - lower, result));
-            BOOST_TEST(result == std::vector<uint32_t>({'a', 0x16f}));
-        }
+        std::u32string str = U"aA\u016F\u0170";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - lower, result));
+        BOOST_TEST(result == std::vector<uint32_t>({'a', 0x16f}));
+    }
 
-        // upper_
-        {
-            auto parser = +upper;
+    // upper_
+    {
+        auto parser = +upper;
 
-            std::u32string str = U"aA\u0105\u0106";
-            std::vector<uint32_t> result;
-            BOOST_TEST(parse(str, parser, char_ - upper, result));
-            BOOST_TEST(result == std::vector<uint32_t>({'A', 0x106}));
-        }
+        std::u32string str = U"aA\u0105\u0106";
+        std::vector<uint32_t> result;
+        BOOST_TEST(parse(str, parser, char_ - upper, result));
+        BOOST_TEST(result == std::vector<uint32_t>({'A', 0x106}));
+    }
 
-        // no_need_for_sprit_2_hold_directive
-        {
-            namespace bp = boost::parser;
+    // no_need_for_sprit_2_hold_directive
+    {
+        namespace bp = boost::parser;
 
-            std::vector<int> v;
-            auto result = bp::parse(
-                "1 2",
-                bp::repeat(3)[bp::int_] | repeat(2)[bp::int_] >> bp::attr(0),
-                bp::ws,
-                v,
-                bp::trace::on);
-            BOOST_TEST(result);
+        std::vector<int> v;
+        auto result = bp::parse(
+            "1 2",
+            bp::repeat(3)[bp::int_] | repeat(2)[bp::int_] >> bp::attr(0),
+            bp::ws,
+            v,
+            bp::trace::on);
+        BOOST_TEST(result);
 
-            BOOST_TEST(v.size() == 3u);
-            BOOST_TEST(v == std::vector<int>({1, 2, 0}));
-        }
+        BOOST_TEST(v.size() == 3u);
+        BOOST_TEST(v == std::vector<int>({1, 2, 0}));
+    }
 
-        // raw_doc_example
-        {
-            namespace bp = boost::parser;
-            auto int_parser =
-                bp::int_ % ','; // ATTR(int_parser) is std::vector<int>
-            auto subrange_parser =
-                bp::raw[int_parser]; // ATTR(subrange_parser) is a subrange
+    // raw_doc_example
+    {
+        namespace bp = boost::parser;
+        auto int_parser =
+            bp::int_ % ','; // ATTR(int_parser) is std::vector<int>
+        auto subrange_parser =
+            bp::raw[int_parser]; // ATTR(subrange_parser) is a subrange
 
-            // Parse using int_parser, generating integers.
-            auto ints = bp::parse("1, 2, 3, 4", int_parser, bp::ws);
-            assert(ints);
-            assert(*ints == std::vector<int>({1, 2, 3, 4}));
+        // Parse using int_parser, generating integers.
+        auto ints = bp::parse("1, 2, 3, 4", int_parser, bp::ws);
+        assert(ints);
+        assert(*ints == std::vector<int>({1, 2, 3, 4}));
 
-            // Parse again using int_parser, but this time generating only the
-            // subrange matched by int_parser.  (prefix_parse() allows matches
-            // that don't consume the entire input.)
-            auto const str = std::string("1, 2, 3, 4, a, b, c");
-            auto first = str.begin();
-            auto range =
-                bp::prefix_parse(first, str.end(), subrange_parser, bp::ws);
-            assert(range);
-            assert(range->begin() == str.begin());
-            assert(range->end() == str.begin() + 10);
+        // Parse again using int_parser, but this time generating only the
+        // subrange matched by int_parser.  (prefix_parse() allows matches
+        // that don't consume the entire input.)
+        auto const str = std::string("1, 2, 3, 4, a, b, c");
+        auto first = str.begin();
+        auto range =
+            bp::prefix_parse(first, str.end(), subrange_parser, bp::ws);
+        assert(range);
+        assert(range->begin() == str.begin());
+        assert(range->end() == str.begin() + 10);
 
-            static_assert(
-                std::is_same_v<
-                    decltype(range),
-                    std::optional<
-                        BOOST_PARSER_SUBRANGE<std::string::const_iterator>>>);
+        static_assert(std::is_same_v<
+                      decltype(range),
+                      std::optional<
+                          BOOST_PARSER_SUBRANGE<std::string::const_iterator>>>);
 
 #if defined(__cpp_char8_t)
-            auto const u8str = std::u8string(u8"1, 2, 3, 4, a, b, c");
-            auto u8first = u8str.begin();
-            auto u8range =
-                bp::prefix_parse(u8first, u8str.end(), subrange_parser, bp::ws);
-            assert(u8range);
-            assert(u8range->begin().base() == u8str.begin());
-            assert(u8range->end().base() == u8str.begin() + 10);
+        auto const u8str = std::u8string(u8"1, 2, 3, 4, a, b, c");
+        auto u8first = u8str.begin();
+        auto u8range =
+            bp::prefix_parse(u8first, u8str.end(), subrange_parser, bp::ws);
+        assert(u8range);
+        assert(u8range->begin().base() == u8str.begin());
+        assert(u8range->end().base() == u8str.begin() + 10);
 #endif
-        }
+    }
 
 
 #if BOOST_PARSER_USE_CONCEPTS
-        // string_view_doc_example
-        {
-            namespace bp = boost::parser;
-            auto int_parser =
-                bp::int_ % ','; // ATTR(int_parser) is std::vector<int>
-            auto sv_parser = bp::string_view[int_parser]; // ATTR(subrange_parser)
-                                                          // is a string_view
+    // string_view_doc_example
+    {
+        namespace bp = boost::parser;
+        auto int_parser =
+            bp::int_ % ','; // ATTR(int_parser) is std::vector<int>
+        auto sv_parser = bp::string_view[int_parser]; // ATTR(subrange_parser)
+                                                      // is a string_view
 
-            auto const str = std::string("1, 2, 3, 4, a, b, c");
-            auto first = str.begin();
-            auto sv1 = bp::prefix_parse(first, str.end(), sv_parser, bp::ws);
-            assert(sv1);
-            assert(*sv1 == str.substr(0, 10));
+        auto const str = std::string("1, 2, 3, 4, a, b, c");
+        auto first = str.begin();
+        auto sv1 = bp::prefix_parse(first, str.end(), sv_parser, bp::ws);
+        assert(sv1);
+        assert(*sv1 == str.substr(0, 10));
 
-            static_assert(
-                std::is_same_v<decltype(sv1), std::optional<std::string_view>>);
+        static_assert(
+            std::is_same_v<decltype(sv1), std::optional<std::string_view>>);
 
-            auto sv2 =
-                bp::parse("1, 2, 3, 4" | bp::as_utf32, sv_parser, bp::ws);
-            assert(sv2);
-            assert(*sv2 == "1, 2, 3, 4");
+        auto sv2 = bp::parse("1, 2, 3, 4" | bp::as_utf32, sv_parser, bp::ws);
+        assert(sv2);
+        assert(*sv2 == "1, 2, 3, 4");
 
-            static_assert(
-                std::is_same_v<decltype(sv2), std::optional<std::string_view>>);
-        }
+        static_assert(
+            std::is_same_v<decltype(sv2), std::optional<std::string_view>>);
+    }
 #endif
 
-        // variant_compat_example
+    // variant_compat_example
+    {
+        struct key_value
         {
-            struct key_value
-            {
-                int key;
-                double value;
-            };
+            int key;
+            double value;
+        };
 
-            namespace bp = boost::parser;
-            key_value kv;
-            bp::parse("42 13.0", bp::int_ >> bp::double_, kv); // Ok.
+        namespace bp = boost::parser;
+        key_value kv;
+        bp::parse("42 13.0", bp::int_ >> bp::double_, kv); // Ok.
 #if 0
             std::variant<key_value, double> kv_or_d;
             bp::parse("42 13.0", bp::int_ >> bp::double_, kv_or_d); // Error: ill-formed!
 #endif
-        }
+    }
 
 
-        // utf_iterator_copy_ctor
+    // utf_iterator_copy_ctor
+    {
+        namespace bp = boost::parser;
+
+        char mut_chars[] = "foo";
+        char const const_chars[] = "bar";
+
+        auto mut_view = mut_chars | bp::as_utf8;
+        auto const_view = const_chars | bp::as_utf8;
+
+        auto mut_it = mut_view.begin();
+        auto mut_last = mut_view.end();
+        auto const_it = const_view.begin();
+        auto const_last = const_view.begin();
+
+        const_it = mut_it;
+        const_last = mut_last;
+
+        std::string copy;
+        copy.resize(3);
+        std::copy(const_it, const_last, copy.begin());
+        BOOST_TEST(copy == "foo");
+    }
+
+    // detail_printing
+    {
+        // print_printable(char > 127)
         {
-            namespace bp = boost::parser;
-
-            char mut_chars[] = "foo";
-            char const const_chars[] = "bar";
-
-            auto mut_view = mut_chars | bp::as_utf8;
-            auto const_view = const_chars | bp::as_utf8;
-
-            auto mut_it = mut_view.begin();
-            auto mut_last = mut_view.end();
-            auto const_it = const_view.begin();
-            auto const_last = const_view.begin();
-
-            const_it = mut_it;
-            const_last = mut_last;
-
-            std::string copy;
-            copy.resize(3);
-            std::copy(const_it, const_last, copy.begin());
-            BOOST_TEST(copy == "foo");
+            std::ostringstream oss;
+            detail::print_printable(oss, char(130));
+            BOOST_TEST(oss.str() == "'\\x82'");
         }
 
-        // detail_printing
+        // print_printable(char32_t)
         {
-            // print_printable(char > 127)
-            {
-                std::ostringstream oss;
-                detail::print_printable(oss, char(130));
-                BOOST_TEST(oss.str() == "'\\x82'");
-            }
-
-            // print_printable(char32_t)
-            {
-                std::ostringstream oss;
-                detail::print_printable(oss, U'a');
-                BOOST_TEST(oss.str() == "U'a'");
-            }
-            {
-                std::ostringstream oss;
-                detail::print_printable(oss, U'ß');
-                BOOST_TEST(oss.str() == "U'\\xdf'");
-            }
-
-            // print(tuple)
-            {
-                std::ostringstream oss;
-                tuple<int, float> tup(42, 13.8);
-                detail::print(oss, tup);
-                BOOST_TEST(oss.str() == "(42, 13.8)");
-            }
-
-            // print(optional)
-            {
-                std::ostringstream oss;
-                detail::print(oss, std::optional<int>());
-                BOOST_TEST(oss.str() == "<<empty>>");
-            }
-            {
-                std::ostringstream oss;
-                detail::print(oss, std::optional(42));
-                BOOST_TEST(oss.str() == "42");
-            }
-
-            // print(variant)
-            {
-                std::ostringstream oss;
-                detail::print(oss, std::variant<int, double>());
-                BOOST_TEST(oss.str() == "<<variant>>");
-            }
+            std::ostringstream oss;
+            detail::print_printable(oss, U'a');
+            BOOST_TEST(oss.str() == "U'a'");
+        }
+        {
+            std::ostringstream oss;
+            detail::print_printable(oss, U'ß');
+            BOOST_TEST(oss.str() == "U'\\xdf'");
         }
 
-        return boost::report_errors();
+        // print(tuple)
+        {
+            std::ostringstream oss;
+            tuple<int, float> tup(42, 13.8);
+            detail::print(oss, tup);
+            BOOST_TEST(oss.str() == "(42, 13.8)");
         }
+
+        // print(optional)
+        {
+            std::ostringstream oss;
+            detail::print(oss, std::optional<int>());
+            BOOST_TEST(oss.str() == "<<empty>>");
+        }
+        {
+            std::ostringstream oss;
+            detail::print(oss, std::optional(42));
+            BOOST_TEST(oss.str() == "42");
+        }
+
+        // print(variant)
+        {
+            std::ostringstream oss;
+            detail::print(oss, std::variant<int, double>());
+            BOOST_TEST(oss.str() == "<<variant>>");
+        }
+    }
+
+    return boost::report_errors();
+}