[gcc r13-3758] libstdc++: Implement ranges::cartesian_product_view from P2374R4

[gcc r13-3758] libstdc++: Implement ranges::cartesian_product_view from P2374R4

[Patrick Palka]

https://gcc.gnu.org/g:f471cb71c86c1e7a3dead324142bdf880f00a3da

commit r13-3758-gf471cb71c86c1e7a3dead324142bdf880f00a3da
Author: Patrick Palka <ppalka@redhat.com>
Date:   Mon Nov 7 13:29:30 2022 -0500

    libstdc++: Implement ranges::cartesian_product_view from P2374R4
    
    This also implements the proposed resolutions of the tentatively ready
    LWG issues 3760, 3761 and 3801 for cartesian_product_view.
    
    I'm not sure how/if we should implement the recommended practice of:
    
      iterator::difference_type should be the smallest signed-integer-like
      type that is sufficiently wide to store the product of the maximum
      sizes of all underlying ranges if such a type exists
    
    because for e.g.
    
      extern std::vector<int> x, y;
      auto v = views::cartesian_product(x, y);
    
    IIUC it'd mean difference_type should be __int128 (on 64-bit systems),
    which seems quite wasteful: in practice the size of any cartesian product
    probably won't exceed the precision of say ptrdiff_t, and using anything
    larger will just incur unnecessary space/time overhead.  It's also
    probably not worth the complexity to use less precision than ptrdiff_t
    (when possible) either.  So this patch defines difference_type as
    
      common_type_t<ptrdiff_t, range_difference_t<_First>, range_difference_t<_Vs>...>
    
    which should mean it's least as large as the difference_type of each
    underlying range, and at least as large as ptrdiff_t.  This patch also
    adds assertions to catch any overflow that occurs due to this choice of
    difference_type.
    
    libstdc++-v3/ChangeLog:
    
            * include/std/ranges (__maybe_const_t): New alias for
            __detail::__maybe_const_t.
            (__detail::__cartesian_product_is_random_access): Define.
            (__detail::__cartesian_product_common_arg): Define.
            (__detail::__cartesian_product_is_bidirectional): Define.
            (__detail::__cartesian_product_is_common): Define.
            (__detail::__cartesian_product_is_sized): Define.
            (__detail::__cartesian_is_sized_sentinel): Define.
            (__detail::__cartesian_common_arg_end): Define.
            (cartesian_product_view): Define.
            (cartesian_product_view::_Iterator): Define.
            (views::__detail::__can_cartesian_product_view): Define.
            (views::_CartesianProduct, views::cartesian_product): Define.
            * testsuite/std/ranges/cartesian_product/1.cc: New test.

Diff:
---
 libstdc++-v3/include/std/ranges                    | 513 +++++++++++++++++++++
 .../testsuite/std/ranges/cartesian_product/1.cc    | 186 ++++++++
 2 files changed, 699 insertions(+)

diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index a55e9e7f760..959886a1a55 100644
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -829,6 +829,9 @@ namespace __detail
 
 } // namespace __detail
 
+// Shorthand for __detail::__maybe_const_t.
+using __detail::__maybe_const_t;
+
 namespace views::__adaptor
 {
   // True if the range adaptor _Adaptor can be applied with _Args.
@@ -7973,6 +7976,516 @@ namespace views::__adaptor
 
     inline constexpr _Stride stride;
   }
