diff --git a/stl/inc/ranges b/stl/inc/ranges
index 76f11b526b..fe82e88999 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -38,6 +38,9 @@ namespace ranges {
     template <class _Ty>
     inline constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;
 
+    template <auto> // _Require_constant<E> is a valid template-id iff E is a constant expression of structural type
+    struct _Require_constant;
+
 #if _HAS_CXX23
     _EXPORT_STD template <range _Rng>
     using const_iterator_t = const_iterator<iterator_t<_Rng>>;
@@ -47,6 +50,34 @@ namespace ranges {
 
     _EXPORT_STD template <range _Rng>
     using range_const_reference_t = iter_const_reference_t<iterator_t<_Rng>>;
+
+    template <range _Ty>
+    inline constexpr auto _Compile_time_max_size =
+        (numeric_limits<_Make_unsigned_like_t<range_difference_t<_Ty>>>::max)();
+
+    template <sized_range _Ty>
+    inline constexpr auto _Compile_time_max_size<_Ty> = (numeric_limits<range_size_t<_Ty>>::max)();
+
+    template <sized_range _Ty>
+        requires requires { typename _Require_constant<_Ty::size()>; }
+    inline constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
+
+    template <class _Ty, size_t _Size>
+    inline constexpr auto _Compile_time_max_size<_Ty[_Size]> = _Size;
+
+    template <class _Ty, size_t _Size>
+    inline constexpr auto _Compile_time_max_size<array<_Ty, _Size>> = _Size;
+
+    template <class _Ty, size_t _Size>
+    inline constexpr auto _Compile_time_max_size<const array<_Ty, _Size>> = _Size;
+
+    template <class _Ty, size_t _Extent>
+        requires (_Extent != dynamic_extent)
+    inline constexpr auto _Compile_time_max_size<span<_Ty, _Extent>> = _Extent;
+
+    template <class _Ty, size_t _Extent>
+        requires (_Extent != dynamic_extent)
+    inline constexpr auto _Compile_time_max_size<const span<_Ty, _Extent>> = _Extent;
 #endif // _HAS_CXX23
 
     // clang-format off
@@ -1828,6 +1859,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
     _EXPORT_STD template <range _Rng>
         requires (movable<_Rng> && !_Is_initializer_list<_Rng>)
     class owning_view : public view_interface<owning_view<_Rng>> {
@@ -1915,6 +1954,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<owning_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<owning_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const owning_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <class _Rng>
         concept _Can_ref_view = requires(_Rng&& __r) { ref_view{static_cast<_Rng&&>(__r)}; };
@@ -2050,6 +2097,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<as_rvalue_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<as_rvalue_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const as_rvalue_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <class _Rng>
         concept _Can_as_rvalue = requires(_Rng&& __r) { as_rvalue_view{static_cast<_Rng&&>(__r)}; };
@@ -2327,6 +2382,11 @@ namespace ranges {
     template <class _Rng, class _Pr>
     filter_view(_Rng&&, _Pr) -> filter_view<views::all_t<_Rng>, _Pr>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    inline constexpr auto _Compile_time_max_size<filter_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Filter_fn {
             // clang-format off
@@ -2757,6 +2817,14 @@ namespace ranges {
     template <class _Rng, class _Fn>
     transform_view(_Rng&&, _Fn) -> transform_view<views::all_t<_Rng>, _Fn>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Fn>
+    inline constexpr auto _Compile_time_max_size<transform_view<_Rng, _Fn>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Fn>
+    inline constexpr auto _Compile_time_max_size<const transform_view<_Rng, _Fn>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Transform_fn {
             // clang-format off
@@ -2970,6 +3038,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<take_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<take_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const take_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <class _Rng>
         concept _Random_sized_range = random_access_range<_Rng> && sized_range<_Rng>;
@@ -3211,6 +3287,14 @@ namespace ranges {
     template <class _Rng, class _Pr>
     take_while_view(_Rng&&, _Pr) -> take_while_view<views::all_t<_Rng>, _Pr>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    inline constexpr auto _Compile_time_max_size<take_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Pr>
+    inline constexpr auto _Compile_time_max_size<const take_while_view<_Rng, _Pr>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Take_while_fn {
             template <viewable_range _Rng, class _Pr>
@@ -3360,6 +3444,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<drop_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<drop_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const drop_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         class _Drop_fn {
         private:
@@ -3525,6 +3617,11 @@ namespace ranges {
     template <class _Rng, class _Pr>
     inline constexpr bool enable_borrowed_range<drop_while_view<_Rng, _Pr>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    inline constexpr auto _Compile_time_max_size<drop_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Drop_while_fn {
             template <viewable_range _Rng, class _Pr>
@@ -3940,6 +4037,30 @@ namespace ranges {
     template <class _Rng>
     explicit join_view(_Rng&&) -> join_view<views::all_t<_Rng>>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    _NODISCARD consteval auto _Join_view_compile_time_max_size() {
+        using _Inner = remove_reference_t<range_reference_t<_Rng>>;
+        using _Size_type =
+            common_type_t<decltype(_Compile_time_max_size<_Rng>), decltype(_Compile_time_max_size<_Inner>)>;
+        _Size_type _Result{};
+        const bool _Overflow = _Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rng>),
+            static_cast<_Size_type>(_Compile_time_max_size<_Inner>), _Result);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<join_view<_Rng>> = _Join_view_compile_time_max_size<_Rng>();
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const join_view<_Rng>> =
+        _Join_view_compile_time_max_size<const _Rng>();
+#endif // _HAS_CXX23
+
     namespace views {
         class _Join_fn : public _Pipe::_Base<_Join_fn> {
         public:
@@ -4447,6 +4568,37 @@ namespace ranges {
     join_with_view(_Rng&&, range_value_t<range_reference_t<_Rng>>)
         -> join_with_view<views::all_t<_Rng>, single_view<range_value_t<range_reference_t<_Rng>>>>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pat>
+    _NODISCARD consteval auto _Join_with_view_compile_time_max_size() {
+        using _Inner     = remove_reference_t<range_reference_t<_Rng>>;
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rng>),
+            decltype(_Compile_time_max_size<_Inner>), decltype(_Compile_time_max_size<_Pat>)>;
+        _Size_type _Joined_max_size{};
+        _Size_type _Pattern_max_size{};
+        _Size_type _Result{};
+        const bool _Overflow =
+            _Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rng>),
+                static_cast<_Size_type>(_Compile_time_max_size<_Inner>), _Joined_max_size)
+            || _Mul_overflow((_STD max)(static_cast<_Size_type>(_Compile_time_max_size<_Rng>), _Size_type{1}) - 1,
+                static_cast<_Size_type>(_Compile_time_max_size<_Pat>), _Pattern_max_size)
+            || _Add_overflow(_Joined_max_size, _Pattern_max_size, _Result);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class _Rng, class _Pat>
+    inline constexpr auto _Compile_time_max_size<join_with_view<_Rng, _Pat>> =
+        _Join_with_view_compile_time_max_size<_Rng, _Pat>();
+
+    template <class _Rng, class _Pat>
+    inline constexpr auto _Compile_time_max_size<const join_with_view<_Rng, _Pat>> =
+        _Join_with_view_compile_time_max_size<const _Rng, const _Pat>();
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Join_with_fn {
             // clang-format off
@@ -4471,9 +4623,6 @@ namespace ranges {
     } // namespace views
 #endif // _HAS_CXX23
 
-    template <auto> // _Require_constant<E> is a valid template-id iff E is a constant expression of structural type
-    struct _Require_constant;
-
     // clang-format off
     template <class _Ty>
     concept _Tiny_range = sized_range<_Ty>
@@ -4868,6 +5017,15 @@ namespace ranges {
     lazy_split_view(_Rng&&, range_value_t<_Rng>)
         -> lazy_split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pat>
+    inline constexpr auto _Compile_time_max_size<lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, class _Pat>
+    inline constexpr auto _Compile_time_max_size<const lazy_split_view<_Rng, _Pat>> =
+        _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Lazy_split_fn {
             // clang-format off
@@ -5064,6 +5222,11 @@ namespace ranges {
     template <forward_range _Rng>
     split_view(_Rng&&, range_value_t<_Rng>) -> split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pat>
+    inline constexpr auto _Compile_time_max_size<split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Split_fn {
             // clang-format off
@@ -5214,6 +5377,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<common_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const common_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         class _Common_fn : public _Pipe::_Base<_Common_fn> {
         private:
@@ -5333,6 +5504,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<reverse_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<reverse_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const reverse_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <class _Rng>
         concept _Can_extract_base = requires(_Rng&& __r) { static_cast<_Rng&&>(__r).base(); };
@@ -5470,6 +5649,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<as_const_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<as_const_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const as_const_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <class _Rng>
         concept _Can_as_const = requires(_Rng&& __r) { as_const_view{static_cast<_Rng&&>(__r)}; };
@@ -5940,6 +6127,15 @@ namespace ranges {
     template <class _Rng, size_t _Index>
     inline constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng, size_t _Index>
+    inline constexpr auto _Compile_time_max_size<elements_view<_Rng, _Index>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng, size_t _Index>
+    inline constexpr auto _Compile_time_max_size<const elements_view<_Rng, _Index>> =
+        _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     _EXPORT_STD template <class _Rng>
     using keys_view = elements_view<_Rng, 0>;
     _EXPORT_STD template <class _Rng>
@@ -6282,6 +6478,14 @@ namespace ranges {
     template <class _Rng>
     inline constexpr bool enable_borrowed_range<enumerate_view<_Rng>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<enumerate_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const enumerate_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         class _Enumerate_fn : public _Pipe::_Base<_Enumerate_fn> {
         public:
@@ -6876,6 +7080,15 @@ namespace ranges {
     template <class _Vw>
     inline constexpr bool enable_borrowed_range<chunk_view<_Vw>> = enable_borrowed_range<_Vw> && forward_range<_Vw>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<chunk_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+        requires forward_range<_Rng>
+    inline constexpr auto _Compile_time_max_size<const chunk_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Chunk_fn {
             // clang-format off
@@ -7268,6 +7481,14 @@ namespace ranges {
     template <class _Vw>
     inline constexpr bool enable_borrowed_range<slide_view<_Vw>> = enable_borrowed_range<_Vw>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<slide_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const slide_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Slide_fn {
             // clang-format off
@@ -7467,6 +7688,11 @@ namespace ranges {
     template <class _Rng, class _Pr>
     chunk_by_view(_Rng&&, _Pr) -> chunk_by_view<views::all_t<_Rng>, _Pr>;
 
+#if _HAS_CXX23
+    template <class _Rng, class _Pr>
+    inline constexpr auto _Compile_time_max_size<chunk_by_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Chunk_by_fn {
             // clang-format off
@@ -7856,6 +8082,14 @@ namespace ranges {
     template <class _Vw>
     inline constexpr bool enable_borrowed_range<stride_view<_Vw>> = enable_borrowed_range<_Vw>;
 
+#if _HAS_CXX23
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<stride_view<_Rng>> = _Compile_time_max_size<_Rng>;
+
+    template <class _Rng>
+    inline constexpr auto _Compile_time_max_size<const stride_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Stride_fn {
             // clang-format off
@@ -8349,6 +8583,21 @@ namespace ranges {
     template <class... _ViewTypes>
     inline constexpr bool enable_borrowed_range<zip_view<_ViewTypes...>> = (enable_borrowed_range<_ViewTypes> && ...);
 
+#if _HAS_CXX23
+    template <class... _Rngs>
+    _NODISCARD consteval auto _Zip_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rngs>)...>;
+        return (_STD min)({static_cast<_Size_type>(_Compile_time_max_size<_Rngs>)...});
+    }
+
+    template <class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<_Rngs...>();
+
+    template <class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<const zip_view<_Rngs...>> =
+        _Zip_view_compile_time_max_size<const _Rngs...>();
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Zip_fn {
         private:
@@ -8687,6 +8936,16 @@ namespace ranges {
     template <class _Func, class... _Ranges>
     zip_transform_view(_Func, _Ranges&&...) -> zip_transform_view<_Func, views::all_t<_Ranges>...>;
 
+#if _HAS_CXX23
+    template <class _Fn, class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<zip_transform_view<_Fn, _Rngs...>> =
+        _Compile_time_max_size<zip_view<_Rngs...>>;
+
+    template <class _Fn, class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<const zip_transform_view<_Fn, _Rngs...>> =
+        _Compile_time_max_size<const zip_view<_Rngs...>>;
+#endif // _HAS_CXX23
+
     namespace views {
         struct _Zip_transform_fn {
         private:
@@ -9143,6 +9402,24 @@ namespace ranges {
     template <class _Rng, size_t _Nx>
     inline constexpr bool enable_borrowed_range<adjacent_view<_Rng, _Nx>> = enable_borrowed_range<_Rng>;
 
+#if _HAS_CXX23
+    template <class _Rng, size_t _Nx>
+    _NODISCARD consteval auto _Adjacent_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Compile_time_max_size<_Rng>), size_t>;
+        auto _Size       = static_cast<_Size_type>(_Compile_time_max_size<_Rng>);
+        _Size -= (_STD min)(_Size, static_cast<_Size_type>(_Nx - 1));
+        return static_cast<_Size_type>(_Size);
+    }
+
+    template <class _Rng, size_t _Nx>
+    inline constexpr auto _Compile_time_max_size<adjacent_view<_Rng, _Nx>> =
+        _Adjacent_view_compile_time_max_size<_Rng, _Nx>();
+
+    template <class _Rng, size_t _Nx>
+    inline constexpr auto _Compile_time_max_size<const adjacent_view<_Rng, _Nx>> =
+        _Adjacent_view_compile_time_max_size<const _Rng, _Nx>();
+#endif // _HAS_CXX23
+
     namespace views {
         template <size_t _Nx>
         class _Adjacent_fn : public _Pipe::_Base<_Adjacent_fn<_Nx>> {
@@ -9478,6 +9755,16 @@ namespace ranges {
         }
     };
 
+#if _HAS_CXX23
+    template <class _Rng, class _Fn, size_t _Nx>
+    inline constexpr auto _Compile_time_max_size<adjacent_transform_view<_Rng, _Fn, _Nx>> =
+        _Compile_time_max_size<adjacent_view<_Rng, _Nx>>;
+
+    template <class _Rng, class _Fn, size_t _Nx>
+    inline constexpr auto _Compile_time_max_size<const adjacent_transform_view<_Rng, _Fn, _Nx>> =
+        _Compile_time_max_size<const adjacent_view<_Rng, _Nx>>;
+#endif // _HAS_CXX23
+
     namespace views {
         template <size_t _Nx>
         class _Adjacent_transform_fn {
@@ -9551,69 +9838,28 @@ namespace ranges {
         }
     }
 
-    template <sized_range _Ty>
-    inline constexpr auto _Compile_time_max_size = (numeric_limits<range_size_t<_Ty>>::max)();
-
-    template <class _Ty>
-    concept _Constant_sized_range =
-        sized_range<_Ty> && requires { typename _Require_constant<remove_reference_t<_Ty>::size()>; };
-
-    template <_Constant_sized_range _Ty>
-    inline constexpr auto _Compile_time_max_size<_Ty> = remove_reference_t<_Ty>::size();
-
-    template <class _Ty, size_t _Size>
-    inline constexpr auto _Compile_time_max_size<array<_Ty, _Size>> = _Size;
-
-    template <class _Ty, size_t _Size>
-    inline constexpr auto _Compile_time_max_size<const array<_Ty, _Size>> = _Size;
-
-    template <class _Ty, size_t _Extent>
-        requires (_Extent != dynamic_extent)
-    inline constexpr auto _Compile_time_max_size<span<_Ty, _Extent>> = _Extent;
-
-    template <class _Ty, size_t _Extent>
-        requires (_Extent != dynamic_extent)
-    inline constexpr auto _Compile_time_max_size<const span<_Ty, _Extent>> = _Extent;
-
-    template <class _Ty>
-    inline constexpr auto _Compile_time_max_size<ref_view<_Ty>> = _Compile_time_max_size<_Ty>;
-
-    template <class _Ty>
-        requires sized_range<const _Ty>
-    inline constexpr auto _Compile_time_max_size<const ref_view<_Ty>> = _Compile_time_max_size<const _Ty>;
-
-    template <class _Ty>
-    inline constexpr auto _Compile_time_max_size<owning_view<_Ty>> = _Compile_time_max_size<_Ty>;
-
-    template <class _Ty>
-        requires sized_range<const _Ty>
-    inline constexpr auto _Compile_time_max_size<const owning_view<_Ty>> = _Compile_time_max_size<const _Ty>;
-
-    template <range _Rng>
-    _NODISCARD consteval int _Cartesian_product_max_size_bit_width() noexcept {
-        if constexpr (sized_range<_Rng>) {
-            if constexpr (requires(range_size_t<_Rng> _Val) { _STD bit_width(_Val); }) {
-                return _STD bit_width(_Compile_time_max_size<_Rng>);
-            } else {
-                return numeric_limits<range_size_t<_Rng>>::digits;
-            }
+    template <class _Rng>
+    _NODISCARD consteval int _Cartesian_product_max_size_bit_width() {
+        using _Size_type = decltype(_Compile_time_max_size<_Rng>);
+        if constexpr (requires(_Size_type _Val) { _STD bit_width(_Val); }) {
+            return _STD bit_width(_Compile_time_max_size<_Rng>);
         } else {
-            return numeric_limits<_Make_unsigned_like_t<range_difference_t<_Rng>>>::digits;
+            return numeric_limits<_Size_type>::digits;
         }
     }
 
-    template <class _First, class... _Rest>
+    template <class... _Rngs>
+        requires (sizeof...(_Rngs) > 0)
     _NODISCARD consteval auto _Cartesian_product_optimal_size_type() noexcept {
-        constexpr int _Optimal_size_type_bit_width =
-            (_Cartesian_product_max_size_bit_width<_First>() + ... + _Cartesian_product_max_size_bit_width<_Rest>());
+        constexpr int _Optimal_size_type_bit_width = (_Cartesian_product_max_size_bit_width<_Rngs>() + ...);
         if constexpr (_Optimal_size_type_bit_width <= 8) {
-            return uint_least8_t{};
+            return uint8_t{};
         } else if constexpr (_Optimal_size_type_bit_width <= 16) {
-            return uint_least16_t{};
+            return uint16_t{};
         } else if constexpr (_Optimal_size_type_bit_width <= 32) {
-            return uint_least32_t{};
+            return uint32_t{};
         } else if constexpr (_Optimal_size_type_bit_width <= 64) {
-            return uint_least64_t{};
+            return uint64_t{};
         } else {
             return _Unsigned128{};
         }
@@ -10037,6 +10283,30 @@ namespace ranges {
     template <class... _Rngs>
     cartesian_product_view(_Rngs&&...) -> cartesian_product_view<views::all_t<_Rngs>...>;
 
+#if _HAS_CXX23
+    template <class... _Rngs>
+    _NODISCARD consteval auto _Cartesian_product_view_compile_time_max_size() {
+        using _Size_type = common_type_t<decltype(_Cartesian_product_optimal_size_type<_Rngs...>()),
+            decltype(_Compile_time_max_size<_Rngs>)...>;
+        _Size_type _Result{1};
+        const bool _Overflow =
+            (_Mul_overflow(static_cast<_Size_type>(_Compile_time_max_size<_Rngs>), _Result, _Result) || ...);
+        if (_Overflow) {
+            return (numeric_limits<_Size_type>::max)();
+        } else {
+            return _Result;
+        }
+    }
+
+    template <class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<cartesian_product_view<_Rngs...>> =
+        _Cartesian_product_view_compile_time_max_size<_Rngs...>();
+
+    template <class... _Rngs>
+    inline constexpr auto _Compile_time_max_size<const cartesian_product_view<_Rngs...>> =
+        _Cartesian_product_view_compile_time_max_size<const _Rngs...>();
+#endif // _HAS_CXX23
+
     namespace views {
         class _Cartesian_product_fn {
         public:
diff --git a/tests/std/test.lst b/tests/std/test.lst
index 3059eef140..9482c7ea7a 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -591,6 +591,7 @@ tests\P2322R6_ranges_alg_fold
 tests\P2374R4_checked_arithmetic_operations
 tests\P2374R4_views_cartesian_product
 tests\P2374R4_views_cartesian_product_death
+tests\P2374R4_views_cartesian_product_recommended_practices
 tests\P2387R3_bind_back
 tests\P2387R3_pipe_support_for_user_defined_range_adaptors
 tests\P2401R0_conditional_noexcept_for_exchange
diff --git a/tests/std/tests/P2374R4_views_cartesian_product/test.cpp b/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
index eedcde49ee..b38606f23d 100644
--- a/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
+++ b/tests/std/tests/P2374R4_views_cartesian_product/test.cpp
@@ -922,57 +922,6 @@ using move_only_view = test::range<Category, const ValTy, IsSized, test::CanDiff
     test::CanCompare{derived_from<Category, forward_iterator_tag>},
     test::ProxyRef{!derived_from<Category, contiguous_iterator_tag>}, test::CanView::yes, test::Copyability::move_only>;
 
-namespace check_recommended_practice_implementation { // MSVC STL specific behavior
-    using ranges::cartesian_product_view, ranges::empty_view, ranges::single_view, views::all_t, ranges::range_size_t,
-        ranges::range_difference_t, ranges::ref_view, ranges::owning_view;
-    using Arr  = array<int, 4>;
-    using Vec  = vector<int>;
-    using Span = span<int, 4>;
-
-    // Computing product for such small array does not require big range_size_t
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Arr>>>) <= sizeof(size_t));
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Arr>, all_t<Arr>>>) <= sizeof(size_t));
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Arr>, all_t<Arr>, all_t<Arr>>>) <= sizeof(size_t));
-
-    // Same thing with range_difference_t<array>
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Arr>>>) <= sizeof(ptrdiff_t));
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Arr>, all_t<Arr>>>) <= sizeof(ptrdiff_t));
-    STATIC_ASSERT(
-        sizeof(range_difference_t<cartesian_product_view<all_t<Arr>, all_t<Arr>, all_t<Arr>>>) <= sizeof(ptrdiff_t));
-
-    // Computing product for such small span does not require big range_size_t
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Span>>>) <= sizeof(size_t));
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Span>, all_t<Span>>>) <= sizeof(size_t));
-    STATIC_ASSERT(
-        sizeof(range_size_t<cartesian_product_view<all_t<Span>, all_t<Span>, all_t<Span>>>) <= sizeof(size_t));
-
-    // Same thing with range_difference_t<span>
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Span>>>) <= sizeof(ptrdiff_t));
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Span>, all_t<Span>>>) <= sizeof(ptrdiff_t));
-    STATIC_ASSERT(
-        sizeof(range_difference_t<cartesian_product_view<all_t<Span>, all_t<Span>, all_t<Span>>>) <= sizeof(ptrdiff_t));
-
-    // Check 'single_view' and 'empty_view'
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<empty_view<int>, single_view<int>>>) <= sizeof(size_t));
-    STATIC_ASSERT(
-        sizeof(range_difference_t<cartesian_product_view<empty_view<int>, single_view<int>>>) <= sizeof(ptrdiff_t));
-
-    // Check 'ref_view<(const) V>' and 'owning_view<V>'
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<ref_view<Arr>, ref_view<const Arr>, owning_view<Arr>>>)
-                  <= sizeof(size_t));
-    STATIC_ASSERT(
-        sizeof(range_difference_t<cartesian_product_view<ref_view<Arr>, ref_view<const Arr>, owning_view<Arr>>>)
-        <= sizeof(ptrdiff_t));
-
-    // One vector should not use big integer-class type...
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Vec>>>) <= sizeof(size_t));
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Vec>>>) <= sizeof(ptrdiff_t));
-
-    // ... but two vectors will
-    STATIC_ASSERT(sizeof(range_size_t<cartesian_product_view<all_t<Vec>, all_t<Vec>>>) > sizeof(size_t));
-    STATIC_ASSERT(sizeof(range_difference_t<cartesian_product_view<all_t<Vec>, all_t<Vec>>>) > sizeof(ptrdiff_t));
-} // namespace check_recommended_practice_implementation
-
 // GH-3733: cartesian_product_view would incorrectly reject a call to size() claiming that big*big*big*0 is not
 // representable as range_size_t because big*big*big is not.
 constexpr void test_gh_3733() {
diff --git a/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/env.lst b/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/env.lst
new file mode 100644
index 0000000000..8ac7033b20
--- /dev/null
+++ b/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\strict_concepts_latest_matrix.lst
diff --git a/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/test.compile.pass.cpp b/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/test.compile.pass.cpp
new file mode 100644
index 0000000000..42f982da64
--- /dev/null
+++ b/tests/std/tests/P2374R4_views_cartesian_product_recommended_practices/test.compile.pass.cpp
@@ -0,0 +1,497 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Check MSVC-STL internal machinery
+
+#include <array>
+#include <cstddef>
+#include <limits>
+#include <ranges>
+#include <span>
+#include <tuple>
+#include <utility>
+
+using namespace std;
+using ranges::_Compile_time_max_size, ranges::cartesian_product_view, ranges::sized_range, ranges::range_difference_t,
+    ranges::range_size_t, views::all_t;
+
+template <class... Rngs>
+using cpv_size_t = range_size_t<cartesian_product_view<Rngs...>>;
+
+template <class... Rngs>
+using cpv_difference_t = range_difference_t<cartesian_product_view<Rngs...>>;
+
+template <class... Rngs>
+using cpv_const_size_t = range_size_t<const cartesian_product_view<Rngs...>>;
+
+template <class... Rngs>
+using cpv_const_difference_t = range_difference_t<const cartesian_product_view<Rngs...>>;
+
+#ifdef _WIN64
+constexpr bool is_64_bit = true;
+#else // ^^^ 64 bit ^^^ / vvv 32 bit vvv
+constexpr bool is_64_bit = false;
+#endif // ^^^ 32 bit ^^^
+
+constexpr void check_array() {
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<int[3]> == 3);
+    static_assert(_Compile_time_max_size<int[9]> == 9);
+
+    // Check '_Compile_time_max_size' type trait for const arrays
+    static_assert(_Compile_time_max_size<const int[3]> == 3);
+    static_assert(_Compile_time_max_size<const int[9]> == 9);
+
+    // Computing cartesian product for small arrays does not require big range_size_t
+    using A1 = all_t<int(&)[4]>;
+    static_assert(sizeof(cpv_size_t<A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<A1, A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<A1, A1, A1>) <= sizeof(size_t));
+
+    // Same thing with range_difference_t<array>
+    static_assert(sizeof(cpv_difference_t<A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<A1, A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<A1, A1, A1>) <= sizeof(ptrdiff_t));
+
+#ifndef __clang__ // TRANSITION, Clang 17
+    // Computing cartesian product for big arrays requires bigger types
+    using A2 = all_t<int(&)[500'000'000]>;
+    static_assert(sizeof(cpv_size_t<A2, A2, A2>) > sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<A2, A2, A2>) > sizeof(ptrdiff_t));
+#endif // __clang__
+}
+
+constexpr void check_std_array() {
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<array<int, 0>> == 0);
+    static_assert(_Compile_time_max_size<array<int, 3>> == 3);
+    static_assert(_Compile_time_max_size<array<int, 9>> == 9);
+
+    // Check '_Compile_time_max_size' type trait for const arrays
+    static_assert(_Compile_time_max_size<const array<int, 0>> == 0);
+    static_assert(_Compile_time_max_size<const array<int, 3>> == 3);
+    static_assert(_Compile_time_max_size<const array<int, 9>> == 9);
+
+    // Computing cartesian product for small arrays does not require big range_size_t
+    using A1 = all_t<array<int, 4>>;
+    static_assert(sizeof(cpv_size_t<A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<A1, A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<A1, A1, A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<A1, A1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<A1, A1, A1>) <= sizeof(size_t));
+
+    // Same thing with range_difference_t<array>
+    static_assert(sizeof(cpv_difference_t<A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<A1, A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<A1, A1, A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<A1, A1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<A1, A1, A1>) <= sizeof(ptrdiff_t));
+
+    // Computing cartesian product for big arrays requires bigger types
+    using A2 = all_t<array<int, 500'000'000>&>;
+    static_assert(sizeof(cpv_size_t<A2, A2, A2>) > sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<A2, A2, A2>) > sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<A2, A2, A2>) > sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<A2, A2, A2>) > sizeof(ptrdiff_t));
+}
+
+constexpr void check_span() {
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<span<int, 0>> == 0);
+    static_assert(_Compile_time_max_size<span<int, 3>> == 3);
+    static_assert(_Compile_time_max_size<span<int, 9>> == 9);
+    static_assert(_Compile_time_max_size<span<int>> == (numeric_limits<span<int>::size_type>::max)());
+
+    // Check '_Compile_time_max_size' type trait for const spans
+    static_assert(_Compile_time_max_size<const span<int, 0>> == 0);
+    static_assert(_Compile_time_max_size<const span<int, 3>> == 3);
+    static_assert(_Compile_time_max_size<const span<int, 9>> == 9);
+    static_assert(_Compile_time_max_size<const span<int>> == (numeric_limits<span<int>::size_type>::max)());
+
+    // Computing cartesian product for small spans does not require big range_size_t
+    using S1 = all_t<span<int, 4>>;
+    static_assert(sizeof(cpv_size_t<S1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<S1, S1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<S1, S1, S1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<S1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<S1, S1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<S1, S1, S1>) <= sizeof(size_t));
+
+    // Same thing with range_difference_t<span>
+    static_assert(sizeof(cpv_difference_t<S1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<S1, S1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<S1, S1, S1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<S1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<S1, S1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<S1, S1, S1>) <= sizeof(ptrdiff_t));
+
+    // Computing cartesian product for big spans requires bigger types
+    using S2 = span<int, 500'000'000>;
+    static_assert(sizeof(cpv_size_t<S2, S2, S2>) > sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<S2, S2, S2>) > sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<S2, S2, S2>) > sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<S2, S2, S2>) > sizeof(ptrdiff_t));
+}
+
+constexpr void check_empty_view() {
+    using ranges::empty_view;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<empty_view<int>> == 0);
+    static_assert(_Compile_time_max_size<empty_view<const int>> == 0);
+    static_assert(_Compile_time_max_size<const empty_view<int>> == 0);
+    static_assert(_Compile_time_max_size<const empty_view<const int>> == 0);
+
+    using E = empty_view<int>;
+    static_assert(sizeof(cpv_size_t<E>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<E>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_size_t<E, E>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<E, E>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<E>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<E>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<E, E>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<E, E>) <= sizeof(ptrdiff_t));
+}
+
+constexpr void check_single_view() {
+    using ranges::single_view;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<single_view<int>> == 1);
+    static_assert(_Compile_time_max_size<single_view<const int>> == 1);
+    static_assert(_Compile_time_max_size<const single_view<int>> == 1);
+    static_assert(_Compile_time_max_size<const single_view<const int>> == 1);
+
+    using S = single_view<int>;
+    static_assert(sizeof(cpv_size_t<S>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<S>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_size_t<S, S>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_difference_t<S, S>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<S>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<S>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_size_t<S, S>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_difference_t<S, S>) <= sizeof(ptrdiff_t));
+}
+
+enum class CheckConstAdaptor : bool { no, yes };
+
+template <template <class, class...> class SimpleRangeAdaptor, CheckConstAdaptor CCA, class... Args>
+constexpr void check_simple_range_adaptor() {
+    using ValTy = tuple<int>; // for ranges::elements_view
+    using V1    = SimpleRangeAdaptor<all_t<array<ValTy, 100>>, Args...>; // owning_view
+    using V2    = SimpleRangeAdaptor<span<ValTy, 500'000'000>, Args...>; // "already view"
+    using V3    = SimpleRangeAdaptor<all_t<array<ValTy, 500'000'000>&>, Args...>; // ref_view
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<V1> == 100);
+    static_assert(_Compile_time_max_size<V2> == 500'000'000);
+    static_assert(_Compile_time_max_size<V3> == 500'000'000);
+
+    static_assert(
+        sized_range<V1> == (sized_range<V2> && sized_range<V3>) ); // If V1 is sized, then all of them should be
+    if constexpr (sized_range<V1>) {
+        static_assert(sizeof(cpv_size_t<V1>) <= sizeof(size_t));
+        static_assert(sizeof(cpv_size_t<V1, V1>) <= sizeof(size_t));
+        static_assert(sizeof(cpv_size_t<V2>) <= sizeof(size_t));
+        static_assert((sizeof(cpv_size_t<V2, V2>) <= sizeof(size_t)) == is_64_bit);
+        static_assert(sizeof(cpv_size_t<V3>) <= sizeof(size_t));
+        static_assert(sizeof(cpv_size_t<V3, V3, V3>) > sizeof(size_t));
+    }
+
+    static_assert(sizeof(cpv_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert((sizeof(cpv_difference_t<V2, V2>) <= sizeof(ptrdiff_t)) == is_64_bit);
+    static_assert(sizeof(cpv_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+
+    static_assert(
+        to_underlying(CCA) == (ranges::range<const V1> && ranges::range<const V2> && ranges::range<const V3>) );
+    if constexpr (to_underlying(CCA)) {
+        static_assert(_Compile_time_max_size<const V1> == 100);
+        static_assert(_Compile_time_max_size<const V2> == 500'000'000);
+        static_assert(_Compile_time_max_size<const V3> == 500'000'000);
+
+        if constexpr (sized_range<const V1>) {
+            static_assert(sizeof(cpv_const_size_t<V1>) <= sizeof(size_t));
+            static_assert(sizeof(cpv_const_size_t<V1, V1>) <= sizeof(size_t));
+        }
+
+        if constexpr (sized_range<const V2>) {
+            static_assert(sizeof(cpv_const_size_t<V2>) <= sizeof(size_t));
+            static_assert(sizeof(cpv_const_size_t<V2, V2, V2>) > sizeof(size_t));
+        }
+
+        if constexpr (sized_range<const V3>) {
+            static_assert(sizeof(cpv_const_size_t<V3>) <= sizeof(size_t));
+            static_assert(sizeof(cpv_const_size_t<V3, V3, V3>) > sizeof(size_t));
+        }
+
+        static_assert(sizeof(cpv_const_difference_t<V1>) <= sizeof(ptrdiff_t));
+        static_assert(sizeof(cpv_const_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+        static_assert(sizeof(cpv_const_difference_t<V2>) <= sizeof(ptrdiff_t));
+        static_assert(sizeof(cpv_const_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+        static_assert(sizeof(cpv_const_difference_t<V3>) <= sizeof(ptrdiff_t));
+        static_assert(sizeof(cpv_const_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+    }
+}
+
+constexpr void check_join_view() {
+    using V1 = ranges::join_view<all_t<array<array<int, 10>, 20>>>;
+    using V2 = ranges::join_view<all_t<array<span<int, 5'000'000>, 100>>>;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<V1> == 200);
+    static_assert(_Compile_time_max_size<V2> == 500'000'000);
+
+    static_assert(sizeof(cpv_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+    static_assert(_Compile_time_max_size<const V1> == 200);
+    static_assert(_Compile_time_max_size<const V2> == 500'000'000);
+
+    static_assert(sizeof(cpv_const_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+#ifdef _WIN64
+    using V3 = ranges::join_view<all_t<span<span<int, 10'000'000'000>, 5'000'000'000>>>;
+    static_assert(_Compile_time_max_size<V3> == (numeric_limits<size_t>::max)());
+    static_assert(sizeof(cpv_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+    static_assert(_Compile_time_max_size<const V3> == (numeric_limits<size_t>::max)());
+    static_assert(sizeof(cpv_const_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+#endif // ^^^ 64 bit ^^^
+}
+
+constexpr void check_join_with_view() {
+    using V1 = ranges::join_with_view<all_t<array<array<int, 3>, 4>>, all_t<array<int, 2>>>;
+    using V2 = ranges::join_with_view<all_t<array<span<int, 100'000>, 100>&>, all_t<array<int, 2>>>;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<V1> == 18);
+    static_assert(_Compile_time_max_size<V2> == 10'000'198);
+
+    static_assert(sizeof(cpv_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+    static_assert(_Compile_time_max_size<const V1> == 18);
+    static_assert(_Compile_time_max_size<const V2> == 10'000'198);
+
+    static_assert(sizeof(cpv_const_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+#ifdef _WIN64
+    using V3 = ranges::join_with_view<span<span<int, 10'000'000'000>, 5'000'000'000>, span<int, 1>>;
+    static_assert(_Compile_time_max_size<V3> == (numeric_limits<size_t>::max)());
+    static_assert(sizeof(cpv_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+    static_assert(_Compile_time_max_size<const V3> == (numeric_limits<size_t>::max)());
+    static_assert(sizeof(cpv_const_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+#endif // ^^^ 64 bit ^^^
+
+    // Check '_Compile_time_max_size' when size of joined range is 0
+    using V4 = ranges::join_with_view<span<span<int, 5>, 0>, span<int, 2>>;
+    static_assert(_Compile_time_max_size<V4> == 0);
+    static_assert(sizeof(cpv_difference_t<V4>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V4, V4, V4>) <= sizeof(ptrdiff_t));
+    static_assert(_Compile_time_max_size<const V4> == 0);
+    static_assert(sizeof(cpv_const_difference_t<V4>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V4, V4, V4>) <= sizeof(ptrdiff_t));
+}
+
+template <template <class...> class ZipAdaptor>
+constexpr void check_zip_adaptor() {
+    using ValTy = int;
+    using V1    = all_t<array<ValTy, 100>>; // owning_view
+    using V2    = span<ValTy, 100'000'000>; // "already view"
+    using V3    = all_t<array<ValTy, 500'000'000>&>; // ref_view
+    using Z1    = ZipAdaptor<V1, V2, V3>;
+    using Z2    = ZipAdaptor<V2, V3>;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<Z1> == 100);
+    static_assert(_Compile_time_max_size<Z2> == 100'000'000);
+
+    static_assert(sizeof(cpv_size_t<Z1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<Z1, Z1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<Z2>) <= sizeof(size_t));
+    static_assert((sizeof(cpv_size_t<Z2, Z2>) <= sizeof(size_t)) == is_64_bit);
+    static_assert(sizeof(cpv_size_t<Z2, Z2, Z2>) > sizeof(size_t));
+
+    static_assert(sizeof(cpv_difference_t<Z1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<Z1, Z1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<Z2>) <= sizeof(ptrdiff_t));
+    static_assert((sizeof(cpv_difference_t<Z2, Z2>) <= sizeof(ptrdiff_t)) == is_64_bit);
+    static_assert(sizeof(cpv_difference_t<Z2, Z2, Z2>) > sizeof(ptrdiff_t));
+
+    static_assert(_Compile_time_max_size<const Z1> == 100);
+    static_assert(_Compile_time_max_size<const Z2> == 100'000'000);
+
+    static_assert(sizeof(cpv_const_size_t<Z1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<Z1, Z1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<Z2>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<Z2, Z2, Z2>) > sizeof(size_t));
+
+    static_assert(sizeof(cpv_const_difference_t<Z1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<Z1, Z1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<Z2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<Z2, Z2, Z2>) > sizeof(ptrdiff_t));
+}
+
+template <template <class, size_t> class AdjacentAdaptor>
+constexpr void check_adjacent_adaptor() {
+    using ValTy = int;
+    using V1    = AdjacentAdaptor<all_t<array<ValTy, 100>>, 1>; // owning_view
+    using V2    = AdjacentAdaptor<span<ValTy, 500'000'000>, 6>; // "already view"
+    using V3    = AdjacentAdaptor<all_t<array<ValTy, 500'000'000>&>, 11>; // ref_view
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<V1> == 100);
+    static_assert(_Compile_time_max_size<V2> == 499'999'995);
+    static_assert(_Compile_time_max_size<V3> == 499'999'990);
+
+    static_assert(sizeof(cpv_size_t<V1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<V1, V1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<V2>) <= sizeof(size_t));
+    static_assert((sizeof(cpv_size_t<V2, V2>) <= sizeof(size_t)) == is_64_bit);
+    static_assert(sizeof(cpv_size_t<V3>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_size_t<V3, V3, V3>) > sizeof(size_t));
+
+    static_assert(sizeof(cpv_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert((sizeof(cpv_difference_t<V2, V2>) <= sizeof(ptrdiff_t)) == is_64_bit);
+    static_assert(sizeof(cpv_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+
+    static_assert(_Compile_time_max_size<const V1> == 100);
+    static_assert(_Compile_time_max_size<const V2> == 499'999'995);
+    static_assert(_Compile_time_max_size<const V3> == 499'999'990);
+
+    static_assert(sizeof(cpv_const_size_t<V1>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<V1, V1>) <= sizeof(size_t));
+
+    static_assert(sizeof(cpv_const_size_t<V2>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<V2, V2, V2>) > sizeof(size_t));
+
+    static_assert(sizeof(cpv_const_size_t<V3>) <= sizeof(size_t));
+    static_assert(sizeof(cpv_const_size_t<V3, V3, V3>) > sizeof(size_t));
+
+    static_assert(sizeof(cpv_const_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V3>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+}
+
+constexpr void check_cartesian_product_view() {
+    using V1 = cartesian_product_view<all_t<array<int, 2>>, all_t<array<float, 3>>, all_t<array<char, 5>>>;
+    using V2 = cartesian_product_view<all_t<array<int, 200'000>&>, all_t<array<float, 300'000>&>, span<char, 500'000>>;
+
+    // Check '_Compile_time_max_size' type trait
+    static_assert(_Compile_time_max_size<V1> == 30);
+    static_assert(_Compile_time_max_size<V2> == 30'000'000'000'000'000);
+
+    static_assert(sizeof(cpv_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert((sizeof(cpv_difference_t<V2>) <= sizeof(ptrdiff_t)) == is_64_bit);
+    static_assert(sizeof(cpv_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+    static_assert(_Compile_time_max_size<const V1> == 30);
+    static_assert(_Compile_time_max_size<const V2> == 30'000'000'000'000'000);
+
+    static_assert(sizeof(cpv_const_difference_t<V1>) <= sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V1, V1>) <= sizeof(ptrdiff_t));
+    static_assert((sizeof(cpv_const_difference_t<V2>) <= sizeof(ptrdiff_t)) == is_64_bit);
+    static_assert(sizeof(cpv_const_difference_t<V2, V2, V2>) > sizeof(ptrdiff_t));
+
+#ifdef _WIN64
+    using V3 = cartesian_product_view<span<int, 10'000'000'000'000>, span<float, 500'000'000'000>,
+        span<char, 900'000'000'000'000>>;
+    static_assert(_Compile_time_max_size<V3> == (numeric_limits<_Unsigned128>::max)());
+    static_assert(sizeof(cpv_difference_t<V3>) > sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+    static_assert(_Compile_time_max_size<const V3> == (numeric_limits<_Unsigned128>::max)());
+    static_assert(sizeof(cpv_const_difference_t<V3>) > sizeof(ptrdiff_t));
+    static_assert(sizeof(cpv_const_difference_t<V3, V3, V3>) > sizeof(ptrdiff_t));
+#endif // ^^^ 64 bit ^^^
+}
+
+struct Pred {
+    bool operator()(auto&&) const; // not defined
+    bool operator()(auto&&, auto&&) const; // not defined
+};
+
+struct Transformer {
+    float operator()(auto&&...) const; // not defined
+};
+
+template <class View>
+using CommonView = ranges::common_view<ranges::take_while_view<View, Pred>>;
+
+template <class View>
+using ElementsView = ranges::elements_view<View, 0>;
+
+template <class... Views>
+using ZipTransformView = ranges::zip_transform_view<Transformer, Views...>;
+
+template <class View, size_t N>
+using AdjacentTransformView = ranges::adjacent_transform_view<View, Transformer, N>;
+
+constexpr bool test() {
+    // Containers
+    check_array();
+    check_std_array();
+    check_span();
+
+    // Range factories
+    check_empty_view();
+    check_single_view();
+
+    // Simple range adaptors (take one range and possibly extra arguments)
+    check_simple_range_adaptor<ranges::as_const_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::as_rvalue_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::chunk_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::chunk_by_view, CheckConstAdaptor::no, Pred>();
+    check_simple_range_adaptor<CommonView, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::drop_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::drop_while_view, CheckConstAdaptor::no, Pred>();
+    check_simple_range_adaptor<ElementsView, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::enumerate_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::filter_view, CheckConstAdaptor::no, Pred>();
+    check_simple_range_adaptor<ranges::lazy_split_view, CheckConstAdaptor::yes, ranges::single_view<tuple<int>>>();
+    check_simple_range_adaptor<ranges::split_view, CheckConstAdaptor::no, ranges::single_view<tuple<int>>>();
+    check_simple_range_adaptor<ranges::owning_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::ref_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::reverse_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::slide_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::stride_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::take_view, CheckConstAdaptor::yes>();
+    check_simple_range_adaptor<ranges::take_while_view, CheckConstAdaptor::yes, Pred>();
+    check_simple_range_adaptor<ranges::transform_view, CheckConstAdaptor::yes, Transformer>();
+
+    check_join_view();
+    check_join_with_view();
+    check_zip_adaptor<ranges::zip_view>();
+    check_zip_adaptor<ZipTransformView>();
+    check_adjacent_adaptor<ranges::adjacent_view>();
+    check_adjacent_adaptor<AdjacentTransformView>();
+    check_cartesian_product_view();
+
+    return true;
+}
+
+static_assert(test());