[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

304

Question: is __is_empty_view necessary here?

308

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.

310

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

310

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

170

This value is incorrect.

libcxx/docs/Status/Cxx2bPapers.csv

80 ↗

(On Diff #507729)

done.

libcxx/include/__ranges/drop_view.h

304

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

308

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

310

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?

310

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

79

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

310

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_unordered_map_try_emplace``             ``201411L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_variant``                               ``202102L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_void_t``                                ``201411L``
     --------------------------------------------------- -----------------
     **C++ 20**
     ---------------------------------------------------------------------
     ``__cpp_lib_array_constexpr``                       ``201811L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_assume_aligned``                        ``201811L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_atomic_flag_test``                      ``201907L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_atomic_float``                          *unimplemented*
     --------------------------------------------------- -----------------
.. 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``                         ``202207L``
+    --------------------------------------------------- -----------------
     ``__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/ReleaseNotes/17.rst

 - P2505R5 - Monadic operations for ``std::expected``
 - P2711R1 - Making Multi-Param Constructors Of views explicit (``join_with_view`` is not done yet)
 - P2572R1 - ``std::format`` fill character allowances
 - P2510R3 - Formatting pointers
 - P2136R3 - ``invoke_r``
 - P2494R2 - Relaxing range adaptors to allow for move only types
 - P2585R0 - Improving default container formatting
 - P0408R7 - Efficient Access to ``basic_stringbuf``'s Buffer
-
+- P2474R2 - ``views::repeat``
 
 Improvements and New Features
 -----------------------------
 - ``std::equal``, ``std::ranges::equal``, ``std::find``, and
   ``std::ranges::find``  are now forwarding to ``std::memcmp`` for trivially
   equality comparable types, which can lead up to 40x performance improvements.
 
 - ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe

libcxx/docs/Status/Cxx23Issues.csv

 "`3843 <https://wg21.link/LWG3843>`__","``std::expected<T,E>::value() &`` assumes ``E`` is copy constructible","February 2023","|Complete|","17.0",""
 "`3847 <https://wg21.link/LWG3847>`__","``ranges::to`` can still return views","February 2023","","","|ranges|"
 "`3862 <https://wg21.link/LWG3862>`__","``basic_const_iterator``'s ``common_type`` specialization is underconstrained","February 2023","","",""
 "`3865 <https://wg21.link/LWG3865>`__","Sorting a range of ``pairs``","February 2023","|Complete|","17.0","|ranges|"
 "`3869 <https://wg21.link/LWG3869>`__","Deprecate ``std::errc`` constants related to UNIX STREAMS","February 2023","","",""
 "`3870 <https://wg21.link/LWG3870>`__","Remove ``voidify``","February 2023","","",""
 "`3871 <https://wg21.link/LWG3871>`__","Adjust note about ``terminate``","February 2023","","",""
 "`3872 <https://wg21.link/LWG3872>`__","``basic_const_iterator`` should have custom ``iter_move``","February 2023","","",""
-"`3875 <https://wg21.link/LWG3875>`__","``std::ranges::repeat_view<T, IntegerClass>::iterator`` may be ill-formed","February 2023","","","|ranges|"
+"`3875 <https://wg21.link/LWG3875>`__","``std::ranges::repeat_view<T, IntegerClass>::iterator`` may be ill-formed","February 2023","|Complete|","17.0","|ranges|"
 "`3876 <https://wg21.link/LWG3876>`__","Default constructor of ``std::layout_XX::mapping`` misses precondition","February 2023","","",""
 "`3877 <https://wg21.link/LWG3877>`__","Incorrect constraints on ``const``-qualified monadic overloads for ``std::expected``","February 2023","|Complete|","17.0",""
 "`3878 <https://wg21.link/LWG3878>`__","import ``std;`` should guarantee initialization of standard iostreams objects","February 2023","","",""
 "`3879 <https://wg21.link/LWG3879>`__","``erase_if`` for ``flat_{,multi}set`` is incorrectly specified","February 2023","","",""
 "`3880 <https://wg21.link/LWG3880>`__","Clarify ``operator+=`` complexity for ``{chunk,stride}_view::iterator``","February 2023","","","|ranges|"
 "`3881 <https://wg21.link/LWG3881>`__","Incorrect formatting of container adapters backed by ``std::string``","February 2023","|Complete|","17.0","|format|"

libcxx/docs/Status/Cxx23Papers.csv

 "`P2417R2 <https://wg21.link/P2417R2>`__","LWG","A more ``constexpr`` ``bitset``","July 2022","|Complete|","16.0"
 "`P2419R2 <https://wg21.link/P2419R2>`__","LWG","Clarify handling of encodings in localized formatting of chrono types","July 2022","",""
 "`P2438R2 <https://wg21.link/P2438R2>`__","LWG","``std::string::substr() &&``","July 2022","|Complete|","16.0"
 "`P2445R1 <https://wg21.link/P2445R1>`__","LWG","``forward_like``","July 2022","|Complete|","16.0"
 "`P2446R2 <https://wg21.link/P2446R2>`__","LWG","``views::as_rvalue``","July 2022","|Complete|","16.0","|ranges|"
 "`P2460R2 <https://wg21.link/P2460R2>`__","LWG","Relax requirements on ``wchar_t`` to match existing practices","July 2022","",""
 "`P2465R3 <https://wg21.link/P2465R3>`__","LWG","Standard Library Modules ``std`` and ``std.compat``","July 2022","",""
 "`P2467R1 <https://wg21.link/P2467R1>`__","LWG","Support exclusive mode for ``fstreams``","July 2022","",""
-"`P2474R2 <https://wg21.link/P2474R2>`__","LWG","``views::repeat``","July 2022","","","|ranges|"
+"`P2474R2 <https://wg21.link/P2474R2>`__","LWG","``views::repeat``","July 2022","|Complete|","17.0","|ranges|"
 "`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","|Complete|","17.0","|ranges|"
 "`P2499R0 <https://wg21.link/P2499R0>`__","LWG","``string_view`` range constructor should be ``explicit``","July 2022","|Complete|","16.0","|ranges|"
 "`P2502R2 <https://wg21.link/P2502R2>`__","LWG","``std::generator``: Synchronous Coroutine Generator for Ranges","July 2022","","","|ranges|"
 "`P2508R1 <https://wg21.link/P2508R1>`__","LWG","Exposing ``std::basic-format-string``","July 2022","|Complete|","15.0"
 "`P2513R4 <https://wg21.link/P2513R4>`__","LWG","``char8_t`` Compatibility and Portability Fixes","July 2022","",""
 "`P2517R1 <https://wg21.link/P2517R1>`__","LWG","Add a conditional ``noexcept`` specification to ``std::apply``","July 2022","",""
 "`P2520R0 <https://wg21.link/P2520R0>`__","LWG","``move_iterator`` should be a random access iterator","July 2022","|Complete| [#note-P2520R0]_","17.0","|ranges|"
 "`P2540R1 <https://wg21.link/P2540R1>`__","LWG","Empty Product for certain Views","July 2022","","","|ranges|"

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>`_,✅
 C++23,`stride <https://wg21.link/P1899R3>`_,Hristo Hristov,No patch yet,In Progress
 C++23,`enumerate <https://wg21.link/P2164R9>`_,Hristo Hristov,No patch yet,In Progress

libcxx/include/CMakeLists.txt

set(files
   __ranges/lazy_split_view.h
   __ranges/movable_box.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 <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/remove_cvref.h>
-> decltype(      _RawRange(
       // expression used in the `noexcept` clause and the return statement).
       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)
                               );}
+// clang-format off
+#if _LIBCPP_STD_VER >= 23
+  // [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_repeat_specialization<_RawRange> && sized_range<_RawRange>)
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+    -> decltype(      views::repeat(*__range.__value_, ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))))
+    { return          views::repeat(*__range.__value_, 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_repeat_specialization<_RawRange> && !sized_range<_RawRange>)
+  _LIBCPP_NODISCARD_EXT _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)); }
+#endif
+// clang-format on
 
   // [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> ||
