[libc++][ranges] implement `std::ranges::split_view` (targeting llvm 16)

[huixie90]

Summary

• implement std::ranges::split_view (last c++20 view)

[huixie90]

libcxx/include/__ranges/split_view.h

60

pointless _LIBCPP_NO_UNIQUE_ADDRESS .

[philnik]

The implementation looks mostly good. I didn't look at the tests yet.

libcxx/include/__ranges/split_view.h

121

Having this first seems like a bad idea. On 64-bit platforms this results in 7 bytes of padding. Maybe it would make sense to bit-pack this into the split_view<_View, _Pattern>*?

176

Why the comment here specifically, but not anywhere else?

190–194

Can you move this directly below the split_view, like we normally do?

201

same for the other one.

[var-const]

Looking great so far, thank you for working on this!

libcxx/include/__ranges/split_view.h

60

Can we omit it?

91

Nit: s/ele/elem/ (or el if you prefer a shorter name).

121

Also I don't think we have to follow the order in the standard, but there it's the last member variable.

201

@philnik We've been doing it this way for many (perhaps all) other views, should we change the others as well?

libcxx/test/std/ranges/range.adaptors/range.split/begin.pass.cpp

152

Question: is it not guaranteed to be 1?

170

I'll just leave a comment here to make sure we don't forget to revisit this test later (I presume it's a TODO).

libcxx/test/std/ranges/range.adaptors/range.split/ctor.range.pass.cpp

31

Optional: can counting be refactored out into a base class that is used as a mixin for RangeWithCounting?

libcxx/test/std/ranges/range.adaptors/range.split/end.pass.cpp

40

Nit: can you use a more visible number for splitting, e.g. 0 or -1? 3 doesn't really stand out.

56

Nit: I'm not sure what st stands for, can you consider a more descriptive name?

libcxx/test/std/ranges/range.adaptors/range.split/general.pass.cpp

2

Would it be possible to reuse tests from /range.adaptors/range.lazy.split/general.pass.cpp?

[philnik]

libcxx/include/__ranges/split_view.h

201

I think so, since it's an extension. I think we used [[nodiscard]] before because we wanted the extension for most users, but back then we didn't enable the [[nodiscard]] extensions by default. Now we do, so we can just say "don't disable the extension if you want it".

Looking through the views, it seems like we use [[nodiscard]] on views, and didn't declare views::iota, views::istream and views::zip with any [[nodiscard]] version.

[huixie90]

address comments

[huixie90]

CI:wq

[huixie90]

libcxx/include/__ranges/split_view.h

121

Yes I will move the bool to the end
Could you please elaborate on bit-packing?

201

let's do the others in a separate change

libcxx/test/std/ranges/range.adaptors/range.split/begin.pass.cpp

152

I am not totally sure as that is the implementation detail of std::ranges::search. What we care here is that the first time it is called the numbers go up and from the second time, the numbers won't go up anymore.

[huixie90]

CI

[philnik]

libcxx/include/__ranges/split_view.h

121

We can make sure that split_view is always at least 2 byte aligned (which it is in most cases anyways), which guarantees that the low bit of the pointer is always zero. Since we know that the low bit is always zero, we can use it as a flag. We just have to bit-and the pointer if we want to dereference it. I have an implementation of a utility class for this purpose in D140278, but that's currently not constexpr-friendly and needs some more work in general. Using it would essentially mean that we can't ship split_view in LLVM16, but I think QoI is more important than having split_view now.

[ldionne]

This looks reasonable to me. This is missing tests for iterators though. I'll let @var-const give the final approval.

libcxx/docs/Status/Cxx2bIssues.csv

134–137

For each issue being marked as completed, can you please make sure that we have a regression test? I don't mind if that means you don't mark them as completed in this patch, but I would like to avoid marking something as completed if we don't have a test for it.

libcxx/include/__ranges/split_view.h

121

Can you remove this constraint and see if anything fails? If not, it means we're missing test coverage. In particular, if you have a Pattern that would both work with all_t and is also the range_value_t of your range, I guess we want to take this deduction guide, not the one above.

121

I agree we should try to use pointer_int_pair here. One thing we could do is ship split_view in LLVM 16, but ship (just that view) as experimental, still. We could guard just that view with _LIBCPP_ENABLE_EXPERIMENTAL.

Edit: Thinking about it some more, I think we'll always need to reinterpret_cast stuff around to make this work. It's not clear to me that it'll ever work inside constexpr (quite unfortunately). If we don't think we have a reasonable path forward to make it work inside constexpr, it probably doesn't make sense to artificially delay this "just because". @philnik , unless you can think of a way to make pointer_int_pair constexpr in the future and you think it is likely to materialize, I wouldn't delay this.

libcxx/test/std/ranges/range.adaptors/range.split/begin.pass.cpp

2

High-level comment: @var-const had found some really surprising behavior when using lazy_split with e.g. C-style strings, because the separator would be e.g. abc\0. He had a test file where he tested a bunch of these corner cases, which are (unfortunately) mandated by the standard, despite being really surprising for users. I think split probably has the same corner cases, so we should also test those. It's probably easy to copy the tests over.

[var-const]

Addressed comments look good, I'll hold off final approval until the test coverage is finished. Thanks!

libcxx/include/__ranges/split_view.h

121

We don't do this optimization in a very similar case of lazy_split_view::outer-iterator (neither do the other implementations, for lazy_split_view or split_view). More importantly, is this optimization worth doing? It adds a runtime penalty on many invocations of operator++ and operator==, while I'm not sure if the benefit is worth it -- it makes the iterator type occupy less space, but it still won't fit into a register, and it doesn't seem likely that users are going to store it often. It seems like it would penalize the most common use case for the sake of a more niche one.

[philnik]

libcxx/include/__ranges/split_view.h

121

@philnik , unless you can think of a way to make pointer_int_pair constexpr in the future and you think it is likely to materialize, I wouldn't delay this.

While not super efficient, we can always just allocate a chunk of memory during constant evaluation to store a pointer and int.

We don't do this optimization in a very similar case of lazy_split_view::outer-iterator (neither do the other implementations, for lazy_split_view or split_view). More importantly, is this optimization worth doing? It adds a runtime penalty on many invocations of operator++ and operator==, while I'm not sure if the benefit is worth it -- it makes the iterator type occupy less space, but it still won't fit into a register, and it doesn't seem likely that users are going to store it often. It seems like it would penalize the most common use case for the sake of a more niche one.

I would expect the penalty to be extremely small. The operation itself is very fast on modern machines, and the compiler should be able to hoist the bit-and out of a loop. Here is a simple example: https://godbolt.org/z/Y7T1Ge6zW

[huixie90]

libcxx/include/__ranges/split_view.h

121

@philnik

While not super efficient, we can always just allocate a chunk of memory during constant evaluation to store a pointer and int.

What if it is a constexpr variable in namespace scope? Presumably you can't leak the memory allocation in the constexpr context?

[philnik]

libcxx/include/__ranges/split_view.h

121

Right, that doesn't work for constant initialization. Then I don't think it's possible without compiler magic, which I don't think is viable for now.

127–130

This makes it possible to pack the bool into the subrange.

[huixie90]

added remaining tests

[huixie90]

libcxx/include/__ranges/split_view.h

121

The constraint does not seem to be able to disambiguate these two overloads.
https://godbolt.org/z/h6Kcj53qY

[var-const]

Thanks a lot for working on this! LGTM with just a few comments.

(two more important comments are to fix a stray lazy_split and update the release notes (for release notes it's fine to do a follow-up). The rest is optional)

libcxx/docs/Status/Cxx20Papers.csv

197

This should also be mentioned in the release notes. It might be easier to do that in a follow-up.

libcxx/test/std/ranges/range.adaptors/range.split/general.pass.cpp

46

s/lazy_split/split/.

libcxx/test/std/ranges/range.adaptors/range.split/iterator/increment.pass.cpp

27 ↗

(On Diff #491181)

Optional: maybe make one of the next ranges have more characters than one?

27 ↗

(On Diff #491181)

Do we need to also check for cases where there are two or more separators in a row and when the input is empty? If it's covered by general.pass.cpp, that's fine.

37 ↗

(On Diff #491181)

Nit: any reason not to use same_as in the statement above? (If it's a compiler bug or something like that, never mind)

libcxx/test/std/ranges/range.adaptors/range.split/iterator/member_types.compile.pass.cpp

27 ↗

(On Diff #491181)

Optional: a typedef for SplitIter<Range<Iter>, Range<PatternIter> would cut a little boilerplate here. If you prefer having this more explicit, that's totally fine too.

libcxx/test/std/ranges/range.adaptors/range.split/sentinel/equal.pass.cpp

36 ↗

(On Diff #491181)

Optional: maybe advance the iterator to also check the case when it equals the sentinel?

[huixie90]

addressing comments

libcxx/test/std/ranges/range.adaptors/range.split/iterator/increment.pass.cpp

27 ↗

(On Diff #491181)

yes it is covered in general.pass.cpp

37 ↗

(On Diff #491181)

some apple platforms based on an older version of clang cannot deduce reference types in the same_as checking

[h-vetinari]

libcxx/docs/ReleaseNotes.rst

45–46 ↗

(On Diff #491649)

I guess the second sentence here has now become obsolete, and should be replaced?

[ldionne]

libcxx/docs/ReleaseNotes.rst

37 ↗

(On Diff #491649)

@huixie90 I think you forgot to update the Ranges status page, since https://libcxx.llvm.org/Status/Ranges.html is still showing split_view as not being done!

libcxx/docs/Status/Cxx20Papers.csv

 "`P1963R0 <https://wg21.link/P1963R0>`__","LWG","Fixing US 313","Prague","* *","",""
 "`P1964R2 <https://wg21.link/P1964R2>`__","LWG","Wording for boolean-testable","Prague","|Complete|","13.0"
 "`P1970R2 <https://wg21.link/P1970R2>`__","LWG","Consistency for size() functions: Add ranges::ssize","Prague","|Complete|","15.0","|ranges|"
 "`P1973R1 <https://wg21.link/P1973R1>`__","LWG","Rename ""_default_init"" Functions, Rev1","Prague","* *",""
 "`P1976R2 <https://wg21.link/P1976R2>`__","LWG","Fixed-size span construction from dynamic range","Prague","|Complete|","11.0","|ranges|"
 "`P1981R0 <https://wg21.link/P1981R0>`__","LWG","Rename leap to leap_second","Prague","* *",""
 "`P1982R0 <https://wg21.link/P1982R0>`__","LWG","Rename link to time_zone_link","Prague","* *",""
 "`P1983R0 <https://wg21.link/P1983R0>`__","LWG","Wording for GB301, US296, US292, US291, and US283","Prague","|Complete|","15.0","|ranges|"
-"`P1994R1 <https://wg21.link/P1994R1>`__","LWG","elements_view needs its own sentinel","Prague","Complete","16.0","|ranges|"
+"`P1994R1 <https://wg21.link/P1994R1>`__","LWG","elements_view needs its own sentinel","Prague","|Complete|","16.0","|ranges|"
 "`P2002R1 <https://wg21.link/P2002R1>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
 "`P2045R1 <https://wg21.link/P2045R1>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
 "`P2085R0 <https://wg21.link/P2085R0>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
 "`P2091R0 <https://wg21.link/P2091R0>`__","LWG","Issues with range access CPOs","Prague","|Complete|","15.0","|ranges|"
 "`P2101R0 <https://wg21.link/P2101R0>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102R0 <https://wg21.link/P2102R0>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106R0 <https://wg21.link/P2106R0>`__","LWG","Alternative wording for GB315 and GB316","Prague","|Complete|","15.0","|ranges|"
 "`P2116R0 <https://wg21.link/P2116R0>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"
 "","","","","","",""
 "`P2231R1 <https://wg21.link/P2231R1>`__","LWG","Missing constexpr in std::optional and std::variant","June 2021","|Partial| [#note-P2231]_","13.0"
 "`P2325R3 <https://wg21.link/P2325R3>`__","LWG","Views should not be required to be default constructible","June 2021","|Complete|","16.0","|ranges|"
-"`P2210R2 <https://wg21.link/P2210R2>`__","LWG","Superior String Splitting","June 2021","|In progress|","","|ranges|"
+"`P2210R2 <https://wg21.link/P2210R2>`__","LWG","Superior String Splitting","June 2021","|Complete|","16.0","|ranges|"
 "`P2216R3 <https://wg21.link/P2216R3>`__","LWG","std::format improvements","June 2021","|Complete|","15.0"
 "`P2281R1 <https://wg21.link/P2281R1>`__","LWG","Clarifying range adaptor objects","June 2021","|Complete|","14.0","|ranges|"
 "`P2328R1 <https://wg21.link/P2328R1>`__","LWG","join_view should join all views of ranges","June 2021","|Complete|","15.0","|ranges|"
 "`P2367R0 <https://wg21.link/P2367R0>`__","LWG","Remove misuses of list-initialization from Clause 24","June 2021","|Complete|","15.0","|ranges|"
 "","","","","","",""
 "`P2372R3 <https://wg21.link/P2372R3>`__","LWG","Fixing locale handling in chrono formatters","October 2021","|In Progress|",""
 "`P2415R2 <https://wg21.link/P2415R2>`__","LWG","What is a ``view``","October 2021","|Complete|","14.0","|ranges|"
 "`P2418R2 <https://wg21.link/P2418R2>`__","LWG","Add support for ``std::generator``-like types to ``std::format``","October 2021","|Complete|","15.0"
 "`P2432R1 <https://wg21.link/P2432R1>`__","LWG","Fix ``istream_view``","October 2021","|Complete|","16.0","|ranges|"

libcxx/docs/Status/Cxx2bIssues.csv

 "`3391 <https://wg21.link/LWG3391>`__","Problems with ``counted_iterator``/``move_iterator::base() const &``","February 2021","","","|ranges|"
 "`3433 <https://wg21.link/LWG3433>`__","``subrange::advance(n)`` has UB when ``n < 0``","February 2021","|Complete|","14.0","|ranges|"
 "`3490 <https://wg21.link/LWG3490>`__","``ranges::drop_while_view::begin()`` is missing a precondition","February 2021","|Nothing To Do|","","|ranges|"
 "`3492 <https://wg21.link/LWG3492>`__","Minimal improvements to ``elements_view::iterator``","February 2021","|Complete|","16.0","|ranges|"
 "`3494 <https://wg21.link/LWG3494>`__","Allow ranges to be conditionally borrowed","February 2021","Superseded by `P2017R1 <https://wg21.link/P2017R1>`__","","|ranges|"
 "`3495 <https://wg21.link/LWG3495>`__","``constexpr launder`` makes pointers to inactive members of unions usable","February 2021","|Nothing To Do|",""
 "`3500 <https://wg21.link/LWG3500>`__","``join_view::iterator::operator->()`` is bogus","February 2021","|Complete|","14.0","|ranges|"
 "`3502 <https://wg21.link/LWG3502>`__","``elements_view`` should not be allowed to return dangling reference","February 2021","|Complete|","16.0","|ranges|"
-"`3505 <https://wg21.link/LWG3505>`__","``split_view::outer-iterator::operator++`` misspecified","February 2021","","","|ranges|"
+"`3505 <https://wg21.link/LWG3505>`__","``split_view::outer-iterator::operator++`` misspecified","February 2021","|Complete|","16.0","|ranges|"
 "","","","","",""
 `2774 <https://wg21.link/LWG2774>`__,"``std::function`` construction vs assignment","June 2021","",""
 `2818 <https://wg21.link/LWG2818>`__,"``::std::`` everywhere rule needs tweaking","June 2021","|Nothing To Do|",""
 `2997 <https://wg21.link/LWG2997>`__,"LWG 491 and the specification of ``{forward_,}list::unique``","June 2021","",""
 `3410 <https://wg21.link/LWG3410>`__,"``lexicographical_compare_three_way`` is overspecified","June 2021","","","|spaceship|"
 `3430 <https://wg21.link/LWG3430>`__,"``std::fstream`` & co. should be constructible from string_view","June 2021","",""
 `3462 <https://wg21.link/LWG3462>`__,"§[formatter.requirements]: Formatter requirements forbid use of ``fc.arg()``","June 2021","","","|format|"
 `3481 <https://wg21.link/LWG3481>`__,"``viewable_range`` mishandles lvalue move-only views","June 2021","Superseded by `P2415R2 <https://wg21.link/P2415R2>`__","","|ranges|"
 `3506 <https://wg21.link/LWG3506>`__,"Missing allocator-extended constructors for ``priority_queue``","June 2021","|Complete|","14.0"
 `3517 <https://wg21.link/LWG3517>`__,"``join_view::iterator``'s ``iter_swap`` is underconstrained","June 2021","|Complete|","14.0","|ranges|"
 `3518 <https://wg21.link/LWG3518>`__,"Exception requirements on char trait operations unclear","June 2021","|Nothing To Do|",""
 `3519 <https://wg21.link/LWG3519>`__,"Incomplete synopses for ``<random>`` classes","June 2021","",""
 `3520 <https://wg21.link/LWG3520>`__,"``iter_move`` and ``iter_swap`` are inconsistent for ``transform_view::iterator``","June 2021","|Complete|","14.0","|ranges|"
 `3521 <https://wg21.link/LWG3521>`__,"Overly strict requirements on ``qsort`` and ``bsearch``","June 2021","|Nothing To Do|",""
 `3522 <https://wg21.link/LWG3522>`__,"Missing requirement on ``InputIterator`` template parameter for ``priority_queue`` constructors","June 2021","|Complete|","14.0"
 `3523 <https://wg21.link/LWG3523>`__,"``iota_view::sentinel`` is not always ``iota_view``'s sentinel","June 2021","","","|ranges|"
 `3526 <https://wg21.link/LWG3526>`__,"Return types of ``uses_allocator_construction_args`` unspecified","June 2021","",""
 `3527 <https://wg21.link/LWG3527>`__,"``uses_allocator_construction_args`` handles rvalue pairs of rvalue references incorrectly","June 2021","",""
 `3528 <https://wg21.link/LWG3528>`__,"``make_from_tuple`` can perform (the equivalent of) a C-style cast","June 2021","",""
 `3529 <https://wg21.link/LWG3529>`__,"``priority_queue(first, last)`` should construct ``c`` with ``(first, last)``","June 2021","|Complete|","14.0"
 `3530 <https://wg21.link/LWG3530>`__,"``BUILTIN-PTR-MEOW`` should not opt the type out of syntactic checks","June 2021","",""
-`3532 <https://wg21.link/LWG3532>`__,"``split_view<V, P>::inner-iterator<true>::operator++(int)`` should depend on ``Base``","June 2021","","","|ranges|"
+`3532 <https://wg21.link/LWG3532>`__,"``split_view<V, P>::inner-iterator<true>::operator++(int)`` should depend on ``Base``","June 2021","|Complete|","16.0","|ranges|"
 `3533 <https://wg21.link/LWG3533>`__,"Make ``base() const &`` consistent across iterator wrappers that supports ``input_iterators``","June 2021","|Complete|","14.0","|ranges|"
 `3536 <https://wg21.link/LWG3536>`__,"Should ``chrono::from_stream()`` assign zero to duration for failure?","June 2021","","","|chrono|"
 `3539 <https://wg21.link/LWG3539>`__,"``format_to`` must not copy models of ``output_iterator<const charT&>``","June 2021","|Complete|","14.0","|format|"
 `3540 <https://wg21.link/LWG3540>`__,"§[format.arg] There should be no const in ``basic_format_arg(const T* p)``","June 2021","|Complete|","14.0","|format|"
 `3541 <https://wg21.link/LWG3541>`__,"``indirectly_readable_traits`` should be SFINAE-friendly for all types","June 2021","|Complete|","14.0","|ranges|"
 `3542 <https://wg21.link/LWG3542>`__,"``basic_format_arg`` mishandles ``basic_string_view`` with custom traits","June 2021","|Complete|","14.0","|format|"
 `3543 <https://wg21.link/LWG3543>`__,"Definition of when ``counted_iterators`` refer to the same sequence isn't quite right","June 2021","|Nothing To Do|","","|ranges|"
 `3544 <https://wg21.link/LWG3544>`__,"``format-arg-store::args`` is unintentionally not exposition-only","June 2021","|Complete|","14.0","|format|"
 `3546 <https://wg21.link/LWG3546>`__,"``common_iterator``'s postfix-proxy is not quite right","June 2021","","","|ranges|"
 `3548 <https://wg21.link/LWG3548>`__,"``shared_ptr`` construction from ``unique_ptr`` should move (not copy) the deleter","June 2021","|Complete|","15.0"
 `3549 <https://wg21.link/LWG3549>`__,"``view_interface`` is overspecified to derive from ``view_base``","June 2021","|Complete|","14.0","|ranges|"
 `3551 <https://wg21.link/LWG3551>`__,"``borrowed_{iterator,subrange}_t`` are overspecified","June 2021","|Nothing To Do|","","|ranges|"
 `3552 <https://wg21.link/LWG3552>`__,"Parallel specialized memory algorithms should require forward iterators","June 2021","",""
-`3553 <https://wg21.link/LWG3553>`__,"Useless constraint in ``split_view::outer-iterator::value_type::begin()``","June 2021","","","|ranges|"
+`3553 <https://wg21.link/LWG3553>`__,"Useless constraint in ``split_view::outer-iterator::value_type::begin()``","June 2021","|Complete|","16.0","|ranges|"
 `3555 <https://wg21.link/LWG3555>`__,"``{transform,elements}_view::iterator::iterator_concept`` should consider const-qualification of the underlying range","June 2021","","","|ranges|"
 "","","","","",""
 `2191 <https://wg21.link/LWG2191>`__,"Incorrect specification of ``match_results(match_results&&)``","October 2021","|Nothing To Do|",""
 `2381 <https://wg21.link/LWG2381>`__,"Inconsistency in parsing floating point numbers","October 2021","",""
 `2762 <https://wg21.link/LWG2762>`__,"``unique_ptr operator*()`` should be ``noexcept``","October 2021","",""
 `3121 <https://wg21.link/LWG3121>`__,"``tuple`` constructor constraints for ``UTypes&&...`` overloads","October 2021","",""
 `3123 <https://wg21.link/LWG3123>`__,"``duration`` constructor from representation shouldn't be effectively non-throwing","October 2021","","","|chrono|"
 `3146 <https://wg21.link/LWG3146>`__,"Excessive unwrapping in ``std::ref/cref``","October 2021","|Complete|","14.0"

 `3571 <https://wg21.link/LWG3571>`__,"``flush_emit`` should set ``badbit`` if the ``emit`` call fails","October 2021","",""
 `3572 <https://wg21.link/LWG3572>`__,"``copyable-box`` should be fully ``constexpr``","October 2021","|Complete|","14.0","|ranges|"
 `3573 <https://wg21.link/LWG3573>`__,"Missing Throws element for ``basic_string_view(It begin, End end)``","October 2021","|Complete|","14.0"
 `3574 <https://wg21.link/LWG3574>`__,"``common_iterator`` should be completely ``constexpr``-able","October 2021","|Complete|","14.0","|ranges|"
 `3580 <https://wg21.link/LWG3580>`__,"``iota_view``'s ``iterator``'s binary ``operator+`` should be improved","October 2021","|Complete|","14.0","|ranges|"
 `3581 <https://wg21.link/LWG3581>`__,"The range constructor makes ``basic_string_view`` not trivially move constructible","October 2021","|Complete|","14.0","|ranges|"
 `3585 <https://wg21.link/LWG3585>`__,"``variant`` converting assignment with immovable alternative","October 2021","",""
 `3589 <https://wg21.link/LWG3589>`__,"The ``const`` lvalue reference overload of ``get`` for ``subrange`` does not constrain ``I`` to be ``copyable`` when ``N == 0``","October 2021","|Complete|","14.0","|ranges|"
-`3590 <https://wg21.link/LWG3590>`__,"``split_view::base() const &`` is overconstrained","October 2021","","","|ranges|"
-`3591 <https://wg21.link/LWG3591>`__,"``lazy_split_view<input_view>::inner-iterator::base() &&`` invalidates outer iterators","October 2021","","","|ranges|"
-`3592 <https://wg21.link/LWG3592>`__,"``lazy_split_view`` needs to check the simpleness of Pattern","October 2021","","","|ranges|"
-`3593 <https://wg21.link/LWG3593>`__,"Several iterators' ``base() const &`` and ``lazy_split_view::outer-iterator::value_type::end()`` missing ``noexcept``","October 2021","","","|ranges|"
+`3590 <https://wg21.link/LWG3590>`__,"``split_view::base() const &`` is overconstrained","October 2021","|Complete|","16.0","|ranges|"
+`3591 <https://wg21.link/LWG3591>`__,"``lazy_split_view<input_view>::inner-iterator::base() &&`` invalidates outer iterators","October 2021","|Complete|","16.0","|ranges|"
+`3592 <https://wg21.link/LWG3592>`__,"``lazy_split_view`` needs to check the simpleness of Pattern","October 2021","|Complete|","16.0","|ranges|"
+`3593 <https://wg21.link/LWG3593>`__,"Several iterators' ``base() const &`` and ``lazy_split_view::outer-iterator::value_type::end()`` missing ``noexcept``","October 2021","|Complete|","16.0","|ranges|"
 `3595 <https://wg21.link/LWG3595>`__,"Exposition-only classes proxy and postfix-proxy for ``common_iterator`` should be fully ``constexpr``","October 2021","|Complete|","14.0","|ranges|"
 "","","","","",""
 "`3088 <https://wg21.link/LWG3088>`__","``forward_list::merge`` behaviour unclear when passed ``*this``","February 2022","",""
 "`3471 <https://wg21.link/LWG3471>`__","``polymorphic_allocator::allocate`` does not satisfy ``Cpp17Allocator`` requirements","February 2022","",""
 "`3525 <https://wg21.link/LWG3525>`__","``uses_allocator_construction_args`` fails to handle types convertible to ``pair``","February 2022","",""
 "`3598 <https://wg21.link/LWG3598>`__","``system_category().default_error_condition(0)`` is underspecified","February 2022","",""
 "`3601 <https://wg21.link/LWG3601>`__","common_iterator's postfix-proxy needs ``indirectly_readable`` ","February 2022","","","|ranges|"
 "`3607 <https://wg21.link/LWG3607>`__","``contiguous_iterator`` should not be allowed to have custom ``iter_move`` and ``iter_swap`` behavior","February 2022","|Nothing to do|","","|ranges|"

libcxx/include/CMakeLists.txt

set(files
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.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
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer

libcxx/include/__ranges/split_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_SPLIT_VIEW_H
+#define _LIBCPP___RANGES_SPLIT_VIEW_H
+
+#include <__algorithm/ranges_search.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/single_view.h>
+#include <__ranges/subrange.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <class _View, class _Pattern>
+struct __split_view_iterator;
+
+template <class _View, class _Pattern>
+struct __split_view_sentinel;
+
+template <forward_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+           indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to>
+class split_view : public view_interface<split_view<_View, _Pattern>> {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_       = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
+  using _Cache                                  = __non_propagating_cache<subrange<iterator_t<_View>>>;
+  _Cache __cached_begin_                        = _Cache();
+
+  template <class, class>
+  friend struct __split_view_iterator;
+
+  template <class, class>
+  friend struct __split_view_sentinel;
+
+  using __iterator = __split_view_iterator<_View, _Pattern>;
+  using __sentinel = __split_view_sentinel<_View, _Pattern>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<iterator_t<_View>> __find_next(iterator_t<_View> __it) {
+    auto [__begin, __end] = ranges::search(subrange(__it, ranges::end(__base_)), __pattern_);
+    if (__begin != ranges::end(__base_) && ranges::empty(__pattern_)) {
+      ++__begin;
+      ++__end;
+    }
+    return {__begin, __end};
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr split_view(_View __base, _Pattern __pattern)
+      : __base_(std::move(__base)), __pattern_(std::move((__pattern))) {}
+
+  template <forward_range _Range>
+    requires constructible_from<_View, views::all_t<_Range>> &&
+                 constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr split_view(_Range&& __range, range_value_t<_Range> __elem)
+      : __base_(views::all(std::forward<_Range>(__range))), __pattern_(views::single(std::move(__elem))) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    if (!__cached_begin_.__has_value()) {
+      __cached_begin_.__emplace(__find_next(ranges::begin(__base_)));
+    }
+    return {*this, ranges::begin(__base_), *__cached_begin_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>) {
+      return __iterator{*this, ranges::end(__base_), {}};
+    } else {
+      return __sentinel{*this};
+    }
+  }
+};
+
+template <class _Range, class _Pattern>
+split_view(_Range&&, _Pattern&&) -> split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
+
+template <forward_range _Range>
+split_view(_Range&&, range_value_t<_Range>) -> split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+
+template <class _View, class _Pattern>
+struct __split_view_iterator {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __cur_            = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS subrange<iterator_t<_View>> __next_ = subrange<iterator_t<_View>>();
+  split_view<_View, _Pattern>* __parent_                        = nullptr;
+  bool __trailing_empty_                                        = false;
+
+  template <class, class>
+  friend struct __split_view_sentinel;
+
+public:
+  using iterator_concept  = forward_iterator_tag;
+  using iterator_category = input_iterator_tag;
+  using value_type        = subrange<iterator_t<_View>>;
+  using difference_type   = range_difference_t<_View>;
+
+  _LIBCPP_HIDE_FROM_ABI __split_view_iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __split_view_iterator(
+      split_view<_View, _Pattern>& __parent, iterator_t<_View> __current, subrange<iterator_t<_View>> __next)
+      : __cur_(std::move(__current)), __next_(std::move(__next)), __parent_(std::addressof(__parent)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() const { return __cur_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const { return {__cur_, __next_.begin()}; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __split_view_iterator& operator++() {
+    __cur_ = __next_.begin();
+    if (__cur_ != ranges::end(__parent_->__base_)) {
+      __cur_ = __next_.end();
+      if (__cur_ == ranges::end(__parent_->__base_)) {
+        __trailing_empty_ = true;
+        __next_           = {__cur_, __cur_};
+      } else {
+        __next_ = __parent_->__find_next(__cur_);
+      }
+    } else {
+      __trailing_empty_ = false;
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __split_view_iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const __split_view_iterator& __x, const __split_view_iterator& __y) {
+    return __x.__cur_ == __y.__cur_ && __x.__trailing_empty_ == __y.__trailing_empty_;
+  }
+};
+
+template <class _View, class _Pattern>
+struct __split_view_sentinel {
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_View> __end_ = sentinel_t<_View>();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __split_view_sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __split_view_sentinel(split_view<_View, _Pattern>& __parent)
+      : __end_(ranges::end(__parent.__base_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const __split_view_iterator<_View, _Pattern>& __x, const __split_view_sentinel& __y) {
+    return __x.__cur_ == __y.__end_ && !__x.__trailing_empty_;
+  }
+};
+
+namespace views {
+namespace __split_view {
+struct __fn : __range_adaptor_closure<__fn> {
+  // clang-format off
+  template <class _Range, class _Pattern>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+    noexcept(noexcept(split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+    -> decltype(      split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
+    { return          split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+  // clang-format on
+
+  template <class _Pattern>
+    requires constructible_from<decay_t<_Pattern>, _Pattern>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
+  }
+};
+} // namespace __split_view
+
+inline namespace __cpo {
+inline constexpr auto split = __split_view::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_SPLIT_VIEW_H

libcxx/include/module.modulemap.in

module __ranges {
       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 reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }
       module size                   { private header "__ranges/size.h" }
+      module split_view             { private header "__ranges/split_view.h" }
       module subrange               {
         private header "__ranges/subrange.h"
 
         module subrange_fwd { private header "__fwd/subrange.h" }
       }
       module take_view              { private header "__ranges/take_view.h" }
       module take_while_view        { private header "__ranges/take_while_view.h" }
       module transform_view         {

libcxx/include/ranges

template<class R>
     concept tiny-range = see below;   // exposition only
 
   template<input_range V, forward_range Pattern>
     requires view<V> && view<Pattern> &&
              indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
              (forward_range<V> || tiny-range<Pattern>)
   class lazy_split_view;
 
+  // [range.split], split view
+  template<forward_range V, forward_range Pattern>
+    requires view<V> && view<Pattern> &&
+             indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
+  class split_view;  
+
   namespace views {
     inline constexpr unspecified lazy_split = unspecified;
+    inline constexpr unspecified split = unspecified;
   }
 
   // [range.istream], istream view
   template<movable Val, class CharT, class Traits = char_traits<CharT>>
     requires see below
   class basic_istream_view;
 
   template<class Val>

 #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/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>
 #include <__ranges/view_interface.h>
 #include <__ranges/views.h>
 #include <__ranges/zip_view.h>
 #include <type_traits>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/owning_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/owning_view.h'}}
 #include <__ranges/range_adaptor.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/range_adaptor.h'}}
 #include <__ranges/rbegin.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rbegin.h'}}
 #include <__ranges/ref_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/ref_view.h'}}
 #include <__ranges/rend.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/rend.h'}}
 #include <__ranges/reverse_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/reverse_view.h'}}
 #include <__ranges/single_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/single_view.h'}}
 #include <__ranges/size.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/size.h'}}
+#include <__ranges/split_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/split_view.h'}}
 #include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
 #include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
 #include <__ranges/take_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_while_view.h'}}
 #include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}

libcxx/test/libcxx/ranges/range.adaptors/range.split/no_unique_address.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
+
+// clang-cl and cl currently don't support [[no_unique_address]]
+// XFAIL: msvc
+
+// class split_view {
+//   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+//   _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
+// };
+
+#include <ranges>
+
+#include "test_iterators.h"
+
+struct EmptyView : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+using SplitView = std::ranges::split_view<EmptyView, EmptyView>;
+static_assert(sizeof(SplitView) == sizeof(std::ranges::__non_propagating_cache<std::ranges::subrange<int*>>));

libcxx/test/std/ranges/range.adaptors/range.split/adaptor.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
+
+// std::views::split
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <string_view>
+#include <utility>
+
+#include "test_iterators.h"
+
+template <class View, class T>
+concept CanBePiped = requires (View&& view, T&& t) {
+  { std::forward<View>(view) | std::forward<T>(t) };
+};
+
+struct SomeView : std::ranges::view_base {
+  const std::string_view* v_;
+  constexpr SomeView(const std::string_view& v) : v_(&v) {}
+  constexpr auto begin() const { return v_->begin(); }
+  constexpr auto end() const { return v_->end(); }
+};
+
+struct NotAView { };
+
+static_assert(!std::is_invocable_v<decltype(std::views::split)>);
+static_assert(!std::is_invocable_v<decltype(std::views::split), SomeView, NotAView>);
+static_assert(!std::is_invocable_v<decltype(std::views::split), NotAView, SomeView>);
+static_assert( std::is_invocable_v<decltype(std::views::split), SomeView, SomeView>);
+
+static_assert( CanBePiped<SomeView&,    decltype(std::views::split)>);
+static_assert( CanBePiped<char(&)[10],  decltype(std::views::split)>);
+static_assert(!CanBePiped<char(&&)[10], decltype(std::views::split)>);
+static_assert(!CanBePiped<NotAView,     decltype(std::views::split)>);
+
+static_assert(std::same_as<decltype(std::views::split), decltype(std::ranges::views::split)>);
+
+constexpr bool test() {
+  std::string_view input = "abc";
+  std::string_view sep = "a";
+
+  // Test that `std::views::split` is a range adaptor.
+
+  // Test `views::split(input, sep)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::split_view<SomeView, std::string_view>;
+    std::same_as<Result> decltype(auto) result = std::views::split(view, sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `views::split(sep)(input)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::split_view<SomeView, std::string_view>;
+    std::same_as<Result> decltype(auto) result = std::views::split(sep)(view);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `view | views::split`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::split_view<SomeView, std::string_view>;
+    std::same_as<Result> decltype(auto) result = view | std::views::split(sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `adaptor | views::split`.
+  {
+    SomeView view(input);
+    auto f = [](char c) { return c; };
+    auto partial = std::views::transform(f) | std::views::split(sep);
+
+    using Result = std::ranges::split_view<std::ranges::transform_view<SomeView, decltype(f)>, std::string_view>;
+    std::same_as<Result> decltype(auto) result = partial(view);
+    assert(result.base().base().begin() == input.begin());
+    assert(result.base().base().end() == input.end());
+  }
+
+  // Test `views::split | adaptor`.
+  {
+    SomeView view(input);
+    auto f = [](auto v) { return v; };
+    auto partial = std::views::split(sep) | std::views::transform(f);
+
+    using Result = std::ranges::transform_view<std::ranges::split_view<SomeView, std::string_view>, decltype(f)>;
+    std::same_as<Result> decltype(auto) result = partial(view);
+    assert(result.base().base().begin() == input.begin());
+    assert(result.base().base().end() == input.end());
+  }
+
+  // Test that one can call `std::views::split` with arbitrary stuff, as long as we
+  // don't try to actually complete the call by passing it a range.
+  //
+  // That makes no sense and we can't do anything with the result, but it's valid.
+  {
+    struct X { };
+    [[maybe_unused]] auto partial = std::views::split(X{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/base.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr V base() const & requires copy_constructible<V> { return base_; }
+// constexpr V base() && { return std::move(base_); }
+
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+
+struct View : std::ranges::view_base {
+  int i;
+  int* begin() const;
+  int* end() const;
+};
+
+struct MoveOnlyView : View {
+  MoveOnly mo;
+};
+
+template <class T>
+concept HasBase = requires(T&& t) { std::forward<T>(t).base(); };
+
+static_assert(HasBase<std::ranges::split_view<View, View> const&>);
+static_assert(HasBase<std::ranges::split_view<View, View>&&>);
+
+static_assert(!HasBase<std::ranges::split_view<MoveOnlyView, View> const&>);
+static_assert(HasBase<std::ranges::split_view<MoveOnlyView, View>&&>);
+
+constexpr bool test() {
+  // const &
+  {
+    const std::ranges::split_view<View, View> sv{View{{}, 5}, View{{}, 0}};
+    std::same_as<View> decltype(auto) v = sv.base();
+    assert(v.i == 5);
+  }
+
+  // &
+  {
+    std::ranges::split_view<View, View> sv{View{{}, 5}, View{{}, 0}};
+    std::same_as<View> decltype(auto) v = sv.base();
+    assert(v.i == 5);
+  }
+
+  // &&
+  {
+    std::ranges::split_view<View, View> sv{View{{}, 5}, View{{}, 0}};
+    std::same_as<View> decltype(auto) v = std::move(sv).base();
+    assert(v.i == 5);
+  }
+
+  // const &&
+  {
+    std::ranges::split_view<View, View> sv{View{{}, 5}, View{{}, 0}};
+    std::same_as<View> decltype(auto) v = std::move(sv).base();
+    assert(v.i == 5);
+  }
+
+  // move only
+  {
+    std::ranges::split_view<MoveOnlyView, View> sv{MoveOnlyView{{}, 5}, View{{}, 0}};
+    std::same_as<MoveOnlyView> decltype(auto) v = std::move(sv).base();
+    assert(v.mo.get() == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/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
+
+// constexpr auto begin();
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+// Test that begin is not const
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+static_assert(HasBegin<std::ranges::split_view<View, View>>);
+static_assert(!HasBegin<const std::ranges::split_view<View, View>>);
+
+template <template <class> class MakeIter>
+constexpr void testOne() {
+  constexpr auto make_subrange = []<class T, std::size_t N>(T(&buffer)[N]) {
+    using Iter = MakeIter<T*>;
+    using Sent = sentinel_wrapper<Iter>;
+    return std::ranges::subrange<Iter, Sent>{Iter{buffer}, Sent{Iter{buffer + N}}};
+  };
+
+  using Iter  = MakeIter<int*>;
+  using Sent  = sentinel_wrapper<Iter>;
+  using Range = std::ranges::subrange<Iter, Sent>;
+
+  // empty view
+  {
+    std::array<int, 0> a;
+    Range range{Iter{a.data()}, Sent{Iter{a.data() + a.size()}}};
+    std::ranges::split_view sv{std::move(range), 1};
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == range.end());
+  }
+
+  // empty pattern
+  {
+    int buffer[] = {1, 2, 3};
+    auto range   = make_subrange(buffer);
+    std::ranges::split_view sv{std::move(range), std::views::empty<int>};
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == std::next(range.begin()));
+  }
+
+  // empty view and empty pattern
+  {
+    std::array<int, 0> a;
+    Range range{Iter{a.data()}, Sent{Iter{a.data() + a.size()}}};
+    std::ranges::split_view sv{std::move(range), std::views::empty<int>};
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == range.end());
+  }
+
+  // pattern found at the beginning
+  {
+    int buffer[]  = {1, 2, 3};
+    auto range    = make_subrange(buffer);
+    int pattern[] = {1, 2};
+    std::ranges::split_view sv{range, pattern};
+
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == range.begin());
+  }
+
+  // pattern found in the middle
+  {
+    int buffer[]  = {1, 2, 3, 4};
+    auto range    = make_subrange(buffer);
+    int pattern[] = {2, 3};
+    std::ranges::split_view sv{range, pattern};
+
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == std::next(range.begin()));
+  }
+
+  // pattern found at the end
+  {
+    int buffer[]  = {1, 2, 3};
+    auto range    = make_subrange(buffer);
+    int pattern[] = {2, 3};
+    std::ranges::split_view sv{range, pattern};
+
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == std::next(range.begin()));
+  }
+
+  // pattern not found
+  {
+    int buffer[]  = {1, 2, 3};
+    auto range    = make_subrange(buffer);
+    int pattern[] = {1, 3};
+    std::ranges::split_view sv{range, pattern};
+
+    auto it         = sv.begin();
+    auto firstRange = *it;
+    assert(firstRange.begin() == range.begin());
+    assert(firstRange.end() == range.end());
+  }
+
+  // Make sure that we cache the result of begin() on subsequent calls
+  {
+    struct Foo {
+      int& equalsCalledTimes;
+
+      constexpr bool operator==(const Foo&) const {
+        ++equalsCalledTimes;
+        return true;
+      }
+    };
+
+    int equalsCalledTimes = 0;
+    Foo buffer[]          = {Foo{equalsCalledTimes}, Foo{equalsCalledTimes}};
+    auto range            = make_subrange(buffer);
+
+    std::ranges::split_view sv{range, Foo{equalsCalledTimes}};
+
+    assert(equalsCalledTimes == 0);
+
+    [[maybe_unused]] auto it1       = sv.begin();
+    auto calledTimesAfterFirstBegin = equalsCalledTimes;
+    assert(calledTimesAfterFirstBegin != 0);
+
+    for (int i = 0; i < 10; ++i) {
+      [[maybe_unused]] auto it2 = sv.begin();
+      assert(equalsCalledTimes == calledTimesAfterFirstBegin);
+    }
+  }
+}
+
+constexpr bool test() {
+  testOne<forward_iterator>();
+  testOne<bidirectional_iterator>();
+  testOne<random_access_iterator>();
+  testOne<contiguous_iterator>();
+  testOne<std::type_identity_t>();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/constraints.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
+
+// template<forward_range V, forward_range Pattern>
+//   requires view<V> && view<Pattern> &&
+//            indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
+// class split_view;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template <class It>
+using Range = std::ranges::subrange<It, sentinel_wrapper<It>>;
+
+template <class View, class Pattern>
+concept HasSplitView = requires { typename std::ranges::split_view<View, Pattern>; };
+
+static_assert(HasSplitView<Range<int*>, Range<int*>>);
+
+// !forward_range<V>
+static_assert(!HasSplitView<Range<cpp20_input_iterator<int*>>, Range<int*>>);
+
+// !forward_range<Pattern>
+static_assert(!HasSplitView<Range<int*>, Range<cpp20_input_iterator<int*>>>);
+
+struct NotAView {
+  int* begin() const;
+  int* end() const;
+};
+
+// !view<V>
+static_assert(!HasSplitView<NotAView, Range<int*>>);
+
+// !view<Pattern>
+static_assert(!HasSplitView<Range<int*>, NotAView>);
+
+// indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to
+struct Foo {};
+static_assert(!HasSplitView<Range<int*>, Range<Foo*>>);

libcxx/test/std/ranges/range.adaptors/range.split/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
+
+// template <class R, class P>
+// split_view(R&&, P&&) -> split_view<views::all_t<R>, views::all_t<P>>;
+//
+// template <input_range R>
+// split_view(R&&, range_value_t<R>) -> split_view<views::all_t<R>, single_view<range_value_t<R>>>;
+
+#include <concepts>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+struct Container {
+  int* begin() const;
+  int* end() const;
+};
+
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+template <class I1, class I2, class ExpectedView, class ExpectedPattern>
+constexpr void test() {
+  static_assert(std::is_same_v<decltype(std::ranges::split_view(std::declval<I1>(), std::declval<I2>())),
+                               std::ranges::split_view<ExpectedView, ExpectedPattern>>);
+}
+
+constexpr void testCtad() {
+  // (Range, Pattern)
+  test<View, View, View, View>();
+  test<Container&, Container&, std::ranges::ref_view<Container>, std::ranges::ref_view<Container>>();
+  test<Container&&, Container&&, std::ranges::owning_view<Container>, std::ranges::owning_view<Container>>();
+
+  // (Range, RangeElement)
+  test<Container&, int, std::ranges::ref_view<Container>, std::ranges::single_view<int>>();
+  test<View, int, View, std::ranges::single_view<int>>();
+
+  // (Range, RangeElement) with implicit conversion.
+  test<Container&, bool, std::ranges::ref_view<Container>, std::ranges::single_view<int>>();
+  test<View, bool, View, std::ranges::single_view<int>>();
+}

libcxx/test/std/ranges/range.adaptors/range.split/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
+
+// constexpr split_view() requires
+//   default_initializable<V> && default_initializable<Pattern> = default;
+
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+
+template <bool DefaultInitializable>
+struct View : std::ranges::view_base {
+  int i = 42;
+  constexpr explicit View()
+    requires DefaultInitializable
+  = default;
+  int* begin() const;
+  int* end() const;
+};
+
+// clang-format off
+static_assert( std::is_default_constructible_v<std::ranges::split_view<View<true >, View<true >>>);
+static_assert(!std::is_default_constructible_v<std::ranges::split_view<View<false>, View<true >>>);
+static_assert(!std::is_default_constructible_v<std::ranges::split_view<View<true >, View<false>>>);
+static_assert(!std::is_default_constructible_v<std::ranges::split_view<View<false>, View<false>>>);
+// clang-format on
+
+constexpr bool test() {
+  {
+    std::ranges::split_view<View<true>, View<true>> sv = {};
+    assert(sv.base().i == 42);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/ctor.range.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
+
+// template <input_range Range>
+//   requires constructible_from<View, views::all_t<Range>> &&
+//             constructible_from<Pattern, single_view<range_value_t<Range>>>
+// constexpr split_view(Range&& r, range_value_t<Range> e);
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+struct Counting {
+  int* times_copied = nullptr;
+  int* times_moved  = nullptr;
+
+  constexpr Counting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
+
+  constexpr Counting(const Counting& rhs) : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
+    ++(*times_copied);
+  }
+  constexpr Counting(Counting&& rhs) : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
+    ++(*times_moved);
+  }
+
+  constexpr Counting& operator=(const Counting&) = default;
+  constexpr Counting& operator=(Counting&&)      = default;
+};
+
+struct ElementWithCounting : Counting {
+  using Counting::Counting;
+
+  constexpr bool operator==(const ElementWithCounting&) const { return true; }
+};
+
+struct RangeWithCounting : Counting {
+  using Counting::Counting;
+
+  constexpr const ElementWithCounting* begin() const { return nullptr; }
+  constexpr const ElementWithCounting* end() const { return nullptr; }
+
+  constexpr bool operator==(const RangeWithCounting&) const { return true; }
+};
+static_assert(std::ranges::forward_range<RangeWithCounting>);
+static_assert(!std::ranges::view<RangeWithCounting>);
+
+struct StrView : std::ranges::view_base {
+  std::string buffer_;
+
+  template <std::ranges::range R>
+  constexpr StrView(R&& r) : buffer_(std::ranges::begin(r), std::ranges::end(r)) {}
+  constexpr const char* begin() const { return buffer_.data(); }
+  constexpr const char* end() const { return buffer_.data() + buffer_.size(); }
+  constexpr bool operator==(const StrView& rhs) const { return buffer_ == rhs.buffer_; }
+};
+static_assert(std::ranges::random_access_range<StrView>);
+static_assert(std::ranges::view<StrView>);
+static_assert(std::is_copy_constructible_v<StrView>);
+
+constexpr bool test() {
+  {
+    using V = std::ranges::split_view<StrView, StrView>;
+
+    // Calling the constructor with `(std::string, range_value_t)`.
+    {
+      std::string input("abc def");
+      V v(input, ' ');
+      assert(v.base() == input);
+      assert(std::ranges::equal(*v.begin(), std::string_view("abc")));
+    }
+
+    // Calling the constructor with `(StrView, range_value_t)`.
+    {
+      StrView input("abc def");
+      V v(input, ' ');
+      assert(v.base() == input);
+      assert(std::ranges::equal(*v.begin(), std::string_view("abc")));
+    }
+
+    struct Empty {};
+    static_assert(!std::is_constructible_v<V, Empty, std::string_view>);
+    static_assert(!std::is_constructible_v<V, std::string_view, Empty>);
+  }
+
+  // Make sure the arguments are moved, not copied.
+  {
+    using Range   = RangeWithCounting;
+    using Element = ElementWithCounting;
+    using Pattern = std::ranges::single_view<Element>;
+
+    // Arguments are lvalues.
+    {
+      using View = std::ranges::ref_view<Range>;
+
+      int range_copied = 0, range_moved = 0, element_copied = 0, element_moved = 0;
+      Range range(range_copied, range_moved);
+      Element element(element_copied, element_moved);
+
+      std::ranges::split_view<View, Pattern> v(range, element);
+      assert(range_copied == 0);   // `ref_view` does neither copy...
+      assert(range_moved == 0);    // ...nor move the element.
+      assert(element_copied == 1); // The element is copied into the argument...
+      assert(element_moved == 1);  // ...and moved into the member variable.
+    }
+
+    // Arguments are rvalues.
+    {
+      using View = std::ranges::owning_view<Range>;
+
+      int range_copied = 0, range_moved = 0, element_copied = 0, element_moved = 0;
+      std::ranges::split_view<View, Pattern> v(
+          Range(range_copied, range_moved), Element(element_copied, element_moved));
+      assert(range_copied == 0);
+      assert(range_moved == 1); // `owning_view` moves the given argument.
+      assert(element_copied == 0);
+      assert(element_moved == 1);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/ctor.view.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr split_view(View base, Pattern pattern);
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <string_view>
+#include <utility>
+
+struct ViewWithCounting : std::ranges::view_base {
+  int* times_copied = nullptr;
+  int* times_moved  = nullptr;
+
+  constexpr ViewWithCounting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
+
+  constexpr ViewWithCounting(const ViewWithCounting& rhs)
+      : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
+    ++(*times_copied);
+  }
+  constexpr ViewWithCounting(ViewWithCounting&& rhs) : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
+    ++(*times_moved);
+  }
+
+  constexpr const char* begin() const { return nullptr; }
+  constexpr const char* end() const { return nullptr; }
+
+  constexpr ViewWithCounting& operator=(const ViewWithCounting&) = default;
+  constexpr ViewWithCounting& operator=(ViewWithCounting&&)      = default;
+  constexpr bool operator==(const ViewWithCounting&) const { return true; }
+};
+
+constexpr bool test() {
+  {
+    std::string_view input = "abc def";
+    std::ranges::lazy_split_view<std::string_view, std::string_view> v(input, " ");
+    assert(v.base() == input);
+    assert(std::ranges::equal(*v.begin(), std::string_view{"abc"}));
+  }
+
+  // Make sure the arguments are moved, not copied.
+  {
+    using View    = ViewWithCounting;
+    using Pattern = ViewWithCounting;
+
+    // Arguments are lvalues.
+    {
+      int view_copied = 0, view_moved = 0, pattern_copied = 0, pattern_moved = 0;
+      View view(view_copied, view_moved);
+      Pattern pattern(pattern_copied, pattern_moved);
+
+      std::ranges::split_view<View, Pattern> v(view, pattern);
+      assert(view_copied == 1); // The local variable is copied into the argument.
+      assert(view_moved == 1);
+      assert(pattern_copied == 1);
+      assert(pattern_moved == 1);
+    }
+
+    // Arguments are rvalues.
+    {
+      int view_copied = 0, view_moved = 0, pattern_copied = 0, pattern_moved = 0;
+      std::ranges::split_view<View, Pattern> v(View(view_copied, view_moved), Pattern(pattern_copied, pattern_moved));
+      assert(view_copied == 0);
+      assert(view_moved == 1);
+      assert(pattern_copied == 0);
+      assert(pattern_moved == 1);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/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
+
+// constexpr auto end();
+
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+// Test that end is not const
+template <class T>
+concept HasEnd = requires(T t) { t.end(); };
+
+static_assert(HasEnd<std::ranges::split_view<View, View>>);
+static_assert(!HasEnd<const std::ranges::split_view<View, View>>);
+
+constexpr bool test() {
+  // return iterator
+  {
+    int buffer[]   = {1, 2, -1, 4, 5, 6, 5, 4, -1, 2, 1};
+    auto inputView = std::views::all(buffer);
+    static_assert(std::ranges::common_range<decltype(inputView)>);
+
+    std::ranges::split_view sv(buffer, -1);
+    using SplitIter                           = std::ranges::iterator_t<decltype(sv)>;
+    std::same_as<SplitIter> decltype(auto) sentinel = sv.end();
+    assert(sentinel.base() == buffer + 11);
+  }
+
+  // return sentinel
+  {
+    using Iter   = int*;
+    using Sent   = sentinel_wrapper<Iter>;
+    using Range  = std::ranges::subrange<Iter, Sent>;
+    int buffer[] = {1, 2, -1, 4, 5, 6, 5, 4, -1, 2, 1};
+    Range range  = {buffer, Sent{buffer + 11}};
+    static_assert(!std::ranges::common_range<Range>);
+
+    std::ranges::split_view sv(range, -1);
+    auto sentinel = sv.end();
+
+    using SplitIter = std::ranges::iterator_t<decltype(sv)>;
+    static_assert(!std::same_as<decltype(sentinel), SplitIter>);
+
+    assert(std::next(sv.begin(), 3) == sentinel);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.split/general.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
+
+// Some basic examples of how split_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <vector>
+
+int main(int, char**) {
+  std::string str{"the quick brown fox"};
+  std::vector<std::string_view> result;
+  for (auto r : std::views::split(str, ' ')) {
+    result.emplace_back(r.begin(), r.end());
+  }
+  using namespace std::string_view_literals;
+  auto expected = {"the"sv, "quick"sv, "brown"sv, "fox"sv};
+  assert(std::ranges::equal(result, expected));
+
+  return 0;
+}