[libc++][ranges] Implement P2474R2(`views::repeat`).

[yronglin]

Summary

• Implement https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2474r2.html
• Implement LWG3875(https://cplusplus.github.io/LWG/issue3875).

Depends on D151629

[var-const]

libcxx/include/__ranges/drop_view.h

279

Question: is __is_empty_view necessary here?

283

Nit: in existing files, we try to format the three expressions (the actual return expression and its two duplicates inside the noexcept and the decltype) so that all the three are aligned, making it easier to quickly check that they are exactly the same. Can you format these similarly? Feel free to disable clang-format for those lines if it gets in the way.

285

In the standard, it uses views::repeat rather than repeat_view, is there a reason not to do the same here?

285

Question: the standard instead uses __range.value_, is using begin instead deliberate?

libcxx/include/__ranges/repeat_view.h

44

Hmm, it's move_constructible in the latest draft of the Standard. Is landing https://reviews.llvm.org/D151629 a prerequisite to do that?

46

The latest draft of the Standard uses integer-like-with-usable-difference-type which seems to have a couple more conditions. If this is deliberate, can you please add a comment with a TODO?

46

Question: can _Bound be a user-defined type?

55

requires copy_constructible<T>?

58

must be greater than or equal to 0

69

Perhaps we could add an assertion for the The behavior is undefined if Bound is not unreachable_sentinel_t and bound_ is negative clause?

110

Question: this is already asserted in the constructor of the view. What is the situation where it needs to be asserted again when creating the iterator?

134

Perhaps assert on Preconditions: If Bound is not unreachable_sentinel_t, current_ > 0?

libcxx/test/libcxx/ranges/range.factories/range.repeat.view/ctor.value.bound.verify.cpp

20 ↗

(On Diff #507729)

We need to check both constructors (and the iterator's constructor if we keep the assertion there).

libcxx/test/std/ranges/range.adaptors/range.drop/adaptor.pass.cpp

224

Ultranit: s/returns an/return a/.

224

Ultranit: can you also put backticks around repeat_view and sized_range (here and in the similar comment below)? Otherwise it's a little inconsistent.

224

Can you also add a static_assert to show that the view models sized_range (and similarly doesn't model sized_range below)?

233

Ultranit: s/not models/doesn't model/.

libcxx/test/std/ranges/range.factories/range.repeat.view/begin.pass.cpp

19

Can you add a short comment to each test case to briefly explain what it does? It makes tests much easier to read.

45

Nit: I'd suggest s/1024/10/ here to make it more obvious that this test case checks for the same thing as the previous one but for a const repeat_view.

55

Same comment re. s/33/20/ as above.

libcxx/test/std/ranges/range.factories/range.repeat.view/ctad.compile.pass.cpp

16

Nit: <cassert> can be removed.

22

Ultranit: if the space between the two closing angle brackets is deliberate, then perhaps also add a space after the corresponding opening angle bracket?

26

Nit: I'd just use Empty() for this line and the line below -- we already checked the references deduce to a non-reference type above, and these 3 lines seem focused on how the bound is deduced.

30

Nit: this main is unnecessary.

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.default.pass.cpp

19

These preceding underscores are unnecessary -- we only use them within the library to make sure the names of our variables/functions/etc. cannot clash with user-defined macros. It also creates an impression that the tests below are accessing some internal state.

(honestly, I'd even remove the trailing underscore but that's a matter of taste. Personally, I only use it for private variables)

24

Optional: since this struct is only used to do a compile-time check, you could remove the member variable and just have the constructor defined as Int(int) {}.

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.piecewise.pass.cpp

81

Can we also test that the view is not constructible when given a tuple that can be used to construct A and a tuple that cannot be used to construct the bound?

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.value.bound.pass.cpp

39

Nit: consider replacing specific with user-provided, explicitly provided or similar.

59

Nit: this e is const but similar ones below aren't, can this be consistent?

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

12

Nit: I think this should return unreachable_sentinel_t and be noexcept.

18

Nit: <utility> seems unused, but unreachable_sentinel_t requires <iterator>.

31

Question: do we have a test where we iterate over a whole bounded view, i.e. go from begin to end and make sure the same value is repeated?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/compare.pass.cpp

19

Can you add comments to each test case?

33

I think we should also check the generated comparison operators (unless there's precedent for not doing so in existing tests).

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/ctor.default.pass.cpp

18

Question: is the default constructor guaranteed to be nothrow?

20

Nit: in new code, we prefer to use [[maybe_unused]] instead of a void cast.

20

Are there any properties of a default-constructed iterator that we could check? It it perhaps equal to end()?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/decrement.pass.cpp

23

Rather than comparing the two iterators, consider comparing the return values to rv.begin() + some-index, i.e. something like assert(iter1-- == rv.begin() + 9);.

31

Can you check the exact type? That would be more specific and replace all the 3 static_asserts.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/increment.pass.cpp

34

Nit: the static assertions below that check for the exact type make these redundant.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/member_typedefs.compile.pass.cpp

54

Would it be possible to use std::uint64_t or similar?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus.pass.cpp

24

(applies throughout) If the iterator is random access, can you avoid using next and just do v.begin() + 10?

27

Nit: I don't think this check adds much value.

28

Nit: consider using next from begin instead.

30

Nit: if possible, it's better to check for the exact return type (applies throughout).

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus_eq.pass.cpp

24

Same comments as the minus.pass.cpp file.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/plus.pass.cpp

27

Same comments as for operator- -- I think it's better to compare to v.begin() + N.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/star.pass.cpp

19

Can you add test cases to check a view that has bounds? I'd check a one-element view and a view of several elements.

24

Nit: I don't think it's necessary to use addressof in a test, it's used to make sure we don't have to deal with an overloaded operator& which cannot be the case here.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/subscript.pass.cpp

22

Nit: use std::ranges::all_of?

libcxx/test/std/ranges/range.factories/range.repeat.view/size.pass.cpp

12

Nit: s/see below/(!same_as<Bound, unreachable_sentinel_t>);/.

18

Nit: can these be sorted? (And I think also s/<utility>/<iterator>/)

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

12

Nit: it would be helpful to have the constraints here as well.

41

Please add tests for piping the view with other views, see various adaptor.pass.cpp tests for examples.

[yronglin]

Address comments.
Implement LWG3875(https://cplusplus.github.io/LWG/issue3875).

[yronglin]

Sorry for the late reply and thanks a lot for your review! @var-const

libcxx/docs/FeatureTestMacroTable.rst

343

This value is incorrect.

libcxx/docs/Status/Cxx2bPapers.csv

80 ↗

(On Diff #507729)

done.

libcxx/include/__ranges/drop_view.h

279

We don't need __is_empty_view here, I'll remove that.

283

Thanks for your tips, add // clang format off here.

285

I used ranges::begin previously, because __range.__value_ was a private member of repeat_view. Nowadays, I make the std::views::__take::__fn and std::views::__drop::__fn as the friend of repeat_view, so we can access the private member __range.__value_. WDYT?

285

done, use views::repeat.

libcxx/include/__ranges/repeat_view.h

44

Yes!

46

LWG3875(https://cplusplus.github.io/LWG/issue3875) introduced integer-like-with-usable-difference-type , I think this patch need update to apply this change.

46

Question: can _Bound be a user-defined type?

As far as I know, _Bound can not be a user-define type.

55

The constraint requires copy_constructible<T> introduced by https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2494r2.html#wording-range.adjacent.transform.view . Once D151629 landed, I'll add requires copy_constructible<T>.

69

done!

110

Good catch! I think it's unnecessary, I'll remove it.

libcxx/include/__ranges/take_view.h

34

Sorry, somehow I have missed this, I've added __fwd/repeat_view.h now.

libcxx/test/std/ranges/range.factories/range.repeat.view/ctad.compile.pass.cpp

22

Thanks, I'll remove this whitespace

30

Thanks, removed.

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

31

Good catch, I'll try to add a new test case.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/compare.pass.cpp

33

Thanks, I'll add test to check the generated comparison operators.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/ctor.default.pass.cpp

18

Nope, I have not found any words that guaranteed the default ctor to be nothrow in the latest draft, I'll try to use std::is_default_constructible_v.

20

IMO, if we want to check the properties of a default-constructed iterator, we can only check the __current_ = _IndexT()

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/decrement.pass.cpp

23

agree

31

agree

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/member_typedefs.compile.pass.cpp

54

done

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus.pass.cpp

27

Thanks, removed.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/subscript.pass.cpp

22

done!

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

12

done.

libcxx/utils/generate_feature_test_macro_components.py

562

Oops, this value should be False.

[yronglin]

Try fix ci.

[yronglin]

Fix ci

[yronglin]

Try fix ci

[yronglin]

Try fix ci

[yronglin]

Rebase

[yronglin]

Try fix ci

[yronglin]

Fix ci

[yronglin]

Fix ci

[yronglin]

Update comments in test

[var-const]

libcxx/include/__fwd/repeat_view.h

45 ↗

(On Diff #529949)

Does __fn have to be here and not in the main repeat_view.h file? It's not a forward declaration, it's a definition.

libcxx/include/__ranges/drop_view.h

285

I think staying close to the standard is preferable here (having to use friends is a little unfortunate, but seems like the right tradeoff).

libcxx/test/std/ranges/range.factories/range.repeat.view/begin.pass.cpp

45

Seems not done -- I'd prefer the two test cases to only differ in whether the rv variable is const or not, but otherwise use same values (0 and 10 in this case).

55

Seems not done.

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

31

Quick question, which file contains the newly-added test case?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/member_typedefs.compile.pass.cpp

18

Nit: s/bellow/below/.

47

Can this check be ==? If I'm reading the wording correctly, if index-type is signed, then difference_type is the same type as index-type, so std::int8_t in this case?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus.pass.cpp

24

Still not done -- I think you can completely remove next from this file and just use arithmetic operations on iterators.

56

This is brittle. Can we check against something like ptrdiff_t instead of "concrete" types? If not, I'd rather remove the check than do platform-specific definitions.

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus_eq.pass.cpp

21

You can probably remove this next (similarly in other iterator test files).

30

Missing calls to test().

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/star.pass.cpp

37

Can you also check the value of iter?

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

41

For consistency, please make sure we have the same coverage as various other adaptor.pass.cpp test files. See e.g. test/std/ranges/range.adaptors/range.split/adaptor.pass.cpp and make sure all the relevant test cases from that file are also applied to repeat_view.

[yronglin]

Rebase and apply P2494R2

[yronglin]

Merge fwd/repeat_view.h and ranges/repeat_view.h, and address comments.

[yronglin]

Thanks for your review @var-const !

libcxx/include/__fwd/repeat_view.h

45 ↗

(On Diff #529949)

Yeah, because in drop_view.h and take_view.h called views::repeat(...), should we merge this file and the main repeat_view.h ?

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

31

In star.pass.cpp, I'd be glad to add a range-based-for in this file?

for (const auto &v : repeat_view) {
   assert(v == some_value);
}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus.pass.cpp

24

sorry, I missed it earlier

56

I agree ptrdiff_t is better

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

41

Okay, I have add test for repeat_view piping with adaptors, except join_view.

[yronglin]

Try fix ci

[yronglin]

fix ci

[yronglin]

Fix ci

[yronglin]

libcxx/include/__ranges/take_view.h

34

@philnik I have tried to forward-declare repeat_view in __fwd/repeat_view.h before Diff 43, but in the standard, it uses views::repeat rather than repeat_view in take_view.h and drop_view.h, so we have to definition but not forward-declaration the __cpo struct in __fwd/repeat_view.h, and I have merged __fwd/repeat_view.h into the main __ranges/repeat_view.h. If this was not a correct approach, I'm glad to split a forward-declaration file again.

[yronglin]

friendly ping~

[var-const]

In D141699#4485284, @yronglin wrote:

friendly ping~

I'll take a look today or tomorrow, real sorry about the slow review!

[yronglin]

In D141699#4490495, @var-const wrote:

In D141699#4485284, @yronglin wrote:

friendly ping~

I'll take a look today or tomorrow, real sorry about the slow review!

Thanks a lot and no worries about that!

[var-const]

LGTM with the remaining comments addressed (and a green CI). Feel free to ping me directly if you have any questions re. my comments. Thanks!

libcxx/include/__fwd/repeat_view.h

45 ↗

(On Diff #529949)

Honestly, I don't have a strong preference here. @philnik What do you think? I don't think we had a precedent for defining the function objects in a fwd file (and IMO it makes it not really a forward file), so it feels perhaps a little "inelegant" (to me). Do you think this results in a meaningful reduction of compilation times?

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

183

Ultranit: s/return/returns/ (here and below, and same in the range.drop test)

libcxx/test/std/ranges/range.factories/range.repeat.view/begin.pass.cpp

19

For each test case, can you add a very short comment to explain which case it's testing?

{ // `(value)` constructor, non-const view
  std::ranges::repeat_view<int> rv(0);
  std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
  assert(*iter == 0);
}
{ // `(value)` constructor, const view
  const std::ranges::repeat_view<int> rv(0);
  std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
  assert(*iter == 0);
}
// ...

30

Hmm, does this case differ from std::ranges::repeat_view<int> rv(0); other than in which value is being repeated? (same for the const version below)

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

31

Yes, can you please add the test case to star.pass.cpp?

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/plus_eq.pass.cpp

26

This next can be replaced by arithmetics.

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

41

I think testing with just a couple of different adaptors (e.g. drop and transform) is completely sufficient -- I'd remove the rest because it will be hard to maintain going forward.

102

There is no need to check all the possible view combinations, it would be hard to maintain and I don't think it meaningfully increases test coverage.

[philnik]

libcxx/include/__fwd/repeat_view.h

45 ↗

(On Diff #529949)

I don't think it worth it. We might consider this a problem once we remove transitive includes, but until then any avoided includes should be kept to the big gains IMO. I really hope we will do a big cleanup soon. Looking at the amount of includes removed from old standards in this and the last release makes it look like it's just a matter of time before we have to anyways.

[philnik]

I'm trusting @var-const here. I don't really have the time to do another deep dive here.

[yronglin]

Address comments

[yronglin]

Thanks for your review! @var-const @philnik

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

183

Thanks! done.

libcxx/test/std/ranges/range.factories/range.repeat.view/begin.pass.cpp

19

done

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

31

Thanks, added!

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/plus_eq.pass.cpp

26

Sorry, somehow, I have missed this before.

[Mordante]

I mainly skimmed over it. I trust @philnik and @var-const to have done a deeper review; they are more familiar with the ranges details.

[yronglin]

NFC, Use + instead of std::ranges::next in tests.

[yronglin]

In D141699#4510812, @Mordante wrote:

I mainly skimmed over it. I trust @philnik and @var-const to have done a deeper review; they are more familiar with the ranges details.

Thanks a lot for your review!

[yronglin]

Waiting for CI green

[yronglin]

NFC, fix ci, use _LIBCPP_ENABLE_DEBUG_MODE instead of _LIBCPP_ENABLE_ASSERTIONS

[var-const]

In D141699#4513287, @yronglin wrote:

NFC, fix ci, use _LIBCPP_ENABLE_DEBUG_MODE instead of _LIBCPP_ENABLE_ASSERTIONS

Rather than explicitly enabling debug mode (which will fail in the hardened mode test), please add // UNSUPPORTED: !libcpp-has-hardened-mode && !libcpp-has-debug-mode

[yronglin]

Address comments

[yronglin]

In D141699#4513484, @var-const wrote:

In D141699#4513287, @yronglin wrote:

NFC, fix ci, use _LIBCPP_ENABLE_DEBUG_MODE instead of _LIBCPP_ENABLE_ASSERTIONS

Rather than explicitly enabling debug mode (which will fail in the hardened mode test), please add // UNSUPPORTED: !libcpp-has-hardened-mode && !libcpp-has-debug-mode

Thanks for your advice, fixed.

[yronglin]

Rebase

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_ranges_chunk``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_chunk_by``                     *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_iota``                         *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_join_with``                    *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_ranges_repeat``                       *unimplemented*
+    ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_slide``                        *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_starts_ends_with``             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_to_container``                 *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges_zip``                          *unimplemented*
     ------------------------------------------------- -----------------

libcxx/docs/Status/RangesViews.csv

 C++20,`counted <https://wg21.link/P0896R4>`_,Zoe Carver,`D106923 <https://llvm.org/D106923>`_,✅
 C++20,`common <https://wg21.link/P0896R4>`_,Zoe Carver,`D105753 <https://llvm.org/D105753>`_,✅
 C++20,`reverse <https://wg21.link/P0896R4>`_,Zoe Carver,`D107096 <https://llvm.org/D107096>`_,✅
 C++20,`elements / keys / values <https://wg21.link/P1035R7>`_,Hui Xie,`D136268 <https://llvm.org/D136268>`_,✅
 C++20,`istream <https://wg21.link/P1035R7>`_,Hui Xie,`D133317 <https://llvm.org/D133317>`_,✅
 ,,,,
 ,,,,
 ,,,,
-C++23,`repeat <https://wg21.link/P2474R2>`_,Unassigned,No patch yet,Not started
+C++23,`repeat <https://wg21.link/P2474R2>`_,Yrong,`D141699 <https://llvm.org/D141699>`_,✅ 
 C++23,`cartesian_product <https://wg21.link/P2374R4>`_,Unassigned,No patch yet,Not started
 C++23,`zip <https://wg21.link/P2321R2>`_,Hui Xie,`D122806 <https://llvm.org/D122806>`_,✅
 C++23,`zip_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`adjacent_transform <https://wg21.link/P2321R2>`_,Hui Xie,No patch yet,Not started
 C++23,`join_with <https://wg21.link/P2441R2>`_,Unassigned,No patch yet,Not started
 C++23,`slide <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk <https://wg21.link/P2442R1>`_,Unassigned,No patch yet,Not started
 C++23,`chunk_by <https://wg21.link/P2443R1>`_,Unassigned,No patch yet,Not started
 C++23,`as_const <https://wg21.link/P2278R4>`_,Unassigned,No patch yet,Not started
 C++23,`as_rvalue <https://wg21.link/P2446R2>`_,Nikolas Klauser,`D137637 <https://llvm.org/D137637>`_,Complete
 C++23,`stride <https://wg21.link/P1899R3>`_,Unassigned,No patch yet,Not started

libcxx/include/CMakeLists.txt

set(files
   __ranges/join_view.h
   __ranges/lazy_split_view.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.h
+  __ranges/repeat_view.h
   __ranges/reverse_view.h
   __ranges/single_view.h
   __ranges/size.h
   __ranges/split_view.h
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/take_while_view.h
   __ranges/transform_view.h

libcxx/include/__ranges/drop_view.h

 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
+#include <__ranges/repeat_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <type_traits>
 

 
 template <class _Tp>
 inline constexpr bool __is_empty_view = false;
 
 template <class _Tp>
 inline constexpr bool __is_empty_view<empty_view<_Tp>> = true;
 
 template <class _Tp>
+inline constexpr bool __is_repeat_view = false;
+
+template <class _Tp, class _BoundSentinel>
+inline constexpr bool __is_repeat_view<repeat_view<_Tp, _BoundSentinel>> = true;
+
+template <class _Tp>
 inline constexpr bool __is_passthrough_specialization = false;
 
 template <class _Tp, size_t _Extent>
 inline constexpr bool __is_passthrough_specialization<span<_Tp, _Extent>> = true;
 
 template <class _CharT, class _Traits>
 inline constexpr bool __is_passthrough_specialization<basic_string_view<_CharT, _Traits>> = true;
 
-template <class _Np, class _Bound>
-inline constexpr bool __is_passthrough_specialization<iota_view<_Np, _Bound>> = true;
+template <class _Np, class _BoundSentinel>
+inline constexpr bool __is_passthrough_specialization<iota_view<_Np, _BoundSentinel>> = true;
 
 template <class _Iter, class _Sent, subrange_kind _Kind>
 inline constexpr bool __is_passthrough_specialization<subrange<_Iter, _Sent, _Kind>> =
     !subrange<_Iter, _Sent, _Kind>::_StoreSize;
 
 template <class _Tp>
 inline constexpr bool __is_subrange_specialization_with_store_size = false;
 
-> decltype(      _RawRange(
       auto __dist = ranges::distance(__rng);
       auto __clamped = std::min<_Dist>(__dist, std::forward<_Np>(__n));
       return          _RawRange(
                               ranges::begin(__rng) + __clamped,
                               ranges::end(__rng),
                               std::__to_unsigned_like(__dist - __clamped)
                               );}
 
+  // [range.drop.overview]: the `repeat_view` "_RawRange models sized_range" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires (!__is_empty_view<_RawRange> &&
+              __is_repeat_view<_RawRange> &&
+              sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const noexcept(
+      noexcept(views::repeat(*ranges::begin(__range),
+                         ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+      -> decltype(views::repeat(*ranges::begin(__range),
+                            ranges::distance(__range) -
+                                std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))) {
+      return views::repeat(*ranges::begin(__range),
+                       ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)));
+  }
+
+  // [range.drop.overview]: the `repeat_view` "otherwise" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires (!__is_empty_view<_RawRange> &&
+              __is_repeat_view<_RawRange> &&
+              !sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Np&&) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
+    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+
   // [range.drop.overview]: the "otherwise" case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>>
     // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
     // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
+    requires (!(__is_empty_view<_RawRange> || __is_repeat_view<_RawRange> ||
                (__is_subrange_specialization_with_store_size<_RawRange> &&
                sized_range<_RawRange> &&
                 random_access_range<_RawRange>) ||
                (__is_passthrough_specialization<_RawRange> &&
                 sized_range<_RawRange> &&
                 random_access_range<_RawRange>)
              ))
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/repeat_view.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_REPEAT_VIEW_H
+#define _LIBCPP___RANGES_REPEAT_VIEW_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/same_as.h>
+#include <__concepts/semiregular.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/unreachable_sentinel.h>
+#include <__memory/addressof.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/iota_view.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/view_interface.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
+#include <type_traits>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <copy_constructible _Tp, semiregular _BoundSentinel>
+  requires __integer_like<_BoundSentinel> || same_as<_BoundSentinel, unreachable_sentinel_t>
+class __repeat_view_iterator;
+
+template <copy_constructible _Tp, semiregular _BoundSentinel = unreachable_sentinel_t>
+  requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
+           (__integer_like<_BoundSentinel> || same_as<_BoundSentinel, unreachable_sentinel_t>))
+class repeat_view : public view_interface<repeat_view<_Tp, _BoundSentinel>> {
+  using __iterator = __repeat_view_iterator<_Tp, _BoundSentinel>;
+
+  template <copy_constructible _ValueType, semiregular _BoundSentinelType>
+    requires __integer_like<_BoundSentinelType> || same_as<_BoundSentinelType, unreachable_sentinel_t>
+  friend class __repeat_view_iterator;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI repeat_view()
+    requires default_initializable<_Tp>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(const _Tp& __value,
+                                                       _BoundSentinel __bound_sentinel = _BoundSentinel())
+      : __value_(std::in_place, __value), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_BoundSentinel, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__bound_ >= 0, "The value of bound must greater equal than 0");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(_Tp&& __value,
+                                                       _BoundSentinel __bound_sentinel = _BoundSentinel())
+      : __value_(std::in_place, std::move(__value)), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_BoundSentinel, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__bound_ >= 0, "The value of bound must greater equal than 0");
+  }
+
+  template <class... _TpArgs, class... _BoundSentinelArgs>
+    requires constructible_from<_Tp, _TpArgs...> && constructible_from<_BoundSentinel, _BoundSentinelArgs...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(
+      piecewise_construct_t, tuple<_TpArgs...> __value_args, tuple<_BoundSentinelArgs...> __bound_args = tuple<>{})
+      : __value_(std::in_place, std::make_from_tuple<_Tp>(std::move(__value_args))),
+        __bound_(std::make_from_tuple<_BoundSentinel>(std::move(__bound_args))) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator(std::addressof(*__value_)); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
+    requires(!same_as<_BoundSentinel, unreachable_sentinel_t>)
+  {
+    return __iterator(std::addressof(*__value_), __bound_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr unreachable_sentinel_t end() const noexcept { return unreachable_sentinel; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(!same_as<_BoundSentinel, unreachable_sentinel_t>)
+  {
+    return std::__to_unsigned_like(__bound_);
+  }
+
+private:
+  __copyable_box<_Tp> __value_                      = __copyable_box<_Tp>(std::in_place, _Tp());
+  _LIBCPP_NO_UNIQUE_ADDRESS _BoundSentinel __bound_ = _BoundSentinel();
+};
+
+template <class _Tp, class _BoundSentinel>
+repeat_view(_Tp, _BoundSentinel) -> repeat_view<_Tp, _BoundSentinel>;
+
+// [range.repeat.iterator]
+template <copy_constructible _Tp, semiregular _BoundSentinel>
+  requires __integer_like<_BoundSentinel> || same_as<_BoundSentinel, unreachable_sentinel_t>
+class __repeat_view_iterator {
+  template <copy_constructible _ValueType, semiregular _BoundSentinelType>
+    requires(is_object_v<_ValueType> && same_as<_ValueType, remove_cv_t<_ValueType>> &&
+             (__integer_like<_BoundSentinelType> || same_as<_BoundSentinelType, unreachable_sentinel_t>))
+  friend class repeat_view;
+
+  using _IndexT = conditional_t<same_as<_BoundSentinel, unreachable_sentinel_t>, ptrdiff_t, _BoundSentinel >;
+
+  constexpr explicit __repeat_view_iterator(const _Tp* __value, _IndexT __bound_sentinel = _IndexT())
+      : __value_(__value), __current_(__bound_sentinel) {
+    if constexpr (!same_as<_BoundSentinel, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ >= 0, "The value of bound must greater equal than 0");
+  }
+
+public:
+  using iterator_concept  = random_access_iterator_tag;
+  using iterator_category = random_access_iterator_tag;
+  using value_type        = _Tp;
+  using difference_type   = conditional_t<__signed_integer_like<_IndexT>, _IndexT, _IotaDiffT<_IndexT> >;
+
+  _LIBCPP_HIDE_FROM_ABI __repeat_view_iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator operator++(int) {
+    auto tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator--() {
+    --__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator operator--(int) {
+    auto tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator+=(difference_type __n) {
+    if constexpr (!same_as<_BoundSentinel, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ + __n >= 0, "The value of bound must greater equal than 0");
+    __current_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator-=(difference_type __n) {
+    if constexpr (!same_as<_BoundSentinel, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ - __n >= 0, "The value of bound must greater equal than 0");
+    __current_ -= __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](difference_type __n) const noexcept { return *(*this + __n); }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const __repeat_view_iterator& __x, const __repeat_view_iterator& __y) {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto
+  operator<=>(const __repeat_view_iterator& __x, const __repeat_view_iterator& __y) {
+    return __x.__current_ <=> __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator+(__repeat_view_iterator __i, difference_type __n) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator+(difference_type __n, __repeat_view_iterator __i) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator-(__repeat_view_iterator __i, difference_type __n) {
+    __i -= __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+  operator-(const __repeat_view_iterator& __x, const __repeat_view_iterator& __y) {
+    return static_cast<difference_type>(__x.__current_) - static_cast<difference_type>(__y.__current_);
+  }
+
+private:
+  const _Tp* __value_ = nullptr;
+  _IndexT __current_  = _IndexT();
+};
+
+namespace views {
+namespace __repeat {
+
+template <class _Tp>
+concept __can_unbound_repeat_view = requires { repeat_view(std::declval<_Tp>()); };
+
+template <class _Tp, class _BoundSentinel>
+concept __can_bound_repeat_view = requires { repeat_view(std::declval<_Tp>(), std::declval<_BoundSentinel>()); };
+
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Tp>
+    requires __can_unbound_repeat_view<_Tp>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value) const
+      noexcept(noexcept(ranges::repeat_view(std::forward<_Tp>(__value))))
+          -> decltype(ranges::repeat_view(std::forward<_Tp>(__value))) {
+    return ranges::repeat_view(std::forward<_Tp>(__value));
+  }
+
+  template <class _Tp, class _BoundSentinel>
+    requires __can_bound_repeat_view<_Tp, _BoundSentinel>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto
+  operator()(_Tp&& __value, _BoundSentinel&& __bound_sentinel) const noexcept(
+      noexcept(ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_BoundSentinel>(__bound_sentinel))))
+      -> decltype(ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_BoundSentinel>(__bound_sentinel))) {
+    return ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_BoundSentinel>(__bound_sentinel));
+  }
+};
+} // namespace __repeat
+
+inline namespace __cpo {
+inline constexpr auto repeat = __repeat::__fn{};
+} // namespace __cpo
+
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER > 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_REPEAT_VIEW_H

libcxx/include/__ranges/take_view.h

 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/range_adaptor.h>
+#include <__ranges/repeat_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/maybe_const.h>
 #include <__utility/auto_cast.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <type_traits>

 inline constexpr bool __is_passthrough_specialization<basic_string_view<_CharT, _Traits>> = true;
 
 template <class _Iter, class _Sent, subrange_kind _Kind>
 inline constexpr bool __is_passthrough_specialization<subrange<_Iter, _Sent, _Kind>> = true;
 
 template <class _Tp>
 inline constexpr bool __is_iota_specialization = false;
 
-template <class _Np, class _Bound>
-inline constexpr bool __is_iota_specialization<iota_view<_Np, _Bound>> = true;
+template <class _Np, class _BoundSentinel>
+inline constexpr bool __is_iota_specialization<iota_view<_Np, _BoundSentinel>> = true;
+
+template <class _Tp>
+inline constexpr bool __is_repeat_view = false;
+
+template <class _Tp, class _BoundSentinel>
+inline constexpr bool __is_repeat_view<repeat_view<_Tp, _BoundSentinel>> = true;
 
 template <class _Tp>
 struct __passthrough_type;
 
 template <class _Tp, size_t _Extent>
 struct __passthrough_type<span<_Tp, _Extent>> {
   using type = span<_Tp>;
 };
 
 template <class _CharT, class _Traits>
 struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
   using type = basic_string_view<_CharT, _Traits>;
 };
 
 template <class _Iter, class _Sent, subrange_kind _Kind>
   requires requires{typename subrange<_Iter>;}
-> decltype(      ranges::iota_view(
                               *ranges::begin(__rng),
                               *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
                               ))
     { return          ranges::iota_view(
                               *ranges::begin(__rng),
                               *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
                               ); }
 
+  // [range.take.overview]: the `repeat_view` "_RawRange models sized_range" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && __is_repeat_view<_RawRange> && sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const noexcept(noexcept(
+      views::repeat(*ranges::begin(__range), std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+      -> decltype(views::repeat(*ranges::begin(__range),
+                                std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))) {
+    return views::repeat(*ranges::begin(__range), std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)));
+  }
+
+  // [range.take.overview]: the `repeat_view` "otherwise" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && __is_repeat_view<_RawRange> && !sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(views::repeat(*ranges::begin(__range), static_cast<_Dist>(__n))))
+          -> decltype(views::repeat(*ranges::begin(__range), static_cast<_Dist>(__n))) {
+    return views::repeat(*ranges::begin(__range), static_cast<_Dist>(__n));
+  }
+
   // [range.take.overview]: the "otherwise" case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>>
     // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
     // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
+    requires (!(__is_empty_view<_RawRange> || __is_repeat_view<_RawRange> ||
                (__is_iota_specialization<_RawRange> &&
                 sized_range<_RawRange> &&
                 random_access_range<_RawRange>) ||
                (__is_passthrough_specialization<_RawRange> &&
                 sized_range<_RawRange> &&
                 random_access_range<_RawRange>)
              ))
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI

libcxx/include/module.modulemap.in

module __ranges {
       module join_view              { private header "__ranges/join_view.h" }
       module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module rend                   { private header "__ranges/rend.h" }
+      module repeat_view            { private header "__ranges/repeat_view.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }
       module size                   { private header "__ranges/size.h" }
       module split_view             { private header "__ranges/split_view.h" }
       module subrange               {
         private header "__ranges/subrange.h"
 
         module subrange_fwd { private header "__fwd/subrange.h" }

libcxx/include/ranges

// [range.reverse], reverse view
 
   template<weakly_incrementable W, semiregular Bound = unreachable_sentinel_t>
     requires weakly-equality-comparable-with<W, Bound> && copyable<W>
   class iota_view;
 
   template<class W, class Bound>
     inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
+
+  // [range.repeat], repeat view
+  template<copy_constructible W, semiregular Bound = unreachable_sentinel_t>
+    requires (is_object_v<W> && same_as<W, remove_cv_t<W>>
+      && (is-integer-like<Bound> || same_as<Bound, unreachable_sentinel_t>))
+  class repeat_view;
+
+  namespace views { inline constexpr unspecified repeat = unspecified; }
+
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
   class join_view;
 
   // [range.lazy.split], lazy split view
   template<class R>
     concept tiny-range = see below;   // exposition only

 #include <__ranges/enable_view.h>
 #include <__ranges/filter_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>
+#include <__ranges/repeat_view.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/split_view.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/take_while_view.h>
 #include <__ranges/transform_view.h>

libcxx/include/version

 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
 __cpp_lib_ranges                                        202106L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
+__cpp_lib_ranges_repeat                                 202110L <ranges> <tuple> <utility>
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>
 __cpp_lib_ranges_to_container                           202202L <deque> <forward_list> <list>
                                                                 <map> <priority_queue> <queue>
                                                                 <set> <stack> <string>
                                                                 <unordered_map> <unordered_set> <vector>
-__cpp_lib_ranges_zip                                    202110L <ranges> <tuple> <utility>
+__cpp_lib_ranges_zip                                    202207L <ranges> <tuple> <utility>
 __cpp_lib_raw_memory_algorithms                         201606L <memory>
 __cpp_lib_reference_from_temporary                      202202L <type_traits>
 __cpp_lib_remove_cvref                                  201711L <type_traits>
 __cpp_lib_result_of_sfinae                              201210L <functional> <type_traits>
 __cpp_lib_robust_nonmodifying_seq_ops                   201304L <algorithm>
 __cpp_lib_sample                                        201603L <algorithm>
 __cpp_lib_scoped_lock                                   201703L <mutex>
 __cpp_lib_semaphore                                     201907L <semaphore>

 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_ranges_chunk                         202202L
 // # define __cpp_lib_ranges_chunk_by                      202202L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
+// # define __cpp_lib_ranges_repeat                        202110L
 // # define __cpp_lib_ranges_slide                         202202L
 // # define __cpp_lib_ranges_starts_ends_with              202106L
 // # define __cpp_lib_ranges_to_container                  202202L
-// # define __cpp_lib_ranges_zip                           202110L
+// # define __cpp_lib_ranges_zip                           202207L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
 # define __cpp_lib_stdatomic_h                          202011L
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L
 # define __cpp_lib_to_underlying                        202102L
 # define __cpp_lib_unreachable                          202202L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp

 
 // Test the feature test macros defined by <ranges>
 
 /*  Constant                      Value
     __cpp_lib_ranges              202106L [C++20]
     __cpp_lib_ranges_chunk        202202L [C++2b]
     __cpp_lib_ranges_chunk_by     202202L [C++2b]
     __cpp_lib_ranges_join_with    202202L [C++2b]
+    __cpp_lib_ranges_repeat       202110L [C++2b]
     __cpp_lib_ranges_slide        202202L [C++2b]
-    __cpp_lib_ranges_zip          202110L [C++2b]
+    __cpp_lib_ranges_zip          202207L [C++2b]
 */
 
 #include <ranges>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_chunk_by
 #   error "__cpp_lib_ranges_chunk_by should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 

 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_join_with
 #     error "__cpp_lib_ranges_join_with should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should be defined in c++2b"
+#   endif
+#   if __cpp_lib_ranges_repeat != 202110L
+#     error "__cpp_lib_ranges_repeat should have the value 202110L in c++2b"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++2b"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should be defined in c++2b"
 #   endif
-#   if __cpp_lib_ranges_zip != 202110L
-#     error "__cpp_lib_ranges_zip should have the value 202110L in c++2b"
+#   if __cpp_lib_ranges_zip != 202207L
+#     error "__cpp_lib_ranges_zip should have the value 202207L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.compile.pass.cpp

 // <tuple>
 
 // Test the feature test macros defined by <tuple>
 
 /*  Constant                     Value
     __cpp_lib_apply              201603L [C++17]
     __cpp_lib_constexpr_tuple    201811L [C++20]
     __cpp_lib_make_from_tuple    201606L [C++17]
-    __cpp_lib_ranges_zip         202110L [C++2b]
+    __cpp_lib_ranges_repeat      202110L [C++2b]
+    __cpp_lib_ranges_zip         202207L [C++2b]
     __cpp_lib_tuple_element_t    201402L [C++14]
     __cpp_lib_tuples_by_type     201304L [C++14]
 */
 
 #include <tuple>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_apply
 #   error "__cpp_lib_apply should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_constexpr_tuple
 #   error "__cpp_lib_constexpr_tuple should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should not be defined before c++14"
 # endif
 

 # ifdef __cpp_lib_constexpr_tuple
 #   error "__cpp_lib_constexpr_tuple should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should be defined in c++14"
 # endif
 # if __cpp_lib_tuple_element_t != 201402L

 
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++17"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++17"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should be defined in c++17"
 # endif
 # if __cpp_lib_tuple_element_t != 201402L

 
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++20"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++20"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifndef __cpp_lib_tuple_element_t
 #   error "__cpp_lib_tuple_element_t should be defined in c++20"
 # endif
 # if __cpp_lib_tuple_element_t != 201402L

 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++2b"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++2b"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should be defined in c++2b"
+#   endif
+#   if __cpp_lib_ranges_repeat != 202110L
+#     error "__cpp_lib_ranges_repeat should have the value 202110L in c++2b"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should be defined in c++2b"
 #   endif
-#   if __cpp_lib_ranges_zip != 202110L
-#     error "__cpp_lib_ranges_zip should have the value 202110L in c++2b"
+#   if __cpp_lib_ranges_zip != 202207L
+#     error "__cpp_lib_ranges_zip should have the value 202207L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_tuple_element_t

libcxx/test/std/language.support/support.limits/support.limits.general/utility.version.compile.pass.cpp

 /*  Constant                                  Value
     __cpp_lib_as_const                        201510L [C++17]
     __cpp_lib_constexpr_algorithms            201806L [C++20]
     __cpp_lib_constexpr_utility               201811L [C++20]
     __cpp_lib_exchange_function               201304L [C++14]
     __cpp_lib_forward_like                    202207L [C++2b]
     __cpp_lib_integer_comparison_functions    202002L [C++20]
     __cpp_lib_integer_sequence                201304L [C++14]
-    __cpp_lib_ranges_zip                      202110L [C++2b]
+    __cpp_lib_ranges_repeat                   202110L [C++2b]
+    __cpp_lib_ranges_zip                      202207L [C++2b]
     __cpp_lib_to_underlying                   202102L [C++2b]
     __cpp_lib_tuples_by_type                  201304L [C++14]
     __cpp_lib_unreachable                     202202L [C++2b]
 */
 
 #include <utility>
 #include "test_macros.h"
 

 # ifdef __cpp_lib_integer_comparison_functions
 #   error "__cpp_lib_integer_comparison_functions should not be defined before c++20"
 # endif
 
 # ifdef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should not be defined before c++14"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_to_underlying
 #   error "__cpp_lib_to_underlying should not be defined before c++2b"
 # endif
 

 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++14"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++14"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_to_underlying
 #   error "__cpp_lib_to_underlying should not be defined before c++2b"
 # endif
 

 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++17"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++17"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_to_underlying
 #   error "__cpp_lib_to_underlying should not be defined before c++2b"
 # endif
 

 
 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++20"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++20"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_zip
 #   error "__cpp_lib_ranges_zip should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_to_underlying
 #   error "__cpp_lib_to_underlying should not be defined before c++2b"
 # endif
 

 # ifndef __cpp_lib_integer_sequence
 #   error "__cpp_lib_integer_sequence should be defined in c++2b"
 # endif
 # if __cpp_lib_integer_sequence != 201304L
 #   error "__cpp_lib_integer_sequence should have the value 201304L in c++2b"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should be defined in c++2b"
+#   endif
+#   if __cpp_lib_ranges_repeat != 202110L
+#     error "__cpp_lib_ranges_repeat should have the value 202110L in c++2b"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should be defined in c++2b"
 #   endif
-#   if __cpp_lib_ranges_zip != 202110L
-#     error "__cpp_lib_ranges_zip should have the value 202110L in c++2b"
+#   if __cpp_lib_ranges_zip != 202207L
+#     error "__cpp_lib_ranges_zip should have the value 202207L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_to_underlying

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_parallel_algorithm                   201603L [C++17]
     __cpp_lib_polymorphic_allocator                201902L [C++20]
     __cpp_lib_quoted_string_io                     201304L [C++14]
     __cpp_lib_ranges                               202106L [C++20]
     __cpp_lib_ranges_chunk                         202202L [C++2b]
     __cpp_lib_ranges_chunk_by                      202202L [C++2b]
     __cpp_lib_ranges_iota                          202202L [C++2b]
     __cpp_lib_ranges_join_with                     202202L [C++2b]
+    __cpp_lib_ranges_repeat                        202110L [C++2b]
     __cpp_lib_ranges_slide                         202202L [C++2b]
     __cpp_lib_ranges_starts_ends_with              202106L [C++2b]
     __cpp_lib_ranges_to_container                  202202L [C++2b]
-    __cpp_lib_ranges_zip                           202110L [C++2b]
+    __cpp_lib_ranges_zip                           202207L [C++2b]
     __cpp_lib_raw_memory_algorithms                201606L [C++17]
     __cpp_lib_reference_from_temporary             202202L [C++2b]
     __cpp_lib_remove_cvref                         201711L [C++20]
     __cpp_lib_result_of_sfinae                     201210L [C++14]
     __cpp_lib_robust_nonmodifying_seq_ops          201304L [C++14]
     __cpp_lib_sample                               201603L [C++17]
     __cpp_lib_scoped_lock                          201703L [C++17]
     __cpp_lib_semaphore                            201907L [C++20]

 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++2b"
 # endif
 

 # ifdef __cpp_lib_ranges_iota
 #   error "__cpp_lib_ranges_iota should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_join_with
 #   error "__cpp_lib_ranges_join_with should not be defined before c++2b"
 # endif
 
+# ifdef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_ranges_slide
 #   error "__cpp_lib_ranges_slide should not be defined before c++2b"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++2b"
 # endif
 

 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_join_with
 #     error "__cpp_lib_ranges_join_with should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should be defined in c++2b"
+#   endif
+#   if __cpp_lib_ranges_repeat != 202110L
+#     error "__cpp_lib_ranges_repeat should have the value 202110L in c++2b"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_ranges_repeat
+#     error "__cpp_lib_ranges_repeat should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+# if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++2b"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_slide

 #     error "__cpp_lib_ranges_to_container should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should be defined in c++2b"
 #   endif
-#   if __cpp_lib_ranges_zip != 202110L
-#     error "__cpp_lib_ranges_zip should have the value 202110L in c++2b"
+#   if __cpp_lib_ranges_zip != 202207L
+#     error "__cpp_lib_ranges_zip should have the value 202207L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_ranges_zip
 #     error "__cpp_lib_ranges_zip should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms

libcxx/test/std/ranges/range.adaptors/range.drop/adaptor.pass.cpp

constexpr bool test() {
   // When the size of the input range `s` is shorter than `n`, an `empty_view` is returned.
   {
     test_small_range(std::span(buf));
     test_small_range(std::string_view("abcdef"));
     test_small_range(std::ranges::subrange(buf, buf + N));
     test_small_range(std::views::iota(1, 8));
   }
 
+  // `views::drop(repeat_view, n)` returns an `repeat_view` when repeat_view models sized_range.
+  {
+    auto repeat                                = std::ranges::repeat_view<int, int>(1, 8);
+    using Result                               = std::ranges::repeat_view<int, int>;
+    std::same_as<Result> decltype(auto) result = repeat | std::views::drop(3);
+    assert(result.size() == 5);
+    assert(*result.begin() == 1);
+  }
+
+  // `views::drop(repeat_view, n)` returns an `repeat_view` when repeat_view not models sized_range.
+  {
+    auto repeat                                = std::ranges::repeat_view<int>(1);
+    using Result                               = std::ranges::repeat_view<int, std::unreachable_sentinel_t>;
+    std::same_as<Result> decltype(auto) result = repeat | std::views::drop(3);
+    static_assert(std::same_as<std::unreachable_sentinel_t, decltype(result.end())>);
+  }
+
   // Test that it's possible to call `std::views::drop` with any single argument as long as the resulting closure is
   // never invoked. There is no good use case for it, but it's valid.
   {
     struct X { };
     [[maybe_unused]] auto partial = std::views::drop(X{});
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.take/adaptor.pass.cpp

// `views::take(iota_view, n)` returns an `iota_view`.
     // The second template argument of the resulting `iota_view` is different because it has to be able to hold
     // the `range_difference_t` of the input `iota_view`.
     using Result = std::ranges::iota_view<int, std::ranges::range_difference_t<decltype(iota)>>;
     std::same_as<Result> decltype(auto) result = iota | std::views::take(3);
     assert(result.size() == 3);
   }
 
   // When the size of the input range `s` is shorter than `n`, only `s` elements are taken.
   {
     test_small_range(std::span(buf));
     test_small_range(std::string_view("abcdef"));
     test_small_range(std::ranges::subrange(buf, buf + N));
     test_small_range(std::views::iota(1, 8));
   }
 
+  // `views::take(repeat_view, n)` returns an `repeat_view` when repeat_view models sized_range.
+  {
+    auto repeat                                = std::ranges::repeat_view<int, int>(1, 8);
+    using Result                               = std::ranges::repeat_view<int, int>;
+    std::same_as<Result> decltype(auto) result = repeat | std::views::take(3);
+    assert(result.size() == 3);
+    assert(*result.begin() == 1);
+  }
+
+  // `views::take(repeat_view, n)` returns an `repeat_view` when repeat_view not models sized_range.
+  {
+    auto repeat                                = std::ranges::repeat_view<int>(1);
+    using Result                               = std::ranges::repeat_view<int, long>;
+    std::same_as<Result> decltype(auto) result = repeat | std::views::take(3);
+    assert(result.size() == 3);
+    assert(*result.begin() == 1);
+  }
+
   // Test that it's possible to call `std::views::take` with any single argument as long as the resulting closure is
   // never invoked. There is no good use case for it, but it's valid.
   {
     struct X { };
     [[maybe_unused]] auto partial = std::views::take(X{});
   }
 
   // Test when `subrange<Iter>` is not well formed

libcxx/test/std/ranges/range.factories/range.repeat.view/begin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator begin() const;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  {
+    std::ranges::repeat_view<int> rv(0);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 0);
+  }
+  {
+    const std::ranges::repeat_view<int> rv(0);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 0);
+  }
+  {
+    std::ranges::repeat_view<int> rv(42);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 42);
+  }
+  {
+    const std::ranges::repeat_view<int> rv(42);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 42);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/ctad.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class W, class Bound>
+//    repeat_view(W, Bound) -> repeat_view<W, Bound>;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+struct Empty {};
+
+constexpr bool test() {
+  static_assert(std::same_as< decltype(std::ranges::repeat_view(Empty())), std::ranges::repeat_view<Empty> >);
+
+  static_assert(
+      std::same_as< decltype(std::ranges::repeat_view(std::declval<Empty&>())), std::ranges::repeat_view<Empty> >);
+
+  static_assert(
+      std::same_as< decltype(std::ranges::repeat_view(std::declval<Empty&&>())), std::ranges::repeat_view<Empty> >);
+
+  static_assert(std::same_as< decltype(std::ranges::repeat_view(Empty(), 1)), std::ranges::repeat_view<Empty, int> >);
+
+  static_assert(std::same_as< decltype(std::ranges::repeat_view(std::declval<Empty&>(), 1U)),
+                              std::ranges::repeat_view<Empty, unsigned> >);
+
+  static_assert(std::same_as< decltype(std::ranges::repeat_view(std::declval<Empty&&>(), 1UL)),
+                              std::ranges::repeat_view<Empty, unsigned long> >);
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// repeat_view() requires default_initializable<W> = default;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+struct DefaultInt42 {
+  int __value_ = 42;
+};
+
+constexpr bool test() {
+  std::ranges::repeat_view<DefaultInt42> rv(DefaultInt42{});
+  assert((*rv.begin()).__value_ == 42);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.piecewise.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class... WArgs, class... BoundArgs>
+//   requires constructible_from<W, WArgs...> && constructible_from<Bound, BoundArgs...>
+// constexpr explicit repeat_view(
+//     piecewise_construct_t, tuple<WArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+struct A {
+  int x_;
+  int y_;
+};
+
+constexpr bool test() {
+  std::ranges::repeat_view<A, int> rv(std::piecewise_construct, std::tuple{1, 2}, std::tuple{3});
+  assert(rv.size() == 3);
+  assert(rv[0].x_ == 1);
+  assert(rv[0].y_ == 2);
+  assert(std::ranges::next(rv.begin(), 3) == rv.end());
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.value.bound.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit repeat_view(W&& value, Bound bound = Bound());
+// constexpr explicit repeat_view(const W& value, Bound bound = Bound());
+
+#include <ranges>
+#include <cassert>
+#include <iterator>
+
+struct Empty {};
+
+constexpr bool test() {
+  // Move && unbound && default argument
+  {
+    std::ranges::repeat_view<Empty> rv(Empty{});
+    assert(std::ranges::next(rv.begin(), 10) != rv.end());
+  }
+
+  // Move && unbound && specific argument
+  {
+    std::ranges::repeat_view<Empty> rv(Empty{}, std::unreachable_sentinel);
+    assert(std::ranges::next(rv.begin(), 10) != rv.end());
+  }
+
+  // Move && bound && default argument
+  {
+    std::ranges::repeat_view<Empty, int> rv(Empty{});
+    assert(rv.begin() == rv.end());
+  }
+
+  // Move && bound && specific argument
+  {
+    std::ranges::repeat_view<Empty, int> rv(Empty{}, 10);
+    assert(std::ranges::next(rv.begin(), 10) == rv.end());
+  }
+
+  // Copy && unbound && default argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty> rv(e);
+    assert(std::ranges::next(rv.begin(), 10) != rv.end());
+  }
+
+  // Copy && unbound && specific argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty> rv(e, std::unreachable_sentinel);
+    assert(std::ranges::next(rv.begin(), 10) != rv.end());
+  }
+
+  // Copy && bound && default argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty, int> rv(e);
+    assert(rv.begin() == rv.end());
+  }
+
+  // Copy && bound && specific argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty, int> rv(e, 10);
+    assert(std::ranges::next(rv.begin(), 10) == rv.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/end.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto end() const;
+// constexpr iterator end() const requires same_as<W, Bound>;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+constexpr bool test() {
+  // bound
+  {
+    std::ranges::repeat_view<int, int> rv(0, 10);
+    assert(std::ranges::next(rv.begin(), 10) == rv.end());
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.end();
+    static_assert(std::same_as<decltype(*iter), const int&>);
+  }
+
+  // unbound
+  {
+    std::ranges::repeat_view<int> rv(0);
+    assert(std::ranges::next(rv.begin(), 10) != rv.end());
+    static_assert(std::same_as<decltype(rv.end()), std::unreachable_sentinel_t>);
+    //ASSERT_NOEXCEPT(rv.end());
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/compare.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// repeat_view::<iterator>::operator{==,<=>}
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  {
+    using R = std::ranges::repeat_view<int>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    std::same_as<R> auto r = std::views::repeat(42);
+    auto iter1             = r.begin();
+    auto iter2             = iter1 + 1;
+
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+
+    assert((iter1 <=> iter2) == std::strong_ordering::less);
+    assert((iter1 <=> iter1) == std::strong_ordering::equal);
+    assert((iter2 <=> iter1) == std::strong_ordering::greater);
+  }
+
+  {
+    using R = std::ranges::repeat_view<int, int>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    std::same_as<R> auto r = std::views::repeat(42, 10);
+    auto iter1             = r.begin();
+    auto iter2             = iter1 + 1;
+
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+
+    assert((iter1 <=> iter2) == std::strong_ordering::less);
+    assert((iter1 <=> iter1) == std::strong_ordering::equal);
+    assert((iter2 <=> iter1) == std::strong_ordering::greater);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// iterator() = default;
+
+#include <ranges>
+
+constexpr bool test() {
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  Iter iter;
+  (void)iter;
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/decrement.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator--();
+// constexpr iterator operator--(int);
+
+#include <ranges>
+#include <cassert>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> rv(10);
+  auto iter1 = rv.begin() + 10;
+  auto iter2 = rv.begin() + 10;
+
+  assert(iter1 == iter2);
+  assert(iter1-- == iter2--);
+  assert(--iter1 == --iter2);
+  assert(iter1-- != --iter2);
+  assert(iter1 == iter2);
+  assert(--iter1 != iter2--);
+  assert(iter1 == iter2);
+
+  static_assert(!std::is_reference_v<decltype(iter2++)>);
+  static_assert(std::is_reference_v<decltype(++iter2)>);
+
+  static_assert(std::same_as<std::remove_reference_t<decltype(--iter2)>, decltype(iter2--)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/increment.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator++();
+// constexpr void operator++(int);
+
+#include <ranges>
+#include <cassert>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> rv(10);
+  auto iter1 = rv.begin();
+  auto iter2 = rv.begin();
+
+  assert(iter1 == iter2);
+  assert(iter1++ == iter2++);
+  assert(++iter1 == ++iter2);
+  assert(iter1++ != ++iter2);
+  assert(iter1 == iter2);
+  assert(++iter1 != iter2++);
+  assert(iter1 == iter2);
+
+  static_assert(!std::is_reference_v<decltype(iter2++)>);
+  static_assert(std::is_reference_v<decltype(++iter2)>);
+
+  static_assert(std::same_as<std::remove_reference_t<decltype(++iter2)>, decltype(iter2++)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/member_typedefs.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// Test iterator category and iterator concepts.
+
+// using index-type = conditional_t<same_as<Bound, unreachable_sentinel_t>, ptrdiff_t, Bound>;
+// using iterator_concept = random_access_iterator_tag;
+// using iterator_category = random_access_iterator_tag;
+// using value_type = W;
+// using difference_type = conditional_t<is-signed-like<index-type>, index-type, IOTA-DIFF-T(index-type)>;
+
+#include <cassert>
+#include <cstdint>
+#include <concepts>
+#include <ranges>
+
+constexpr bool test() {
+  // unbound
+  {
+    const std::ranges::repeat_view<int> v(0);
+    using Iter = decltype(v.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, int>);
+    static_assert(std::same_as<Iter::difference_type, ptrdiff_t>);
+    static_assert(std::is_signed_v<Iter::difference_type>);
+  }
+
+  // bound && signed bound sentinel
+  {
+    const std::ranges::repeat_view<int, long> v(0, 10);
+    using Iter = decltype(v.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, int>);
+    static_assert(std::same_as<Iter::difference_type, long>);
+    static_assert(std::is_signed_v<Iter::difference_type>);
+    static_assert(sizeof(Iter::difference_type) >= sizeof(long));
+  }
+
+  // bound && unsigned bound sentinel
+  {
+    const std::ranges::repeat_view<int, unsigned> v(0);
+    using Iter = decltype(v.begin());
+    static_assert(std::same_as<Iter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<Iter::value_type, int>);
+
+    // If we're compiling for 32 bit or windows, int and long are the same size, so long long is the correct difference type.
+#if INTPTR_MAX == INT32_MAX || defined(_WIN32)
+    static_assert(std::same_as<Iter::difference_type, long long>);
+#else
+    static_assert(std::same_as<Iter::difference_type, long>);
+#endif
+    static_assert(std::is_signed_v<Iter::difference_type>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// friend constexpr iterator operator-(iterator i, difference_type n);
+// friend constexpr difference_type operator-(const iterator& x, const iterator& y);
+
+#include <ranges>
+#include <cassert>
+#include <cstdint>
+#include <concepts>
+
+constexpr bool test() {
+  // <iterator> - difference_type
+  {
+    std::ranges::repeat_view<int> v(0);
+    auto iter1 = std::next(v.begin(), 10);
+    auto iter2 = std::next(v.begin(), 10);
+    assert(iter1 == iter2);
+    assert(iter1 - 5 != iter2);
+    assert(iter1 - 5 == std::ranges::prev(iter2, 5));
+
+    static_assert(!std::is_reference_v<decltype(iter2 - 5)>);
+  }
+
+  // <iterator> - <iterator>
+  {
+    // unbound
+    {
+      std::ranges::repeat_view<int> v(0);
+      auto iter1 = std::next(v.begin(), 10);
+      auto iter2 = std::next(v.begin(), 5);
+      assert(iter1 - iter2 == 5);
+      static_assert(std::same_as<decltype(iter1 - iter2), ptrdiff_t>);
+    }
+
+    // bound && signed bound sentinel
+    {
+      std::ranges::repeat_view<int, int> v(0, 20);
+      auto iter1 = std::next(v.begin(), 10);
+      auto iter2 = std::next(v.begin(), 5);
+      assert(iter1 - iter2 == 5);
+      static_assert(std::same_as<decltype(iter1 - iter2), int>);
+    }
+
+    // bound && unsigned bound sentinel
+    {
+      std::ranges::repeat_view<int, unsigned> v(0, 20);
+      auto iter1 = std::next(v.begin(), 10);
+      auto iter2 = std::next(v.begin(), 5);
+      assert(iter1 - iter2 == 5);
+#if INTPTR_MAX == INT32_MAX || defined(_WIN32)
+      static_assert(std::same_as<decltype(iter1 - iter2), long long>);
+#else
+      static_assert(std::same_as<decltype(iter1 - iter2), long>);
+#endif
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/minus_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator-=(difference_type n);
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> v(10);
+  auto iter1 = std::next(v.begin(), 10);
+  auto iter2 = std::next(v.begin(), 10);
+  assert(iter1 == iter2);
+  iter1 -= 5;
+  assert(iter1 != iter2);
+  assert(iter1 == std::ranges::prev(iter2, 5));
+
+  static_assert(std::is_reference_v<decltype(iter2 -= 5)>);
+
+  return true;
+}
+
+int main(int, char**) { return 0; }

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/plus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// friend constexpr iterator operator+(iterator i, difference_type n);
+// friend constexpr iterator operator+(difference_type n, iterator i);
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> v(10);
+  auto iter1 = v.begin();
+  auto iter2 = v.begin();
+  assert(iter1 == iter2);
+  assert(iter1 + 5 != iter2);
+  assert(iter1 + 5 == std::ranges::next(iter2, 5));
+  assert(5 + iter1 != iter2);
+  assert(5 + iter1 == 5 + iter2);
+  assert(2 + iter1 == iter2 + 2);
+  assert(3 + iter1 == std::ranges::next(iter2, 3));
+
+  static_assert(!std::is_reference_v<decltype(iter2 + 5)>);
+  static_assert(!std::is_reference_v<decltype(5 + iter2)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/plus_eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr iterator& operator+=(difference_type n);
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> v(10);
+  auto iter1 = std::next(v.begin(), 10);
+  auto iter2 = std::next(v.begin(), 10);
+  assert(iter1 == iter2);
+  iter1 += 5;
+  assert(iter1 != iter2);
+  assert(iter1 == std::ranges::next(iter2, 5));
+
+  static_assert(std::is_reference_v<decltype(iter2 += 5)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/star.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr const W & operator*() const noexcept;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> v(31);
+  auto iter = v.begin();
+  for (int i = 0; i < 100; ++i, ++iter)
+    assert(*iter == 31);
+
+  static_assert(noexcept(*iter));
+  static_assert(std::is_reference_v<decltype(*iter)>);
+  static_assert(std::same_as<decltype(*iter), const int&>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/iterator/subscript.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// constexpr const W & operator[](difference_type n) const noexcept;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  std::ranges::repeat_view<int> v(31);
+  auto iter = v.begin();
+  for (int i = 0; i < 100; ++i)
+    assert(iter[i] == 31);
+
+  static_assert(noexcept(iter[0]));
+  static_assert(std::is_reference_v<decltype(iter[0])>);
+  static_assert(std::same_as<decltype(iter[0]), const int&>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/size.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr auto size() const requires see below;
+
+#include <ranges>
+#include <numeric>
+#include <concepts>
+#include <cassert>
+
+template <class T>
+concept has_size = requires(T&& view) {
+                     { std::forward<T>(view).size() };
+                   };
+
+static_assert(has_size<std::ranges::repeat_view<int, int>>);
+static_assert(!has_size<std::ranges::repeat_view<int>>);
+static_assert(!has_size<std::ranges::repeat_view<int, std::unreachable_sentinel_t>>);
+
+constexpr bool test() {
+  {
+    std::ranges::repeat_view<int, int> rv(10, 20);
+    assert(rv.size() == 20);
+  }
+
+  {
+    std::ranges::repeat_view<int, int> rv(10, std::numeric_limits<int>::max());
+    assert(rv.size() == std::numeric_limits<int>::max());
+  }
+
+  {
+    std::ranges::repeat_view<int, int> rv(10, -1);
+    assert(rv.size() == std::numeric_limits<unsigned>::max());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.factories/range.repeat.view/views_repeat.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// views::repeat
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  assert(*std::views::repeat(33).begin() == 33);
+  assert(*std::views::repeat(33, 10).begin() == 33);
+  static_assert(std::same_as<decltype(std::views::repeat(42)), std::ranges::repeat_view<int>>);
+  static_assert(std::same_as<decltype(std::views::repeat(42, 3)), std::ranges::repeat_view<int, int>>);
+  static_assert(std::same_as<decltype(std::views::repeat), decltype(std::ranges::views::repeat)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "headers": ["numeric"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_join_with",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
     "unimplemented": True,
   }, {
+    "name": "__cpp_lib_ranges_repeat",
+    "values": { "c++2b": 202110 },
+    "headers": ["ranges", "tuple", "utility"],
+    "unimplemented": True,
+  }, {
     "name": "__cpp_lib_ranges_slide",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_starts_ends_with",
     "values": { "c++2b": 202106 },
     "headers": ["algorithm"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_to_container",
     "values": { "c++2b": 202202 },
     "headers": ["deque", "forward_list", "list", "map", "priority_queue", "queue", "set", "stack", "string", "unordered_map", "unordered_set", "vector"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_ranges_zip",
-    "values": { "c++2b": 202110 },
+    "values": { "c++2b": 202207 },
     "headers": ["ranges", "tuple", "utility"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_raw_memory_algorithms",
     "values": { "c++17": 201606 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_reference_from_temporary",