diff --git a/test/test_cartesian_power.cpp b/test/test_cartesian_power.cpp
index ad795533..8eadadf9 100644
--- a/test/test_cartesian_power.cpp
+++ b/test/test_cartesian_power.cpp
@@ -52,240 +52,242 @@ constexpr bool test_cartesian_power()
 {
     // 1D `cartesian_product repeat`.
     {
-      auto cart = flux::cartesian_product_repeat_n<2>(std::array{100, 200, 300});
-      static_assert(cart.size() == 9);
-
-      using C = decltype(cart);
-
-      static_assert(flux::sequence<C>);
-      static_assert(flux::multipass_sequence<C>);
-      static_assert(flux::bidirectional_sequence<C>);
-      static_assert(flux::random_access_sequence<C>);
-      static_assert(not flux::contiguous_sequence<C>);
-      static_assert(flux::bounded_sequence<C>);
-      static_assert(flux::sized_sequence<C>);
-
-      static_assert(flux::sequence<C const>);
-      static_assert(flux::multipass_sequence<C const>);
-      static_assert(flux::bidirectional_sequence<C const>);
-      static_assert(flux::random_access_sequence<C const>);
-      static_assert(not flux::contiguous_sequence<C const>);
-      static_assert(flux::bounded_sequence<C const>);
-      static_assert(flux::sized_sequence<C const>);
-
-      static_assert(std::same_as<flux::element_t<C>, std::tuple<int&, int&>>);
-      static_assert(std::same_as<flux::value_t<C>, std::tuple<int, int>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<int&&, int&&>>);
-
-      static_assert(std::same_as<flux::element_t<C const>, std::tuple<int const&, int const&>>);
-      static_assert(std::same_as<flux::value_t<C const>, std::tuple<int, int>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<int const&&, int const&&>>);
-
-      STATIC_CHECK(flux::size(cart) == 9);
-
-      STATIC_CHECK(check_equal(cart, {
-          std::tuple{100, 100},
-          std::tuple{100, 200},
-          std::tuple{100, 300},
-          std::tuple{200, 100},
-          std::tuple{200, 200},
-          std::tuple{200, 300},
-          std::tuple{300, 100},
-          std::tuple{300, 200},
-          std::tuple{300, 300},
-      }));
-
-      STATIC_CHECK(flux::distance(cart, cart.first(), cart.last()) == 9);
-
-      {
-        auto cur = flux::next(cart, cart.first(), 2);
-        STATIC_CHECK(cart[cur] == std::tuple{100, 300});
-        flux::inc(cart, cur, -2);
-        STATIC_CHECK(cart[cur] == std::tuple{100, 100});
-      }
-
-      int sum_i = 0;
-      int sum_j = 0;
-      cart.for_each(flux::unpack([&] (int i, int j) {
-        sum_i += i;
-        sum_j += j;
-      }));
-      STATIC_CHECK(sum_i == 3 * (100 + 200 + 300));
-      STATIC_CHECK(sum_j == 3 * (100 + 200 + 300));
+        auto cart = flux::cartesian_product_repeat_n<2>(std::array{100, 200, 300});
+        static_assert(cart.size() == 9);
+
+        using C = decltype(cart);
+
+        static_assert(flux::sequence<C>);
+        static_assert(flux::multipass_sequence<C>);
+        static_assert(flux::bidirectional_sequence<C>);
+        static_assert(flux::random_access_sequence<C>);
+        static_assert(not flux::contiguous_sequence<C>);
+        static_assert(flux::bounded_sequence<C>);
+        static_assert(flux::sized_sequence<C>);
+
+        static_assert(flux::sequence<C const>);
+        static_assert(flux::multipass_sequence<C const>);
+        static_assert(flux::bidirectional_sequence<C const>);
+        static_assert(flux::random_access_sequence<C const>);
+        static_assert(not flux::contiguous_sequence<C const>);
+        static_assert(flux::bounded_sequence<C const>);
+        static_assert(flux::sized_sequence<C const>);
+
+        static_assert(std::same_as<flux::element_t<C>, std::tuple<int&, int&>>);
+        static_assert(std::same_as<flux::value_t<C>, std::tuple<int, int>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<int&&, int&&>>);
+
+        static_assert(std::same_as<flux::element_t<C const>, std::tuple<int const&, int const&>>);
+        static_assert(std::same_as<flux::value_t<C const>, std::tuple<int, int>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<int const&&, int const&&>>);
+
+        STATIC_CHECK(flux::size(cart) == 9);
+
+        STATIC_CHECK(check_equal(cart, {
+            std::tuple{100, 100},
+            std::tuple{100, 200},
+            std::tuple{100, 300},
+            std::tuple{200, 100},
+            std::tuple{200, 200},
+            std::tuple{200, 300},
+            std::tuple{300, 100},
+            std::tuple{300, 200},
+            std::tuple{300, 300},
+        }));
+
+        STATIC_CHECK(flux::distance(cart, cart.first(), cart.last()) == 9);
+
+        {
+            auto cur = flux::next(cart, cart.first(), 2);
+            STATIC_CHECK(cart[cur] == std::tuple{100, 300});
+            flux::inc(cart, cur, -2);
+            STATIC_CHECK(cart[cur] == std::tuple{100, 100});
+        }
+
+        int sum_i = 0;
+        int sum_j = 0;
+        cart.for_each(flux::unpack([&] (int i, int j) {
+            sum_i += i;
+            sum_j += j;
+        }));
+        STATIC_CHECK(sum_i == 3 * (100 + 200 + 300));
+        STATIC_CHECK(sum_j == 3 * (100 + 200 + 300));
 
     }
 
     {
-      auto cart = flux::cartesian_power<2>(std::array{100, 200, 300});
-
-      using C = decltype(cart);
-
-      static_assert(flux::sequence<C>);
-      static_assert(flux::multipass_sequence<C>);
-      static_assert(flux::bidirectional_sequence<C>);
-      static_assert(flux::random_access_sequence<C>);
-      static_assert(not flux::contiguous_sequence<C>);
-      static_assert(flux::bounded_sequence<C>);
-      static_assert(flux::sized_sequence<C>);
-
-      static_assert(flux::sequence<C const>);
-      static_assert(flux::multipass_sequence<C const>);
-      static_assert(flux::bidirectional_sequence<C const>);
-      static_assert(flux::random_access_sequence<C const>);
-      static_assert(not flux::contiguous_sequence<C const>);
-      static_assert(flux::bounded_sequence<C const>);
-      static_assert(flux::sized_sequence<C const>);
-
-      static_assert(std::same_as<flux::element_t<C>, std::tuple<int&, int&>>);
-      static_assert(std::same_as<flux::value_t<C>, std::tuple<int, int>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<int&&, int&&>>);
-
-      static_assert(std::same_as<flux::element_t<C const>, std::tuple<int const&, int const&>>);
-      static_assert(std::same_as<flux::value_t<C const>, std::tuple<int, int>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<int const&&, int const&&>>);
-
-      STATIC_CHECK(flux::size(cart) == 9);
-
-      STATIC_CHECK(check_equal(cart, {
-          std::tuple{100, 100},
-          std::tuple{100, 200},
-          std::tuple{100, 300},
-          std::tuple{200, 100},
-          std::tuple{200, 200},
-          std::tuple{200, 300},
-          std::tuple{300, 100},
-          std::tuple{300, 200},
-          std::tuple{300, 300},
-      }));
-
-      STATIC_CHECK(flux::distance(cart, cart.first(), cart.last()) == 9);
-
-      {
-        auto cur = flux::next(cart, cart.first());
-        flux::inc(cart, cur);
-        STATIC_CHECK(cart[cur] == std::tuple{100, 300});
-        flux::inc(cart, cur, -2);
-        STATIC_CHECK(cart[cur] == std::tuple{100, 100});
-      }
-
-      int sum_i = 0;
-      int sum_j = 0;
-      cart.for_each(flux::unpack([&] (int i, int j) {
-        sum_i += i;
-        sum_j += j;
-      }));
-      STATIC_CHECK(sum_i == 3 * (100 + 200 + 300));
-      STATIC_CHECK(sum_j == 3 * (100 + 200 + 300));
+        auto cart = flux::cartesian_power<2>(std::array{100, 200, 300});
+
+        using C = decltype(cart);
+
+        static_assert(flux::sequence<C>);
+        static_assert(flux::multipass_sequence<C>);
+        static_assert(flux::bidirectional_sequence<C>);
+        static_assert(flux::random_access_sequence<C>);
+        static_assert(not flux::contiguous_sequence<C>);
+        static_assert(flux::bounded_sequence<C>);
+        static_assert(flux::sized_sequence<C>);
+
+        static_assert(flux::sequence<C const>);
+        static_assert(flux::multipass_sequence<C const>);
+        static_assert(flux::bidirectional_sequence<C const>);
+        static_assert(flux::random_access_sequence<C const>);
+        static_assert(not flux::contiguous_sequence<C const>);
+        static_assert(flux::bounded_sequence<C const>);
+        static_assert(flux::sized_sequence<C const>);
+
+        static_assert(std::same_as<flux::element_t<C>, std::tuple<int&, int&>>);
+        static_assert(std::same_as<flux::value_t<C>, std::tuple<int, int>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<int&&, int&&>>);
+
+        static_assert(std::same_as<flux::element_t<C const>, std::tuple<int const&, int const&>>);
+        static_assert(std::same_as<flux::value_t<C const>, std::tuple<int, int>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<int const&&, int const&&>>);
+
+        STATIC_CHECK(flux::size(cart) == 9);
+
+        STATIC_CHECK(check_equal(cart, {
+            std::tuple{100, 100},
+            std::tuple{100, 200},
+            std::tuple{100, 300},
+            std::tuple{200, 100},
+            std::tuple{200, 200},
+            std::tuple{200, 300},
+            std::tuple{300, 100},
+            std::tuple{300, 200},
+            std::tuple{300, 300},
+        }));
+
+        STATIC_CHECK(flux::distance(cart, cart.first(), cart.last()) == 9);
+
+        {
+            auto cur = flux::next(cart, cart.first());
+            flux::inc(cart, cur);
+            STATIC_CHECK(cart[cur] == std::tuple{100, 300});
+            flux::inc(cart, cur, 0);
+            STATIC_CHECK(cart[cur] == std::tuple{100, 300});
+            flux::inc(cart, cur, -2);
+            STATIC_CHECK(cart[cur] == std::tuple{100, 100});
+        }
+
+        int sum_i = 0;
+        int sum_j = 0;
+        cart.for_each(flux::unpack([&] (int i, int j) {
+            sum_i += i;
+            sum_j += j;
+        }));
+        STATIC_CHECK(sum_i == 3 * (100 + 200 + 300));
+        STATIC_CHECK(sum_j == 3 * (100 + 200 + 300));
 
     }
 
     {
-      auto prod = flux::cartesian_power<3>(std::array{'a', 'b', 'c', 'd'});
-      static_assert(prod.size() == 64);
-
-      using C = decltype(prod);
-
-      static_assert(flux::sequence<C>);
-      static_assert(flux::multipass_sequence<C>);
-      static_assert(flux::bidirectional_sequence<C>);
-      static_assert(flux::random_access_sequence<C>);
-      static_assert(not flux::contiguous_sequence<C>);
-      static_assert(flux::bounded_sequence<C>);
-      static_assert(flux::sized_sequence<C>);
-
-      static_assert(flux::sequence<C const>);
-      static_assert(flux::multipass_sequence<C const>);
-      static_assert(flux::bidirectional_sequence<C const>);
-      static_assert(flux::random_access_sequence<C const>);
-      static_assert(not flux::contiguous_sequence<C const>);
-      static_assert(flux::bounded_sequence<C const>);
-      static_assert(flux::sized_sequence<C const>);
-
-      static_assert(std::same_as<flux::element_t<C>, std::tuple<char&, char&, char&>>);
-      static_assert(std::same_as<flux::value_t<C>, std::tuple<char, char, char>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<char&&, char&&, char&&>>);
-
-      static_assert(std::same_as<flux::element_t<C const>, std::tuple<char const&, char const&, char const&>>);
-      static_assert(std::same_as<flux::value_t<C const>, std::tuple<char, char, char>>);
-      static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<char const&&, char const&&, char const&&>>);
-
-      STATIC_CHECK(flux::size(prod) == 64);
-
-      STATIC_CHECK(check_equal(prod, {
-          std::tuple{'a', 'a', 'a'},
-          std::tuple{'a', 'a', 'b'},
-          std::tuple{'a', 'a', 'c'},
-          std::tuple{'a', 'a', 'd'},
-          std::tuple{'a', 'b', 'a'},
-          std::tuple{'a', 'b', 'b'},
-          std::tuple{'a', 'b', 'c'},
-          std::tuple{'a', 'b', 'd'},
-          std::tuple{'a', 'c', 'a'},
-          std::tuple{'a', 'c', 'b'},
-          std::tuple{'a', 'c', 'c'},
-          std::tuple{'a', 'c', 'd'},
-          std::tuple{'a', 'd', 'a'},
-          std::tuple{'a', 'd', 'b'},
-          std::tuple{'a', 'd', 'c'},
-          std::tuple{'a', 'd', 'd'},
-          std::tuple{'b', 'a', 'a'},
-          std::tuple{'b', 'a', 'b'},
-          std::tuple{'b', 'a', 'c'},
-          std::tuple{'b', 'a', 'd'},
-          std::tuple{'b', 'b', 'a'},
-          std::tuple{'b', 'b', 'b'},
-          std::tuple{'b', 'b', 'c'},
-          std::tuple{'b', 'b', 'd'},
-          std::tuple{'b', 'c', 'a'},
-          std::tuple{'b', 'c', 'b'},
-          std::tuple{'b', 'c', 'c'},
-          std::tuple{'b', 'c', 'd'},
-          std::tuple{'b', 'd', 'a'},
-          std::tuple{'b', 'd', 'b'},
-          std::tuple{'b', 'd', 'c'},
-          std::tuple{'b', 'd', 'd'},
-          std::tuple{'c', 'a', 'a'},
-          std::tuple{'c', 'a', 'b'},
-          std::tuple{'c', 'a', 'c'},
-          std::tuple{'c', 'a', 'd'},
-          std::tuple{'c', 'b', 'a'},
-          std::tuple{'c', 'b', 'b'},
-          std::tuple{'c', 'b', 'c'},
-          std::tuple{'c', 'b', 'd'},
-          std::tuple{'c', 'c', 'a'},
-          std::tuple{'c', 'c', 'b'},
-          std::tuple{'c', 'c', 'c'},
-          std::tuple{'c', 'c', 'd'},
-          std::tuple{'c', 'd', 'a'},
-          std::tuple{'c', 'd', 'b'},
-          std::tuple{'c', 'd', 'c'},
-          std::tuple{'c', 'd', 'd'},
-          std::tuple{'d', 'a', 'a'},
-          std::tuple{'d', 'a', 'b'},
-          std::tuple{'d', 'a', 'c'},
-          std::tuple{'d', 'a', 'd'},
-          std::tuple{'d', 'b', 'a'},
-          std::tuple{'d', 'b', 'b'},
-          std::tuple{'d', 'b', 'c'},
-          std::tuple{'d', 'b', 'd'},
-          std::tuple{'d', 'c', 'a'},
-          std::tuple{'d', 'c', 'b'},
-          std::tuple{'d', 'c', 'c'},
-          std::tuple{'d', 'c', 'd'},
-          std::tuple{'d', 'd', 'a'},
-          std::tuple{'d', 'd', 'b'},
-          std::tuple{'d', 'd', 'c'},
-          std::tuple{'d', 'd', 'd'}
-      }));
-
-      STATIC_CHECK(flux::distance(prod, prod.first(), prod.last()) == 64);
-
-      {
-        auto cur = flux::next(prod, prod.first(), 2);
-        STATIC_CHECK(prod[cur] == std::tuple{'a', 'a', 'c'});
-        flux::inc(prod, cur, -2);
-        STATIC_CHECK(prod[cur] == std::tuple{'a', 'a', 'a'});
-      }
+        auto prod = flux::cartesian_power<3>(std::array{'a', 'b', 'c', 'd'});
+        static_assert(prod.size() == 64);
+
+        using C = decltype(prod);
+
+        static_assert(flux::sequence<C>);
+        static_assert(flux::multipass_sequence<C>);
+        static_assert(flux::bidirectional_sequence<C>);
+        static_assert(flux::random_access_sequence<C>);
+        static_assert(not flux::contiguous_sequence<C>);
+        static_assert(flux::bounded_sequence<C>);
+        static_assert(flux::sized_sequence<C>);
+
+        static_assert(flux::sequence<C const>);
+        static_assert(flux::multipass_sequence<C const>);
+        static_assert(flux::bidirectional_sequence<C const>);
+        static_assert(flux::random_access_sequence<C const>);
+        static_assert(not flux::contiguous_sequence<C const>);
+        static_assert(flux::bounded_sequence<C const>);
+        static_assert(flux::sized_sequence<C const>);
+
+        static_assert(std::same_as<flux::element_t<C>, std::tuple<char&, char&, char&>>);
+        static_assert(std::same_as<flux::value_t<C>, std::tuple<char, char, char>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C>, std::tuple<char&&, char&&, char&&>>);
+
+        static_assert(std::same_as<flux::element_t<C const>, std::tuple<char const&, char const&, char const&>>);
+        static_assert(std::same_as<flux::value_t<C const>, std::tuple<char, char, char>>);
+        static_assert(std::same_as<flux::rvalue_element_t<C const>, std::tuple<char const&&, char const&&, char const&&>>);
+
+        STATIC_CHECK(flux::size(prod) == 64);
+
+        STATIC_CHECK(check_equal(prod, {
+            std::tuple{'a', 'a', 'a'},
+            std::tuple{'a', 'a', 'b'},
+            std::tuple{'a', 'a', 'c'},
+            std::tuple{'a', 'a', 'd'},
+            std::tuple{'a', 'b', 'a'},
+            std::tuple{'a', 'b', 'b'},
+            std::tuple{'a', 'b', 'c'},
+            std::tuple{'a', 'b', 'd'},
+            std::tuple{'a', 'c', 'a'},
+            std::tuple{'a', 'c', 'b'},
+            std::tuple{'a', 'c', 'c'},
+            std::tuple{'a', 'c', 'd'},
+            std::tuple{'a', 'd', 'a'},
+            std::tuple{'a', 'd', 'b'},
+            std::tuple{'a', 'd', 'c'},
+            std::tuple{'a', 'd', 'd'},
+            std::tuple{'b', 'a', 'a'},
+            std::tuple{'b', 'a', 'b'},
+            std::tuple{'b', 'a', 'c'},
+            std::tuple{'b', 'a', 'd'},
+            std::tuple{'b', 'b', 'a'},
+            std::tuple{'b', 'b', 'b'},
+            std::tuple{'b', 'b', 'c'},
+            std::tuple{'b', 'b', 'd'},
+            std::tuple{'b', 'c', 'a'},
+            std::tuple{'b', 'c', 'b'},
+            std::tuple{'b', 'c', 'c'},
+            std::tuple{'b', 'c', 'd'},
+            std::tuple{'b', 'd', 'a'},
+            std::tuple{'b', 'd', 'b'},
+            std::tuple{'b', 'd', 'c'},
+            std::tuple{'b', 'd', 'd'},
+            std::tuple{'c', 'a', 'a'},
+            std::tuple{'c', 'a', 'b'},
+            std::tuple{'c', 'a', 'c'},
+            std::tuple{'c', 'a', 'd'},
+            std::tuple{'c', 'b', 'a'},
+            std::tuple{'c', 'b', 'b'},
+            std::tuple{'c', 'b', 'c'},
+            std::tuple{'c', 'b', 'd'},
+            std::tuple{'c', 'c', 'a'},
+            std::tuple{'c', 'c', 'b'},
+            std::tuple{'c', 'c', 'c'},
+            std::tuple{'c', 'c', 'd'},
+            std::tuple{'c', 'd', 'a'},
+            std::tuple{'c', 'd', 'b'},
+            std::tuple{'c', 'd', 'c'},
+            std::tuple{'c', 'd', 'd'},
+            std::tuple{'d', 'a', 'a'},
+            std::tuple{'d', 'a', 'b'},
+            std::tuple{'d', 'a', 'c'},
+            std::tuple{'d', 'a', 'd'},
+            std::tuple{'d', 'b', 'a'},
+            std::tuple{'d', 'b', 'b'},
+            std::tuple{'d', 'b', 'c'},
+            std::tuple{'d', 'b', 'd'},
+            std::tuple{'d', 'c', 'a'},
+            std::tuple{'d', 'c', 'b'},
+            std::tuple{'d', 'c', 'c'},
+            std::tuple{'d', 'c', 'd'},
+            std::tuple{'d', 'd', 'a'},
+            std::tuple{'d', 'd', 'b'},
+            std::tuple{'d', 'd', 'c'},
+            std::tuple{'d', 'd', 'd'}
+        }));
+
+        STATIC_CHECK(flux::distance(prod, prod.first(), prod.last()) == 64);
+
+        {
+            auto cur = flux::next(prod, prod.first(), 2);
+            STATIC_CHECK(prod[cur] == std::tuple{'a', 'a', 'c'});
+            flux::inc(prod, cur, -2);
+            STATIC_CHECK(prod[cur] == std::tuple{'a', 'a', 'a'});
+        }
     }
 
     return true;