+
+  namespace __detail
+  {
+    template<bool _Const, typename _First, typename... _Vs>
+      concept __cartesian_product_is_random_access
+	= (random_access_range<__maybe_const_t<_Const, _First>>
+	   && ...
+	   && (random_access_range<__maybe_const_t<_Const, _Vs>>
+	       && sized_range<__maybe_const_t<_Const, _Vs>>));
+
+    template<typename _Range>
+      concept __cartesian_product_common_arg
+	= common_range<_Range> || (sized_range<_Range> && random_access_range<_Range>);
+
+    template<bool _Const, typename _First, typename... _Vs>
+      concept __cartesian_product_is_bidirectional
+	= (bidirectional_range<__maybe_const_t<_Const, _First>>
+	   && ...
+	   && (bidirectional_range<__maybe_const_t<_Const, _Vs>>
+	       && __cartesian_product_common_arg<__maybe_const_t<_Const, _Vs>>));
+
+    template<typename _First, typename... _Vs>
+      concept __cartesian_product_is_common = __cartesian_product_common_arg<_First>;
+
+    template<typename... _Vs>
+      concept __cartesian_product_is_sized = (sized_range<_Vs> && ...);
+
+    template<bool _Const, template<typename> class FirstSent, typename _First, typename... _Vs>
+      concept __cartesian_is_sized_sentinel
+	= (sized_sentinel_for<FirstSent<__maybe_const_t<_Const, _First>>,
+			      iterator_t<__maybe_const_t<_Const, _First>>>
+	   && ...
+	   && (sized_range<__maybe_const_t<_Const, _Vs>>
+	       && sized_sentinel_for<iterator_t<__maybe_const_t<_Const, _Vs>>,
+				     iterator_t<__maybe_const_t<_Const, _Vs>>>));
+
+    template<__cartesian_product_common_arg _Range>
+      constexpr auto
+      __cartesian_common_arg_end(_Range& __r)
+      {
+	if constexpr (common_range<_Range>)
+	  return ranges::end(__r);
+	else
+	  return ranges::begin(__r) + ranges::distance(__r);
+      }
+  } // namespace __detail
+
+  template<input_range _First, forward_range... _Vs>
+    requires (view<_First> && ... && view<_Vs>)
+  class cartesian_product_view : public view_interface<cartesian_product_view<_First, _Vs...>>
+  {
+    tuple<_First, _Vs...> _M_bases;
+
+    template<bool> class _Iterator;
+
+    static auto
+    _S_difference_type()
+    {
+      // TODO: Implement the recommended practice of using the smallest
+      // sufficiently wide type according to the maximum sizes of the
+      // underlying ranges?
+      return common_type_t<ptrdiff_t,
+			   range_difference_t<_First>,
+			   range_difference_t<_Vs>...>{};
+    }
+
+  public:
+    cartesian_product_view() = default;
+
+    constexpr explicit
+    cartesian_product_view(_First __first, _Vs... __rest)
+    : _M_bases(std::move(__first), std::move(__rest)...)
+    { }
+
+    constexpr _Iterator<false>
+    begin() requires (!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
+    { return _Iterator<false>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
+
+    constexpr _Iterator<true>
+    begin() const requires (range<const _First> && ... && range<const _Vs>)
+    { return _Iterator<true>(*this, __detail::__tuple_transform(ranges::begin, _M_bases)); }
+
+    constexpr _Iterator<false>
+    end() requires ((!__detail::__simple_view<_First> || ... || !__detail::__simple_view<_Vs>)
+		    && __detail::__cartesian_product_is_common<_First, _Vs...>)
+    {
+      bool __empty_tail = [this]<size_t... _Is>(index_sequence<_Is...>) {
+	return (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
+      }(make_index_sequence<sizeof...(_Vs)>{});
+
+      auto __it = __detail::__tuple_transform(ranges::begin, _M_bases);
+      if (!__empty_tail)
+	std::get<0>(__it) = __detail::__cartesian_common_arg_end(std::get<0>(_M_bases));
+      return _Iterator<false>{*this, std::move(__it)};
+    }
+
+    constexpr _Iterator<true>
+    end() const requires __detail::__cartesian_product_is_common<const _First, const _Vs...>
+    {
+      bool __empty_tail = [this]<size_t... _Is>(index_sequence<_Is...>) {
+	return (ranges::empty(std::get<1 + _Is>(_M_bases)) || ...);
+      }(make_index_sequence<sizeof...(_Vs)>{});
+
+      auto __it = __detail::__tuple_transform(ranges::begin, _M_bases);
+      if (!__empty_tail)
+	std::get<0>(__it) = __detail::__cartesian_common_arg_end(std::get<0>(_M_bases));
+      return _Iterator<true>{*this, std::move(__it)};
+    }
+
+    constexpr default_sentinel_t
+    end() const noexcept
+    { return default_sentinel; }
+
+    constexpr auto
+    size() requires __detail::__cartesian_product_is_sized<_First, _Vs...>
+    {
+      using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
+      return [&]<size_t... _Is>(index_sequence<_Is...>) {
+	auto __size = static_cast<_ST>(1);
+#ifdef _GLIBCXX_ASSERTIONS
+	if constexpr (integral<_ST>)
+	  {
+	    bool __overflow
+	      = (__builtin_mul_overflow(__size,
+					static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
+					&__size)
+		 || ...);
+	    __glibcxx_assert(!__overflow);
+	  }
+	else
+#endif
+	  __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
+	return __size;
+      }(make_index_sequence<1 + sizeof...(_Vs)>{});
+    }
+
+    constexpr auto
+    size() const requires __detail::__cartesian_product_is_sized<const _First, const _Vs...>
+    {
+      using _ST = __detail::__make_unsigned_like_t<decltype(_S_difference_type())>;
+      return [&]<size_t... _Is>(index_sequence<_Is...>) {
+	auto __size = static_cast<_ST>(1);
+#ifdef _GLIBCXX_ASSERTIONS
+	if constexpr (integral<_ST>)
+	  {
+	    bool __overflow
+	      = (__builtin_mul_overflow(__size,
+					static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
+					&__size)
+		 || ...);
+	    __glibcxx_assert(!__overflow);
+	  }
+	else
+#endif
+	  __size = (static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))) * ...);
+	return __size;
+      }(make_index_sequence<1 + sizeof...(_Vs)>{});
+    }
+  };
+
+  template<typename... _Vs>
+    cartesian_product_view(_Vs&&...) -> cartesian_product_view<views::all_t<_Vs>...>;
+
+  template<input_range _First, forward_range... _Vs>
+    requires (view<_First> && ... && view<_Vs>)
+  template<bool _Const>
+  class cartesian_product_view<_First, _Vs...>::_Iterator
+  {
+    using _Parent = __maybe_const_t<_Const, cartesian_product_view>;
+    _Parent* _M_parent = nullptr;
+    __detail::__tuple_or_pair_t<iterator_t<__maybe_const_t<_Const, _First>>,
+				iterator_t<__maybe_const_t<_Const, _Vs>>...> _M_current;
+
+    constexpr
+    _Iterator(_Parent& __parent, decltype(_M_current) __current)
+    : _M_parent(std::__addressof(__parent)),
+      _M_current(std::move(__current))
+    { }
+
+    static auto
+    _S_iter_concept()
+    {
+      if constexpr (__detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>)
+	return random_access_iterator_tag{};
+      else if constexpr (__detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>)
+	return bidirectional_iterator_tag{};
+      else if constexpr (forward_range<__maybe_const_t<_Const, _First>>)
+	return forward_iterator_tag{};
+      else
+	return input_iterator_tag{};
+    }
+
+    friend cartesian_product_view;
+
+  public:
+    using iterator_category = input_iterator_tag;
+    using iterator_concept = decltype(_S_iter_concept());
+    using value_type
+      = __detail::__tuple_or_pair_t<range_value_t<__maybe_const_t<_Const, _First>>,
+				    range_value_t<__maybe_const_t<_Const, _Vs>>...>;
+    using reference
+      = __detail::__tuple_or_pair_t<range_reference_t<__maybe_const_t<_Const, _First>>,
+				    range_reference_t<__maybe_const_t<_Const, _Vs>>...>;
+    using difference_type = decltype(cartesian_product_view::_S_difference_type());
+
+    _Iterator() requires forward_range<__maybe_const_t<_Const, _First>> = default;
+
+    constexpr
+    _Iterator(_Iterator<!_Const> __i)
+      requires _Const
+	&& (convertible_to<iterator_t<_First>, iterator_t<const _First>>
+	    && ... && convertible_to<iterator_t<_Vs>, iterator_t<const _Vs>>)
+    : _M_parent(std::__addressof(__i._M_parent)),
+      _M_current(std::move(__i._M_current))
+    { }
+
+    constexpr auto
+    operator*() const
+    {
+      auto __f = [](auto& __i) -> decltype(auto) {
+	return *__i;
+      };
+      return __detail::__tuple_transform(__f, _M_current);
+    }
+
+    constexpr _Iterator&
+    operator++()
+    {
+      _M_next();
+      return *this;
+    }
+
+    constexpr void
+    operator++(int)
+    { ++*this; }
+
+    constexpr _Iterator
+    operator++(int) requires forward_range<__maybe_const_t<_Const, _First>>
+    {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+
+    constexpr _Iterator&
+    operator--()
+      requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
+    {
+      _M_prev();
+      return *this;
+    }
+
+    constexpr _Iterator
+    operator--(int)
+      requires __detail::__cartesian_product_is_bidirectional<_Const, _First, _Vs...>
+    {
+      auto __tmp = *this;
+      --*this;
+      return __tmp;
+    }
+
+    constexpr _Iterator&
+    operator+=(difference_type __x)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    {
+      _M_advance(__x);
+      return *this;
+    }
+
+    constexpr _Iterator&
+    operator-=(difference_type __x)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    { return *this += -__x; }
+
+    constexpr reference
+    operator[](difference_type __n) const
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    { return *((*this) + __n); }
+
+    friend constexpr bool
+    operator==(const _Iterator& __x, const _Iterator& __y)
+      requires equality_comparable<iterator_t<__maybe_const_t<_Const, _First>>>
+    { return __x._M_current == __y._M_current; }
+
+    friend constexpr bool
+    operator==(const _Iterator& __x, default_sentinel_t)
+    {
+      return [&]<size_t... _Is>(index_sequence<_Is...>) {
+	return ((std::get<_Is>(__x._M_current)
+		 == ranges::end(std::get<_Is>(__x._M_parent->_M_bases)))
+		|| ...);
+      }(make_index_sequence<1 + sizeof...(_Vs)>{});
+    }
+
+    friend constexpr auto
+    operator<=>(const _Iterator& __x, const _Iterator& __y)
+      requires __detail::__all_random_access<_Const, _First, _Vs...>
+    { return __x._M_current <=> __y._M_current; }
+
+    friend constexpr _Iterator
+    operator+(_Iterator __x, difference_type __y)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    { return __x += __y; }
+
+    friend constexpr _Iterator
+    operator+(difference_type __x, _Iterator __y)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    { return __y += __x; }
+
+    friend constexpr _Iterator
+    operator-(_Iterator __x, difference_type __y)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    { return __x -= __y; }
+
+    friend constexpr difference_type
+    operator-(const _Iterator& __x, const _Iterator& __y)
+      requires __detail::__cartesian_is_sized_sentinel<_Const, iterator_t, _First, _Vs...>
+    { return __x._M_distance_from(__y._M_current); }
+
+    friend constexpr difference_type
+    operator-(const _Iterator& __i, default_sentinel_t)
+      requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
+    {
+      tuple __end_tuple = [&]<size_t... _Is>(index_sequence<_Is...>) {
+	return tuple{ranges::end(std::get<0>(__i._M_parent->_M_bases)),
+		     ranges::begin(std::get<1 + _Is>(__i._M_parent->_M_bases))...};
+      }(make_index_sequence<sizeof...(_Vs)>{});
+      return __i._M_distance_from(__end_tuple);
+    }
+
+    friend constexpr difference_type
+    operator-(default_sentinel_t, const _Iterator& __i)
+      requires __detail::__cartesian_is_sized_sentinel<_Const, sentinel_t, _First, _Vs...>
+    { return -(__i - default_sentinel); }
+
+    friend constexpr auto
+    iter_move(const _Iterator& __i)
+    { return __detail::__tuple_transform(ranges::iter_move, __i._M_current); }
+
+    friend constexpr void
+    iter_swap(const _Iterator& __l, const _Iterator& __r)
+      requires (indirectly_swappable<iterator_t<__maybe_const_t<_Const, _First>>>
+		&& ...
+		&& indirectly_swappable<iterator_t<__maybe_const_t<_Const, _Vs>>>)
+    {
+      [&]<size_t... _Is>(index_sequence<_Is...>) {
+	(ranges::iter_swap(std::get<_Is>(__l._M_current), std::get<_Is>(__r._M_current)), ...);
+      }(make_index_sequence<1 + sizeof...(_Vs)>{});
+    }
+
+  private:
+    template<size_t _Nm = sizeof...(_Vs)>
+    constexpr void
+    _M_next()
+    {
+      auto& __it = std::get<_Nm>(_M_current);
+      ++__it;
+      if constexpr (_Nm > 0)
+	if (__it == ranges::end(std::get<_Nm>(_M_parent->_M_bases)))
+	  {
+	    __it = ranges::begin(std::get<_Nm>(_M_parent->_M_bases));
+	    _M_next<_Nm - 1>();
+	  }
+    }
+
+    template<size_t _Nm = sizeof...(_Vs)>
+    constexpr void
+    _M_prev()
+    {
+      auto& __it = std::get<_Nm>(_M_current);
+      if (__it == ranges::begin(std::get<_Nm>(_M_parent->_M_bases)))
+	{
+	  __it = __detail::__cartesian_common_arg_end(std::get<_Nm>(_M_parent->_M_bases));
+	  if constexpr (_Nm > 0)
+	    _M_prev<_Nm - 1>();
+	}
+      --__it;
+    }
+
+    template<size_t _Nm = sizeof...(_Vs)>
+    constexpr void
+    _M_advance(difference_type __x)
+      requires __detail::__cartesian_product_is_random_access<_Const, _First, _Vs...>
+    {
+      if (__x == 1)
+	_M_next<_Nm>();
+      else if (__x == -1)
+	_M_prev<_Nm>();
+      else if (__x != 0)
+	{
+	  // Constant time iterator advancement.
+	  auto& __r = std::get<_Nm>(_M_parent->_M_bases);
+	  auto& __it = std::get<_Nm>(_M_current);
+	  if constexpr (_Nm == 0)
+	    {
+#ifdef _GLIBCXX_ASSERTIONS
+	      auto __size = ranges::ssize(__r);
+	      auto __begin = ranges::begin(__r);
+	      auto __offset = __it - __begin;
+	      __glibcxx_assert(__offset + __x >= 0 && __offset + __x <= __size);
+#endif
+	      __it += __x;
+	    }
+	  else
+	    {
+	      auto __size = ranges::ssize(__r);
+	      auto __begin = ranges::begin(__r);
+	      auto __offset = __it - __begin;
+	      __offset += __x;
+	      __x = __offset / __size;
+	      __offset %= __size;
+	      if (__offset < 0)
+		{
+		  __offset = __size + __offset;
+		  --__x;
+		}
+	      __it = __begin + __offset;
+	      _M_advance<_Nm - 1>(__x);
+	    }
+	}
+    }
+
+    template<typename _Tuple>
+    constexpr difference_type
+    _M_distance_from(const _Tuple& __t) const
+    {
+      return [&]<size_t... _Is>(index_sequence<_Is...>) {
+	auto __sum = static_cast<difference_type>(0);
+#ifdef _GLIBCXX_ASSERTIONS
+	if constexpr (integral<difference_type>)
+	  {
+	    bool __overflow
+	      = (__builtin_add_overflow(__sum, _M_scaled_distance<_Is>(__t), &__sum)
+		 || ...);
+	    __glibcxx_assert(!__overflow);
+	  }
+	else
+#endif
+	  __sum = (_M_scaled_distance<_Is>(__t) + ...);
+	return __sum;
+      }(make_index_sequence<1 + sizeof...(_Vs)>{});
+    }
+
+    template<size_t _Nm, typename _Tuple>
+    constexpr difference_type
+    _M_scaled_distance(const _Tuple& __t) const
+    {
+      auto __dist = static_cast<difference_type>(std::get<_Nm>(_M_current)
+						 - std::get<_Nm>(__t));
+#ifdef _GLIBCXX_ASSERTIONS
+      if constexpr (integral<difference_type>)
+	{
+	  bool __overflow = __builtin_mul_overflow(__dist, _M_scaled_size<_Nm+1>(), &__dist);
+	  __glibcxx_assert(!__overflow);
+	}
+      else
+#endif
+	__dist *= _M_scaled_size<_Nm+1>();
+      return __dist;
+    }
+
+    template<size_t _Nm>
+    constexpr difference_type
+    _M_scaled_size() const
+    {
+      if constexpr (_Nm <= sizeof...(_Vs))
+	{
+	  auto __size = static_cast<difference_type>(ranges::size
+						     (std::get<_Nm>(_M_parent->_M_bases)));
+#ifdef _GLIBCXX_ASSERTIONS
+	  if constexpr (integral<difference_type>)
+	    {
+	      bool __overflow = __builtin_mul_overflow(__size, _M_scaled_size<_Nm+1>(), &__size);
+	      __glibcxx_assert(!__overflow);
+	    }
+	  else
+#endif
+	    __size *= _M_scaled_size<_Nm+1>();
+	  return __size;
+	}
+      else
+	return static_cast<difference_type>(1);
+    }
+  };
+
+  namespace views
+  {
+    namespace __detail
+    {
+      template<typename... _Ts>
+	concept __can_cartesian_product_view
+	  = requires { cartesian_product_view<all_t<_Ts>...>(std::declval<_Ts>()...); };
+    }
+
+    struct _CartesianProduct
+    {
+      template<typename... _Ts>
+	requires (sizeof...(_Ts) == 0 || __detail::__can_cartesian_product_view<_Ts...>)
+	constexpr auto
+	operator() [[nodiscard]] (_Ts&&... __ts) const
+	{
+	  if constexpr (sizeof...(_Ts) == 0)
+	    return views::empty<tuple<>>;
+	  else
+	    return cartesian_product_view<all_t<_Ts>...>(std::forward<_Ts>(__ts)...);
+	}
+    };
+
+    inline constexpr _CartesianProduct cartesian_product;
+  }
 #endif // C++23
 } // namespace ranges
 