+#if _LIBCPP_STD_VER >= 23
+                __is_repeat_specialization<_RawRange> ||
+#endif
                (__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
   constexpr auto operator()(_Range&& __range, _Np&& __n) const
     noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
     -> decltype(      drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
     { return          drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }

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/iota_view.h>
+#include <__ranges/movable_box.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_cv.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
+#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 <class _Tp>
+concept __integer_like_with_usable_difference_type =
+    __signed_integer_like<_Tp> || (__integer_like<_Tp> && weakly_incrementable<_Tp>);
+
+template <class _Tp>
+struct __repeat_view_iterator_difference {
+  using type = _IotaDiffT<_Tp>;
+};
+
+template <__signed_integer_like _Tp>
+struct __repeat_view_iterator_difference<_Tp> {
+  using type = _Tp;
+};
+
+template <class _Tp>
+using __repeat_view_iterator_difference_t = typename __repeat_view_iterator_difference<_Tp>::type;
+
+namespace views::__drop {
+struct __fn;
+} // namespace views::__drop
+
+namespace views::__take {
+struct __fn;
+} // namespace views::__take
+
+template <move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
+  requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
+           (__integer_like_with_usable_difference_type<_Bound> || same_as<_Bound, unreachable_sentinel_t>))
+class repeat_view : public view_interface<repeat_view<_Tp, _Bound>> {
+  friend struct views::__take::__fn;
+  friend struct views::__drop::__fn;
+  class __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_sentinel = _Bound())
+    requires copy_constructible<_Tp>
+      : __value_(in_place, __value), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__bound_ >= 0, "The value of bound must be greater than or equal to 0");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(_Tp&& __value, _Bound __bound_sentinel = _Bound())
+      : __value_(in_place, std::move(__value)), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__bound_ >= 0, "The value of bound must be greater than or equal to 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_(in_place, std::make_from_tuple<_Tp>(std::move(__value_args))),
+        __bound_(std::make_from_tuple<_Bound>(std::move(__bound_args))) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(
+          __bound_ >= 0, "The behavior is undefined if Bound is not unreachable_sentinel_t and bound is negative");
+  }
+
+  _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>)
+  {
+    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:
+  __movable_box<_Tp> __value_;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Bound __bound_ = _Bound();
+};
+
+template <class _Tp, class _Bound>
+repeat_view(_Tp, _Bound) -> repeat_view<_Tp, _Bound>;
+
+// [range.repeat.iterator]
+template <move_constructible _Tp, semiregular _Bound>
+  requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
+           (__integer_like_with_usable_difference_type<_Bound> || same_as<_Bound, unreachable_sentinel_t>))
+class repeat_view<_Tp, _Bound>::__iterator {
+  friend class repeat_view;
+
+  using _IndexT = conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(const _Tp* __value, _IndexT __bound_sentinel = _IndexT())
+      : __value_(__value), __current_(__bound_sentinel) {}
+
+public:
+  using iterator_concept  = random_access_iterator_tag;
+  using iterator_category = random_access_iterator_tag;
+  using value_type        = _Tp;
+  using difference_type   = __repeat_view_iterator_difference_t<_IndexT>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--() {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ > 0, "The value of bound must be greater than or equal to 0");
+    --__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int) {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ + __n >= 0, "The value of bound must be greater than or equal to 0");
+    __current_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT(__current_ - __n >= 0, "The value of bound must be greater than or equal to 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 __iterator& __x, const __iterator& __y) {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_ <=> __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n) {
+    __i -= __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y) {
+    return static_cast<difference_type>(__x.__current_) - static_cast<difference_type>(__y.__current_);
+  }
+
+private:
+  const _Tp* __value_ = nullptr;
+  _IndexT __current_  = _IndexT();
+};
+
+// clang-format off
+namespace views {
+namespace __repeat {
+struct __fn {
+  template <class _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 _Bound>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __value, _Bound&& __bound_sentinel) const
+    noexcept(noexcept(ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel))))
+    -> decltype(      ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel)))
+    { return          ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel)); }
+};
+} // namespace __repeat
+// clang-format on
+
+inline namespace __cpo {
+inline constexpr auto repeat = __repeat::__fn{};
+} // namespace __cpo
+} // namespace views
+
+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;
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_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/decay.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/maybe_const.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/auto_cast.h>

 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>
 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(
                               // Note: deliberately not forwarding `__rng` to guard against double moves.
                               *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))
                               ); }
