[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

43

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

45

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?

45

Question: can _Bound be a user-defined type?

54

requires copy_constructible<T>?

57

must be greater than or equal to 0

68

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

109

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?

133

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 ↗

(On Diff #507729)

Ultranit: s/returns an/return a/.

224 ↗

(On Diff #507729)

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 ↗

(On Diff #507729)

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

233 ↗

(On Diff #507729)

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

15 ↗

(On Diff #507729)

Nit: <cassert> can be removed.

21 ↗

(On Diff #507729)

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

25 ↗

(On Diff #507729)

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.

29 ↗

(On Diff #507729)

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

80 ↗

(On Diff #507729)

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

38 ↗

(On Diff #507729)

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

58 ↗

(On Diff #507729)

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

18 ↗

(On Diff #507729)

Can you add comments to each test case?

32 ↗

(On Diff #507729)

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

17 ↗

(On Diff #507729)

Question: is the default constructor guaranteed to be nothrow?

19 ↗

(On Diff #507729)

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

19 ↗

(On Diff #507729)

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

22 ↗

(On Diff #507729)

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);.

30 ↗

(On Diff #507729)

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

33 ↗

(On Diff #507729)

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

53 ↗

(On Diff #507729)

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

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

23 ↗

(On Diff #507729)

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

26 ↗

(On Diff #507729)

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

27 ↗

(On Diff #507729)

Nit: consider using next from begin instead.

29 ↗

(On Diff #507729)

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

23 ↗

(On Diff #507729)

Same comments as the minus.pass.cpp file.

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

26 ↗

(On Diff #507729)

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

18 ↗

(On Diff #507729)

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.

23 ↗

(On Diff #507729)

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

21 ↗

(On Diff #507729)

Nit: use std::ranges::all_of?

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

11 ↗

(On Diff #507729)

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

17 ↗

(On Diff #507729)

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

11 ↗

(On Diff #507729)

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

40 ↗

(On Diff #507729)

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

347 ↗

(On Diff #507729)

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

43

Yes!

45

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

45

Question: can _Bound be a user-defined type?

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

54

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>.

68

done!

109

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

21 ↗

(On Diff #507729)

Thanks, I'll remove this whitespace

29 ↗

(On Diff #507729)

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

32 ↗

(On Diff #507729)

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

17 ↗

(On Diff #507729)

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.

19 ↗

(On Diff #507729)

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

22 ↗

(On Diff #507729)

agree

30 ↗

(On Diff #507729)

agree

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

53 ↗

(On Diff #507729)

done

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

26 ↗

(On Diff #507729)

Thanks, removed.

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

21 ↗

(On Diff #507729)

done!

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

11 ↗

(On Diff #507729)

done.

libcxx/utils/generate_feature_test_macro_components.py

563

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

17 ↗

(On Diff #529949)

Nit: s/bellow/below/.

46 ↗

(On Diff #529949)

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

23 ↗

(On Diff #507729)

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

55 ↗

(On Diff #529949)

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

20 ↗

(On Diff #529949)

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

29 ↗

(On Diff #529949)

Missing calls to test().

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

36 ↗

(On Diff #529949)

Can you also check the value of iter?

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

40 ↗

(On Diff #507729)

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

23 ↗

(On Diff #507729)

sorry, I missed it earlier

55 ↗

(On Diff #529949)

I agree ptrdiff_t is better

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

40 ↗

(On Diff #507729)

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 ↗

(On Diff #534929)

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

25 ↗

(On Diff #534929)

This next can be replaced by arithmetics.

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

101 ↗

(On Diff #534929)

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.

40 ↗

(On Diff #507729)

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.

[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 ↗

(On Diff #534929)

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

25 ↗

(On Diff #534929)

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/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>`_,Under review
 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>`_,Under review
 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/subrange.h
   __ranges/take_view.h
   __ranges/take_while_view.h
   __ranges/transform_view.h
   __ranges/view_interface.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 _Bound>
+inline constexpr bool __is_repeat_view<repeat_view<_Tp, _Bound>> = 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;
 
-> 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> &&
+              sized_range<_RawRange> &&
+              __is_repeat_view<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const noexcept(
+      noexcept(_RawRange(*ranges::begin(__range),
+                         ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+      -> decltype(_RawRange(*ranges::begin(__range),
+                            ranges::distance(__range) -
+                                std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))) {
+      // Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
+      // expression used in the `noexcept` clause and the return statement).
+      auto dist    = ranges::distance(__range);
+      auto clamped = std::min<_Dist>(dist, std::forward<_Np>(__n));
+      return _RawRange(*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> &&
+              !sized_range<_RawRange> &&
+              __is_repeat_view<_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> ||
                (__is_subrange_specialization_with_store_size<_RawRange> &&
                sized_range<_RawRange> &&

libcxx/include/__ranges/repeat_view.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
 
-#define _LIBCPP_STD_VER 23
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 namespace ranges {
+
+template <copy_constructible _Tp, semiregular _Bound>
+  requires __integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>
+class __repeat_view_iterator;
+
 template <copy_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
   requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
            (__integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>))
 class repeat_view : public view_interface<repeat_view<_Tp, _Bound>> {
-private:
-  struct __iterator;
+  using __iterator = __repeat_view_iterator<_Tp, _Bound>;
 
-  __copyable_box<_Tp> __value_;
-  _Bound __bound_ = _Bound();
+  template <copy_constructible _ValueType, semiregular _BoundType>
+    requires __integer_like<_BoundType> || same_as<_BoundType, 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, _Bound __bound = _Bound())
       : __value_(__value), __bound_(__bound) {
     if constexpr (!same_as<_Bound, 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, _Bound __bound = _Bound())
       : __value_(std::move(__value)), __bound_(__bound) {
     if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
       _LIBCPP_ASSERT(__bound_ >= 0, "The value of bound must greater equal than 0");
   }
 
   template <class... _TpArgs, class... _BoundArgs>
     requires constructible_from<_Tp, _TpArgs...> && constructible_from<_Bound, _BoundArgs...>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(
       piecewise_construct_t, tuple<_TpArgs...> __value_args, tuple<_BoundArgs...> __bound_args = tuple<>{})
       : __value_(std::forward<_TpArgs>(__value_args)...), __bound_(std::forward<_BoundArgs>(__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<Bound, unreachable_sentinel_t>)
+    requires(!same_as<_Bound, 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<_Bound, unreachable_sentinel_t>)
   {
     return std::__to_unsigned_like(__bound_);
   }
+
+private:
+  __copyable_box<_Tp> __value_              = _Tp();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Bound __bound_ = _Bound();
 };
 
 template <class _Tp, class _Bound>
 repeat_view(_Tp, _Bound) -> repeat_view<_Tp, _Bound>;
 
 // [range.repeat.iterator]
-template <copy_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
+template <copy_constructible _Tp, semiregular _Bound>
   requires __integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>
-struct repeat_view<_Tp, Bound>::__iterator {
-private:
+class __repeat_view_iterator {
   using _IndexT = conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound >;
 
-  const _Tp* __value_ = nullptr;
-  _IndexT __current_  = _IndexT();
-
-  constexpr explicit __iterator(const _Tp* __value, _IndexT __bound = _IndexT())
+  constexpr explicit __repeat_view_iterator(const _Tp* __value, _IndexT __bound = _IndexT())
       : __value_(__value), __current_(__bound) {
     if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
       static_assert(__bound >= 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> >;
 
-  __iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI __repeat_view_iterator() = default;
 
-  constexpr const _Tp& operator*() const noexcept { return *__value_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
 
-  constexpr __iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator++() {
     ++__current_;
     return *this;
   }
 
-  constexpr __iterator operator++(int) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator operator++(int) {
     auto tmp = *this;
     ++*this;
     return tmp;
   }
 
-  constexpr __iterator& operator--() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator--() {
     --__current_;
     return *this;
   }
 
-  constexpr __iterator operator--(int) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator operator--(int) {
     auto tmp = *this;
     --*this;
     return tmp;
   }
 
-  constexpr __iterator& operator+=(difference_type __n) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator+=(difference_type __n) {
     if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
       static_assert(__current_ + __n >= 0, "The value of bound must greater equal than 0");
     __current_ += __n;
     return *this;
   }
 
-  constexpr __iterator& operator-=(difference_type __n) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __repeat_view_iterator& operator-=(difference_type __n) {
     if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
       static_assert(__current_ - __n >= 0, "The value of bound must greater equal than 0");
-    __current_ -= n;
+    __current_ -= __n;
     return *this;
   }
 
-  constexpr const _Tp& operator[](difference_type __n) const noexcept { return *(*this + __n); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](difference_type __n) const noexcept { return *(*this + __n); }
 
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const __repeat_view_iterator& __x, const __repeat_view_iterator& __y) {
     return __x.__current_ == __y.__current_;
   }
 
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto
+  operator<=>(const __repeat_view_iterator& __x, const __repeat_view_iterator& __y) {
     return __x.__current_ <=> __y.__current_;
   }
 
-  friend constexpr __iterator operator+(__iterator __i, difference_type __n) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator+(__repeat_view_iterator __i, difference_type __n) {
     __i += __n;
     return __i;
   }
 
-  friend constexpr __iterator operator+(difference_type __n, __iterator __i) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator+(difference_type __n, __repeat_view_iterator __i) {
     __i += __n;
     return __i;
   }
 
-  friend constexpr __iterator operator-(__iterator __i, difference_type __n) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __repeat_view_iterator
+  operator-(__repeat_view_iterator __i, difference_type __n) {
     __i -= __n;
     return __i;
   }
 
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y) {
+  _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_view {
 
 template <class _Tp>
-inline constexpr bool __can_bound_repeat_view<repeat_view<_Tp>> = true;
+concept __can_unbound_repeat_view = requires { repeat_view(std::declval<_Tp>()); };
+
 template <class _Tp, class _Bound>
-inline constexpr bool __can_unbound_repeat_view<repeat_view<_Tp, _Bound>> = true;
+concept __can_bound_repeat_view = requires { repeat_view(std::declval<_Tp>(), std::declval<_Bound>()); };
 
 struct __fn : __range_adaptor_closure<__fn> {
   template <class _Tp>
     requires __can_unbound_repeat_view<_Tp>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value) const {
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value) const {
     return repeat_view(std::forward<_Tp>(__value));
   }
 
   template <class _Tp, class _Bound>
     requires __can_bound_repeat_view<_Tp, _Bound>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value, _Bound&& __bound) const {
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value, _Bound&& __bound) const {
     return repeat_view(std::forward<_Tp>(__value), __bound);
   }
 };
 } // namespace __repeat_view
 
 inline namespace __cpo {
 inline constexpr auto repeat = __repeat_view::__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<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 _Tp>
+inline constexpr bool __is_repeat_specialization = false;
+
+template <class _Tp, class _Bound>
+inline constexpr bool __is_repeat_specialization<repeat_view<_Tp, _Bound>> = 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>
-> 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> && sized_range<_RawRange> && __is_repeat_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(ranges::repeat_view(
+          *ranges::begin(__range),
+          *ranges::begin(__range) + std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+          -> decltype(ranges::repeat_view(
+              // Note: deliberately not forwarding `__range` to guard against double moves.
+              *ranges::begin(__range),
+              *ranges::begin(__range) + std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))) {
+    return ranges::repeat_view(
+        *ranges::begin(__range),
+        *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> && !sized_range<_RawRange> && __is_repeat_specialization<_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.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> ||
                (__is_iota_specialization<_RawRange> &&
                 sized_range<_RawRange> &&

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 subrange               { private header "__ranges/subrange.h" }
       module take_view              { private header "__ranges/take_view.h" }
       module take_while_view        { private header "__ranges/take_while_view.h" }
       module transform_view         {
         private header "__ranges/transform_view.h"

libcxx/include/ranges

 #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/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/take_while_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>

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>
+
+#include "test_macro.h"
+#include "types.h"
+
+constexpr void testType() {
+  {
+    std::ranges::repeat_view<int> repeat(T{0});
+    assert(*repeat.begin() = T{0});
+  }
+  {
+    std::ranges::repeat_view<int> repeat(T{10});
+    assert(*repeat.begin() == T{10});
+    assert(*std::move(repeat).begin() == T{10});
+  }
+  {
+    const std::ranges::repeat_view<int> repeat(T{0});
+    assert(*repeat.begin() == T{0});
+  }
+  {
+    const std::ranges::repeat_view<int> repeat(T{10});
+    assert(*repeat.begin() == T{10});
+  }
+}
+
+constexpr bool test() {
+  testType();
+
+  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> repeat(DefaultInt42{});
+  assert((*repeat.begin()).value_ == 42);
+
+  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 <utility>
+
+#include "test_macros.h"
+
+constexpr void testUnBoundTypes() {
+  {
+    std::ranges::repeat_view<int> repeat(T{0});
+    assert(repeat.begin() != repeat.end());
+    assert(repeat.end() == std::unreachable_sentinel);
+    ASSERT_NOEXCEPT(repeat.end());
+    ASSERT_SAME_TYPE(decltype(repeat.end()), std::unreachable_sentinel_t);
+  }
+  {
+    const std::ranges::repeat_view<int> repeat(T{0});
+    assert(repeat.begin() != repeat.end());
+    assert(repeat.end() == std::unreachable_sentinel);
+    ASSERT_NOEXCEPT(repeat.end());
+    ASSERT_SAME_TYPE(decltype(repeat.end()), std::unreachable_sentinel_t);
+  }
+  {
+    std::ranges::repeat_view<int> repeat(T{0});
+    assert(std::move(repeat).begin() != std::move(repeat).end());
+    assert(std::move(repeat).end() == std::unreachable_sentinel);
+    ASSERT_NOEXCEPT(std::move(repeat).end());
+    ASSERT_SAME_TYPE(decltype(std::move(repeat).end()), std::unreachable_sentinel_t);
+  }
+  {
+    const std::ranges::repeat_view<int> repeat(T{0});
+    assert(std::move(repeat).begin() != std::move(repeat).end());
+    assert(std::move(repeat).end() == std::unreachable_sentinel);
+    ASSERT_NOEXCEPT(std::move(repeat).end());
+    ASSERT_SAME_TYPE(decltype(std::move(repeat).end()), std::unreachable_sentinel_t);
+  }
+}
+
+constexpr void testBoundTypes() {
+  {
+    std::ranges::repeat_view<int, int> repeat(T{0}, 10);
+    assert(std::ranges::next(repeat.begin(), 10) == repeat.end());
+    ASSERT_NOT_NOEXCEPT(repeat.end());
+    ASSERT_SAME_TYPE(decltype(repeat.end()), std::ranges::iterator_t<decltype(repeat)>);
+  }
+  {
+    const std::ranges::repeat_view<int, int> repeat(T{0}, 10);
+    assert(std::ranges::next(repeat.begin(), 10) == repeat.end());
+    ASSERT_NOT_NOEXCEPT(repeat.end());
+    ASSERT_SAME_TYPE(decltype(repeat.end()), std::ranges::iterator_t<decltype(repeat)>);
+  }
+  {
+    std::ranges::repeat_view<int, int> repeat(T{0}, 10);
+    assert(std::ranges::next(std::move(repeat).begin(), 10) == std::move(repeat).end());
+    ASSERT_NOT_NOEXCEPT(std::move(repeat).end());
+    ASSERT_SAME_TYPE(decltype(std::move(repeat).end()), std::ranges::iterator_t<decltype(std::move(repeat))>);
+  }
+  {
+    const std::ranges::repeat_view<int, int> repeat(T{0}, 10);
+    assert(std::ranges::next(std::move(repeat).begin(), 10) == std::move(repeat).end());
+    ASSERT_NOT_NOEXCEPT(std::move(repeat).end());
+    ASSERT_SAME_TYPE(decltype(std::move(repeat).end()), std::ranges::iterator_t<decltype(std::move(repeat))>);
+  }
+}
+
+constexpr bool test() {
+  testBoundTypes();
+  testUnBoundTypes();
+  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 [
     "name": "__cpp_lib_ranges_join_with",
     "values": { "c++2b": 202202 },
     "headers": ["ranges"],
     "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": 202207 },
+    "headers": ["ranges", "tuple", "utility"],
+    "unimplemented": True,
+  }, {
+    "name": "__cpp_lib_ranges_repeat",
     "values": { "c++2b": 202110 },
     "headers": ["ranges", "tuple", "utility"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_raw_memory_algorithms",
     "values": { "c++17": 201606 },
     "headers": ["memory"],
   }, {