diff --git a/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc b/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
new file mode 100644
index 00000000000..d6e4b538b20
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
@@ -0,0 +1,186 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <ranges>
+#include <algorithm>
+#include <testsuite_hooks.h>
+#include <testsuite_iterators.h>
+
+namespace ranges = std::ranges;
+namespace views = std::views;
+
+constexpr bool
+test01()
+{
+  int x[] = {1, 2, 3};
+  int y[] = {4, 5, 6};
+  int z[] = {7, 8};
+  int w[] = {9};
+
+  auto v0 = views::cartesian_product();
+  VERIFY( ranges::end(v0) - ranges::begin(v0) == 0 );
+  VERIFY( ranges::size(v0) == 0 );
+  VERIFY( ranges::empty(v0) );
+
+  auto v1 = views::cartesian_product(x);
+  VERIFY( ranges::end(v1) - ranges::begin(v1) == 3 );
+  VERIFY( ranges::size(v1) == 3 );
+  VERIFY( ranges::equal(v1 | views::keys, x) );
+  VERIFY( std::get<0>(v1[0]) == 1 );
+  VERIFY( std::get<0>(v1[1]) == 2 );
+  VERIFY( std::get<0>(v1[2]) == 3 );
+  VERIFY( ranges::equal(v1 | views::reverse | views::keys, x | views::reverse));
+
+  auto v2 = views::cartesian_product(x, y);
+  VERIFY( ranges::size(v2) == 9 );
+  VERIFY( ranges::end(v2) - ranges::begin(v2) == 9 );
+  VERIFY( ranges::equal(v2 | views::keys,   (int[]){1, 1, 1, 2, 2, 2, 3, 3, 3}));
+  VERIFY( ranges::equal(v2 | views::values, (int[]){4, 5, 6, 4, 5, 6, 4, 5, 6}));
+  VERIFY( ranges::equal(v2 | views::reverse | views::keys,   (int[]){3, 3, 3, 2, 2, 2, 1, 1, 1}) );
+  VERIFY( ranges::equal(v2 | views::reverse | views::values, (int[]){6, 5, 4, 6, 5, 4, 6, 5, 4}) );
+
+  auto v3 = views::cartesian_product(x, y, z);
+  VERIFY( ranges::size(v3) == 18 );
+  VERIFY( ranges::equal(v3, (std::tuple<int,int,int>[]){{1,4,7}, {1,4,8}, {1,5,7}, {1,5,8},
+							{1,6,7}, {1,6,8}, {2,4,7}, {2,4,8},
+							{2,5,7}, {2,5,8}, {2,6,7}, {2,6,8},
+							{3,4,7}, {3,4,8}, {3,5,7}, {3,5,8},
+							{3,6,7}, {3,6,8}}) );
+
+  auto v4 = views::cartesian_product(x, y, z, w);
+  VERIFY( ranges::size(v4) == 18 );
+  VERIFY( ranges::equal(v4 | views::elements<3>, views::repeat(9, 18)) );
+
+  auto i4 = v4.begin(), j4 = i4 + 1;
+  VERIFY( j4 > i4 );
+  VERIFY( i4[0] == std::tuple(1, 4, 7, 9) );
+  VERIFY( i4 + 18 == v4.end() );
+  i4 += 5;
+  VERIFY( i4 != v4.begin() );
+  VERIFY( i4 - 5 == v4.begin() );
+  VERIFY( *i4 == std::tuple(1, 6, 8, 9) );
+  VERIFY( i4 - 5 != i4 );
+  i4 -= 3;
+  VERIFY( *i4 == std::tuple(1, 5, 7, 9) );
+  VERIFY( j4 + 1 == i4 );
+  ranges::iter_swap(i4, j4);
+  VERIFY( *j4 == std::tuple(1, 5, 7, 9) );
+  VERIFY( *i4 == std::tuple(1, 4, 8, 9) );
+
+  return true;
+}
+
+void
+test02()
+{
+  int x[] = {1, 2};
+  __gnu_test::test_input_range<int> rx(x);
+  auto v = views::cartesian_product(rx, x);
+  auto i = v.begin();
+  std::default_sentinel_t s = v.end();
+  VERIFY( i != s );
+  VERIFY( std::get<0>(*i) == 1 && std::get<1>(*i) == 1 );
+  ++i;
+  VERIFY( i != s );
+  VERIFY( std::get<0>(*i) == 1 && std::get<1>(*i) == 2 );
+  ++i;
+  VERIFY( i != s );
+  VERIFY( std::get<0>(*i) == 2 && std::get<1>(*i) == 1 );
+  ++i;
+  VERIFY( i != s );
+  VERIFY( std::get<0>(*i) == 2 && std::get<1>(*i) == 2 );
+  ++i;
+  VERIFY( i == s );
+}
+
+void
+test03()
+{
+  int x[2];
+  __gnu_test::test_input_range<int> rx(x);
+  auto v = views::cartesian_product(views::counted(rx.begin(), 2), x);
+  VERIFY( v.size() == 4 );
+  auto i = v.begin();
+  std::default_sentinel_t s = v.end();
+  VERIFY( i - s == -4 );
+  VERIFY( s - i == 4 );
+  ++i;
+  VERIFY( i - s == -3 );
+  VERIFY( s - i == 3 );
+  ++i;
+  VERIFY( i - s == -2 );
+  VERIFY( s - i == 2 );
+  ++i;
+  VERIFY( i - s == -1 );
+  VERIFY( s - i == 1 );
+  ++i;
+  VERIFY( i - s == 0 );
+  VERIFY( s - i == 0 );
+}
+
+void
+test04()
+{
+  // Exhaustively verify correctness of our iterator addition implementation
+  // (which runs in constant time) for this 24-element cartesian_product_view.
+  int x[4], y[3], z[2], w[1];
+  auto v = views::cartesian_product(x, y, z, w);
+
+  auto n = ranges::ssize(v);
+  for (int i = 0; i <= n; i++)
+    for (int j = 0; i + j <= n; j++)
+      {
+	auto b1 = v.begin();
+	for (int k = 0; k < i + j; k++)
+	  ++b1;
+	VERIFY( b1 - v.begin() == i + j );
+	auto b2 = (v.begin() + i) + j;
+	auto b3 = v.begin() + (i + j);
+	VERIFY( b1 == b2 && b2 == b3 );
+
+	auto e1 = v.end();
+	for (int k = 0; k < i + j; k++)
+	  --e1;
+	VERIFY( v.end() - e1 == i + j );
+	auto e2 = (v.end() - i) - j;
+	auto e3 = v.end() - (i + j);
+	VERIFY( e1 == e2 && e2 == e3 );
+      }
+}
+
+void
+test05()
+{
+#if __SIZEOF_INT128__
+  auto r = views::iota(__int128(0), __int128(5));
+#else
+  auto r = views::iota(0ll, 5ll);
+#endif
+  auto v = views::cartesian_product(r, r);
+  VERIFY( ranges::size(v) == 25 );
+  VERIFY( v.end() - v.begin() == 25 );
+  VERIFY( v.begin() + ranges::ssize(v) - v.begin() == 25 );
+}
+
+constexpr bool
+test06()
+{
+  int x[] = {1, 2, 3};
+  auto v = views::cartesian_product(x, views::empty<int>, x);
+  VERIFY( ranges::size(v) == 0 );
+  VERIFY( ranges::begin(v) == ranges::end(v) );
+  VERIFY( ranges::begin(v) - ranges::begin(v) == 0 );
+
+  return true;
+}
+
+int
+main()
+{
+  static_assert(test01());
+  test02();
+  test03();
+  test04();
+  test05();
+  static_assert(test06());
+}