+// clang-format off
+#if _LIBCPP_STD_VER >= 23
+  // [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_repeat_specialization<_RawRange> && sized_range<_RawRange>)
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+    -> decltype(      views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))))
+    { return          views::repeat(*__range.__value_, 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_repeat_specialization<_RawRange> && !sized_range<_RawRange>)
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, static_cast<_Dist>(__n))))
+    -> decltype(      views::repeat(*__range.__value_, static_cast<_Dist>(__n)))
+    { return          views::repeat(*__range.__value_, static_cast<_Dist>(__n)); }
+#endif
+// clang-format on
 
   // [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> ||
+#if _LIBCPP_STD_VER >= 23
+                __is_repeat_specialization<_RawRange> ||
+#endif
                (__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 lazy_split_view            { private header "__ranges/lazy_split_view.h" }
       module movable_box                { private header "__ranges/movable_box.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"
         export type_traits.make_unsigned
       }
       module split_view                 { private header "__ranges/split_view.h" }
       module subrange                   {

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<class T>
+    concept integer-like-with-usable-difference-type =  // exposition only
+      is-signed-integer-like<T> || (is-integer-like<T> && weakly_incrementable<T>);
+
+  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
+    requires (is_object_v<T> && same_as<T, remove_cv_t<T>> &&
+              (integer-like-with-usable-difference-type<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/filter_view.h>
 #include <__ranges/from_range.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_quoted_string_io                              201304L <iomanip>
 __cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <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                                 202207L <ranges>
 __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_ratio                                         202306L <ratio>

 # define __cpp_lib_optional                             202110L
 // # define __cpp_lib_out_ptr                              202106L
 // # define __cpp_lib_print                                202207L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # 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                        202207L
 // # 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_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
 # define __cpp_lib_stdatomic_h                          202011L

libcxx/modules/std/ranges.cppm

namespace ranges {
     // [range.iota], iota view
     using std::ranges::iota_view;
 
     namespace views {
       using std::ranges::views::iota;
     } // namespace views
 
     // [range.repeat], repeat view
-#if 0
     using std::ranges::repeat_view;
 
     namespace views {
       using std::ranges::views::repeat;
     } // namespace views
-#endif
+
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
     // [range.istream], istream view
     using std::ranges::basic_istream_view;
     using std::ranges::istream_view;
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     using std::ranges::wistream_view;
 #  endif
 

libcxx/test/libcxx/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-has-hardened-mode && !libcpp-has-debug-mode
+// REQUIRES: has-unix-headers
+// XFAIL: availability-verbose_abort-missing
+
+// template<class... TArgs, class... BoundArgs>
+//       requires constructible_from<T, TArgs...> &&
+//                constructible_from<Bound, BoundArgs...>
+//     constexpr explicit repeat_view(piecewise_construct_t,
+//       tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
+
+#include <ranges>
+#include <tuple>
+
+#include "check_assertion.h"
+
+// clang-format off
+int main(int, char**) {
+  using Repeat = std::ranges::repeat_view<int, int>;
+  TEST_LIBCPP_ASSERT_FAILURE(Repeat(std::piecewise_construct, std::tuple{1}, std::tuple{-1}), "The behavior is undefined if Bound is not unreachable_sentinel_t and bound is negative");
+
+  return 0;
+}
+// clang-format on

libcxx/test/libcxx/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-has-hardened-mode && !libcpp-has-debug-mode
+// REQUIRES: has-unix-headers
+// XFAIL: availability-verbose_abort-missing
+
+// constexpr explicit repeat_view(W&& value, Bound bound = Bound());
+// constexpr explicit repeat_view(const W& value, Bound bound = Bound());
+
+#include <ranges>
+
+#include "check_assertion.h"
+
+// clang-format off
+int main(int, char**) {
+  TEST_LIBCPP_ASSERT_FAILURE(std::ranges::repeat_view(0, -1), "The value of bound must be greater than or equal to 0");
+  const int val = 0;
+  TEST_LIBCPP_ASSERT_FAILURE(std::ranges::repeat_view(val, -1), "The value of bound must be greater than or equal to 0");
+
+  return 0;
+}
+// clang-format on

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              202207L [C++20]
     __cpp_lib_ranges_as_rvalue    202207L [C++23]
     __cpp_lib_ranges_chunk        202202L [C++23]
     __cpp_lib_ranges_chunk_by     202202L [C++23]
     __cpp_lib_ranges_join_with    202202L [C++23]
+    __cpp_lib_ranges_repeat       202207L [C++23]
     __cpp_lib_ranges_slide        202202L [C++23]
     __cpp_lib_ranges_zip          202110L [C++23]
 */
 
 #include <ranges>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14

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

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

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

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

 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++23"
 #   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
 
+# ifndef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_repeat != 202207L
+#   error "__cpp_lib_ranges_repeat should have the value 202207L in c++23"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++23"
 #   endif
 # else // _LIBCPP_VERSION

 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++26"
 #   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
 
+# ifndef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_repeat != 202207L
+#   error "__cpp_lib_ranges_repeat should have the value 202207L in c++26"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++26"
 #   endif
 # else // _LIBCPP_VERSION

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

/*  Constant                                         Value
     __cpp_lib_print                                  202207L [C++23]
     __cpp_lib_quoted_string_io                       201304L [C++14]
     __cpp_lib_ranges                                 202207L [C++20]
     __cpp_lib_ranges_as_rvalue                       202207L [C++23]
     __cpp_lib_ranges_chunk                           202202L [C++23]
     __cpp_lib_ranges_chunk_by                        202202L [C++23]
     __cpp_lib_ranges_iota                            202202L [C++23]
     __cpp_lib_ranges_join_with                       202202L [C++23]
+    __cpp_lib_ranges_repeat                          202207L [C++23]
     __cpp_lib_ranges_slide                           202202L [C++23]
     __cpp_lib_ranges_starts_ends_with                202106L [C++23]
     __cpp_lib_ranges_to_container                    202202L [C++23]
     __cpp_lib_ranges_zip                             202110L [C++23]
     __cpp_lib_ratio                                  202306L [C++26]
     __cpp_lib_raw_memory_algorithms                  201606L [C++17]
     __cpp_lib_rcu                                    202306L [C++26]
     __cpp_lib_reference_from_temporary               202202L [C++23]

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

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

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

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

 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++23"
 #   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
 
+# ifndef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should be defined in c++23"
+# endif
+# if __cpp_lib_ranges_repeat != 202207L
+#   error "__cpp_lib_ranges_repeat should have the value 202207L in c++23"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++23"
 #   endif
 # else // _LIBCPP_VERSION

 #     error "__cpp_lib_ranges_join_with should have the value 202202L in c++26"
 #   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
 
+# ifndef __cpp_lib_ranges_repeat
+#   error "__cpp_lib_ranges_repeat should be defined in c++26"
+# endif
+# if __cpp_lib_ranges_repeat != 202207L
+#   error "__cpp_lib_ranges_repeat should have the value 202207L in c++26"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_slide
 #     error "__cpp_lib_ranges_slide should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_slide != 202202L
 #     error "__cpp_lib_ranges_slide should have the value 202202L in c++26"
 #   endif
 # else // _LIBCPP_VERSION

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));
   }
 
+#if TEST_STD_VER >= 23
+  // `views::drop(repeat_view, n)` returns a `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);
+    static_assert(std::ranges::sized_range<Result>);
+    assert(result.size() == 5);
+    assert(*result.begin() == 1);
+  }
+
+  // `views::drop(repeat_view, n)` returns a `repeat_view` when `repeat_view` doesn't model `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::ranges::sized_range<Result>);
+    static_assert(std::same_as<std::unreachable_sentinel_t, decltype(result.end())>);
+  }
+#endif
+
   // 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`.
     auto iota = std::views::iota(1, 8);
     // 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);
   }
 
+#if TEST_STD_VER >= 23
+  // `views::take(repeat_view, n)` returns a `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);
+    static_assert(std::ranges::sized_range<Result>);
+    assert(result.size() == 3);
+    assert(*result.begin() == 1);
+  }
+
+  // `views::take(repeat_view, n)` returns a `repeat_view` when `repeat_view` doesn't model `sized_range`.
+  {
+    auto repeat  = std::ranges::repeat_view<int>(1);
+    using Result = std::ranges::repeat_view<int, std::ranges::range_difference_t<decltype(repeat)>>;
+    std::same_as<Result> decltype(auto) result = repeat | std::views::take(3);
+    assert(result.size() == 3);
+    assert(*result.begin() == 1);
+  }
+#endif
+
   // 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));
   }
 

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
+
+// constexpr iterator begin() const;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+constexpr bool test() {
+  // Test unbound && 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);
+  }
+
+  // Test unbound && 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);
+  }
+
+  // Test bound && non-const view
+  {
+    std::ranges::repeat_view<int, int> rv(1024, 10);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 1024);
+  }
+
+  // Test bound && const view
+  {
+    const std::ranges::repeat_view<int, long long> rv(1024, 10);
+    std::same_as<std::ranges::iterator_t<decltype(rv)>> decltype(auto) iter = rv.begin();
+    assert(*iter == 1024);
+  }
+
+  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 T, class Bound>
+//    repeat_view(T, Bound) -> repeat_view<T, Bound>;
+
+#include <concepts>
+#include <ranges>
+#include <utility>
+
+struct Empty {};
+
+// clang-format off
+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(10, 1)), std::ranges::repeat_view<int, int>>);
+static_assert(std::same_as<decltype(std::ranges::repeat_view(10, 1U)), std::ranges::repeat_view<int, unsigned>>);
+static_assert(std::same_as<decltype(std::ranges::repeat_view(10, 1UL)), std::ranges::repeat_view<int, unsigned long>>);
+// clang-format on

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<T> = default;
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+
+struct DefaultInt42 {
+  int value = 42;
+};
+
+struct Int {
+  Int(int) {}
+};
+
+static_assert(std::default_initializable<std::ranges::repeat_view<DefaultInt42>>);
+static_assert(!std::default_initializable<std::ranges::repeat_view<Int>>);
+
+constexpr bool test() {
+  std::ranges::repeat_view<DefaultInt42> rv;
+  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
+
+// template<class... TArgs, class... BoundArgs>
+//       requires constructible_from<T, TArgs...> &&
+//                constructible_from<Bound, BoundArgs...>
+//     constexpr explicit repeat_view(piecewise_construct_t,
+//       tuple<TArgs...> value_args, tuple<BoundArgs...> bound_args = tuple<>{});
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+#include <tuple>
+#include <utility>
+
+struct C {};
+
+struct B {
+  int v;
+};
+
+struct A {
+  int x = 111;
+  int y = 222;
+
+  constexpr A() = default;
+  constexpr A(B b) : x(b.v), y(b.v + 1) {}
+  constexpr A(int _x, int _y) : x(_x), y(_y) {}
+};
+
+static_assert(std::constructible_from<std::ranges::repeat_view<A, int>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<int, int>,
+                                      std::tuple<int>>);
+static_assert(std::constructible_from<std::ranges::repeat_view<A, int>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<B>,
+                                      std::tuple<int>>);
+static_assert(std::constructible_from<std::ranges::repeat_view<A, int>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<>,
+                                      std::tuple<int>>);
+static_assert(std::constructible_from<std::ranges::repeat_view<A>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<int, int>,
+                                      std::tuple<std::unreachable_sentinel_t>>);
+static_assert(std::constructible_from<std::ranges::repeat_view<A>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<B>,
+                                      std::tuple<std::unreachable_sentinel_t>>);
+static_assert(std::constructible_from<std::ranges::repeat_view<A>,
+                                      std::piecewise_construct_t,
+                                      std::tuple<>,
+                                      std::tuple<std::unreachable_sentinel_t>>);
+static_assert(!std::constructible_from<std::ranges::repeat_view<A, int>,
+                                       std::piecewise_construct_t,
+                                       std::tuple<C>,
+                                       std::tuple<int>>);
+static_assert(!std::constructible_from<std::ranges::repeat_view<A>,
+                                       std::piecewise_construct_t,
+                                       std::tuple<C>,
+                                       std::tuple<std::unreachable_sentinel_t>>);
+static_assert(!std::constructible_from<std::ranges::repeat_view<A, int>,
+                                       std::piecewise_construct_t,
+                                       std::tuple<int, int, int>,
+                                       std::tuple<int>>);
+static_assert(!std::constructible_from<std::ranges::repeat_view<A>,
+                                       std::piecewise_construct_t,
+                                       std::tuple<int, int, int>,
+                                       std::tuple<std::unreachable_sentinel_t>>);
+static_assert(
+    !std::constructible_from<std::ranges::repeat_view<A>, std::piecewise_construct_t, std::tuple<B>, std::tuple<int>>);
+
+constexpr bool test() {
+  {
+    std::ranges::repeat_view<A, int> rv(std::piecewise_construct, std::tuple{}, std::tuple{3});
+    assert(rv.size() == 3);
+    assert(rv[0].x == 111);
+    assert(rv[0].y == 222);
+    assert(rv.begin() + 3 == rv.end());
+  }
+  {
+    std::ranges::repeat_view<A> rv(std::piecewise_construct, std::tuple{}, std::tuple{std::unreachable_sentinel});
+    assert(rv[0].x == 111);
+    assert(rv[0].y == 222);
+    assert(rv.begin() + 300 != rv.end());
+  }
+  {
+    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(rv.begin() + 3 == rv.end());
+  }
+  {
+    std::ranges::repeat_view<A> rv(std::piecewise_construct, std::tuple{1, 2}, std::tuple{std::unreachable_sentinel});
+    assert(rv[0].x == 1);
+    assert(rv[0].y == 2);
+    assert(rv.begin() + 300 != rv.end());
+  }
+  {
+    std::ranges::repeat_view<A, int> rv(std::piecewise_construct, std::tuple{B{11}}, std::tuple{3});
+    assert(rv.size() == 3);
+    assert(rv[0].x == 11);
+    assert(rv[0].y == 12);
+    assert(rv.begin() + 3 == rv.end());
+  }
+  {
+    std::ranges::repeat_view<A> rv(std::piecewise_construct, std::tuple{B{10}}, std::tuple{std::unreachable_sentinel});
+    assert(rv[0].x == 10);
+    assert(rv[0].y == 11);
+    assert(rv.begin() + 300 != 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
+
+// constexpr explicit repeat_view(const T& value, Bound bound = Bound()) requires copy_constructible<T>;
+// constexpr explicit repeat_view(T&& value, Bound bound = Bound());
+
+#include <ranges>
+#include <cassert>
+#include <iterator>
+#include <type_traits>
+
+#include "MoveOnly.h"
+
+struct Empty {};
+
+// Test explicit
+static_assert(std::is_constructible_v<std::ranges::repeat_view<Empty>, const Empty&>);
+static_assert(std::is_constructible_v<std::ranges::repeat_view<Empty>, Empty&&>);
+static_assert(std::is_constructible_v<std::ranges::repeat_view<Empty, int>, const Empty&>);
+static_assert(std::is_constructible_v<std::ranges::repeat_view<Empty, int>, Empty&&>);
+
+static_assert(!std::is_convertible_v<const Empty&, std::ranges::repeat_view<Empty>>);
+static_assert(!std::is_convertible_v<Empty&&, std::ranges::repeat_view<Empty>>);
+static_assert(!std::is_convertible_v<const Empty&, std::ranges::repeat_view<Empty, int>>);
+static_assert(!std::is_convertible_v<Empty&&, std::ranges::repeat_view<Empty, int>>);
+
+static_assert(!std::is_constructible_v<std::ranges::repeat_view<MoveOnly>, const MoveOnly&>);
+static_assert(std::is_constructible_v<std::ranges::repeat_view<MoveOnly>, MoveOnly&&>);
+
+constexpr bool test() {
+  // Move && unbound && default argument
+  {
+    std::ranges::repeat_view<Empty> rv(Empty{});
+    assert(rv.begin() + 10 != rv.end());
+  }
+
+  // Move && unbound && user-provided argument
+  {
+    std::ranges::repeat_view<Empty> rv(Empty{}, std::unreachable_sentinel);
+    assert(rv.begin() + 10 != rv.end());
+  }
+
+  // Move && bound && default argument
+  {
+    std::ranges::repeat_view<Empty, int> rv(Empty{});
+    assert(rv.begin() == rv.end());
+  }
+
+  // Move && bound && user-provided argument
+  {
+    std::ranges::repeat_view<Empty, int> rv(Empty{}, 10);
+    assert(rv.begin() + 10 == rv.end());
+  }
+
+  // Copy && unbound && default argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty> rv(e);
+    assert(rv.begin() + 10 != rv.end());
+  }
+
+  // Copy && unbound && user-provided argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty> rv(e, std::unreachable_sentinel);
+    assert(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 && user-provided argument
+  {
+    Empty e;
+    std::ranges::repeat_view<Empty, int> rv(e, 10);
+    assert(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
+
+// constexpr unreachable_sentinel_t end() const noexcept;
+// constexpr iterator end() const requires (!same_as<Bound, unreachable_sentinel_t>);
+
+#include <ranges>
+#include <cassert>
+#include <concepts>
+#include <iterator>
+
+constexpr bool test() {
+  // bound
+  {
+    std::ranges::repeat_view<int, int> rv(0, 10);
+    assert(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&>);
+    for (const auto& i : rv) {
+      assert(i == 0);
+    }
+  }
+
+  // unbound
+  {
+    std::ranges::repeat_view<int> rv(0);
+    assert(rv.begin() + 10 != rv.end());
+    static_assert(std::same_as<decltype(rv.end()), std::unreachable_sentinel_t>);
+    static_assert(noexcept(rv.end()));
+    for (const auto& i : rv | std::views::take(10)) {
+      assert(i == 0);
+    }
+  }
+  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() {
+  // Test unbound
+  {
+    using R = std::ranges::repeat_view<int>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    std::ranges::repeat_view<int> r(42);
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    static_assert(std::same_as<decltype(iter1 == iter2), bool>);
+
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+
+    assert(!(iter1 < iter1));
+    assert(iter1 < iter2);
+    assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);
+    assert(iter1 <= iter2);
+    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));
+    assert(!(iter1 > iter2));
+    assert(iter2 > iter1);
+    assert(iter1 >= iter1);
+    assert(!(iter1 >= iter2));
+    assert(iter2 >= iter1);
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+    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);
+
+    static_assert(std::same_as<decltype(iter1 <=> iter2), std::strong_ordering>);
+  }
+
+  // Test bound
+  {
+    using R = std::ranges::repeat_view<int, int>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    std::ranges::repeat_view<int, int> r(42, 10);
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    static_assert(std::same_as<decltype(iter1 == iter2), bool>);
+
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+
+    assert(!(iter1 < iter1));
+    assert(iter1 < iter2);
+    assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);
+    assert(iter1 <= iter2);
+    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));
+    assert(!(iter1 > iter2));
+    assert(iter2 > iter1);
+    assert(iter1 >= iter1);
+    assert(!(iter1 >= iter2));
+    assert(iter2 >= iter1);
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+    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>
+#include <type_traits>
+
+constexpr bool test() {
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  static_assert(std::is_default_constructible_v<Iter>);
+  [[maybe_unused]] Iter 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() {
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  std::ranges::repeat_view<int> rv(10);
+  auto iter = rv.begin() + 10;
+
+  assert(iter-- == rv.begin() + 10);
+  assert(--iter == rv.begin() + 8);
+
+  static_assert(std::same_as<decltype(iter--), Iter>);
+  static_assert(std::same_as<decltype(--iter), Iter&>);
+
+  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 <concepts>
+#include <cassert>
+
+constexpr bool test() {
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  std::ranges::repeat_view<int> rv(10);
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  auto iter  = rv.begin();
+
+  assert(iter++ == rv.begin());
+  assert(++iter == rv.begin() + 2);
+
+  static_assert(std::same_as<decltype(iter++), Iter>);
+  static_assert(std::same_as<decltype(++iter), Iter&>);
+
+  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 = T;
+// using difference_type = see below:
+// If is-signed-integer-like<index-type> is true, the member typedef-name difference_type denotes
+// index-type. Otherwise, it denotes IOTA-DIFF-T(index-type).
+
+#include <cassert>
+#include <concepts>
+#include <cstdint>
+#include <ranges>
+#include <type_traits>
+
+constexpr bool test() {
+  // unbound
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+    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
+  {
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::int8_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) == sizeof(std::int8_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::uint8_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) > sizeof(std::uint8_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::int16_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) == sizeof(std::int16_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::uint16_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) > sizeof(std::uint16_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::int32_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) == sizeof(std::int32_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::uint32_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) > sizeof(std::uint32_t));
+    }
+
+    {
+      using Iter = std::ranges::iterator_t<const std::ranges::repeat_view<int, std::int64_t>>;
+      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::is_signed_v<Iter::difference_type>);
+      static_assert(sizeof(Iter::difference_type) == sizeof(std::int64_t));
+    }
+  }
+
+  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
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+    std::ranges::repeat_view<int> v(0);
+    Iter iter = v.begin() + 10;
+    assert(iter - 5 == v.begin() + 5);
+    static_assert(std::same_as<decltype(iter - 5), Iter>);
+  }
+
+  // <iterator> - <iterator>
+  {
+    // unbound
+    {
+      std::ranges::repeat_view<int> v(0);
+      auto iter1 = v.begin() + 10;
+      auto iter2 = 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 = v.begin() + 10;
+      auto iter2 = 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 = v.begin() + 10;
+      auto iter2 = v.begin() + 5;
+      assert(iter1 - iter2 == 5);
+      static_assert(sizeof(decltype(iter1 - iter2)) > sizeof(unsigned));
+    }
+  }
+
+  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() {
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  std::ranges::repeat_view<int> v(10);
+  auto iter = v.begin() + 10;
+  iter -= 5;
+  assert(iter == v.begin() + 5);
+
+  static_assert(std::same_as<decltype(iter -= 5), Iter&>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  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);
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  auto iter  = v.begin();
+  assert(iter + 5 == v.begin() + 5);
+  assert(5 + iter == v.begin() + 5);
+  assert(2 + iter == v.begin() + 2);
+  assert(3 + iter == v.begin() + 3);
+
+  static_assert(std::same_as<decltype(iter + 5), Iter>);
+  static_assert(std::same_as<decltype(5 + iter), Iter>);
+
+  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);
+  using Iter = std::ranges::iterator_t<std::ranges::repeat_view<int>>;
+  auto iter1 = v.begin() + 10;
+  auto iter2 = v.begin() + 10;
+  assert(iter1 == iter2);
+  iter1 += 5;
+  assert(iter1 != iter2);
+  assert(iter1 == iter2 + 5);
+
+  static_assert(std::same_as<decltype(iter2 += 5), Iter&>);
+  assert(std::addressof(iter2) == std::addressof(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() {
+  // unbound
+  {
+    std::ranges::repeat_view<int> v(31);
+    auto iter = v.begin();
+
+    const int& val = *iter;
+    for (int i = 0; i < 100; ++i, ++iter) {
+      assert(*iter == 31);
+      assert(&*iter == &val);
+    }
+
+    static_assert(noexcept(*iter));
+    static_assert(std::same_as<decltype(*iter), const int&>);
+  }
+
+  // bound && one element
+  {
+    std::ranges::repeat_view<int, int> v(31, 1);
+    auto iter = v.begin();
+    assert(*iter == 31);
+    static_assert(noexcept(*iter));
+    static_assert(std::same_as<decltype(*iter), const int&>);
+  }
+
+  // bound && several elements
+  {
+    std::ranges::repeat_view<int, int> v(31, 100);
+    auto iter = v.begin();
+
+    const int& val = *iter;
+    for (int i = 0; i < 100; ++i, ++iter) {
+      assert(*iter == 31);
+      assert(&*iter == &val);
+    }
+  }
+
+  // bound && foreach
+  {
+    for (const auto& val : std::views::repeat(31, 100))
+      assert(val == 31);
+  }
+
+  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>
+#include <algorithm>
+
+constexpr bool test() {
+  // unbound
+  {
+    std::ranges::repeat_view<int> v(31);
+    auto iter = v.begin();
+    assert(std::ranges::all_of(std::views::iota(0, 100), [&v](int i) { return v[i] == 31; }));
+
+    static_assert(noexcept(iter[0]));
+    static_assert(std::same_as<decltype(iter[0]), const int&>);
+  }
+
+  // bound
+  {
+    std::ranges::repeat_view<int, int> v(32);
+    auto iter = v.begin();
+    assert(std::ranges::all_of(v, [](int i) { return i == 32; }));
+    static_assert(noexcept(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, c++20
+
+// constexpr auto size() const requires (!same_as<Bound, unreachable_sentinel_t>);
+
+#include <ranges>
+#include <numeric>
+#include <concepts>
+#include <cassert>
+#include <iterator>
+
+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());
+  }
+
+  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, c++20
+
+// template <class T>
+// views::repeat(T &&) requires constructible_from<ranges::repeat_view<T>, T>;
+
+// templaye <class T, class Bound>
+// views::repeat(T &&, Bound &&) requires constructible_from<ranges::repeat_view<T, Bound>, T, Bound>;
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+
+#include "MoveOnly.h"
+
+struct NonCopyable {
+  NonCopyable(NonCopyable&) = delete;
+};
+
+struct NonDefaultCtor {
+  NonDefaultCtor(int) {}
+};
+
+struct Empty {};
+
+struct LessThan3 {
+  constexpr bool operator()(int i) const { return i < 3; }
+};
+
+struct EqualTo33 {
+  constexpr bool operator()(int i) const { return i == 33; }
+};
+
+struct Add3 {
+  constexpr int operator()(int i) const { return i + 3; }
+};
+
+// Tp is_object
+static_assert(std::is_invocable_v<decltype(std::views::repeat), int>);
+static_assert(!std::is_invocable_v<decltype(std::views::repeat), void>);
+
+// _Bound is semiregular, integer like or std::unreachable_sentinel_t
+static_assert(!std::is_invocable_v<decltype(std::views::repeat), int, Empty>);
+static_assert(!std::is_invocable_v<decltype(std::views::repeat), int, NonCopyable>);
+static_assert(!std::is_invocable_v<decltype(std::views::repeat), int, NonDefaultCtor>);
+static_assert(std::is_invocable_v<decltype(std::views::repeat), int, std::unreachable_sentinel_t>);
+
+// Tp is copy_constructible
+static_assert(!std::is_invocable_v<decltype(std::views::repeat), NonCopyable>);
+
+// Tp is move_constructible
+static_assert(std::is_invocable_v<decltype(std::views::repeat), MoveOnly>);
+
+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)>);
+
+  // unbound && drop_view
+  {
+    auto r = std::views::repeat(33) | std::views::drop(3);
+    static_assert(!std::ranges::sized_range<decltype(r)>);
+    assert(*r.begin() == 33);
+  }
+
+  // bound && drop_view
+  {
+    auto r = std::views::repeat(33, 8) | std::views::drop(3);
+    static_assert(std::ranges::sized_range<decltype(r)>);
+    assert(*r.begin() == 33);
+    assert(r.size() == 5);
+  }
+
+  // unbound && take_view
+  {
+    auto r = std::views::repeat(33) | std::views::take(3);
+    static_assert(std::ranges::sized_range<decltype(r)>);
+    assert(*r.begin() == 33);
+    assert(r.size() == 3);
+  }
+
+  // bound && take_view
+  {
+    auto r = std::views::repeat(33, 8) | std::views::take(3);
+    static_assert(std::ranges::sized_range<decltype(r)>);
+    assert(*r.begin() == 33);
+    assert(r.size() == 3);
+  }
+
+  // bound && transform_view
+  {
+    auto r = std::views::repeat(33, 8) | std::views::transform(Add3{});
+    assert(*r.begin() == 36);
+    assert(r.size() == 8);
+  }
+
+  // unbound && transform_view
+  {
+    auto r = std::views::repeat(33) | std::views::transform(Add3{});
+    assert(*r.begin() == 36);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

 #                   is only used when a feature isn't fully implemented. Once
 #                   you've fully implemented the feature, you should remove
 #                   this field.
 # ================  ============================================================
 feature_test_macros = [
     add_version_header(x)
     for x in [
         {
             "name": "__cpp_lib_adaptor_iterator_pair_constructor",
             "values": {"c++23": 202106},
             "headers": ["queue", "stack"],
         },
         {
             "name": "__cpp_lib_addressof_constexpr",
             "values": {"c++17": 201603},
             "headers": ["memory"],
         },
for x in [
         },
         {
             "name": "__cpp_lib_ranges_join_with",
             "values": {"c++23": 202202},
             "headers": ["ranges"],
             "unimplemented": True,
         },
         {
+            "name": "__cpp_lib_ranges_repeat",
+            "values": { "c++23": 202207},
+            "headers": ["ranges"],
+        },
+        {
             "name": "__cpp_lib_ranges_slide",
             "values": {"c++23": 202202},
             "headers": ["ranges"],
             "unimplemented": True,
         },
         {
             "name": "__cpp_lib_ranges_starts_ends_with",
             "values": {"c++23": 202106},