libstdc++: Implement ranges::cartesian_product_view from P2374R4

This also implements the proposed resolutions of the tentatively ready
LWG issues 3760 and 3761.

I'm not sure how/if we should implement the recommended practice of:

  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 or so, which seems
quite wasteful: in practice the size of the cartesian product probably
won't exceed the precision of say ptrdiff_t, and it's probably also not
worth adding logic for using less precision than that either.  So this
patch chooses 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.  If overflow
occurs due to this choice of difference_type, this patch has debug mode
checks to catch this.

Tested on x86_64-pc-linux-gnu, does this look OK for trunk?

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::_Cartesian_product, views::cartesian_product): Define.
	* testsuite/std/ranges/cartesian_product/1.cc: New test.
---
 libstdc++-v3/include/std/ranges               | 500 ++++++++++++++++++
 .../std/ranges/cartesian_product/1.cc         | 162 ++++++
 2 files changed, 662 insertions(+)
 create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc

On Thu, 27 Oct 2022, Patrick Palka wrote:

> This also implements the proposed resolutions of the tentatively ready
> LWG issues 3760 and 3761.
> 
> I'm not sure how/if we should implement the recommended practice of:
> 
>   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 or so, which seems
> quite wasteful: in practice the size of the cartesian product probably
> won't exceed the precision of say ptrdiff_t, and it's probably also not
> worth adding logic for using less precision than that either.  So this
> patch chooses 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.  If overflow
> occurs due to this choice of difference_type, this patch has debug mode
> checks to catch this.
> 
> Tested on x86_64-pc-linux-gnu, does this look OK for trunk?
> 
> 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::_Cartesian_product, views::cartesian_product): Define.
> 	* testsuite/std/ranges/cartesian_product/1.cc: New test.
> ---
>  libstdc++-v3/include/std/ranges               | 500 ++++++++++++++++++
>  .../std/ranges/cartesian_product/1.cc         | 162 ++++++
>  2 files changed, 662 insertions(+)
>  create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> 
> diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> index a55e9e7f760..771da97ed6d 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,503 @@ 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...>) {
> +#ifdef _GLIBCXX_ASSERTIONS
> +	_ST __sz = 1;
> +	bool __overflow
> +	  = (__builtin_mul_overflow(__sz,
> +				    static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
> +				    &__sz)
> +	     || ...);
> +	__glibcxx_assert(!__overflow);
> +	return __sz;

__builtin_add/mul_overflow can't handle integer-class types so these
debug-mode checks must be disabled for such types.  Here's v2 which
corrects and adds a test for the case where the difference type is
an integer-class type:

-- >8 --

Subject: [PATCH] libstdc++: Implement ranges::cartesian_product_view from
 P2374R4

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::_Cartesian_product, views::cartesian_product): Define.
	* testsuite/std/ranges/cartesian_product/1.cc: New test.
---
 libstdc++-v3/include/std/ranges               | 515 ++++++++++++++++++
 .../std/ranges/cartesian_product/1.cc         | 178 ++++++
 2 files changed, 693 insertions(+)
 create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc

diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index a55e9e7f760..92d15c81e51 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,518 @@ 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;
+
+    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;
+    }
+
+    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;
+    }
+
+  private:
+    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 addition.
+	  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);
+	    }
+	}
+    }
+
+  public:
+    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, const _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<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..5f1610d6458
--- /dev/null
+++ b/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
@@ -0,0 +1,178 @@
+// { dg-options "-std=gnu++23" }
+// { dg-do run { target c++23 } }
+
+#include <ranges>
+#include <algorithm>
+#include <utility>
+#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[] = {1, 2};
+  __gnu_test::test_input_range<int> rx(x);
+  auto v = views::cartesian_product(views::counted(rx.begin(), 2), x);
+  VERIFY( v.size() == 4 );
+  VERIFY( std::as_const(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 18-element cartesian_product_view.
+  int x[] = {1, 2, 3};
+  int y[] = {4, 5, 6};
+  int z[] = {7, 8};
+  int w[] = {9};
+  auto v = views::cartesian_product(x, y, z, w);
+
+  for (int i = 0; i <= ranges::ssize(v); i++)
+    for (int j = 0; i + j <= ranges::ssize(v); 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( ranges::size(std::as_const(v)) == 25 );
+  VERIFY( v.end() - v.begin() == 25 );
+  VERIFY( v.begin() + ranges::size(v) - v.begin() == 25 );
+}
+
+int
+main()
+{
+  static_assert(test01());
+  test02();
+  test03();
+  test04();
+  test05();
+}

On Thu, 27 Oct 2022, Patrick Palka wrote:

> On Thu, 27 Oct 2022, Patrick Palka wrote:
> 
> > This also implements the proposed resolutions of the tentatively ready
> > LWG issues 3760 and 3761.
> > 
> > I'm not sure how/if we should implement the recommended practice of:
> > 
> >   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 or so, which seems
> > quite wasteful: in practice the size of the cartesian product probably
> > won't exceed the precision of say ptrdiff_t, and it's probably also not
> > worth adding logic for using less precision than that either.  So this
> > patch chooses 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.  If overflow
> > occurs due to this choice of difference_type, this patch has debug mode
> > checks to catch this.
> > 
> > Tested on x86_64-pc-linux-gnu, does this look OK for trunk?
> > 
> > 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::_Cartesian_product, views::cartesian_product): Define.
> > 	* testsuite/std/ranges/cartesian_product/1.cc: New test.
> > ---
> >  libstdc++-v3/include/std/ranges               | 500 ++++++++++++++++++
> >  .../std/ranges/cartesian_product/1.cc         | 162 ++++++
> >  2 files changed, 662 insertions(+)
> >  create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> > 
> > diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> > index a55e9e7f760..771da97ed6d 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,503 @@ 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...>) {
> > +#ifdef _GLIBCXX_ASSERTIONS
> > +	_ST __sz = 1;
> > +	bool __overflow
> > +	  = (__builtin_mul_overflow(__sz,
> > +				    static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
> > +				    &__sz)
> > +	     || ...);
> > +	__glibcxx_assert(!__overflow);
> > +	return __sz;
> 
> __builtin_add/mul_overflow can't handle integer-class types so these
> debug-mode checks must be disabled for such types.  Here's v2 which
> corrects and adds a test for the case where the difference type is
> an integer-class type:

Ping.

> 
> -- >8 --
> 
> Subject: [PATCH] libstdc++: Implement ranges::cartesian_product_view from
>  P2374R4
> 
> 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::_Cartesian_product, views::cartesian_product): Define.
> 	* testsuite/std/ranges/cartesian_product/1.cc: New test.
> ---
>  libstdc++-v3/include/std/ranges               | 515 ++++++++++++++++++
>  .../std/ranges/cartesian_product/1.cc         | 178 ++++++
>  2 files changed, 693 insertions(+)
>  create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> 
> diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> index a55e9e7f760..92d15c81e51 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,518 @@ 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;
> +
> +    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;
> +    }
> +
> +    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;
> +    }
> +
> +  private:
> +    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 addition.
> +	  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);
> +	    }
> +	}
> +    }
> +
> +  public:
> +    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, const _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<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..5f1610d6458
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> @@ -0,0 +1,178 @@
> +// { dg-options "-std=gnu++23" }
> +// { dg-do run { target c++23 } }
> +
> +#include <ranges>
> +#include <algorithm>
> +#include <utility>
> +#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[] = {1, 2};
> +  __gnu_test::test_input_range<int> rx(x);
> +  auto v = views::cartesian_product(views::counted(rx.begin(), 2), x);
> +  VERIFY( v.size() == 4 );
> +  VERIFY( std::as_const(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 18-element cartesian_product_view.
> +  int x[] = {1, 2, 3};
> +  int y[] = {4, 5, 6};
> +  int z[] = {7, 8};
> +  int w[] = {9};
> +  auto v = views::cartesian_product(x, y, z, w);
> +
> +  for (int i = 0; i <= ranges::ssize(v); i++)
> +    for (int j = 0; i + j <= ranges::ssize(v); 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( ranges::size(std::as_const(v)) == 25 );
> +  VERIFY( v.end() - v.begin() == 25 );
> +  VERIFY( v.begin() + ranges::size(v) - v.begin() == 25 );
> +}
> +
> +int
> +main()
> +{
> +  static_assert(test01());
> +  test02();
> +  test03();
> +  test04();
> +  test05();
> +}
> -- 
> 2.38.1.175.gdb29e6bbae
> 
>

On Thu, 27 Oct 2022 at 19:48, Patrick Palka via Libstdc++
<libstdc++@gcc.gnu.org> wrote:
>
> On Thu, 27 Oct 2022, Patrick Palka wrote:
>
> > This also implements the proposed resolutions of the tentatively ready
> > LWG issues 3760 and 3761.
> >
> > I'm not sure how/if we should implement the recommended practice of:
> >
> >   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 or so, which seems
> > quite wasteful: in practice the size of the cartesian product probably
> > won't exceed the precision of say ptrdiff_t, and it's probably also not
> > worth adding logic for using less precision than that either.  So this
> > patch chooses 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.  If overflow
> > occurs due to this choice of difference_type, this patch has debug mode


s/debug mode/assertions/ here I think, as _GLIBCXX_ASSERTIONS works
without the rest of debug mode.

Otherwise, the v2 patch looks good. OK for trunk, thanks!




> > checks to catch this.
> >
> > Tested on x86_64-pc-linux-gnu, does this look OK for trunk?
> >
> > 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::_Cartesian_product, views::cartesian_product): Define.
> >       * testsuite/std/ranges/cartesian_product/1.cc: New test.
> > ---
> >  libstdc++-v3/include/std/ranges               | 500 ++++++++++++++++++
> >  .../std/ranges/cartesian_product/1.cc         | 162 ++++++
> >  2 files changed, 662 insertions(+)
> >  create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> >
> > diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> > index a55e9e7f760..771da97ed6d 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,503 @@ 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...>) {
> > +#ifdef _GLIBCXX_ASSERTIONS
> > +     _ST __sz = 1;
> > +     bool __overflow
> > +       = (__builtin_mul_overflow(__sz,
> > +                                 static_cast<_ST>(ranges::size(std::get<_Is>(_M_bases))),
> > +                                 &__sz)
> > +          || ...);
> > +     __glibcxx_assert(!__overflow);
> > +     return __sz;
>
> __builtin_add/mul_overflow can't handle integer-class types so these
> debug-mode checks must be disabled for such types.  Here's v2 which
> corrects and adds a test for the case where the difference type is
> an integer-class type:
>
> -- >8 --
>
> Subject: [PATCH] libstdc++: Implement ranges::cartesian_product_view from
>  P2374R4
>
> 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::_Cartesian_product, views::cartesian_product): Define.
>         * testsuite/std/ranges/cartesian_product/1.cc: New test.
> ---
>  libstdc++-v3/include/std/ranges               | 515 ++++++++++++++++++
>  .../std/ranges/cartesian_product/1.cc         | 178 ++++++
>  2 files changed, 693 insertions(+)
>  create mode 100644 libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
>
> diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> index a55e9e7f760..92d15c81e51 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,518 @@ 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;
> +
> +    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;
> +    }
> +
> +    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;
> +    }
> +
> +  private:
> +    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 addition.
> +         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);
> +           }
> +       }
> +    }
> +
> +  public:
> +    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, const _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<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..5f1610d6458
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/std/ranges/cartesian_product/1.cc
> @@ -0,0 +1,178 @@
> +// { dg-options "-std=gnu++23" }
> +// { dg-do run { target c++23 } }
> +
> +#include <ranges>
> +#include <algorithm>
> +#include <utility>
> +#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[] = {1, 2};
> +  __gnu_test::test_input_range<int> rx(x);
> +  auto v = views::cartesian_product(views::counted(rx.begin(), 2), x);
> +  VERIFY( v.size() == 4 );
> +  VERIFY( std::as_const(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 18-element cartesian_product_view.
> +  int x[] = {1, 2, 3};
> +  int y[] = {4, 5, 6};
> +  int z[] = {7, 8};
> +  int w[] = {9};
> +  auto v = views::cartesian_product(x, y, z, w);
> +
> +  for (int i = 0; i <= ranges::ssize(v); i++)
> +    for (int j = 0; i + j <= ranges::ssize(v); 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( ranges::size(std::as_const(v)) == 25 );
> +  VERIFY( v.end() - v.begin() == 25 );
> +  VERIFY( v.begin() + ranges::size(v) - v.begin() == 25 );
> +}
> +
> +int
> +main()
> +{
> +  static_assert(test01());
> +  test02();
> +  test03();
> +  test04();
> +  test05();
> +}
> --
> 2.38.1.175.gdb29e6bbae
>