[libc++][ranges] Implement `lazy_split_view`.

[var-const]

Summary

Note that this class was called just split_view in the original One
Ranges Proposal and was renamed to lazy_split_view by
P2210.

Original patch by @zoecarver.

[ldionne]

Thanks a lot for working on this! This is a monster of a view. It generally looks really good, but I do have a few comments and questions.

libcxx/include/__ranges/lazy_split_view.h

41

The guard should be #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES).

52

Can you please add a test with a TinyRange that has a non-constexpr size() static function? It should not satisfy tiny-range. Same for a size that is > 1 (if you don't have one already).

60–61

We could add [[no_unique_address]] here -- I don't foresee this making much of a difference except for a stateless view and pattern (e.g. ones that would generate stuff on the fly), but we don't lose anything.

72–73

[[no_unique_address]]?

156

const auto&? This is mostly for the reader, since it doesn't change the actual meaning.

211

I do not understand the purpose of __trailing_empty (comment for the spec, not for this specific implementation).

What tests start failing if you stop setting __trailing_empty_ to false or true below? Or if you set it to the wrong value (e.g. true here)?

216

// Empty pattern: split on every element in the input range

219

// One-element pattern: use ranges::find because we can?

222

Perhaps we could add a comment like // make sure we point to after the separator we just found or something along those lines -- I was initially surprised that we incremented again after a successful ranges::find.

227

// General case for n-element pattern

229

(perhaps elsewhere too)

235

I am wondering what happens if we do something like this: split("hellofoofooworld"sv, "foo"sv). I would assume we get {"hello"sv, ""sv, "world"sv}, however my understanding is that we'll get {"hello"sv, "fooworld"sv} with the current implementation. Can you confirm what happens, and make sure that it's tested?

251

Do you test that this returns void on non-forward_ranges?

330

Same comment about checking for void return here.

358

Do we have tests with an empty pattern that do not exercise the tiny-range code path?

361

Do you have a test that would fail if __x.__incremented was always false (or true) for a non-tiny-range pattern?

libcxx/test/std/ranges/range.adaptors/range.lazy.split/adaptor.pass.cpp

112

Also consider searching in this patch in case there are other incorrect references.

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

75

I don't think this should be constexpr (applies elsewhere too).

78

It would be better to test the result of functions with ASSERT_SAME_TYPE when it's impossible to test it with same_as, which is (almost) the case for functions that return references. Because if v.base() returned View const& instead of View (as it should), we wouldn't catch it right now.

As you just said in the live review, I think you could also switch to decltype(auto) instead to catch this.

I suspect this comment applies to other functions as well.

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

47–50

Non-blocking suggestion. Initially I thought the ++expected_it was tied to the if because of the indentation.

238

Can you please make sure you have tests for all the corner cases you showed me (the ones we want to take to the reflector)?

317

Can we also add a test case with *really* non-trivial "characters", i.e. splitting a sequence of maps or something like that. It's stretching it, but I just want to confirm that it works, since it's a "corner" case.

[var-const]

Address feedback, use sentinel_wrapper and outer-iterator::value_type to
remove unnecessary boilerplate in types.h.

libcxx/include/__ranges/lazy_split_view.h

52

Done (in range.lazy.split/constraints.compile.pass.cpp). Great suggestion, thanks.

60–61

Done. I also added a (libc++-specific) test for this, and it reminded me that I don't test other [[no_unique_address]] attributes, so I added tests for those as well. Please let me know if you think it's overkill.

72–73

Sorry -- which data member does this apply to?

211

The test case with a trailing separator ("abc def ") starts failing. trailing_empty_ was added specifically for this case -- see P2210 "Superior String Splitting" and LWG 3478 that was fixed by it.

235

It works correctly and is tested in general.pass.cpp:

// Several separators in a row.
{
  std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
  test_one("abc    def", short_sep, expected);
  test_one("abc12121212def", long_sep, expected);
}

If I'm reading the code correctly, it will keep applying mismatch and advancing current until it matches the pattern, then move current to the element past the pattern. So iterations would look like:

1
hellofoofoobar
        ^
2
hellofoofoobar
           ^
3
hellofoofoobar
              ^

On the first iteration, it matches hello, skips the first foo and moves current to the next foo. On the second iteration, it doesn't match anything, skips the second foo and moves current to bar. On the last iteration, it matches bar until the end of the input range.

251

Yes, it's tested in range.lazy.split/range.lazy.split.outer/increment.pass.cpp. Thanks for checking!

306

Note: filed an LWG issue (will try not to forget to add the number here once it's available).

330

Yes, should be checked in range.lazy.split/range.lazy.split.inner/increment.pass.cpp.

358

Yes, the "Empty separator" test case from general.pass.cpp should cover it.

361

Yes, range.lazy.split/range.lazy.split.inner/increment.pass.cpp and general.pass.cpp (the case with an empty separator) start failing.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/adaptor.pass.cpp

112

This was the only one I could find, thanks for noticing!

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

75

These are leftovers. I went through all the test files and I think I removed all of them now.

78

Replaced all uses of same_as.*auto with same_as.*decltype(auto) within this patch's tests.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctad.compile.pass.cpp

50–53

Note: I filed an LWG issue about this, will try to remember to add the number here once it's available.

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

307

Thanks!

[ldionne]

I think this looks good to me once all my comments have been addressed! Thanks a lot for the extreme thoroughness of the tests, you're really raising the bar.

I'll have a last look once everything is addressed, but I think we should be really close to merging this now. Thanks!

libcxx/include/__ranges/lazy_split_view.h

72–73

I think this was a previous comment I never submitted before, please ignore.

235

Just walked through it with you, I understand what's going on. Thanks!

267

We should add a _LIBCPP_ASSERT(__x.__parent_) here, because otherwise we run into UB.

345

Same here, we should add _LIBCPP_ASSERT. For both of those, we can actually add a simple test that we are crashing, look for what we do in other assert.FOO.pass.cpp tests in the test suite.

358

I think we need to add tests that exercise the view with an input range that is a forward_range and a pattern that is a tiny-range to check that this optimization works correctly even when the input range is a forward_range.

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

41–44

IMO it makes more sense to only check the negative cases here, since the positive ones are (or should be) tested "at runtime" below. This comment may apply to other methods you're testing in the patch, too.

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

49

We are currently missing runtime tests for these methods -- we only instantiate them but never actually run them in this test. I would suggest something like:

std::ranges::lazy_split_view<V, P> v;
auto it = v.begin();
static_assert(std::is_same_v<decltype(it)::iterator_concept, std::forward_iterator_tag>);
// You probably want to also test this like you do right now:
static_assert(std::is_same_v<decltype(**it), const char&>);

libcxx/test/std/ranges/range.adaptors/range.lazy.split/copy.pass.cpp

4

Maybe this file should be named ctor.copy_move.pass.cpp?

13

You could say "Test the implicitly-generated copy and move constructors since lazy_split_view has non-trivial members".

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctad.compile.pass.cpp

32–36

I think you should use sentinel_wrapper here instead. We should not be augmenting our iterator archetypes for single tests -- when we need to, it's actually a sign that we're doing something wrong (either in the test, in the implementation/spec or in the archetype itself).

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

16

We should be testing that this isn't explicit by using an implicit construction.

33–34

We should run those tests instead.

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

20

We should be testing with an input_range/forward_range here too.

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

3

The same comments I made for begin() apply here.

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

2

I really like that you're testing the correctness of the view using a more general approach like this. I think we should also be testing the case where we have an input range and a tiny view (etc...) here, because they use a different branch of if constexpr in various cases, like the outer_iterator::operator++.

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

29–37

Run instead (I think you already do below)!

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

19–20

Run this!

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

19–25

Run this!

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/deref.pass.cpp

16

Missing <cassert>

60–62

You said: I'll remove this comment.

I say: I would keep the comment but perhaps just remove the part about it being surprising. I think it's useful as a description of what you are testing here.

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

68

We need a test for the _LIBCPP_ASSERT.

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

19

Missing <cassert> and <type_traits> and "test_macros.h" (and perhaps others)

41

One thing you could do is assert(&i2 == &i) to make sure that we are returning *this and not a reference to some other random iterator. You could do this in the tests for outer-iterator too.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp

82

I might have called this chunk instead, but this is non-blocking.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.pass.cpp

24

This looks like a leftover.

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

20–22

This shouldn't be necessary -- let's figure out why we need it, and fix the root cause.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.default.pass.cpp

39

I don't think this comment is useful in this test, especially if we add a test for this behavior.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.iter.pass.cpp

20–21

Run this!

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/view_interface.pass.cpp

15

Same comment I made for view_interface.

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

29

It would be nice to run these tests instead.

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

22

Run this!

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

22

Run this!

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.pass.cpp

22

Would it make sense to make this a template? Or to use something like

auto check = []<typename View> {
  ...
};

check.operator()<SplitViewDiff>();
check.operator()<SplitViewInput>();

This may apply to other tests as well. I would not spend a ton of energy trying to remove duplication, but when it's easy and doesn't increase complexity, I think it's worth it. I'll let you balance this as you see fit.

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

81

We should add a death test for the _LIBCPP_ASSERT you'll add. You'll need to put it in another file because death tests don't work on Windows.

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

13

Can you add a comment saying that more corner cases are tested elsewhere in general.pass.cpp? Otherwise, someone looking at this test in isolation would be tempted to add a bunch of corner cases, but that would end up duplicating something that already exists elsewhere.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h

30–34

I don't think we want to do this -- I think we want to explicitly test the difference between string literals and char arrays, not hide it in the tests.

85

Nitpick, but it's a good habit when defining non-template functions in header files.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/view_interface.pass.cpp

22

I would simply check that std::is_base_of<lazy_split_view, view_interface<...>> is true, otherwise we're double-testing view_interface. However, I would keep the runtime tests since they're already there and it's kind of nice to confirm that something basic like .front() works on a lazy_split_view.

[var-const]

Address feedback.

[var-const]

libcxx/include/__ranges/lazy_split_view.h

306

https://cplusplus.github.io/LWG/issue3686

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

41–44

In most other cases I fully agree, but here, I did that partially to verify that CanCallBase works correctly (e.g. that it doesn't just return false all the time) and partially to show which kinds of calls are and aren't valid. I'm absolutely open to remove if you still feel like it's overkill, but just wanted to provide a quick rationale.

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

16

Added test/support/is_explicit_ctr.h that provides a concept that should work with a constructor with any number of arguments (including a default constructor), and added the check to all constructor tests in this patch. Please let me know if you think it's overkill.

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

2

Added the following:

// In addition to the `(ForwardView, ForwardView)` case, test the `(ForwardView, tiny-range)` and `(InputView,
// tiny-range)` cases (all of which have unique code paths).
if constexpr (std::is_same_v<std::remove_reference_t<Separator>, char>) {
  assert(test_function_call(CopyableView(input), ForwardTinyView(separator), expected));
  assert(test_with_piping(CopyableView(input), ForwardTinyView(separator), expected));

  assert(test_function_call(InputView(input), ForwardTinyView(separator), expected));
  assert(test_with_piping(InputView(input), ForwardTinyView(separator), expected));
}

317

Added a vector of maps (since neither is constexpr, only checking at runtime).

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.pass.cpp

82

Went with segment if you don't mind (for some reason, I associate chunk with raw bytes or similar).

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

20–22

Looks like it was a leftover. Thanks for noticing!

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

29

I removed the positive is_constructible test, but I think the rest of this is necessary (or at least useful) to verify the setup. Please let me know if you feel it's excessive.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h

30–34

Done. This led to changes in general.pass.cpp (which I think are ultimately an improvement).

[var-const]

Add the forgotten CPO test and try to fix the CI.

[var-const]

Rebase on main.

[var-const]

Fix the CI, pt. 2.

[ldionne]

Thanks a lot! This LGTM with my comments applied and CI passing.

libcxx/include/__ranges/lazy_split_view.h

4

You should rebase on top of 9a44ed43cf9a8d4e3e55d007432e363e094ec6b0. Basically, rm -rf libcxx/test/libcxx/diagnostics/detail.headers and then regenerate auto-generated files.

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

41–44

I've actually had the same discussion with @philnik and he told me he was basically testing the test, which I had not realized at first. I think this is great. However, I think it should be sufficient to have just a single positive case to confirm that CanCallBase works as intended, and then the other ones can be runtime tests instead.

However, here it looks like the const&& and the const& variants don't have runtime tests below -- so we should add some and then remove the positive static_asserts corresponding to them above.

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/assert.equal.pass.cpp

9 ↗

(On Diff #419930)

This should also be unsupported in C++11, C++14, C++17, because we are using ranges.

10 ↗

(On Diff #419930)

This should be -D_LIBCPP_ENABLE_ASSERTIONS=1. Please apply to other assertion tests too!

libcxx/test/support/is_explicit_ctr.h

15 ↗

(On Diff #419930)

Would it be sufficient to use !std::is_convertible<T, U> && std::is_constructible<T, U>? At that point, you might not need this helper at all, since you can probably just query !std::is_convertible<T, U> in your tests (constructibility is already tested by the fact that you construct objects in your tests).

[var-const]

Address feedback, try to fix the CI.

[var-const]

Thanks a lot for the review!

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/assert.equal.pass.cpp

10 ↗

(On Diff #419930)

Couldn't find any other hits, which is weird because I'm sure I copied this from some other assertion test. Maybe it got fixed recently.

libcxx/test/support/is_explicit_ctr.h

15 ↗

(On Diff #419930)

Done.

The only thing is that IsExplicitCtr supports any number of arguments (i.e., also supports multi-argument constructors and default constructors). However, I don't think the Standard ever deliberately applies explicit to anything other than single-argument constructors, so this functionality is probably unnecessary (unless we want to be particularly paranoid and check every constructor for being non-explicit unless specified so).

[var-const]

Try to fix GCC.

[philnik]

Other than moving the libc++-specific tests in the libcxx/ subdirectory all the comments are very nit-picky, so this LGTM!

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

28

I looks like you aren't checking that begin() caches the result. Could you add a test for that?

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

42–50

Why do you have effectively the same test twice?

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

26

It looks like you aren't checking that the constructor doesn't copy the range and pattern. Same for the view, pattern constructor.

30

What is decltype(auto) here? is it const char [8]? Assuming my guess is correct, is it possible to rewrite this as const char str[] = "abc def"? I think that would be clearer.

41–43

I think you should check here that lazy_split_view isn't happy with an input_range. I've got a few ForwardRangeNot* types in D121964. You can snack those if you want. It also looks like you aren't testing the constructible_from<V, views::all_t<R>> requirement. The first static_assert will fail at the forward_range.

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

28–32

Is there a reason you aren't checking base() here?

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/assert.equal.pass.cpp

1 ↗

(On Diff #420695)

Shouldn't these kinds of tests be in libcxx/...?

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

21

Could you check here that the base iterator is default constructed?

[var-const]

Add more friends to try to fix GCC.

[var-const]

Address feedback, try to fix GCC again.

[var-const]

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

28

Hmm, this is actually a very interesting question. My understanding was that this class uses non-propagating-cache for its "non-copying" behavior, not for actual caching, since the description of begin doesn't mention anything about caching, unlike e.g. filter_view::begin(). FWIW, neither GCC nor MSVC do caching here (if I'm reading their sources correctly).

However, using caching here only breaks a couple of tests that instantiate lazy_split_view with an InputView and expect begin() to return the beginning of the range after it has already been iterated on, which is likely an incorrect expectation for an input range.

Looking further, it looks like non-propagating-cache is defined as being equivalent to optional unless specified otherwise. The specification does not "override" operator=(const T&), which means it's equivalent to optional::operator=(const T&), and that does not perform any caching. So if I'm reading this correctly, this line:

current_ = ranges::begin(base_);

in the Standard does not by itself prescribe caching, and I don't see any additional requirements or remarks to change that.

@tcanens Can you please clarify whether caching behavior is intended in lazy_split_view::begin() on the current_ = ranges::begin(base_); line?

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

42–50

I got this pattern from some other range tests we have. These are two different forms of initialization (default initialization vs. copy initialization), and the latter would fail to compile if the default constructor were explicit.

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

26

Done. This required quite a bit of setup, PTAL.

30

Yes. Removed this occurrence and one other (in general.pass.cpp).

41–43

lazy_split_view supports input_ranges as long as Pattern is a tiny-range. I think these tests are covered by the tests in range.lazy.split/constraints.compile.pass.cpp, can you please check and see if you still notice something missing?

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

28–32

InputView isn't comparable. Do you think it's important enough to define a ComparableInputView for this case? (it seems a little not worth it to me, but I'm open to do this if you feel it adds value)

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/assert.equal.pass.cpp

1 ↗

(On Diff #420695)

Thanks for catching this!

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

21

I'm not sure there's a good way of doing that. If the underlying range is an input range, it will crash (base tries to access outer-iterator::parent, which is null for a default-constructed outer-iterator). It will work for a forward range, but my overall impression is that a default-constructed iterator isn't supposed to be used for anything other than reassignment.

[var-const]

Fix the CI (after moving the assert tests, they can no longer include "types.h").

[tcanens]

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

28

No. Caching input iterators doesn't make sense, and begin doesn't perform any non-constant time operation that requires caching anyway.

[ldionne]

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

28

I'm a bit confused. We do have __current_.__emplace(ranges::begin(__base_)); in our implementation for non-forward input-iterators. I think that's what @philnik was referring to as "caching", perhaps incorrectly. But we definitely store the result of ranges::begin in the view itself instead of in the iterators.

I guess it would make sense to have a test that would fail if we tried to store the result of ranges::begin(input-range) in the outer iterator itself, instead of storing it in __current_. I don't think we have one right now.

[tcanens]

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

28

Yes, you have to store it in the view, but it's not a cache for when begin is called again (which is not even valid); it's the state of the lazy algorithm.

[var-const]

Rebase on main, fix the CI.

[var-const]

More GCC workarounds for access control.

[var-const]

Fix the CI.

[var-const]

Rebase on main.

[var-const]

?

[var-const]

Undo accidental change.

[var-const]

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

28

@ldionne no_unique_address.compile.pass.cpp checks whether the underlying iterator is stored in outer-iterator or in the view itself. Re. caching, I think @philnik meant that we don't do something like if (!__current_.__has_value()) __current_.__emplace(...).

[philnik]

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

28

Just so you don't have to guess what I was talking about, I meant https://eel.is/c++draft/range.adaptors#range.split.view-4. Sorry for the confusion.

[var-const]

Fix the CI.

[var-const]

Try to fix the CI.

[var-const]

Fix the CI?

[var-const]

Fix the CI.

[var-const]

Fix the CI?

[var-const]

Fix the CI.

libcxx/docs/Status/RangesPaper.csv

 `[range.single] <https://wg21.link/range.single>`_,`single_view <https://llvm.org/D106840>`_,[view.interface],Zoe Carver,✅
 `[range.iota] <https://wg21.link/range.iota>`_,`iota_view <https://llvm.org/D107396>`_,[range.all],Zoe Carver,✅
 `[range.all] <https://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,✅
 `[range.ref.view] <https://wg21.link/range.ref.view>`_,`ref_view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,✅
 `[range.filter] <https://wg21.link/range.filter>`_,`filter_view <https://llvm.org/D109086>`_,[range.all],Louis Dionne,Under review
 `[range.transform] <https://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.take] <https://wg21.link/range.take>`_,`take_view <https://llvm.org/D106507>`_,[range.all],Zoe Carver,✅
 `[range.join] <https://wg21.link/range.join>`_,`join_view <https://llvm.org/D107671>`_,[range.all],Zoe Carver,✅
-`[range.split] <https://wg21.link/range.split>`_,`split_view (renamed to lazy_split_view by P2210) <https://llvm.org/D107500>`_,[range.all],Zoe Carver,In progress
+`[range.split] <https://wg21.link/range.split>`_,`split_view (renamed to lazy_split_view by P2210) <https://llvm.org/D107500>`_,[range.all],Zoe Carver and Konstantin Varlamov,✅
 `[range.counted] <https://wg21.link/range.counted>`_,`view::counted <https://llvm.org/D106923>`_,[range.subrange],Zoe Carver,✅
 `[range.common] <https://wg21.link/range.common>`_,`common_view <https://llvm.org/D105753>`_,[range.all],Zoe Carver,✅
 `[range.reverse] <https://wg21.link/range.reverse>`_,`reverse_view <https://llvm.org/D107096>`_,[range.all],Zoe Carver,✅

libcxx/include/CMakeLists.txt

set(files
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/iota_view.h
   __ranges/join_view.h
+  __ranges/lazy_split_view.h
   __ranges/non_propagating_cache.h
   __ranges/owning_view.h
   __ranges/range_adaptor.h
   __ranges/rbegin.h
   __ranges/ref_view.h
   __ranges/rend.h
   __ranges/reverse_view.h
   __ranges/single_view.h

libcxx/include/__ranges/lazy_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_LAZY_SPLIT_VIEW_H
+#define _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H
+
+#include <__algorithm/ranges_find.h>
+#include <__algorithm/ranges_mismatch.h>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/iter_swap.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/single_view.h>
+#include <__ranges/view_interface.h>
+#include <__utility/move.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+
+template <auto> struct __require_constant;
+
+template <class _Range>
+concept __tiny_range =
+  sized_range<_Range> &&
+  requires { typename __require_constant<remove_reference_t<_Range>::size()>; } &&
+  (remove_reference_t<_Range>::size() <= 1);
+
+template <input_range _View, forward_range _Pattern>
+  requires view<_View> && view<_Pattern> &&
+            indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to> &&
+            (forward_range<_View> || __tiny_range<_Pattern>)
+class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
+
+  _View __base_ = _View();
+  _Pattern __pattern_ = _Pattern();
+
+  using _MaybeCurrent = _If<!forward_range<_View>, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
+
+  template <bool> struct __outer_iterator;
+  template <bool> struct __inner_iterator;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI
+  lazy_split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern> = default;
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr lazy_split_view(_View __base, _Pattern __pattern)
+    : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
+
+  template <input_range _Range>
+    requires constructible_from<_View, views::all_t<_Range>> &&
+             constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+    : __base_(views::all(std::forward<_Range>(__r)))
+    // TODO(var-const): use `views::single` once it's implemented.
+    , __pattern_(ranges::single_view(std::move(__e))) {}
+
+  _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 auto begin() {
+    if constexpr (forward_range<_View>) {
+      return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::begin(__base_)};
+    } else {
+      __current_.__emplace(ranges::begin(__base_));
+      return __outer_iterator<false>{*this};
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr auto begin() const requires forward_range<_View> && forward_range<const _View> {
+    return __outer_iterator<true>{*this, ranges::begin(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr auto end() requires forward_range<_View> && common_range<_View> {
+    return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  constexpr auto end() const {
+    if constexpr (forward_range<_View> && forward_range<const _View> && common_range<const _View>) {
+      return __outer_iterator<true>{*this, ranges::end(__base_)};
+    } else {
+      return default_sentinel;
+    }
+  }
+
+private:
+
+  template <class>
+  struct __outer_iterator_category {};
+
+  template <forward_range _Tp>
+  struct __outer_iterator_category<_Tp> {
+    using iterator_category = input_iterator_tag;
+  };
+
+  template <bool _Const>
+  struct __outer_iterator : __outer_iterator_category<__maybe_const<_Const, _View>> {
+  private:
+    template <bool>
+    friend struct __inner_iterator;
+    friend __outer_iterator<true>;
+
+    using _Parent = __maybe_const<_Const, lazy_split_view>;
+    using _Base = __maybe_const<_Const, _View>;
+
+    _Parent* __parent_ = nullptr;
+    using _MaybeCurrent = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
+    _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
+    bool __trailing_empty_ = false;
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() noexcept {
+      if constexpr (forward_range<_View>) {
+        return __current_;
+      } else {
+        return *__parent_->__current_;
+      }
+    }
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() const noexcept {
+      if constexpr (forward_range<_View>) {
+        return __current_;
+      } else {
+        return *__parent_->__current_;
+      }
+    }
+
+  public:
+    // using iterator_category = inherited;
+    using iterator_concept = conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>;
+    using difference_type = range_difference_t<_Base>;
+
+    struct value_type : view_interface<value_type> {
+    private:
+      __outer_iterator __i_ = __outer_iterator();
+
+    public:
+      _LIBCPP_HIDE_FROM_ABI
+      value_type() = default;
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr explicit value_type(__outer_iterator __i)
+        : __i_(std::move(__i)) {}
+
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
+      _LIBCPP_HIDE_FROM_ABI
+      constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
+    };
+
+    _LIBCPP_HIDE_FROM_ABI
+    __outer_iterator() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __outer_iterator(_Parent& __parent)
+      requires (!forward_range<_Base>)
+      : __parent_(std::addressof(__parent)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
+      requires forward_range<_Base>
+      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __outer_iterator(__outer_iterator<!_Const> __i)
+      requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr value_type operator*() const { return value_type{*this}; }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __outer_iterator& operator++() {
+      const auto __end = ranges::end(__parent_->__base_);
+      if (__current() == __end) {
+        __trailing_empty_ = false;
+        return *this;
+      }
+
+      const auto [__pbegin, __pend] = ranges::subrange{__parent_->__pattern_};
+      if (__pbegin == __pend) {
+        ++__current();
+
+      } else if constexpr (__tiny_range<_Pattern>) {
+        __current() = ranges::find(std::move(__current()), __end, *__pbegin);
+        if (__current() != __end) {
+          ++__current();
+          if (__current() == __end)
+            __trailing_empty_ = true;
+        }
+
+      } else {
+        do {
+          const auto [__b, __p] = std::ranges::mismatch(__current(), __end, __pbegin, __pend);
+          if (__p == __pend) {
+            __current() = __b;
+            if (__current() == __end) {
+              __trailing_empty_ = true;
+            }
+            break; // The pattern matched; skip it.
+          }
+        } while (++__current() != __end);
+      }
+
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<_Base>) {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+
+      } else {
+        ++*this;
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
+      requires forward_range<_Base> {
+      return __x.__current_ == __y.__current_ && __x.__trailing_empty_ == __y.__trailing_empty_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
+      return __x.__current() == ranges::end(__x.__parent_->__base_) && !__x.__trailing_empty_;
+    }
+  };
+
+  template <class>
+  struct __inner_iterator_category {};
+
+  template <forward_range _Tp>
+  struct __inner_iterator_category<_Tp> {
+    using iterator_category = _If<
+      derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
+      forward_iterator_tag,
+      typename iterator_traits<iterator_t<_Tp>>::iterator_category
+    >;
+  };
+
+  template <bool _Const>
+  struct __inner_iterator : __inner_iterator_category<__maybe_const<_Const, _View>> {
+  private:
+    using _Base = __maybe_const<_Const, _View>;
+    __outer_iterator<_Const> __i_ = __outer_iterator<_Const>();
+    bool __incremented_ = false;
+
+  public:
+    // using iterator_category = inherited;
+    using iterator_concept = typename __outer_iterator<_Const>::iterator_concept;
+    using value_type = range_value_t<_Base>;
+    using difference_type = range_difference_t<_Base>;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __inner_iterator() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __inner_iterator(__outer_iterator<_Const> __i)
+      : __i_(std::move(__i)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr iterator_t<_Base> base() &&
+      requires forward_range<_View> { return std::move(__i_.__current()); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator*() const { return *__i_.__current(); }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __inner_iterator& operator++() {
+      __incremented_ = true;
+
+      if constexpr (!forward_range<_Base>) {
+        if constexpr (_Pattern::size() == 0) {
+          return *this;
+        }
+      }
+
+      ++__i_.__current();
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr decltype(auto) operator++(int) {
+      if constexpr (forward_range<_Base>) {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+
+      } else {
+        ++*this;
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
+      requires forward_range<_Base> {
+      return __x.__i_.__current() == __y.__i_.__current();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
+      auto [__pcur, __pend] = ranges::subrange{__x.__i_.__parent_->__pattern_};
+      auto __end = ranges::end(__x.__i_.__parent_->__base_);
+
+      if constexpr (__tiny_range<_Pattern>) {
+        const auto& __cur = __x.__i_.__current();
+        if (__cur == __end)
+          return true;
+        if (__pcur == __pend)
+          return __x.__incremented_;
+
+        return *__cur == *__pcur;
+
+      } else {
+        auto __cur = __x.__i_.__current();
+        if (__cur == __end)
+          return true;
+        if (__pcur == __pend)
+          return __x.__incremented_;
+
+        do {
+          if (*__cur != *__pcur)
+            return false;
+          if (++__pcur == __pend)
+            return true;
+        } while (++__cur != __end);
+
+        return false;
+      }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr decltype(auto) iter_move(const __inner_iterator& __i)
+        noexcept(noexcept(ranges::iter_move(__i.__i_.__current()))) {
+      return ranges::iter_move(__i.__i_.__current());
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr void iter_swap(const __inner_iterator& __x, const __inner_iterator& __y)
+        noexcept(noexcept(ranges::iter_swap(__x.__i_.__current(), __y.__i_.__current())))
+        requires indirectly_swappable<iterator_t<_Base>> {
+      ranges::iter_swap(__x.__i_.__current(), __y.__i_.__current());
+    }
+  };
+
+};
+
+template <class _Range, class _Pattern>
+lazy_split_view(_Range&&, _Pattern&&) -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
+
+template <input_range _Range>
+lazy_split_view(_Range&&, range_value_t<_Range>)
+  -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+
+namespace views {
+namespace __lazy_split_view {
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range, class _Pattern>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+    noexcept(noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+    -> decltype(      lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
+    { return          lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+
+  template <class _Pattern>
+    requires constructible_from<decay_t<_Pattern>, _Pattern>
+  [[nodiscard]] _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 __lazy_split_view
+
+inline namespace __cpo {
+  inline constexpr auto lazy_split = __lazy_split_view::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H

libcxx/include/module.modulemap

module __ranges {
       module data                   { private header "__ranges/data.h" }
       module drop_view              { private header "__ranges/drop_view.h" }
       module empty                  { private header "__ranges/empty.h" }
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module join_view              { private header "__ranges/join_view.h" }
+      module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module rend                   { private header "__ranges/rend.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }

libcxx/include/ranges

// [range.reverse], reverse view
 
   template<class W, class Bound>
     inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
   // [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
+
+  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;
+
+  namespace views {
+    inline constexpr unspecified lazy_split = unspecified;
+  }
 }
 
 namespace std {
   namespace views = ranges::views;
 
   template<class T> struct tuple_size;
   template<size_t I, class T> struct tuple_element;
 

 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
+#include <__ranges/lazy_split_view.h>
 #include <__ranges/rbegin.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/rend.h>
 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>

libcxx/test/libcxx/diagnostics/detail.headers/ranges/lazy_split_view.module.verify.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__ranges/lazy_split_view.h'}}
+#include <__ranges/lazy_split_view.h>

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::lazy_split
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <string_view>
+#include <utility>
+
+#include "test_iterators.h"
+#include "types.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::lazy_split)>);
+static_assert(!std::is_invocable_v<decltype(std::views::lazy_split), SomeView, NotAView>);
+static_assert(!std::is_invocable_v<decltype(std::views::lazy_split), NotAView, SomeView>);
+static_assert( std::is_invocable_v<decltype(std::views::lazy_split), SomeView, SomeView>);
+
+static_assert( CanBePiped<SomeView&,    decltype(std::views::lazy_split)>);
+static_assert( CanBePiped<char(&)[10],  decltype(std::views::lazy_split)>);
+static_assert(!CanBePiped<char(&&)[10], decltype(std::views::lazy_split)>);
+static_assert(!CanBePiped<NotAView,     decltype(std::views::lazy_split)>);
+
+static_assert(std::same_as<decltype(std::views::lazy_split), decltype(std::ranges::views::lazy_split)>);
+
+constexpr bool test() {
+  constexpr std::string_view input = "abc";
+  constexpr std::string_view sep = "a";
+
+  // Test that `std::views::lazy_split` is a range adaptor.
+
+  // Test `views::lazy_split(input, sep)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = std::views::lazy_split(view, sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `views::lazy_split(sep)(input)`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = std::views::lazy_split(sep)(view);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `view | views::lazy_split`.
+  {
+    SomeView view(input);
+
+    using Result = std::ranges::lazy_split_view<SomeView, std::string_view>;
+    std::same_as<Result> auto result = view | std::views::lazy_split(sep);
+    assert(result.base().begin() == input.begin());
+    assert(result.base().end() == input.end());
+  }
+
+  // Test `adaptor | views::lazy_split`.
+  {
+    SomeView view(input);
+    auto f = [](char c) { return c; };
+    auto partial = std::views::transform(f) | std::views::lazy_split(sep);
+
+    using Result = std::ranges::lazy_split_view<std::ranges::transform_view<SomeView, decltype(f)>, std::string_view>;
+    std::same_as<Result> auto result = partial(view);
+    assert(result.base().base().begin() == input.begin());
+    assert(result.base().base().end() == input.end());
+  }
+
+  // Test `views::lazy_split | adaptor`.
+  {
+    SomeView view(input);
+    auto f = [](auto v) { return v; };
+    auto partial = std::views::lazy_split(sep) | std::views::transform(f);
+
+    using Result = std::ranges::transform_view<std::ranges::lazy_split_view<SomeView, std::string_view>, decltype(f)>;
+    std::same_as<Result> 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::filter 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::lazy_split(X{});
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr View base() const& requires copy_constructible<_View>;
+// constexpr View base() &&;
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+#include "types.h"
+
+struct MoveOnlyView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr MoveOnlyView() = default;
+  constexpr MoveOnlyView(const char* ptr) : view_(ptr) {}
+  constexpr MoveOnlyView(std::string_view v) : view_(v) {}
+  constexpr MoveOnlyView(MoveOnlyView&&) = default;
+  constexpr MoveOnlyView& operator=(MoveOnlyView&&) = default;
+  constexpr const char* begin() const { return view_.begin(); }
+  constexpr const char* end() const { return view_.end(); }
+  constexpr bool operator==(MoveOnlyView rhs) const { return view_ == rhs.view_; }
+};
+static_assert( std::ranges::view<MoveOnlyView>);
+static_assert( std::ranges::contiguous_range<MoveOnlyView>);
+static_assert(!std::copyable<MoveOnlyView>);
+
+template <class View>
+concept CanCallBase = requires(View v) { std::forward<View>(v).base(); };
+
+static_assert( CanCallBase<std::ranges::lazy_split_view<CopyableView, ForwardView>&>);
+static_assert( CanCallBase<std::ranges::lazy_split_view<CopyableView, ForwardView> const &>);
+static_assert( CanCallBase<std::ranges::lazy_split_view<CopyableView, ForwardView>&&>);
+static_assert( CanCallBase<std::ranges::lazy_split_view<CopyableView, ForwardView> const &&>);
+static_assert(!CanCallBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView>&>);
+static_assert(!CanCallBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView> const &>);
+static_assert( CanCallBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView>&&>);
+static_assert(!CanCallBase<std::ranges::lazy_split_view<MoveOnlyView, ForwardView> const &&>);
+
+struct View : std::ranges::view_base {
+  enum class InitializedBy {
+    Copy,
+    Move,
+    Invalid
+  };
+
+  std::string_view v_;
+  InitializedBy initialized_by = InitializedBy::Invalid;
+  constexpr View(std::string_view v) : v_(v) {}
+
+  constexpr auto begin() const { return v_.begin(); }
+  constexpr auto end() const { return v_.end(); }
+
+  constexpr View(const View& rhs) : v_(rhs.v_) { initialized_by = InitializedBy::Copy; }
+  constexpr View(View&& rhs) : v_(rhs.v_) { initialized_by = InitializedBy::Move; }
+  constexpr View& operator=(const View& rhs) = default;
+  constexpr View& operator=(View&& rhs) = default;
+  constexpr bool operator==(const View& rhs) const { return v_ == rhs.v_; }
+};
+
+constexpr bool test() {
+  // Copyable input -- both lvalue and rvalue overloads of `base` are available.
+  {
+    {
+      constexpr View str("abc def");
+      std::ranges::lazy_split_view<View, std::string_view> v(str, " ");
+
+      std::same_as<View> auto result = v.base();
+      assert(result == str);
+      assert(result.initialized_by == View::InitializedBy::Copy);
+    }
+
+    {
+      constexpr View str("abc def");
+      std::ranges::lazy_split_view<View, std::string_view> v(str, " ");
+
+      std::same_as<View> auto result = std::move(v).base();
+      assert(result == str);
+      assert(result.initialized_by == View::InitializedBy::Move);
+    }
+  }
+
+  // Move-only input -- only the rvalue overload of `base` is available.
+  {
+    std::ranges::lazy_split_view<MoveOnlyView, ForwardView> v;
+    assert(std::move(v).base() == MoveOnlyView());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto begin();
+// constexpr auto begin() const requires forward_range<View> && forward_range<const View>;
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class Expected>
+concept OuterIterConceptSameAs =
+    std::same_as<typename std::ranges::iterator_t<View>::iterator_concept, Expected>;
+
+template <class View, class Expected>
+concept InnerIterValueTypeSameAs = requires (View v) {
+  { *(*v.begin()).begin() } -> std::same_as<Expected>;
+};
+
+template <class View>
+concept ConstBeginDisabled = !requires (const View v) {
+  { (*v.begin()) };
+};
+
+constexpr bool test() {
+  // non-const: forward_range<View> && simple-view<View> -> outer-iterator<Const = true>
+  // const: forward_range<View> && forward_range<const View> -> outer-iterator<Const = true>
+  {
+    using V = ForwardView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<View> && !simple-view<View> -> outer-iterator<Const = false>
+  // const: forward_range<View> && forward_range<const View> -> outer-iterator<Const = true>
+  {
+    using V = ForwardDiffView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<View> && !simple-view<View> -> outer-iterator<Const = false>
+  // const: forward_range<View> && !forward_range<const View> -> disabled
+  {
+    using V = ForwardOnlyIfNonConstView;
+    using P = V;
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    static_assert(ConstBeginDisabled<decltype(v)>);
+  }
+
+  // non-const: forward_range<View> && simple-view<View> && !simple-view<Pattern> -> outer-iterator<Const = false>
+  // const: forward_range<View> && forward_range<const View> -> outer-iterator<Const = true>
+  {
+    using V = ForwardView;
+    using P = ForwardOnlyIfNonConstView;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: !forward_range<View> && tiny-range<Pattern> -> outer-iterator<Const = false>
+  // const: !forward_range<View> -> disabled
+  {
+    using V = InputView;
+    using P = ForwardTinyView;
+
+    static_assert(!std::ranges::forward_range<V>);
+    static_assert(std::ranges::forward_range<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::input_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), char&>);
+
+    static_assert(ConstBeginDisabled<decltype(v)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// 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;
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "types.h"
+
+struct ForwardRange {
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
+};
+static_assert( std::ranges::forward_range<ForwardRange>);
+
+template <class View, class Pattern>
+concept CanInstantiate = requires {
+  typename std::ranges::lazy_split_view<View, Pattern>;
+};
+
+// All constraints satisfied (`View` and `Pattern` are forward views).
+namespace test1 {
+
+  using View = ForwardView;
+  using Pattern = ForwardView;
+  static_assert( std::ranges::forward_range<View>);
+  static_assert( std::ranges::forward_range<Pattern>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert( std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert( CanInstantiate<View, Pattern>);
+
+} // namespace test1
+
+// All constraints satisfied (`View` is an input view and `Pattern` is a tiny view).
+namespace test2 {
+
+  using View = InputView;
+  using Pattern = ForwardTinyView;
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::ranges::forward_range<Pattern>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert( std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert( CanInstantiate<View, Pattern>);
+
+} // namespace test2
+
+// `View` is not an input range.
+namespace test3 {
+
+  struct AlmostInputIterator {
+    using value_type = char;
+    using difference_type = ptrdiff_t;
+    using iterator_concept = int;
+
+    constexpr const char& operator*() const;
+    constexpr AlmostInputIterator& operator++();
+    constexpr void operator++(int);
+    constexpr bool operator==(const AlmostInputIterator&) const;
+  };
+
+  static_assert( std::input_or_output_iterator<AlmostInputIterator>);
+  static_assert(!std::input_iterator<AlmostInputIterator>);
+
+  struct NonInputView : std::ranges::view_base {
+    AlmostInputIterator begin() const;
+    AlmostInputIterator end() const;
+  };
+
+  using View = NonInputView;
+  using Pattern = ForwardTinyView;
+  static_assert(!std::ranges::input_range<View>);
+  static_assert( std::ranges::forward_range<Pattern>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert( std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert(!CanInstantiate<View, Pattern>);
+
+} // namespace test3
+
+// `View` is not a view.
+namespace test4 {
+
+  using View = ForwardRange;
+  using Pattern = ForwardView;
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::ranges::forward_range<Pattern>);
+  static_assert(!std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert( std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert(!CanInstantiate<View, Pattern>);
+
+} // namespace test4
+
+// `Pattern` is not a forward range.
+namespace test5 {
+
+  using View = ForwardView;
+  using Pattern = InputView;
+  static_assert( std::ranges::input_range<View>);
+  static_assert(!std::ranges::forward_range<Pattern>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert( std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert(!CanInstantiate<View, Pattern>);
+
+} // namespace test5
+
+// Not indirectly comparable.
+namespace test6 {
+
+  struct Empty{};
+  struct IntForwardView : std::ranges::view_base {
+    constexpr forward_iterator<Empty*> begin() const { return {}; }
+    constexpr forward_iterator<Empty*> end() const { return {}; }
+  };
+
+  using View = ForwardView;
+  using Pattern = IntForwardView;
+  static_assert( std::ranges::input_range<View>);
+  static_assert( std::ranges::forward_range<Pattern>);
+  static_assert( std::ranges::view<View>);
+  static_assert( std::ranges::view<Pattern>);
+  static_assert(!std::indirectly_comparable<
+      std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+  static_assert(!CanInstantiate<View, Pattern>);
+
+} // namespace test6
+
+// `View` is not a forward range and `Pattern` is not a tiny range.
+namespace test7 {
+
+    using View = InputView;
+    using Pattern = ForwardView;
+    static_assert( std::ranges::input_range<View>);
+    static_assert(!std::ranges::forward_range<View>);
+    static_assert( std::ranges::forward_range<Pattern>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__tiny_range<Pattern>);
+    static_assert( std::ranges::view<View>);
+    static_assert( std::ranges::view<Pattern>);
+    static_assert( std::indirectly_comparable<
+        std::ranges::iterator_t<View>, std::ranges::iterator_t<Pattern>, std::ranges::equal_to>);
+    static_assert(!CanInstantiate<View, Pattern>);
+
+} // namespace test7

libcxx/test/std/ranges/range.adaptors/range.lazy.split/copy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view;
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+#include "small_string.h"
+#include "types.h"
+
+constexpr bool operator==(const InputView& lhs, const InputView& rhs) {
+  return SmallString(lhs) == SmallString(rhs);
+}
+
+constexpr bool test() {
+  // Can copy `lazy_split_view`.
+  {
+    // Forward range.
+    {
+      std::ranges::lazy_split_view<std::string_view, std::string_view> v1("abc def", " ");
+      auto v2 = v1;
+      assert(v2.base() == v1.base());
+    }
+
+    // Input range.
+    {
+      SplitViewInput v1("abc def", ' ');
+      auto v2 = v1;
+      assert(v2.base() == v1.base());
+    }
+  }
+
+  // Can move `lazy_split_view`.
+  {
+    // Forward range.
+    {
+      std::string_view base = "abc def";
+      std::ranges::lazy_split_view<std::string_view, std::string_view> v1(base, " ");
+      auto v2 = std::move(v1);
+      assert(v2.base() == base);
+    }
+
+    // Input range.
+    {
+      InputView base("abc def");
+      SplitViewInput v1(base, ' ');
+      auto v2 = std::move(v1);
+      assert(v2.base() == base);
+    }
+  }
+
+  // `non-propagating-cache` is not copied.
+  {
+    SplitViewInput v1("abc def ghi", ' ');
+    auto outer_iter1 = v1.begin();
+    ++outer_iter1;
+    auto val1 = *outer_iter1;
+    auto i1 = val1.begin();
+    assert(*i1 == 'd');
+    ++i1;
+    assert(*i1 == 'e');
+
+    auto v2 = v1;
+    auto val2 = *v2.begin();
+    auto i2 = val2.begin();
+    assert(*i2 == 'a');
+    ++i2;
+    assert(*i2 == 'b');
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class R, class P>
+// lazy_split_view(R&&, P&&) -> lazy_split_view<views::all_t<R>, views::all_t<P>>;
+//
+// template <input_range R>
+// lazy_split_view(R&&, range_value_t<R>) -> lazy_split_view<views::all_t<R>, single_view<range_value_t<R>>>;
+
+#include <ranges>
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+#include "types.h"
+
+struct ForwardRange {
+  forward_iterator<const char*> begin() const;
+  forward_iterator<const char*> end() const;
+};
+static_assert( std::ranges::forward_range<ForwardRange>);
+
+struct InputRange {
+  cpp20_input_iterator<const char*> begin() const;
+  std::default_sentinel_t end() const;
+};
+bool operator==(const cpp20_input_iterator<const char*>&, std::default_sentinel_t);
+static_assert(std::ranges::input_range<InputRange>);
+
+template <class I1, class I2, class ExpectedView, class ExpectedPattern>
+constexpr void test() {
+  I1 i1{};
+  I2 i2{};
+
+  std::ranges::lazy_split_view v(std::move(i1), std::move(i2));
+  static_assert(std::same_as<decltype(v), std::ranges::lazy_split_view<ExpectedView, ExpectedPattern>>);
+  using O = decltype(std::move(v).base());
+  static_assert(std::same_as<O, ExpectedView>);
+}
+
+constexpr void testCtad() {
+  // (Range, Pattern)
+  test<ForwardView, ForwardView, ForwardView, ForwardView>();
+  test<ForwardRange, ForwardRange, std::ranges::views::all_t<ForwardRange>, std::ranges::views::all_t<ForwardRange>>();
+
+  // (Range, RangeElement)
+  test<ForwardRange, char, std::ranges::views::all_t<ForwardRange>, std::ranges::single_view<char>>();
+  test<InputRange, char, std::ranges::views::all_t<InputRange>, std::ranges::single_view<char>>();
+
+  // (Range, RangeElement) with implicit conversion.
+  test<ForwardRange, bool, std::ranges::views::all_t<ForwardRange>, std::ranges::single_view<char>>();
+  test<InputRange, bool, std::ranges::views::all_t<InputRange>, std::ranges::single_view<char>>();
+
+  // Note: CTAD from (InputRange, ForwardTinyRange) doesn't work -- the deduction guide wraps the pattern in
+  // `views::all_t`, resulting in `views::owning_view<ForwardTinyRange>`. That type would never satisfy `tiny-range`
+  // because `views::owning_view` contains a member function `size()` that shadows the static `size()` in
+  // `ForwardTinyRange`.
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+//  lazy_split_view() requires default_initializable<V> && default_initializable<P> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include "types.h"
+
+struct ThrowingDefaultCtorForwardView : std::ranges::view_base {
+  ThrowingDefaultCtorForwardView() noexcept(false);
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
+};
+
+struct NoDefaultCtorForwardView : std::ranges::view_base {
+  NoDefaultCtorForwardView() = delete;
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
+};
+
+static_assert( std::is_default_constructible_v<std::ranges::lazy_split_view<ForwardView, ForwardView>>);
+static_assert(!std::is_default_constructible_v<std::ranges::lazy_split_view<NoDefaultCtorForwardView, ForwardView>>);
+static_assert(!std::is_default_constructible_v<std::ranges::lazy_split_view<ForwardView, NoDefaultCtorForwardView>>);
+
+static_assert( std::is_nothrow_default_constructible_v<std::ranges::lazy_split_view<ForwardView, ForwardView>>);
+static_assert(!std::is_nothrow_default_constructible_v<ThrowingDefaultCtorForwardView>);
+static_assert(!std::is_nothrow_default_constructible_v<
+    std::ranges::lazy_split_view<ThrowingDefaultCtorForwardView, ForwardView>>);
+
+constexpr bool test() {
+  {
+    std::ranges::lazy_split_view<CopyableView, ForwardView> v;
+    assert(v.base() == CopyableView());
+  }
+
+  {
+    std::ranges::lazy_split_view<CopyableView, ForwardView> v = {};
+    assert(v.base() == CopyableView());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <input_range Range>
+//   requires constructible_from<View, views::all_t<Range>> &&
+//             constructible_from<Pattern, single_view<range_value_t<Range>>>
+// constexpr lazy_split_view(Range&& r, range_value_t<Range> e);
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include "types.h"
+
+constexpr bool test() {
+  decltype(auto) str = "abc def";
+  std::ranges::lazy_split_view<std::string_view, std::string_view> v(str, ' ');
+  assert(v.base() == std::string_view(str, sizeof(str)));
+
+  {
+    using V = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+    static_assert( std::is_constructible_v<V, std::string_view, char>);
+    static_assert( std::is_constructible_v<V, char(&)[5], char>);
+    struct Empty {};
+    static_assert(!std::is_constructible_v<V, Empty, std::string_view>);
+    static_assert(!std::is_constructible_v<V, std::string_view, Empty>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr lazy_split_view(View base, Pattern pattern);
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+
+constexpr bool test() {
+  constexpr std::string_view str = "abc def";
+  std::ranges::lazy_split_view<std::string_view, std::string_view> v(str, " ");
+  assert(v.base() == str);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto end() requires forward_range<View> && common_range<View>;
+// constexpr auto end() const;
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+#include "test_iterators.h"
+#include "types.h"
+
+template <class View, class Expected>
+concept OuterIterConceptSameAs =
+    std::same_as<typename decltype(std::declval<View>().end())::iterator_concept, Expected>;
+
+template <class View, class Expected>
+concept InnerIterValueTypeSameAs = requires (View v) {
+  { *(*v.end()).begin() } -> std::same_as<Expected>;
+};
+
+struct ForwardViewCommonIfConst : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardViewCommonIfConst() = default;
+  constexpr ForwardViewCommonIfConst(const char* ptr) : view_(ptr) {}
+  constexpr ForwardViewCommonIfConst(std::string_view v) : view_(v) {}
+  constexpr ForwardViewCommonIfConst(ForwardViewCommonIfConst&&) = default;
+  constexpr ForwardViewCommonIfConst& operator=(ForwardViewCommonIfConst&&) = default;
+  constexpr ForwardViewCommonIfConst(const ForwardViewCommonIfConst&) = default;
+  constexpr ForwardViewCommonIfConst& operator=(const ForwardViewCommonIfConst&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(nullptr); }
+  constexpr std::default_sentinel_t end()  { return std::default_sentinel; }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+};
+bool operator==(forward_iterator<char*>, std::default_sentinel_t) { return false; }
+
+struct ForwardViewNonCommonRange : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardViewNonCommonRange() = default;
+  constexpr ForwardViewNonCommonRange(const char* ptr) : view_(ptr) {}
+  constexpr ForwardViewNonCommonRange(std::string_view v) : view_(v) {}
+  constexpr ForwardViewNonCommonRange(ForwardViewNonCommonRange&&) = default;
+  constexpr ForwardViewNonCommonRange& operator=(ForwardViewNonCommonRange&&) = default;
+  constexpr ForwardViewNonCommonRange(const ForwardViewNonCommonRange&) = default;
+  constexpr ForwardViewNonCommonRange& operator=(const ForwardViewNonCommonRange&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(nullptr); }
+  constexpr std::default_sentinel_t end()  { return std::default_sentinel; }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr std::default_sentinel_t end() const { return std::default_sentinel; }
+};
+bool operator==(forward_iterator<const char*>, std::default_sentinel_t) { return false; }
+
+constexpr bool test() {
+  // non-const: forward_range<V> && simple_view<V> && simple_view<P> -> outer-iterator<Const = true>
+  // const: forward_range<V> && common_range<V> -> outer-iterator<Const = true>
+  {
+    using V = ForwardView;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::common_range<const V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<P>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && common_range<V> && simple_view<V> && !simple_view<P> -> outer-iterator<Const=false>
+  // const: forward_range<V> && forward_range<const V> && common_range<const V> -> outer-iterator<Const = false>
+  {
+    using V = ForwardView;
+    using P = ForwardDiffView;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(std::ranges::common_range<V>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<V>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<P>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && !common_range<V> -> disabled
+  // const: forward_range<V> && forward_range<const V> && common_range<const V> -> outer-iterator<Const = true>
+  {
+    using V = ForwardViewCommonIfConst;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::common_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(OuterIterConceptSameAs<decltype(v), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(v), const char&>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(OuterIterConceptSameAs<decltype(cv), std::forward_iterator_tag>);
+    static_assert(InnerIterValueTypeSameAs<decltype(cv), const char&>);
+  }
+
+  // non-const: forward_range<V> && !common_range<V> -> disabled
+  // const: forward_range<V> && forward_range<const V> && !common_range<const V> -> outer-iterator<Const = false>
+  {
+    using V = ForwardViewNonCommonRange;
+    using P = V;
+
+    static_assert(std::ranges::forward_range<V>);
+    static_assert(!std::ranges::common_range<V>);
+    static_assert(std::ranges::forward_range<const V>);
+    static_assert(!std::ranges::common_range<const V>);
+
+    std::ranges::lazy_split_view<V, P> v;
+    static_assert(std::same_as<decltype(v.end()), std::default_sentinel_t>);
+
+    const std::ranges::lazy_split_view<V, P> cv;
+    static_assert(std::same_as<decltype(cv.end()), std::default_sentinel_t>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class View, class Pattern>
+// class std::ranges::lazy_split_view;
+
+#include <ranges>
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <string_view>
+#include <utility>
+#include "small_string.h"
+
+template <std::ranges::view View, std::ranges::range Expected>
+constexpr bool is_equal(const View& v, const Expected& expected) {
+  using Char = std::ranges::range_value_t<std::ranges::range_value_t<View>>;
+  using Str = BasicSmallString<Char>;
+
+  return std::equal(v.begin(), v.end(), expected.begin(), expected.end(),
+      [](const auto& split_value, const auto& expected_value) {
+        return Str(split_value) == Str(expected_value);
+  });
+}
+
+template <class T, class Separator, class U, size_t M>
+constexpr bool test_function_call(T&& input, Separator&& separator, std::array<U, M> expected) {
+  std::ranges::lazy_split_view v(input, separator);
+
+  return is_equal(v, expected);
+}
+
+template <class T, class Separator, class U, size_t M>
+constexpr bool test_with_piping(T&& input, Separator&& separator, std::array<U, M> expected) {
+  auto expected_it = expected.begin();
+  for (auto e : input | std::ranges::views::lazy_split(separator)) {
+    if (expected_it == expected.end()) return false;
+
+    if (SmallString(e) != *expected_it) return false;
+    ++expected_it;
+  }
+
+  return expected_it == expected.end();
+}
+
+constexpr bool test_l_r_values() {
+  using namespace std::string_view_literals;
+
+  // Both lvalues and rvalues can be used as input.
+  {
+    // Lvalues.
+    {
+      auto input = "abc"sv;
+      auto sep = " "sv;
+      [[maybe_unused]] std::ranges::lazy_split_view v(input, sep);
+    }
+
+    // Const lvalues.
+    {
+      const auto input = "abc"sv;
+      const auto sep = " "sv;
+      [[maybe_unused]] std::ranges::lazy_split_view v(input, sep);
+    }
+
+    // Rvalues.
+    {
+      auto input = "abc"sv;
+      auto sep = " "sv;
+      [[maybe_unused]] std::ranges::lazy_split_view v(std::move(input), std::move(sep));
+    }
+
+    // Const rvalues.
+    {
+      const auto input = "abc"sv;
+      const auto sep = " "sv;
+      [[maybe_unused]] std::ranges::lazy_split_view v(std::move(input), std::move(sep));
+    }
+  }
+
+  return true;
+}
+
+constexpr bool test_string_literal_separator() {
+  // Splitting works as expected when the separator is a single character literal.
+  {
+    std::ranges::lazy_split_view v("abc def", ' ');
+    assert(is_equal(v, std::array{"abc", "def"}));
+  }
+
+  // Counterintuitively, a seemingly equivalent separator expressed as a string literal doesn't match anything. This is
+  // because of the implicit terminating null in the literal.
+  {
+    std::ranges::lazy_split_view v("abc def", " ");
+    assert(is_equal(v, std::array{"abc def"}));
+  }
+
+  // To illustrate the previous point further, the separator is actually a two-character string literal: `{' ', '\0'}`.
+  // Should the input string contain that two-character sequence, the separator would match.
+  {
+    std::ranges::lazy_split_view v("abc \0def", " ");
+    assert(is_equal(v, std::array{"abc", "def"}));
+  }
+
+  return true;
+}
+
+constexpr bool test() {
+  using namespace std::string_view_literals;
+
+  char short_sep = ' ';
+  auto long_sep = "12"sv;
+  // Make sure that a string literal and a `string_view` produce the same results (which isn't always the case, see
+  // below).
+  auto sv = [](auto&& str) { return std::string_view(str); };
+
+  // One separator.
+  {
+    {
+      decltype(auto) input = "abc def";
+      std::array expected = {"abc"sv, "def"sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def";
+      std::array expected = {"abc"sv, "def"sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Several separators in a row.
+  {
+    {
+      decltype(auto) input = "abc    def";
+      std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12121212def";
+      std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Trailing separator.
+  {
+    {
+      decltype(auto) input = "abc def ";
+      std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def12";
+      std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Leading separator.
+  {
+    {
+      decltype(auto) input = " abc def";
+      std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12abc12def";
+      std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // No separator.
+  {
+    {
+      decltype(auto) input = "abc";
+      std::array expected = {"abc"sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc";
+      std::array expected = {"abc"sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Empty string.
+  {
+    // Note: this is one of the edge cases where a built-in string literal and a `string_view` literal would produce
+    // different results. This is essentially because `size(""sv)` is `0` whereas `size("")` is `1` (accounting for the
+    // terminating null). Thus, the terminating null is ignored for a `string_view` but treated as a separate character
+    // for a built-in string literal (for `string_view` to behave identically, its `(ptr, size)` constructor would have
+    // to be used).
+    {
+      decltype(auto) input = "";
+      std::array expected_literal = {""sv};
+      std::array<std::string_view, 0> expected_sv = {};
+
+      assert(test_function_call(input, short_sep, expected_literal));
+      assert(test_function_call(sv(input), short_sep, expected_sv));
+      assert(test_with_piping(input, short_sep, expected_literal));
+      assert(test_with_piping(sv(input), short_sep, expected_sv));
+    }
+
+    {
+      decltype(auto) input = "";
+      std::array expected_literal = {""sv};
+      std::array<std::string_view, 0> expected_sv = {};
+
+      assert(test_function_call(input, long_sep, expected_literal));
+      assert(test_function_call(sv(input), long_sep, expected_sv));
+      assert(test_with_piping(input, long_sep, expected_literal));
+      assert(test_with_piping(sv(input), long_sep, expected_sv));
+    }
+  }
+
+  // Input consisting of a single separator.
+  {
+    {
+      decltype(auto) input = " ";
+      std::array expected = {""sv, ""sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12";
+      std::array expected = {""sv, ""sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Input consisting of only separators.
+  {
+    {
+      decltype(auto) input = "   ";
+      std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "121212";
+      std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // The separator and the string use the same character only.
+  {
+    {
+      auto overlapping_sep = "aaa"sv;
+
+      decltype(auto) input = "aaaaa";
+      std::array expected = {""sv, "aa"sv};
+
+      assert(test_function_call(input, overlapping_sep, expected));
+      assert(test_function_call(sv(input), overlapping_sep, expected));
+      assert(test_with_piping(input, overlapping_sep, expected));
+      assert(test_with_piping(sv(input), overlapping_sep, expected));
+    }
+  }
+
+  // Many redundant separators.
+  {
+    {
+      decltype(auto) input = "  abc   def  ";
+      std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "1212abc121212def1212";
+      std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Separators after every character.
+  {
+    {
+      decltype(auto) input = " a b c ";
+      std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test_function_call(input, short_sep, expected));
+      assert(test_function_call(sv(input), short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      assert(test_with_piping(sv(input), short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12a12b12c12";
+      std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test_function_call(input, long_sep, expected));
+      assert(test_function_call(sv(input), long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      assert(test_with_piping(sv(input), long_sep, expected));
+    }
+  }
+
+  // Empty separator.
+  {
+    // Note: this is one of the edge cases where a built-in string literal and a `string_view` literal would produce
+    // different results. This is essentially because `size(""sv)` is `0` whereas `size("")` is `1` (accounting for the
+    // terminating null). Thus, the terminating null is ignored for a `string_view` but treated as a separate character
+    // for a built-in string literal (for `string_view` to behave identically, its `(ptr, size)` constructor would have
+    // to be used).
+    {
+      auto empty_sep = ""sv;
+
+      decltype(auto) input = "abc";
+      std::array expected_literal = {"a"sv, "b"sv, "c"sv, ""sv};
+      std::array expected_sv = {"a"sv, "b"sv, "c"sv};
+
+      assert(test_function_call(input, empty_sep, expected_literal));
+      assert(test_function_call(sv(input), empty_sep, expected_sv));
+      assert(test_with_piping(input, empty_sep, expected_literal));
+      assert(test_with_piping(sv(input), empty_sep, expected_sv));
+    }
+  }
+
+  // Terminating null as a separator.
+  {
+    {
+      auto null_sep = "\0"sv;
+
+      decltype(auto) input = "abc\0def";
+      // The empty segment at the end is because the implicit terminating null in the string literal is also treated as
+      // a separator.
+      std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test_function_call(input, null_sep, expected));
+      // Note: the `sv` helper uses the `const char*` constructor of `string_view` which would treat the embedded
+      // terminating null as the end of the string.
+      assert(test_function_call(std::string_view(input, sizeof(input)), null_sep, expected));
+      assert(test_with_piping(input, null_sep, expected));
+      assert(test_with_piping(std::string_view(input, sizeof(input)), null_sep, expected));
+    }
+
+    {
+      auto null_sep = "\0\0"sv;
+
+      decltype(auto) input = "abc\0\0def";
+      // Unlike the case above where the separator is a single terminating null, there is no trailing empty segment in
+      // the result. That's because the implicit terminating null in the string literal is a single character, whereas
+      // the separator in this test case is two null characters.
+      std::array expected = {"abc"sv, "def"sv};
+
+      assert(test_function_call(input, null_sep, expected));
+      // Note: the `sv` helper uses the `const char*` constructor of `string_view` which would treat the embedded
+      // terminating null as the end of the string.
+      assert(test_function_call(std::string_view(input, sizeof(input)), null_sep, expected));
+      assert(test_with_piping(input, null_sep, expected));
+      assert(test_with_piping(std::string_view(input, sizeof(input)), null_sep, expected));
+    }
+  }
+
+  // Overlap between the separator and the string (see https://wg21.link/lwg3505).
+  {
+    {
+      auto overlapping_sep = "ab"sv;
+
+      decltype(auto) input = "aabaaababb";
+      std::array expected = {"a"sv, "aa"sv, ""sv, "b"sv};
+
+      assert(test_function_call(input, overlapping_sep, expected));
+      assert(test_function_call(sv(input), overlapping_sep, expected));
+      assert(test_with_piping(input, overlapping_sep, expected));
+      assert(test_with_piping(sv(input), overlapping_sep, expected));
+    }
+  }
+
+  // Different character types.
+  {
+    // `char`.
+    test_function_call("abc def", ' ', std::array{"abc", "def"});
+    // `wchar_t`.
+    test_function_call(L"abc def", L' ', std::array{L"abc", L"def"});
+    // `char8_t`.
+    test_function_call(u8"abc def", u8' ', std::array{u8"abc", u8"def"});
+    // `char16_t`.
+    test_function_call(u"abc def", u' ', std::array{u"abc", u"def"});
+    // `char32_t`.
+    test_function_call(U"abc def", U' ', std::array{U"abc", U"def"});
+  }
+
+  // Non-character input.
+  {
+    {
+      int sep = 0;
+      int input[] = {1, 2, 3, 0, 4, 5, 6};
+      std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test_function_call(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+    }
+
+    {
+      std::array sep = {0, 0, 0};
+      int input[] = {1, 2, 3, 0, 0, 0, 4, 5, 6};
+      std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test_function_call(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  test_l_r_values();
+  static_assert(test_l_r_values());
+
+  test_string_literal_separator();
+  static_assert(test_string_literal_separator());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr const iterator_t<Base>& inner-iterator::base() const& noexcept;
+//
+// constexpr iterator_t<Base> inner-iterator::base() &&
+//   requires forward_range<View>;
+
+#include <ranges>
+
+#include <concepts>
+#include <utility>
+#include "../types.h"
+
+template <class InnerIter, class ReturnT>
+concept CanCallBase = requires(InnerIter i) {
+  { std::forward<InnerIter>(i).base() } -> std::same_as<ReturnT>;
+};
+
+static_assert( CanCallBase<InnerIterForward&, const BaseIterForward&>);
+static_assert( CanCallBase<InnerIterForward const &, const BaseIterForward&>);
+static_assert( CanCallBase<InnerIterForward &&, BaseIterForward>);
+static_assert( CanCallBase<InnerIterForward const &&, const BaseIterForward&>);
+
+static_assert( CanCallBase<InnerIterInput&, const BaseIterInput&>);
+static_assert( CanCallBase<InnerIterInput const &, const BaseIterInput&>);
+static_assert( CanCallBase<InnerIterInput &&, const BaseIterInput&>);
+static_assert( CanCallBase<InnerIterInput const &&, const BaseIterInput&>);
+
+static_assert( noexcept(std::declval<InnerIterForward&>().base()));
+static_assert( noexcept(std::declval<InnerIterForward const &>().base()));
+static_assert( noexcept(std::declval<InnerIterForward const &&>().base()));
+static_assert( noexcept(std::declval<InnerIterInput&>().base()));
+static_assert( noexcept(std::declval<InnerIterInput const &>().base()));
+static_assert( noexcept(std::declval<InnerIterInput const &&>().base()));
+
+constexpr bool test() {
+  // `base` works with a forward view (two different overloads based on ref-qualification of the `inner-iterator`).
+  {
+    using BaseIter = std::ranges::iterator_t<CopyableView>;
+    CopyableView b("abc def");
+    std::ranges::lazy_split_view<CopyableView, ForwardView> v(b, " ");
+
+    auto i = (*v.begin()).begin();
+    static_assert(std::same_as<decltype(i.base()), const BaseIter&>);
+    assert(i.base() == b.begin());
+    static_assert(std::same_as<decltype(std::move(i).base()), BaseIter>);
+    assert(std::move(i).base() == b.begin());
+  }
+
+  // `base` works with an input view (no overloads).
+  {
+    using BaseIter = std::ranges::iterator_t<InputView>;
+    InputView b("abc def");
+    std::ranges::lazy_split_view<InputView, ForwardTinyView> v(b, ' ');
+
+    auto i = (*v.begin()).begin();
+    static_assert(std::same_as<decltype(i.base()), const BaseIter&>);
+    static_assert(std::same_as<decltype(std::move(i).base()), const BaseIter&>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr inner-iterator::inner-iterator() = default;
+
+#include <ranges>
+
+#include "../types.h"
+
+static_assert(std::is_default_constructible_v<InnerIterForward>);
+static_assert(std::is_default_constructible_v<InnerIterInput>);
+
+constexpr bool test() {
+  {
+    [[maybe_unused]] InnerIterForward i;
+  }
+
+  {
+    [[maybe_unused]] InnerIterInput i;
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/ctor.outer_iterator.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit inner-iterator::inner-iterator(outer-iterator<Const> i);
+
+#include <ranges>
+
+#include "../types.h"
+
+static_assert( std::is_constructible_v<InnerIterForward, OuterIterForward>);
+static_assert( std::is_constructible_v<InnerIterInput, OuterIterInput>);
+// Is only constructible if both the outer and the inner iterators have the same constness.
+static_assert( std::is_constructible_v<InnerIterConst, OuterIterConst>);
+// Note: this works because of an implicit conversion (`OuterIterNonConst` is converted to `OuterIterConst`).
+static_assert( std::is_constructible_v<InnerIterConst, OuterIterNonConst>);
+static_assert( std::is_constructible_v<InnerIterNonConst, OuterIterNonConst>);
+static_assert(!std::is_constructible_v<InnerIterNonConst, OuterIterConst>);
+
+template <class Inner>
+void CheckCopyInitialization(Inner);
+
+template <class Inner, class Outer>
+concept CannotCopyInitialize =
+  requires(Inner i) { CheckCopyInitialization(i); } &&
+  !requires(Outer o) { CheckCopyInitialization<Inner>(o); };
+
+template <class Inner, class Outer>
+constexpr void test_impl() {
+  [[maybe_unused]] Inner i(Outer{});
+
+  // Verify that the constructor is `explicit`.
+  static_assert(CannotCopyInitialize<Inner, Outer>);
+}
+
+constexpr bool test() {
+  test_impl<InnerIterForward, OuterIterForward>();
+  test_impl<InnerIterInput, OuterIterInput>();
+  test_impl<InnerIterConst, OuterIterConst>();
+  test_impl<InnerIterConst, OuterIterNonConst>();
+  test_impl<InnerIterNonConst, OuterIterNonConst>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/deref.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr decltype(auto) inner-iterator::operator*() const;
+
+#include <ranges>
+
+#include "../types.h"
+
+constexpr bool test() {
+  // Can call `inner-iterator::operator*`; `View` is a forward range.
+  {
+    SplitViewDiff v("abc def", " ");
+    auto val = *v.begin();
+
+    // Non-const iterator.
+    {
+      auto i = val.begin();
+      static_assert(std::same_as<decltype(*i), char&>);
+      assert(*i == 'a');
+      assert(*(++i) == 'b');
+      assert(*(++i) == 'c');
+    }
+
+    // Const iterator.
+    {
+      const auto ci = val.begin();
+      static_assert(std::same_as<decltype(*ci), char&>);
+      assert(*ci == 'a');
+    }
+  }
+
+  // Can call `inner-iterator::operator*`; `View` is an input range.
+  {
+    SplitViewInput v("abc def", ' ');
+    auto val = *v.begin();
+
+    // Non-const iterator.
+    {
+      auto i = val.begin();
+      static_assert(std::same_as<decltype(*i), char&>);
+      assert(*i == 'a');
+      assert(*(++i) == 'b');
+      assert(*(++i) == 'c');
+    }
+
+    // Const iterator.
+    {
+      const auto ci = val.begin();
+      static_assert(std::same_as<decltype(*ci), char&>);
+      // Note: this can be surprising. When the underlying range is an input range, `current` is stored in the
+      // `lazy_split_view` itself and shared between `inner-iterator`s. Consequently, incrementing one iterator
+      // effectively increments all of them.
+      assert(*ci == 'c');
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/equal.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y);
+//   requires forward_range<Base>;
+//
+// friend constexpr bool operator==(const inner-iterator& x, default_sentinel_t);
+
+#include <ranges>
+
+#include <concepts>
+#include <string_view>
+#include "../types.h"
+
+template <class Iter>
+concept CanCallEquals = requires(const Iter& i) {
+  i == i;
+  i != i;
+};
+
+constexpr bool test() {
+  // When `View` is a forward range, `inner-iterator` supports both overloads of `operator==`.
+  {
+    SplitViewForward v("abc def", " ");
+    auto val = *v.begin();
+    auto b = val.begin();
+    std::same_as<std::default_sentinel_t> auto e = val.end();
+
+    // inner-iterator == inner-iterator
+    {
+      assert(b == b);
+      assert(!(b != b));
+    }
+
+    // inner-iterator == default_sentinel
+    {
+      assert(!(b == e));
+      assert(b != e);
+
+      assert(!(b == std::default_sentinel));
+      assert(b != std::default_sentinel);
+    }
+  }
+
+  // When `View` is an input range, `inner-iterator only supports comparing an `inner-iterator` to the default sentinel.
+  {
+    SplitViewInput v("abc def", ' ');
+    auto val = *v.begin();
+    auto b = val.begin();
+    std::same_as<std::default_sentinel_t> auto e = val.end();
+
+    static_assert(!CanCallEquals<decltype(b)>);
+
+    assert(!(b == std::default_sentinel));
+    assert(b != std::default_sentinel);
+    assert(!(b == e));
+    assert(b != e);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr inner-iterator& inner-iterator::operator++();
+//
+// constexpr decltype(auto) inner-iterator::operator++(int);
+
+#include <ranges>
+
+#include "../types.h"
+
+struct EmptyView : std::ranges::view_base {
+  constexpr int* begin() const { return nullptr; }
+  constexpr int* end() const { return nullptr; }
+  constexpr static size_t size() { return 0; }
+};
+static_assert(std::ranges::forward_range<EmptyView>);
+static_assert(std::ranges::view<EmptyView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__tiny_range<EmptyView>);
+
+constexpr bool test() {
+  // Can call `inner-iterator::operator++`; `View` is a forward range.
+  {
+    SplitViewForward v("abc def", " ");
+    auto val = *v.begin();
+
+    // ++i
+    {
+      auto i = val.begin();
+      assert(*i == 'a');
+
+      decltype(auto) i2 = ++i;
+      static_assert(std::is_lvalue_reference_v<decltype(i2)>);
+      assert(*i2 == 'b');
+    }
+
+    // i++
+    {
+      auto i = val.begin();
+      assert(*i == 'a');
+
+      decltype(auto) i2 = i++;
+      static_assert(!std::is_reference_v<decltype(i2)>);
+      assert(*i2 == 'a');
+      assert(*i == 'b');
+    }
+  }
+
+  // Can call `inner-iterator::operator++`; `View` is an input range.
+  {
+    // ++i
+    {
+      SplitViewInput v("abc def", ' ');
+      auto val = *v.begin();
+
+      auto i = val.begin();
+      assert(*i == 'a');
+
+      decltype(auto) i2 = ++i;
+      static_assert(std::is_lvalue_reference_v<decltype(i2)>);
+      assert(*i2 == 'b');
+    }
+
+    // i++
+    {
+      SplitViewInput v("abc def", ' ');
+      auto val = *v.begin();
+
+      auto i = val.begin();
+      assert(*i == 'a');
+
+      static_assert(std::is_void_v<decltype(i++)>);
+      i++;
+      assert(*i == 'b');
+    }
+  }
+
+  // Can call `inner-iterator::operator++`; `View` is an input range and `Pattern` is an "empty" range.
+  {
+    // ++i
+    {
+      std::ranges::lazy_split_view<InputView, EmptyView> v("a", EmptyView());
+      auto val = *v.begin();
+
+      auto i = val.begin();
+      assert(*i.base() == 'a');
+      assert(i != std::default_sentinel);
+
+      // The iterator doesn't move to the next character but is considered to point to the end.
+      ++i;
+      assert(*i.base() == 'a');
+      assert(i == std::default_sentinel);
+    }
+
+    // i++
+    {
+      std::ranges::lazy_split_view<InputView, EmptyView> v("a", EmptyView());
+      auto val = *v.begin();
+
+      auto i = val.begin();
+      assert(*i.base() == 'a');
+      assert(i != std::default_sentinel);
+
+      // The iterator doesn't move to the next character but is considered to point to the end.
+      i++;
+      assert(*i.base() == 'a');
+      assert(i == std::default_sentinel);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_move.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr decltype(auto) iter_move(const inner-iterator& i)
+//   noexcept(noexcept(ranges::iter_move(i.i_.<current>)));
+
+#include <iterator>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+namespace adl {
+
+template <bool IsNoexcept = false>
+struct Iterator {
+  using value_type = int;
+  using difference_type = ptrdiff_t;
+
+  value_type* ptr_ = nullptr;
+  int* iter_move_invocations_ = nullptr;
+
+  constexpr Iterator() = default;
+  constexpr explicit Iterator(int* p, int& iter_moves) : ptr_(p), iter_move_invocations_(&iter_moves) {}
+
+  constexpr value_type& operator*() const { return *ptr_; }
+
+  Iterator& operator++() { ++ptr_; return *this; }
+  Iterator operator++(int) {
+    Iterator prev = *this;
+    ++ptr_;
+    return prev;
+  }
+
+  constexpr Iterator& operator--() { --ptr_; return *this; }
+  constexpr Iterator operator--(int) {
+    Iterator prev = *this;
+    --ptr_;
+    return prev;
+  }
+
+  constexpr friend value_type&& iter_move(Iterator iter) noexcept(IsNoexcept) {
+    if (iter.iter_move_invocations_) {
+      ++(*iter.iter_move_invocations_);
+    }
+    return std::move(*iter);
+  }
+
+  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+};
+
+template <bool IsNoexcept = false>
+struct View : std::ranges::view_base {
+  static constexpr int N = 3;
+  int a[N] = {0, 1, 2};
+  int* iter_moves = nullptr;
+
+  constexpr View() = default;
+  constexpr View(int& iter_move_invocations) : iter_moves(&iter_move_invocations) {
+  }
+
+  constexpr adl::Iterator<IsNoexcept> begin() { return adl::Iterator<IsNoexcept>(a, *iter_moves); }
+  constexpr adl::Iterator<IsNoexcept> end() { return adl::Iterator<IsNoexcept>(a + N, *iter_moves); }
+};
+
+} // namespace adl
+
+constexpr bool test() {
+  // Can use `iter_move` with `inner-iterator`; `View` is a forward range.
+  {
+    SplitViewForward v("abc def", " ");
+    auto val = *v.begin();
+
+    // Non-const iterator.
+    {
+      auto i = val.begin();
+      static_assert(std::same_as<decltype(iter_move(i)), const char &&>);
+      assert(iter_move(i) == 'a');
+    }
+
+    // Const iterator.
+    {
+      const auto i = val.begin();
+      static_assert(std::same_as<decltype(iter_move(i)), const char &&>);
+      assert(iter_move(i) == 'a');
+    }
+  }
+
+  // Can use `iter_move` with `inner-iterator`, `View` is an input range.
+  {
+    SplitViewInput v("abc def", ' ');
+    auto val = *v.begin();
+
+    // Non-const iterator.
+    {
+      auto i = val.begin();
+      static_assert(std::same_as<decltype(iter_move(i)), char &&>);
+      assert(iter_move(i) == 'a');
+    }
+
+    // Const iterator.
+    {
+      const auto i = val.begin();
+      static_assert(std::same_as<decltype(iter_move(i)), char &&>);
+      assert(iter_move(i) == 'a');
+    }
+  }
+
+  // Ensure the `iter_move` customization point is being used.
+  {
+    int iter_move_invocations = 0;
+    adl::View<> input(iter_move_invocations);
+    std::ranges::lazy_split_view<adl::View<>, adl::View<>> v(input, adl::View<>());
+
+    auto val = *v.begin();
+    auto i = val.begin();
+    int x = iter_move(i);
+    assert(x == 0);
+    assert(iter_move_invocations == 1);
+  }
+
+  // Check the `noexcept` specification.
+  {
+    {
+      using ThrowingSplitView = std::ranges::lazy_split_view<adl::View<false>, adl::View<false>>;
+      using ThrowingValueType = decltype(*std::declval<ThrowingSplitView>().begin());
+      using ThrowingIter = std::ranges::iterator_t<ThrowingValueType>;
+      ASSERT_NOT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::Iterator<false>>()));
+      ASSERT_NOT_NOEXCEPT(iter_move(std::declval<ThrowingIter>()));
+    }
+
+    {
+      using NoexceptSplitView = std::ranges::lazy_split_view<adl::View<true>, adl::View<true>>;
+      using NoexceptValueType = decltype(*std::declval<NoexceptSplitView>().begin());
+      using NoexceptIter = std::ranges::iterator_t<NoexceptValueType>;
+      ASSERT_NOEXCEPT(std::ranges::iter_move(std::declval<adl::Iterator<true>>()));
+      ASSERT_NOEXCEPT(iter_move(std::declval<NoexceptIter>()));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/iter_swap.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr void iter_swap(const inner-iterator& x, const inner-iterator& y)
+//   noexcept(noexcept(ranges::iter_swap(x.i_.<current>, y.i_.<current>)))
+//   requires indirectly_swappable<iterator_t<Base>>;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+#include <iostream>
+
+namespace adl {
+
+template <bool IsNoexcept = false>
+struct Iterator {
+  using value_type = int;
+  using difference_type = ptrdiff_t;
+
+  value_type* ptr_ = nullptr;
+  int* iter_swap_invocations_ = nullptr;
+
+  constexpr Iterator() = default;
+  constexpr explicit Iterator(int& iter_swaps) : iter_swap_invocations_(&iter_swaps) {}
+
+  value_type& operator*() const { return *ptr_; }
+
+  Iterator& operator++() { ++ptr_; return *this; }
+  Iterator operator++(int) {
+    Iterator prev = *this;
+    ++ptr_;
+    return prev;
+  }
+
+  Iterator& operator--() { --ptr_; return *this; }
+  Iterator operator--(int) {
+    Iterator prev = *this;
+    --ptr_;
+    return prev;
+  }
+
+  constexpr friend void iter_swap(Iterator a, Iterator) noexcept(IsNoexcept) {
+    if (a.iter_swap_invocations_) {
+      ++(*a.iter_swap_invocations_);
+    }
+  }
+
+  friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+};
+
+template <bool IsNoexcept = false>
+struct View : std::ranges::view_base {
+  int* iter_swaps = nullptr;
+
+  constexpr View() = default;
+  constexpr View(int& iter_swap_invocations) : iter_swaps(&iter_swap_invocations) {
+  }
+
+  constexpr adl::Iterator<IsNoexcept> begin() { return adl::Iterator<IsNoexcept>(*iter_swaps); }
+  constexpr adl::Iterator<IsNoexcept> end() { return adl::Iterator<IsNoexcept>(*iter_swaps); }
+};
+
+} // namespace adl
+
+constexpr bool test() {
+  // Can use `iter_swap` with `inner-iterator`; `View` is a forward range.
+  {
+    // Non-const iterator.
+    {
+      SplitViewDiff v("abc def", " ");
+      auto val = *v.begin();
+
+      auto i1 = val.begin();
+      auto i2 = i1++;
+      static_assert(std::is_void_v<decltype(iter_swap(i1, i2))>);
+      assert(*i1 == 'b');
+      assert(*i2 == 'a');
+
+      iter_swap(i1, i2);
+      assert(*i1 == 'a');
+      assert(*i2 == 'b');
+      // Note that `iter_swap` swaps characters in the actual underlying range.
+      assert(*v.base().begin() == 'b');
+    }
+
+    // Const iterator.
+    {
+      SplitViewDiff v("abc def", " ");
+      auto val = *v.begin();
+
+      auto i1 = val.begin();
+      const auto i2 = i1++;
+      static_assert(std::is_void_v<decltype(iter_swap(i1, i2))>);
+      static_assert(std::is_void_v<decltype(iter_swap(i2, i2))>);
+      assert(*i1 == 'b');
+      assert(*i2 == 'a');
+
+      iter_swap(i1, i2);
+      assert(*i1 == 'a');
+      assert(*i2 == 'b');
+      assert(*v.base().begin() == 'b');
+    }
+  }
+
+  // Can use `iter_swap` with `inner-iterator`; `View` is an input range.
+  {
+
+    // Non-const iterator.
+    {
+      // Iterators belong to the same view.
+      {
+        SplitViewInput v("abc def", ' ');
+        auto val = *v.begin();
+
+        auto i1 = val.begin();
+        auto i2 = i1;
+        ++i1;
+        static_assert(std::is_void_v<decltype(iter_swap(i1, i2))>);
+        assert(*i1 == 'b');
+        // For an input view, all inner iterators are essentially thin proxies to the same underlying iterator.
+        assert(*i2 == 'b');
+
+        iter_swap(i1, i2);
+        assert(*i1 == 'b');
+        assert(*i2 == 'b');
+      }
+
+      // Iterators belong to different views.
+      {
+        SplitViewInput v1("abc def", ' ');
+        auto val1 = *v1.begin();
+        SplitViewInput v2 = v1;
+        auto val2 = *v2.begin();
+
+        auto i1 = val1.begin();
+        auto i2 = val2.begin();
+        ++i1;
+        assert(*i1 == 'b');
+        assert(*i2 == 'a');
+
+        iter_swap(i1, i2);
+        assert(*i1 == 'a');
+        assert(*i2 == 'b');
+      }
+    }
+
+    // Const iterator.
+    {
+      SplitViewInput v("abc def", ' ');
+      auto val = *v.begin();
+
+      const auto i1 = val.begin();
+      const auto i2 = i1;
+      static_assert(std::is_void_v<decltype(iter_swap(i1, i2))>);
+      assert(*i1 == 'a');
+      assert(*i2 == 'a');
+
+      iter_swap(i1, i2);
+      assert(*i1 == 'a');
+      assert(*i2 == 'a');
+    }
+  }
+
+  // Ensure the `iter_swap` customization point is being used.
+  {
+    int iter_swap_invocations = 0;
+    adl::View<> input(iter_swap_invocations);
+    std::ranges::lazy_split_view<adl::View<>, adl::View<>> v(input, adl::View<>());
+
+    auto val = *v.begin();
+    auto i = val.begin();
+    iter_swap(i, i);
+    assert(iter_swap_invocations == 1);
+  }
+
+  // Check the `noexcept` specification.
+  {
+    {
+      using ThrowingSplitView = std::ranges::lazy_split_view<adl::View<false>, adl::View<false>>;
+      using ThrowingValueType = decltype(*std::declval<ThrowingSplitView>().begin());
+      using ThrowingIter = std::ranges::iterator_t<ThrowingValueType>;
+      ASSERT_NOT_NOEXCEPT(
+          std::ranges::iter_swap(std::declval<adl::Iterator<false>>(), std::declval<adl::Iterator<false>>()));
+      ASSERT_NOT_NOEXCEPT(iter_swap(std::declval<ThrowingIter>(), std::declval<ThrowingIter>()));
+    }
+
+    {
+      using NoexceptSplitView = std::ranges::lazy_split_view<adl::View<true>, adl::View<true>>;
+      using NoexceptValueType = decltype(*std::declval<NoexceptSplitView>().begin());
+      using NoexceptIter = std::ranges::iterator_t<NoexceptValueType>;
+      ASSERT_NOEXCEPT(
+          std::ranges::iter_swap(std::declval<adl::Iterator<true>>(), std::declval<adl::Iterator<true>>()));
+      ASSERT_NOEXCEPT(iter_swap(std::declval<NoexceptIter>(), std::declval<NoexceptIter>()));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.inner/types.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+//  using iterator_category = If<
+//    derived_from<typename iterator_traits<iterator_t<Base>>::iterator_category, forward_iterator_tag>,
+//    forward_iterator_tag,
+//    typename iterator_traits<iterator_t<Base>>::iterator_category
+//  >;
+//  using iterator_concept = typename outer-iterator<Const>::iterator_concept;
+//  using value_type = range_value_t<Base>;
+//  using difference_type = range_difference_t<Base>;
+
+#include <ranges>
+
+#include <concepts>
+#include <iterator>
+#include "../types.h"
+
+template <class Range, class Pattern>
+using OuterIter = std::ranges::iterator_t<std::ranges::lazy_split_view<Range, Pattern>>;
+template <class Range, class Pattern>
+using InnerIter = std::ranges::iterator_t<decltype(*OuterIter<Range, Pattern>())>;
+
+// iterator_concept
+
+static_assert(std::same_as<typename InnerIter<ForwardView, ForwardView>::iterator_concept,
+    typename OuterIter<ForwardView, ForwardView>::iterator_concept>);
+static_assert(std::same_as<typename InnerIter<InputView, ForwardTinyView>::iterator_concept,
+    typename OuterIter<InputView, ForwardTinyView>::iterator_concept>);
+
+// iterator_category
+
+static_assert(std::same_as<typename InnerIter<ForwardView, ForwardView>::iterator_category, std::forward_iterator_tag>);
+
+template <class Range, class Pattern>
+concept NoIteratorCategory = !requires { typename InnerIter<Range, Pattern>::iterator_category; };
+static_assert(NoIteratorCategory<InputView, ForwardTinyView>);
+
+// value_type
+
+static_assert(std::same_as<typename InnerIter<ForwardView, ForwardView>::value_type,
+    std::ranges::range_value_t<ForwardView>>);
+
+// difference_type
+
+static_assert(std::same_as<typename InnerIter<ForwardView, ForwardView>::difference_type,
+    std::ranges::range_difference_t<ForwardView>>);

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::begin()
+
+#include <ranges>
+
+#include <cassert>
+#include "../types.h"
+
+constexpr bool operator==(const cpp20_input_iterator<char*>& lhs, const cpp20_input_iterator<char*>& rhs) {
+  return base(lhs) == base(rhs);
+}
+
+constexpr bool test() {
+  // `View` is a forward range.
+  {
+    CopyableView input("a");
+
+    // Non-const.
+    {
+      SplitViewCopyable v(input, "b");
+      auto val = *v.begin();
+      assert(val.begin().base() == input.begin());
+    }
+
+    // Const.
+    {
+      SplitViewCopyable v(input, "b");
+      const auto val = *v.begin();
+      assert(val.begin().base() == input.begin());
+    }
+  }
+
+  // `View` is an input range.
+  {
+    InputView input("a");
+
+    // Non-const.
+    {
+      SplitViewInput v(input, 'b');
+      auto val = *v.begin();
+      // Copies of `InputView` are independent and the iterators won't compare the same.
+      assert(*val.begin().base() == *input.begin());
+    }
+
+    // Const.
+    {
+      SplitViewInput v(input, 'b');
+      const auto val = *v.begin();
+      // Copies of `InputView` are independent and the iterators won't compare the same.
+      assert(*val.begin().base() == *input.begin());
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::value_type()
+
+#include <ranges>
+
+#include "../types.h"
+
+static_assert(std::is_default_constructible_v<ValueTypeForward>);
+static_assert(std::is_default_constructible_v<ValueTypeInput>);
+
+constexpr bool test() {
+  {
+    [[maybe_unused]] ValueTypeForward val;
+  }
+
+  {
+    [[maybe_unused]] ValueTypeForward val = {};
+  }
+
+  {
+    [[maybe_unused]] ValueTypeInput val;
+  }
+
+  {
+    [[maybe_unused]] ValueTypeInput val = {};
+  }
+
+  // Note: attempting a check like `val.begin() == val.end()` leads to null pointer dereference.
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.iter.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// explicit outer-iterator::value_type::value_type(outer-iterator i)
+
+#include <ranges>
+
+#include <cassert>
+#include "../types.h"
+
+static_assert(std::is_constructible_v<ValueTypeForward, OuterIterForward>);
+static_assert(std::is_constructible_v<ValueTypeInput, OuterIterInput>);
+
+template <class Inner>
+void CheckCopyInitialization(Inner);
+
+template <class Value, class ConvertibleToValue>
+concept CannotCopyInitialize =
+  requires(Value v) { CheckCopyInitialization(v); } &&
+  !requires(ConvertibleToValue c) { CheckCopyInitialization<Value>(c); };
+
+// Verify that the constructor is `explicit`.
+static_assert(CannotCopyInitialize<ValueTypeForward, OuterIterForward>);
+static_assert(CannotCopyInitialize<ValueTypeInput, OuterIterInput>);
+
+constexpr bool test() {
+  // `View` is a forward range.
+  {
+    CopyableView input = "a";
+    SplitViewCopyable v(input, "b");
+    ValueTypeCopyable val(v.begin());
+    assert(val.begin().base() == input.begin());
+  }
+
+  // `View` is an input range.
+  {
+    InputView input = "a";
+    SplitViewInput v(input, 'b');
+    ValueTypeInput val(v.begin());
+    assert(*val.begin().base() == *input.begin());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::end()
+
+#include <ranges>
+
+#include <cassert>
+#include "../types.h"
+
+constexpr bool test() {
+  // `View` is a forward range.
+  {
+    CopyableView input("a");
+
+    // Non-const.
+    {
+      SplitViewCopyable v(input, "b");
+      auto val = *v.begin();
+
+      static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+      static_assert(noexcept(val.end()));
+      [[maybe_unused]] auto e = val.end();
+    }
+
+    // Const.
+    {
+      SplitViewCopyable v(input, "b");
+      const auto val = *v.begin();
+
+      static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+      static_assert(noexcept(val.end()));
+      [[maybe_unused]] auto e = val.end();
+    }
+  }
+
+  // `View` is an input range.
+  {
+    InputView input("a");
+
+    // Non-const.
+    {
+      SplitViewInput v(input, 'b');
+      auto val = *v.begin();
+
+      static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+      static_assert(noexcept(val.end()));
+      [[maybe_unused]] auto e = val.end();
+    }
+
+    // Const.
+    {
+      SplitViewInput v(input, 'b');
+      const auto val = *v.begin();
+
+      static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+      static_assert(noexcept(val.end()));
+      [[maybe_unused]] auto e = val.end();
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/view_interface.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view::outer-iterator::value_type;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include "../types.h"
+
+using V = ValueTypeForward;
+static_assert(std::ranges::forward_range<V>);
+static_assert(std::ranges::view<V>);
+
+// empty()
+template <class View>
+concept CanCallEmpty = requires (View& v) { v.empty(); };
+static_assert(CanCallEmpty<V>);
+
+// operator bool()
+template <class View>
+concept CanCallOperatorBool = requires (View& v) { static_cast<bool>(v); };
+static_assert(CanCallOperatorBool<V>);
+
+// front()
+template <class View>
+concept CanCallFront = requires (View& v) { v.front(); };
+static_assert(CanCallFront<V>);
+
+// size() is unavailable.
+static_assert(!std::sized_sentinel_for<std::ranges::sentinel_t<V>, std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallSize = requires (View& v) { v.size(); };
+static_assert(!CanCallSize<V>);
+
+// back() is unavailable.
+static_assert(!std::ranges::bidirectional_range<V>);
+template <class View>
+concept CanCallBack = requires (View& v) { v.back(); };
+static_assert(!CanCallBack<V>);
+
+// data() is unavailable.
+static_assert(!std::contiguous_iterator<std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallData = requires (View& v) { v.data(); };
+static_assert(!CanCallData<V>);
+
+// operator[] is unavailable.
+static_assert(!std::ranges::random_access_range<V>);
+template <class View>
+concept CanCallOperatorSubscript = requires (View& v) { v[0]; };
+static_assert(!CanCallOperatorSubscript<V>);
+
+constexpr bool test() {
+  // empty()
+  {
+    {
+      SplitViewForward v("abc def", " ");
+      auto val = *v.begin();
+      assert(!val.empty());
+    }
+
+    {
+      SplitViewForward v;
+      auto val = *v.begin();
+      assert(val.empty());
+    }
+  }
+
+  // operator bool()
+  {
+    {
+      SplitViewForward v("abc def", " ");
+      auto val = *v.begin();
+      assert(val);
+    }
+
+    {
+      SplitViewForward v;
+      auto val = *v.begin();
+      assert(!val);
+    }
+  }
+
+  // front()
+  {
+    SplitViewForward v("abc def", " ");
+    auto val = *v.begin();
+    assert(val.front() == 'a');
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.copy.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr outer-iterator(outer-iterator<!Const> i)
+//   requires Const && convertible_to<iterator_t<View>, iterator_t<Base>>
+
+#include <ranges>
+
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+// outer-iterator<Const = true>
+
+template <class Iter>
+concept IsConstOuterIter = requires (Iter i) {
+  { *(*i).begin() } -> std::same_as<const char&>;
+};
+static_assert( IsConstOuterIter<OuterIterConst>);
+
+static_assert( std::convertible_to<
+    std::ranges::iterator_t<SplitViewDiff>, std::ranges::iterator_t<const SplitViewDiff>>);
+
+// outer-iterator<Const = false>
+
+template <class Iter>
+concept IsNonConstOuterIter = requires (Iter i) {
+  { *(*i).begin() } -> std::same_as<char&>;
+};
+static_assert( IsNonConstOuterIter<OuterIterNonConst>);
+
+static_assert( std::is_constructible_v<OuterIterConst, OuterIterNonConst>);
+static_assert(!std::is_constructible_v<OuterIterNonConst, OuterIterConst>);
+
+constexpr bool test() {
+  [[maybe_unused]] OuterIterConst i(OuterIterNonConst{});
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator()
+
+#include <ranges>
+
+#include "../types.h"
+
+static_assert(std::is_default_constructible_v<OuterIterForward>);
+static_assert(std::is_default_constructible_v<OuterIterInput>);
+
+constexpr bool test() {
+  // `View` is a forward range.
+  {
+    [[maybe_unused]] OuterIterForward i;
+  }
+
+  {
+    [[maybe_unused]] OuterIterForward i = {};
+  }
+
+  // `View` is an input range.
+  {
+    [[maybe_unused]] OuterIterInput i;
+  }
+
+  {
+    [[maybe_unused]] OuterIterInput i = {};
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.parent.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator(Parent& parent)
+//   requires (!forward_range<Base>)
+
+#include <ranges>
+
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+static_assert( std::ranges::forward_range<SplitViewForward>);
+static_assert(!std::is_constructible_v<OuterIterForward, SplitViewForward&>);
+
+static_assert( std::ranges::input_range<SplitViewInput>);
+static_assert( std::is_constructible_v<OuterIterInput, SplitViewInput&>);
+
+constexpr bool test() {
+  InputView input;
+  SplitViewInput v(input, ForwardTinyView());
+  [[maybe_unused]] OuterIterInput i(v);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.parent_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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr outer-iterator(Parent& parent, iterator_t<Base> current);
+//   requires forward_range<Base>
+
+#include <ranges>
+
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+static_assert( std::ranges::forward_range<SplitViewForward>);
+static_assert( std::is_constructible_v<OuterIterForward, SplitViewForward&, std::ranges::iterator_t<ForwardView>>);
+
+static_assert(!std::ranges::forward_range<SplitViewInput>);
+static_assert(!std::is_constructible_v<OuterIterInput, SplitViewInput&, std::ranges::iterator_t<InputView>>);
+
+constexpr bool test() {
+  ForwardView input("abc");
+  SplitViewForward v(std::move(input), " ");
+  [[maybe_unused]] OuterIterForward i(v, input.begin());
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/deref.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr outer-iterator::value-type outer-iterator::operator*() const;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+#include "../small_string.h"
+#include "../types.h"
+
+constexpr bool test() {
+  // `View` is a forward range.
+  {
+    SplitViewDiff v("abc def ghi", " ");
+
+    // Non-const iterator.
+    {
+      auto i = v.begin();
+      static_assert(!std::is_reference_v<decltype(*i)>);
+      assert(SmallString(*i) == "abc"_str);
+      assert(SmallString(*(++i)) == "def"_str);
+      assert(SmallString(*(++i)) == "ghi"_str);
+    }
+
+    // Const iterator.
+    {
+      const auto ci = v.begin();
+      static_assert(!std::is_reference_v<decltype(*ci)>);
+      assert(SmallString(*ci) == "abc"_str);
+    }
+  }
+
+  // `View` is an input range.
+  {
+    SplitViewInput v("abc def ghi", ' ');
+
+    // Non-const iterator.
+    {
+      auto i = v.begin();
+      static_assert(!std::is_reference_v<decltype(*i)>);
+      assert(SmallString(*i) == "abc"_str);
+      assert(SmallString(*(++i)) == "def"_str);
+      assert(SmallString(*(++i)) == "ghi"_str);
+    }
+
+    // Const iterator.
+    {
+      const auto ci = v.begin();
+      static_assert(!std::is_reference_v<decltype(*ci)>);
+      assert(SmallString(*ci) == "abc"_str);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/equal.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
+//   requires forward_range<Base>;
+//
+// friend constexpr bool operator==(const outer-iterator& x, default_sentinel_t);
+
+#include <ranges>
+
+#include <concepts>
+#include <string_view>
+#include "../types.h"
+
+template <class Iter>
+concept CanCallEquals = requires(const Iter& i) {
+  i == i;
+  i != i;
+};
+
+constexpr bool test() {
+  // Forward range supports both overloads of `operator==`.
+  {
+    // outer-iterator == outer-iterator
+    {
+      SplitViewForward v("abc def", " ");
+      auto b = v.begin(), e = v.end();
+
+      assert(b == b);
+      assert(!(b != b));
+
+      assert(e == e);
+      assert(!(e != e));
+
+      assert(!(b == e));
+      assert(b != e);
+    }
+
+    // outer-iterator == default_sentinel
+    {
+      SplitViewForward v("abc def", " ");
+      auto b = v.begin(), e = v.end();
+
+      assert(!(b == std::default_sentinel));
+      assert(b != std::default_sentinel);
+      assert(e == std::default_sentinel);
+      assert(!(e != std::default_sentinel));
+    }
+
+      // Default-constructed `outer-iterator`s compare equal.
+      {
+        OuterIterForward i1, i2;
+        assert(i1 == i2);
+        assert(!(i1 != i2));
+      }
+  }
+
+  // Input range only supports comparing an `outer-iterator` to the default sentinel.
+  {
+    using namespace std::string_view_literals;
+    SplitViewInput v("abc def"sv, ' ');
+    auto b = v.begin();
+    std::same_as<std::default_sentinel_t> auto e = v.end();
+
+    static_assert(!CanCallEquals<decltype(b)>);
+
+    assert(!(b == std::default_sentinel));
+    assert(b != std::default_sentinel);
+    assert(!(b == e));
+    assert(b != e);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr outer-iterator& outer-iterator::operator++();
+// constexpr decltype(auto) outer-iterator::operator++(int);
+
+#include <ranges>
+
+#include <algorithm>
+#include <string_view>
+#include "../small_string.h"
+#include "../types.h"
+
+constexpr bool test() {
+  // Can call `outer-iterator::operator++`; `View` is a forward range.
+  {
+    SplitViewForward v("abc def ghi", " ");
+
+    // ++i
+    {
+      auto i = v.begin();
+      assert(*i == "abc"_str);
+
+      decltype(auto) i2 = ++i;
+      static_assert(std::is_lvalue_reference_v<decltype(i2)>);
+      assert(*i2 == "def"_str);
+    }
+
+    // i++
+    {
+      auto i = v.begin();
+      assert(*i == "abc"_str);
+
+      decltype(auto) i2 = i++;
+      static_assert(!std::is_reference_v<decltype(i2)>);
+      assert(*i2 == "abc"_str);
+      assert(*i == "def"_str);
+    }
+  }
+
+  // Can call `outer-iterator::operator++`; `View` is an input range.
+  {
+    SplitViewInput v("abc def ghi", ' ');
+
+    // ++i
+    {
+      auto i = v.begin();
+      assert(*i == "abc"_str);
+
+      decltype(auto) i2 = ++i;
+      static_assert(std::is_lvalue_reference_v<decltype(i2)>);
+      assert(*i2 == "def"_str);
+    }
+
+    // i++
+    {
+      auto i = v.begin();
+      assert(*i == "abc"_str);
+
+      static_assert(std::is_void_v<decltype(i++)>);
+      i++;
+      assert(*i == "def"_str);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/types.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// using iterator_category = input_iterator_tag; // Only defined if `View` is a forward range.
+// using iterator_concept = conditional_t<forward_range<Base>, forward_iterator_tag, input_iterator_tag>;
+// using difference_type = range_difference_t<Base>;
+
+#include <ranges>
+
+#include <concepts>
+#include <iterator>
+#include "../types.h"
+
+template <class Range, class Pattern>
+using OuterIter = decltype(std::declval<std::ranges::lazy_split_view<Range, Pattern>>().begin());
+
+// iterator_category
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::iterator_category, std::input_iterator_tag>);
+
+template <class Range, class Pattern>
+concept NoIteratorCategory = !requires { typename OuterIter<Range, Pattern>::iterator_category; };
+static_assert(NoIteratorCategory<InputView, ForwardTinyView>);
+
+// iterator_concept
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::iterator_concept, std::forward_iterator_tag>);
+static_assert(std::same_as<typename OuterIter<InputView, ForwardTinyView>::iterator_concept, std::input_iterator_tag>);
+
+// difference_type
+
+static_assert(std::same_as<typename OuterIter<ForwardView, ForwardView>::difference_type,
+    std::ranges::range_difference_t<ForwardView>>);

libcxx/test/std/ranges/range.adaptors/range.lazy.split/small_string.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <string_view>
+
+// A constexpr-friendly lightweight string, primarily useful for comparisons.
+// Unlike `std::string`, all functions are `constexpr`. Unlike `std::string_view`, it copies the given string into an
+// internal buffer and can work with non-contiguous inputs.
+template <class Char>
+class BasicSmallString {
+  constexpr static int N = 32;
+  Char buffer_[N] = {};
+  size_t size_ = 0;
+
+  constexpr void omit_terminating_null() {
+    if (size_ > 0 && buffer_[size_ - 1] == '\0') {
+      --size_;
+    }
+  }
+
+public:
+  // Main constructors.
+
+  constexpr BasicSmallString() = default;
+
+  constexpr BasicSmallString(std::basic_string_view<Char> v) : size_(v.size()) {
+    assert(size_ < N);
+    if (size_ == 0) return;
+
+    std::copy(v.begin(), v.end(), buffer_);
+    omit_terminating_null();
+  }
+
+  template <class I, class S>
+  constexpr BasicSmallString(I b, const S& e) {
+    for (; b != e; ++b) {
+      buffer_[size_++] = *b;
+      assert(size_ < N);
+    }
+
+    omit_terminating_null();
+  }
+
+  // Delegating constructors.
+
+  constexpr BasicSmallString(const Char* ptr, size_t size) : BasicSmallString(std::basic_string_view<Char>(ptr, size)) {
+  }
+
+  template <std::ranges::range R>
+  constexpr BasicSmallString(R&& from) : BasicSmallString(from.begin(), from.end()) {
+  }
+
+  // Iterators.
+
+  constexpr Char* begin() { return buffer_; }
+  constexpr Char* end() { return buffer_ + size_; }
+  constexpr const Char* begin() const { return buffer_; }
+  constexpr const Char* end() const { return buffer_ + size_; }
+
+  friend constexpr bool operator==(const BasicSmallString& lhs, const BasicSmallString& rhs) {
+    return lhs.size_ == rhs.size_ && std::equal(lhs.buffer_, lhs.buffer_ + lhs.size_, rhs.buffer_);
+  }
+  friend constexpr bool operator==(const BasicSmallString& lhs, std::string_view rhs) {
+    return lhs == BasicSmallString(rhs);
+  }
+};
+
+using SmallString = BasicSmallString<char>;
+
+constexpr SmallString operator "" _str(const char* ptr, size_t size) {
+  return SmallString(ptr, size);
+}
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_SMALL_STRING_H

libcxx/test/std/ranges/range.adaptors/range.lazy.split/types.h

+//===----------------------------------------------------------------------===//
+//
+// 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 TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H
+
+#include <concepts>
+#include <ranges>
+#include <string_view>
+#include <type_traits>
+#include "small_string.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+
+// CopyableView
+
+struct CopyableView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit CopyableView() = default;
+  constexpr CopyableView(const char* ptr) : view_(ptr) {}
+  constexpr CopyableView(std::string_view v) : view_(v) {}
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+  constexpr bool operator==(const CopyableView& rhs) const { return view_ == rhs.view_; }
+};
+static_assert( std::ranges::forward_range<CopyableView>);
+static_assert( std::ranges::forward_range<const CopyableView>);
+static_assert( std::ranges::view<CopyableView>);
+static_assert( std::is_copy_constructible_v<CopyableView>);
+
+// ForwardView
+
+struct ForwardView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardView() = default;
+  constexpr ForwardView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardView(std::string_view v) : view_(v) {}
+  constexpr ForwardView(ForwardView&&) = default;
+  constexpr ForwardView& operator=(ForwardView&&) = default;
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(view_.end()); }
+};
+static_assert( std::ranges::forward_range<ForwardView>);
+static_assert( std::ranges::forward_range<const ForwardView>);
+static_assert( std::ranges::view<ForwardView>);
+static_assert(!std::is_copy_constructible_v<ForwardView>);
+static_assert( std::is_move_constructible_v<ForwardView>);
+
+// ForwardDiffView
+
+// Iterator types differ based on constness of this class.
+struct ForwardDiffView : std::ranges::view_base {
+  SmallString buffer_;
+  constexpr explicit ForwardDiffView() = default;
+  constexpr ForwardDiffView(const char* ptr) : ForwardDiffView(std::string_view(ptr)) {}
+  constexpr ForwardDiffView(std::string_view v) : buffer_(v) {}
+  constexpr ForwardDiffView(ForwardDiffView&&) = default;
+  constexpr ForwardDiffView& operator=(ForwardDiffView&&) = default;
+  constexpr ForwardDiffView(const ForwardDiffView&) = default;
+  constexpr ForwardDiffView& operator=(const ForwardDiffView&) = default;
+  constexpr forward_iterator<char*> begin() { return forward_iterator<char*>(buffer_.begin()); }
+  constexpr forward_iterator<char*> end()  { return forward_iterator<char*>(buffer_.end()); }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(buffer_.begin()); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(buffer_.end()); }
+};
+static_assert( std::ranges::forward_range<ForwardView>);
+static_assert( std::ranges::forward_range<const ForwardView>);
+static_assert( std::ranges::view<ForwardView>);
+static_assert(!std::same_as<std::ranges::iterator_t<ForwardDiffView>, std::ranges::iterator_t<const ForwardDiffView>>);
+
+// ForwardOnlyIfNonConstView
+
+template <class It>
+class almost_forward_iterator {
+    It it_;
+
+    template <class U> friend class almost_forward_iterator;
+
+public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = typename std::iterator_traits<It>::value_type;
+    using difference_type = typename std::iterator_traits<It>::difference_type;
+    using pointer = It;
+    using reference = typename std::iterator_traits<It>::reference;
+
+    constexpr almost_forward_iterator() : it_() {}
+    constexpr explicit almost_forward_iterator(It it) : it_(it) {}
+    template <class U>
+        constexpr almost_forward_iterator(const almost_forward_iterator<U>& u) : it_(u.it_) {}
+
+    constexpr reference operator*() const { return *it_; }
+    constexpr pointer operator->() const { return it_; }
+
+    constexpr almost_forward_iterator& operator++() { ++it_; return *this; }
+    // Notice the slightly different return type.
+    constexpr const almost_forward_iterator operator++(int) { return almost_forward_iterator(it_); }
+
+    friend constexpr bool operator==(const almost_forward_iterator& x, const almost_forward_iterator& y) {
+      return x.it_ == y.it_;
+    }
+    friend constexpr bool operator!=(const almost_forward_iterator& x, const almost_forward_iterator& y) {
+      return x.it_ != y.it_;
+    }
+};
+static_assert(!std::forward_iterator<almost_forward_iterator<int*>>);
+static_assert( std::input_iterator<almost_forward_iterator<int*>>);
+
+struct ForwardOnlyIfNonConstView : std::ranges::view_base {
+  std::string_view view_;
+
+  constexpr explicit ForwardOnlyIfNonConstView() = default;
+  constexpr ForwardOnlyIfNonConstView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardOnlyIfNonConstView(std::string_view v) : view_(v) {}
+  constexpr ForwardOnlyIfNonConstView(ForwardOnlyIfNonConstView&&) = default;
+  constexpr ForwardOnlyIfNonConstView& operator=(ForwardOnlyIfNonConstView&&) = default;
+
+  constexpr forward_iterator<const char*> begin() { return forward_iterator<const char*>(view_.begin()); }
+  constexpr forward_iterator<const char*> end() { return forward_iterator<const char*>(view_.end()); }
+  constexpr almost_forward_iterator<const char*> begin() const {
+    return almost_forward_iterator<const char*>(view_.begin());
+  }
+  constexpr almost_forward_iterator<const char*> end() const {
+    return almost_forward_iterator<const char*>(view_.end());
+  }
+};
+static_assert( std::ranges::forward_range<ForwardOnlyIfNonConstView>);
+static_assert(!std::ranges::forward_range<const ForwardOnlyIfNonConstView>);
+static_assert( std::ranges::view<ForwardOnlyIfNonConstView>);
+
+// InputView
+
+struct InputView : std::ranges::view_base {
+  SmallString buffer_;
+
+  constexpr InputView() = default;
+  constexpr InputView(const char* s) : InputView(std::string_view(s)) {}
+  constexpr InputView(std::string_view v) : buffer_(v) {}
+
+  constexpr cpp20_input_iterator<char*> begin() { return cpp20_input_iterator<char*>(buffer_.begin()); }
+  constexpr char* end() { return buffer_.end(); }
+  constexpr cpp20_input_iterator<const char*> begin() const {
+    return cpp20_input_iterator<const char*>(buffer_.begin());
+  }
+  constexpr const char* end() const { return buffer_.end(); }
+};
+constexpr bool operator==(const cpp20_input_iterator<char*>& lhs, char* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(char* lhs, const cpp20_input_iterator<char*>& rhs) { return base(rhs) == lhs; }
+constexpr bool operator==(const cpp20_input_iterator<const char*>& lhs, const char* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(const char* lhs, const cpp20_input_iterator<const char*>& rhs) { return base(rhs) == lhs; }
+
+static_assert(std::ranges::input_range<InputView>);
+static_assert(std::ranges::input_range<const InputView>);
+static_assert(std::ranges::view<InputView>);
+
+// ForwardTinyView
+
+struct ForwardTinyView : std::ranges::view_base {
+  char c_[1] = {};
+  constexpr ForwardTinyView() = default;
+  constexpr ForwardTinyView(char c) { *c_ = c; }
+  constexpr forward_iterator<const char*> begin() const { return forward_iterator<const char*>(c_); }
+  constexpr forward_iterator<const char*> end() const { return forward_iterator<const char*>(c_ + 1); }
+  constexpr static size_t size() { return 1; }
+};
+static_assert(std::ranges::forward_range<ForwardTinyView>);
+static_assert(std::ranges::view<ForwardTinyView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__tiny_range<ForwardTinyView>);
+
+// Aliases
+
+using SplitViewCopyable = std::ranges::lazy_split_view<CopyableView, CopyableView>;
+using OuterIterCopyable = std::ranges::iterator_t<SplitViewCopyable>;
+using ValueTypeCopyable = decltype(*std::declval<SplitViewCopyable>().begin());
+using InnerIterCopyable = std::ranges::iterator_t<ValueTypeCopyable>;
+using BaseIterCopyable = std::ranges::iterator_t<CopyableView>;
+
+using SplitViewForward = std::ranges::lazy_split_view<ForwardView, ForwardView>;
+using OuterIterForward = std::ranges::iterator_t<SplitViewForward>;
+using ValueTypeForward = decltype(*std::declval<SplitViewForward>().begin());
+using InnerIterForward = std::ranges::iterator_t<ValueTypeForward>;
+using BaseIterForward = std::ranges::iterator_t<ForwardView>;
+
+using SplitViewInput = std::ranges::lazy_split_view<InputView, ForwardTinyView>;
+using OuterIterInput = std::ranges::iterator_t<SplitViewInput>;
+using ValueTypeInput = decltype(*std::declval<SplitViewInput>().begin());
+using InnerIterInput = std::ranges::iterator_t<ValueTypeInput>;
+using BaseIterInput = std::ranges::iterator_t<InputView>;
+
+using SplitViewDiff = std::ranges::lazy_split_view<ForwardDiffView, ForwardDiffView>;
+using OuterIterConst = decltype(std::declval<const SplitViewDiff>().begin());
+using OuterIterNonConst = decltype(std::declval<SplitViewDiff>().begin());
+static_assert(!std::same_as<OuterIterConst, OuterIterNonConst>);
+using InnerIterConst = decltype((*std::declval<OuterIterConst>()).begin());
+using InnerIterNonConst = decltype((*std::declval<OuterIterNonConst>()).begin());
+static_assert(!std::same_as<InnerIterConst, InnerIterNonConst>);
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_LAZY_SPLIT_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.lazy.split/view_interface.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
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <string_view>
+#include "types.h"
+
+using V = SplitViewForward;
+static_assert(std::ranges::forward_range<V>);
+
+// empty()
+template <class View>
+concept CanCallEmpty = requires (View& v) { v.empty(); };
+static_assert(CanCallEmpty<V>);
+
+// operator bool()
+template <class View>
+concept CanCallOperatorBool = requires (View& v) { static_cast<bool>(v); };
+static_assert(CanCallOperatorBool<V>);
+
+// front()
+template <class View>
+concept CanCallFront = requires (View& v) { v.front(); };
+static_assert(CanCallFront<V>);
+
+// size() is unavailable.
+static_assert(!std::sized_sentinel_for<std::ranges::sentinel_t<V>, std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallSize = requires (View& v) { v.size(); };
+static_assert(!CanCallSize<V>);
+
+// back() is unavailable.
+static_assert(!std::ranges::bidirectional_range<V>);
+template <class View>
+concept CanCallBack = requires (View& v) { v.back(); };
+static_assert(!CanCallBack<V>);
+
+// data() is unavailable.
+static_assert(!std::contiguous_iterator<std::ranges::iterator_t<V>>);
+template <class View>
+concept CanCallData = requires (View& v) { v.data(); };
+static_assert(!CanCallData<V>);
+
+// operator[] is unavailable.
+static_assert(!std::ranges::random_access_range<V>);
+template <class View>
+concept CanCallOperatorSubscript = requires (View& v) { v[0]; };
+static_assert(!CanCallOperatorSubscript<V>);
+
+constexpr bool test() {
+  using namespace std::string_view_literals;
+
+  // empty()
+  {
+    {
+      std::ranges::lazy_split_view v("abc def", " ");
+      assert(!v.empty());
+    }
+
+    {
+      // Note: an empty string literal would still produce a non-empty output because the terminating zero is treated as
+      // a separate character; hence the use of `string_view`.
+      std::ranges::lazy_split_view v(""sv, "");
+      assert(v.empty());
+    }
+  }
+
+  // operator bool()
+  {
+    {
+      std::ranges::lazy_split_view v("abc", "");
+      assert(v);
+    }
+
+    {
+      // Note: an empty string literal would still produce a non-empty output because the terminating zero is treated as
+      // a separate character; hence the use of `string_view`.
+      std::ranges::lazy_split_view v(""sv, "");
+      assert(!v);
+    }
+  }
+
+  // front()
+  {
+    SplitViewForward v("abc", "");
+    assert(*(v.front()).begin() == 'a');
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/support/test_iterators.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
public:
     constexpr cpp20_input_iterator& operator++() { ++it_; return *this; }
     constexpr void operator++(int) { ++it_; }
 
     friend constexpr It base(const cpp20_input_iterator& i) { return i.it_; }
 
     template <class T>
     void operator,(T const &) = delete;
 };
+static_assert(std::input_iterator<cpp20_input_iterator<int*>>);
 
 template<std::input_or_output_iterator>
 struct iter_value_or_void { using type = void; };
 
 template<std::input_iterator I>
 struct iter_value_or_void<I> {
     using type = std::iter_value_t<I>;
 };