[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

3 ↗

(On Diff #418168)

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

12 ↗

(On Diff #418168)

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

28–36 ↗

(On Diff #418168)

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

18–19 ↗

(On Diff #418168)

Run this!

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

18–24 ↗

(On Diff #418168)

Run this!

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

15 ↗

(On Diff #418168)

Missing <cassert>

59–61 ↗

(On Diff #418168)

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

67 ↗

(On Diff #418168)

We need a test for the _LIBCPP_ASSERT.

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

18 ↗

(On Diff #418168)

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

40 ↗

(On Diff #418168)

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

81 ↗

(On Diff #418168)

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

23 ↗

(On Diff #418168)

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

14 ↗

(On Diff #418168)

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

21 ↗

(On Diff #418168)

Run this!

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

21 ↗

(On Diff #418168)

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

29–33 ↗

(On Diff #418168)

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.

84 ↗

(On Diff #418168)

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

81 ↗

(On Diff #418168)

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

29–33 ↗

(On Diff #418168)

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

20 ↗

(On Diff #420695)

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

20 ↗

(On Diff #420695)

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/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 !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>;
+  [[no_unique_address]] _MaybeCurrent __current_;
+
+  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)))
+    , __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 {
+      if (!__current_.__has_value()) {
+        __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 class __inner_iterator;
+
+    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>;
+    [[no_unique_address]] _MaybeCurrent __current_;
+    bool __trailing_empty_ = false;
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() {
+      if constexpr (forward_range<_Base>) {
+        return __current_;
+      } else {
+        return *__parent_->__current_;
+      }
+    }
+
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+    constexpr auto& __current() const {
+      if constexpr (forward_range<_Base>) {
+        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 { 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>) {
+        // TODO(varconst): should be `ranges::find`.
+        __current() = std::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_;
+    }
+
+    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 : private __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_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
+    __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_};
+      const 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 // !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-no-concepts
+// 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) };
+};
+
+static_assert(std::same_as<decltype(std::views::lazy_split), decltype(std::ranges::views::lazy_split)>);
+
+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(); }
+};
+
+constexpr bool test() {
+  using namespace std::string_view_literals;
+
+  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 { };
+    auto partial = std::views::lazy_split_view(X{});
+    (void)partial;
+  }
+
+  // Check SFINAE friendliness.
+  {
+    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)>);
+  }
+
+  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-no-concepts
+// 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"
+
+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-no-concepts
+// 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 decltype(std::declval<View>().begin())::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()) };
+};
+
+struct CountingInputView : std::ranges::view_base {
+  int* begin_calls_count = nullptr;
+  constexpr CountingInputView(int* count) : begin_calls_count(count) {}
+  constexpr cpp20_input_iterator<const int*> begin() const {
+    ++(*begin_calls_count);
+    return cpp20_input_iterator<const int*>(nullptr);
+  }
+  constexpr const int* end() const { return nullptr; }
+};
+constexpr bool operator==(const cpp20_input_iterator<const int*>&, const int*) { return true; }
+constexpr bool operator==(const int*, const cpp20_input_iterator<const int*>&) { return true; }
+static_assert(std::ranges::input_range<CountingInputView>);
+
+struct CountingForwardView : std::ranges::view_base {
+  int* begin_calls_count = nullptr;
+  constexpr CountingForwardView(int* count) : begin_calls_count(count) {}
+  constexpr forward_iterator<const int*> begin() const {
+    ++(*begin_calls_count);
+    return {};
+  }
+  constexpr forward_iterator<const int*> end() const { return {}; }
+};
+static_assert(std::ranges::forward_range<CountingForwardView>);
+
+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> && 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), int&>);
+
+    static_assert(ConstBeginDisabled<decltype(v)>);
+  }
+
+  // For non-forward ranges, the `begin` iterator is cached.
+  {
+    int begin_calls_count = 0;
+    CountingInputView input(&begin_calls_count);
+    std::ranges::lazy_split_view<CountingInputView, ForwardTinyView> v(input, ForwardTinyView());
+    for (int i = 0; i != 3; ++i) {
+      (void)v.begin();
+      assert(begin_calls_count == 1);
+    }
+  }
+
+  // For forward ranges, the `begin` iterator is not cached.
+  {
+    int begin_calls_count = 0;
+    CountingForwardView input(&begin_calls_count);
+    std::ranges::lazy_split_view<CountingForwardView, ForwardView> v(input, ForwardView());
+    for (int i = 0; i != 3; ++i) {
+      (void)v.begin();
+      assert(begin_calls_count == i + 1);
+    }
+  }
+
+  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-no-concepts
+// 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"
+
+template <class I1, class I2, class Expected>
+constexpr void test() {
+  I1 i1{};
+  I2 i2{};
+
+  std::ranges::lazy_split_view v(std::move(i1), std::move(i2));
+  using O = decltype(std::move(v).base());
+  static_assert(std::same_as<O, Expected>);
+}
+
+constexpr void testCtad() {
+  // (Range, Pattern)
+  test<ForwardView, ForwardView, ForwardView>();
+  test<ForwardRange, ForwardRange, std::ranges::views::all_t<ForwardRange>>();
+
+  // (Range, RangeElement)
+  test<ForwardRange, char, std::ranges::views::all_t<ForwardRange>>();
+  test<InputRange, char, std::ranges::views::all_t<InputRange>>();
+
+  // (Range, RangeElement) with implicit conversion.
+  test<ForwardRange, bool, std::ranges::views::all_t<ForwardRange>>();
+  test<InputRange, bool, std::ranges::views::all_t<InputRange>>();
+
+  // Note: CTAD from (InputRange, TinyForwardRange) doesn't work -- the deduction guide wraps the pattern in
+  // `views::all_t`, resulting in `views::owning_view<TinyForwardRange>`. That type would never satisfy `tiny-range`
+  // because `views::owning_view` contains a member function `size()` that shadows the static `size()` in
+  // `TinyForwardRange`.
+}

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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+//  lazy_split_view() requires default_initializable<V> && default_initializable<P> = default;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "types.h"
+
+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>>);
+
+LIBCPP_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());
+
+  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-no-concepts
+// 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 <utility>
+#include "types.h"
+
+template <class V, class P, class R, class D>
+concept CanConstruct = requires(R&& r, D&& d) {
+  std::ranges::lazy_split_view<V, P>(std::forward<R>(r), std::move(d));
+};
+
+static_assert( CanConstruct<std::string_view, std::string_view, std::string_view, char>);
+static_assert( CanConstruct<std::string_view, std::string_view, char(&)[5], char>);
+
+struct Empty {};
+static_assert(!CanConstruct<std::string_view, std::string_view, Empty, std::string_view>);
+static_assert(!CanConstruct<std::string_view, std::string_view, std::string_view, Empty>);
+
+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)));
+
+  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-no-concepts
+// 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-no-concepts
+// 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 = ForwardNonSimpleView;
+
+    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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view;
+
+#include <ranges>
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <string_view>
+#include <utility>
+
+template <class L, class R>
+constexpr bool eq(const L& left, const R& right) {
+  auto l = left.begin();
+  auto r = right.begin();
+
+  for (; l != left.end(); ++l, ++r) {
+    if (r == right.end()) {
+      auto next = l;
+      ++next;
+      return *l == '\0' && next == left.end();
+    }
+    if (*l != *r) return false;
+  }
+
+  return r == right.end();
+}
+
+template <class T, size_t N, class Separator, class U, size_t M>
+constexpr bool test(const T (&input)[N], Separator separator, std::array<U, M> expected) {
+  std::ranges::lazy_split_view v(input, separator);
+
+  return std::equal(v.begin(), v.end(), expected.begin(), expected.end(),
+      [](const auto& split_value, const auto& expected_value) {
+        // TODO(varconst): use `std::ranges::equal`.
+        return eq(split_value, expected_value);
+  });
+}
+
+template <class T, size_t N, class Separator, class U, size_t M>
+constexpr bool test_with_piping(const T (&input)[N], Separator separator, std::array<U, M> expected) {
+  auto expected_it = expected.begin();
+  for (auto e : input | std::ranges::views::lazy_split(separator)) {
+    // TODO(varconst): use `std::ranges::equal`.
+    if (expected_it == expected.end()) return false;
+
+    if (!eq(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.
+    {
+      std::string_view input = "abc";
+      std::string_view sep = " ";
+      std::ranges::lazy_split_view v(input, sep);
+      (void)v;
+    }
+
+    // Const lvalues.
+    {
+      const std::string_view input = "abc";
+      const std::string_view sep = " ";
+      std::ranges::lazy_split_view v(input, sep);
+      (void)v;
+    }
+
+    // Rvalues.
+    {
+      std::ranges::lazy_split_view v("abc"sv, " "sv);
+      (void)v;
+    }
+
+    // Const rvalues.
+    {
+      const std::string_view input = "abc";
+      const std::string_view sep = " ";
+      std::ranges::lazy_split_view v(std::move(input), std::move(sep));
+      (void)v;
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  using namespace std::string_view_literals;
+
+  constexpr char short_sep = ' ';
+  constexpr std::string_view long_sep = "12";
+
+  // One separator.
+  {
+    {
+      decltype(auto) input = "abc def";
+      constexpr std::array expected = {"abc"sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def";
+      constexpr std::array expected = {"abc"sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Several separators in a row.
+  {
+    {
+      decltype(auto) input = "abc    def";
+      constexpr std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12121212def";
+      constexpr std::array expected = {"abc"sv, ""sv, ""sv, ""sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Trailing separator.
+  {
+    {
+      decltype(auto) input = "abc def ";
+      constexpr std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc12def12";
+      constexpr std::array expected = {"abc"sv, "def"sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Leading separator.
+  {
+    {
+      decltype(auto) input = " abc def";
+      constexpr std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12abc12def";
+      constexpr std::array expected = {""sv, "abc"sv, "def"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // No separator.
+  {
+    {
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"abc"sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"abc"sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Empty string.
+  {
+    {
+      decltype(auto) input = "";
+      constexpr std::array expected = {""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "";
+      constexpr std::array expected = {""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Input consisting of a single separator.
+  {
+    {
+      decltype(auto) input = " ";
+      constexpr std::array expected = {""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12";
+      constexpr std::array expected = {""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Input consisting of only separators.
+  {
+    {
+      decltype(auto) input = "   ";
+      constexpr std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "121212";
+      constexpr std::array expected = {""sv, ""sv, ""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Many redundant separators.
+  {
+    {
+      decltype(auto) input = "  abc   def  ";
+      constexpr std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "1212abc121212def1212";
+      constexpr std::array expected = {""sv, ""sv, "abc"sv, ""sv, ""sv, "def"sv, ""sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Separators after every character.
+  {
+    {
+      decltype(auto) input = " a b c ";
+      constexpr std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, short_sep, expected));
+      static_assert(test(input, short_sep, expected));
+      assert(test_with_piping(input, short_sep, expected));
+      static_assert(test_with_piping(input, short_sep, expected));
+    }
+
+    {
+      decltype(auto) input = "12a12b12c12";
+      constexpr std::array expected = {""sv, "a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, long_sep, expected));
+      static_assert(test(input, long_sep, expected));
+      assert(test_with_piping(input, long_sep, expected));
+      static_assert(test_with_piping(input, long_sep, expected));
+    }
+  }
+
+  // Empty separator.
+  {
+    {
+      constexpr std::string_view empty_sep = "";
+
+      decltype(auto) input = "abc";
+      constexpr std::array expected = {"a"sv, "b"sv, "c"sv, ""sv};
+
+      assert(test(input, empty_sep, expected));
+      static_assert(test(input, empty_sep, expected));
+      assert(test_with_piping(input, empty_sep, expected));
+      static_assert(test_with_piping(input, empty_sep, expected));
+    }
+  }
+
+  // Overlap between the separator and the string.
+  {
+    {
+      constexpr std::string_view overlapping_sep = "ab";
+
+      decltype(auto) input = "aabaaababb";
+      constexpr std::array expected = {"a"sv, "aa"sv, ""sv, "b"sv};
+
+      assert(test(input, overlapping_sep, expected));
+      static_assert(test(input, overlapping_sep, expected));
+      assert(test_with_piping(input, overlapping_sep, expected));
+      static_assert(test_with_piping(input, overlapping_sep, expected));
+    }
+  }
+
+  // Non-character input.
+  {
+    {
+      constexpr int sep = 0;
+      constexpr int input[] = {1, 2, 3, 0, 4, 5, 6};
+      constexpr std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test(input, sep, expected));
+      static_assert(test(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+      static_assert(test_with_piping(input, sep, expected));
+    }
+
+    {
+      constexpr std::array sep = {0, 0, 0};
+      constexpr int input[] = {1, 2, 3, 0, 0, 0, 4, 5, 6};
+      constexpr std::array expected = {std::array{1, 2, 3}, std::array{4, 5, 6}};
+
+      assert(test(input, sep, expected));
+      static_assert(test(input, sep, expected));
+      assert(test_with_piping(input, sep, expected));
+      static_assert(test_with_piping(input, sep, expected));
+    }
+  }
+
+  assert(test_l_r_values());
+  static_assert(test_l_r_values());
+
+  return 0;
+}

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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::begin()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+constexpr bool test() {
+  using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+  std::string_view input = "a";
+
+  // Non-const.
+  {
+    View v(input, "b");
+    auto val = *v.begin();
+    assert(val.begin().base() == input);
+  }
+
+  // Const.
+  {
+    View v(input, "b");
+    const auto val = *v.begin();
+    assert(val.begin().base() == input);
+  }
+
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::value_type()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using ValueType = decltype(*std::declval<View>().begin());
+static_assert(std::is_default_constructible_v<ValueType>);
+
+int main(int, char**) {
+  ValueType val;
+  (void)val;
+
+  constexpr ValueType val2;
+  (void)val2;
+  // Note: attempting a check like `val.begin() == val.end()` leads to null pointer dereference.
+
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::value_type(outer-iterator i)
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using ValueType = decltype(*std::declval<View>().begin());
+static_assert(std::is_constructible_v<ValueType, std::ranges::iterator_t<View>>);
+
+constexpr bool test() {
+  std::string_view input = "a";
+  View v(input, "b");
+  ValueType val(v.begin());
+  return val.begin().base() == input;
+}
+
+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/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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::value_type::end()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <utility>
+
+constexpr bool test() {
+  using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+  std::string_view input = "a";
+
+  // Non-const.
+  {
+    View v(input, "b");
+    auto val = *v.begin();
+    static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+  }
+
+  // Const.
+  {
+    View v(input, "b");
+    const auto val = *v.begin();
+    static_assert(std::same_as<decltype(val.end()), std::default_sentinel_t>);
+  }
+
+  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/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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer/ctor.current.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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+int main(int, char**) {
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator()
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+using View = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using OuterIter = decltype(std::declval<View>().begin());
+static_assert(std::is_default_constructible_v<OuterIter>);
+
+int main(int, char**) {
+  OuterIter i;
+  (void)i;
+  constexpr OuterIter i2;
+  (void)i2;
+
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::ranges::lazy_split_view::outer-iterator::outer-iterator(Parent& parent)
+//   requires (!forward_range<Base>)
+
+#include <ranges>
+
+#include <cassert>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include "../types.h"
+
+using SplitView = std::ranges::lazy_split_view<std::string_view, std::string_view>;
+using OuterIter = decltype(std::declval<SplitView>().begin());
+static_assert(std::ranges::forward_range<SplitView>);
+static_assert(!std::is_constructible_v<OuterIter, const SplitView&>);
+
+using SplitViewInput = std::ranges::lazy_split_view<InputView, ForwardTinyView>;
+using OuterIterInput = decltype(std::declval<SplitViewInput>().begin());
+// TODO(varconst): uncomment once `lazy_split_view` can use `ranges::find`.
+//static_assert(!std::ranges::forward_range<SplitViewInput>);
+//static_assert(std::is_constructible_v<OuterIterInput, SplitViewInput&>);
+
+constexpr bool test() {
+  InputView input;
+  SplitViewInput v(input, ForwardTinyView());
+
+  OuterIterInput i(v);
+  (void)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/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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+int main(int, char**) {
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+int main(int, char**) {
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+#include <ranges>
+
+int main(int, char**) {
+  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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view::outer-iterator;
+
+#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_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>);
+
+// 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>);
+
+// 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/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 <ranges>
+#include <string_view>
+#include "test_iterators.h"
+
+int globalBuff[8];
+
+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>);
+
+struct CopyableView : std::ranges::view_base {
+  int start_;
+  constexpr explicit CopyableView(int start = 0) : start_(start) {}
+  constexpr CopyableView(CopyableView const&) = default;
+  constexpr CopyableView& operator=(CopyableView const&) = default;
+  constexpr int *begin() const { return globalBuff + start_; }
+  constexpr int *end() const { return globalBuff + 8; }
+  constexpr bool operator==(CopyableView rhs) const { return start_ == rhs.start_; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+
+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()); }
+};
+
+// Iterator types differ based on constness of this class.
+struct ForwardDiffView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardDiffView() = default;
+  constexpr ForwardDiffView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardDiffView(std::string_view v) : view_(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*>(nullptr); }
+  constexpr forward_iterator<char*> end()  { return forward_iterator<char*>(nullptr); }
+  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()); }
+};
+
+struct ForwardNonSimpleView : std::ranges::view_base {
+  std::string_view view_;
+  constexpr explicit ForwardNonSimpleView() = default;
+  constexpr ForwardNonSimpleView(const char* ptr) : view_(ptr) {}
+  constexpr ForwardNonSimpleView(std::string_view v) : view_(v) {}
+  constexpr ForwardNonSimpleView(ForwardNonSimpleView&&) = default;
+  constexpr ForwardNonSimpleView& operator=(ForwardNonSimpleView&&) = 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 cpp20_input_iterator<const char*> begin() const { return cpp20_input_iterator<const char*>(view_.begin()); }
+  constexpr cpp20_input_iterator<const char*> end() const { return cpp20_input_iterator<const char*>(view_.end()); }
+};
+
+struct ForwardTinyView : ForwardView {
+  ForwardTinyView() = default;
+  constexpr static size_t size() { return 1; }
+};
+
+template <class It>
+class almost_forward_iterator {
+    It it_;
+
+    template <class U> friend class almost_forward_iterator;
+
+public:
+    typedef          std::forward_iterator_tag                 iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    TEST_CONSTEXPR almost_forward_iterator() : it_() {}
+    TEST_CONSTEXPR explicit almost_forward_iterator(It it) : it_(it) {}
+    template <class U>
+        TEST_CONSTEXPR almost_forward_iterator(const almost_forward_iterator<U>& u) : it_(u.it_) {}
+
+    TEST_CONSTEXPR reference operator*() const {return *it_;}
+    TEST_CONSTEXPR pointer operator->() const {return it_;}
+
+    TEST_CONSTEXPR_CXX14 almost_forward_iterator& operator++() { ++it_; return *this; }
+    // Notice the slightly different return type.
+    TEST_CONSTEXPR_CXX14 const almost_forward_iterator operator++(int) {return almost_forward_iterator(it_);}
+
+    friend TEST_CONSTEXPR bool operator==(const almost_forward_iterator& x, const almost_forward_iterator& y) {return x.it_ == y.it_;}
+    friend TEST_CONSTEXPR bool operator!=(const almost_forward_iterator& x, const almost_forward_iterator& y) {return x.it_ != y.it_;}
+
+    template <class T>
+    void operator,(T const &) = delete;
+};
+
+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());
+  }
+};
+
+struct ThrowingDefaultCtorForwardView : std::ranges::view_base {
+  ThrowingDefaultCtorForwardView() noexcept(false);
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct NoDefaultCtorForwardView : std::ranges::view_base {
+  NoDefaultCtorForwardView() = delete;
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct InputView : std::ranges::view_base {
+  constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(globalBuff); }
+  constexpr int* end() { return globalBuff + 8; }
+  constexpr cpp20_input_iterator<const int*> begin() const { return cpp20_input_iterator<const int*>(globalBuff); }
+  constexpr const int* end() const { return globalBuff + 8; }
+};
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return base(lhs) == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return base(rhs) == lhs; }
+
+struct ForwardRange {
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+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>);
+
+#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-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// class std::ranges::lazy_split_view;
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+
+using V = decltype(std::ranges::lazy_split_view("abc", "d"));
+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>);
+
+int main(int, char**) {
+  // empty()
+  {
+    {
+      constexpr std::ranges::lazy_split_view v("abc", "");
+      assert(!v.empty());
+      static_assert(!v.empty());
+    }
+    // Note: a `lazy_split_view` is never empty.
+  }
+
+  // operator bool()
+  {
+    {
+      constexpr std::ranges::lazy_split_view v("abc", "");
+      assert(v);
+      static_assert(v);
+    }
+    // Note: a `lazy_split_view` is never empty.
+  }
+
+  // front()
+  {
+    constexpr std::ranges::lazy_split_view v("abc", "");
+    assert(*(v.front()).begin() == 'a');
+    static_assert(*(v.front()).begin() == 'a');
+  }
+
+  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;
 };
+#ifndef _LIBCPP_HAS_NO_CONCEPTS
+  static_assert(std::input_iterator<cpp20_input_iterator<int*>>);
+#endif
 
 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>;
 };