[libc++] add zip_view and views::zip for C++23

[huixie90]

Summary

• add zip_view and views::zip for C++23
• added unit tests
• implemented section 5.6 (zip) in P2321R2

I used clang-format to format the files but they look nothing like the rest of the code base. Manually indenting each line to match the styles sounds like an impossible task. Is there any clang-format file which can format it reasonable similar to the rest of the code base so that I can manually format the rest lines that look weird?

[huixie90]

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

43

fair enough, i will remove all usage of the macro

47

fair enough. I am ok with either way. To make you feel better, I changed all the same_as to is_same_v

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

34–35

I used to do std::declval a lot in this kind of tests, but in a previous review Arthur pointed out that the test is much less readable than just create a normal variable like normal user would do. So I think I agree with him in this case.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

33

for the sake of simplicity. I declared other operators but not implemented. it is declared so that the random access concept check would pass.

If zip_view is going to use those operators, it would fail the compile time test because these unimplemented operators are not constexpr. Also, it will fail to link if they are used because there are no implementations.

It works for clang trunk and gcc 11.2. i will check if this approach can pass the CI

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_swap.pass.cpp

22

sure I would create a iterator with customised iter_swap.

BTW, std::swap won't work with the current status of libcxx. This is because

using std::swap;
swap(*iter1, *iter2);

would not compile, as there is no swap overload that can take two prvalue of std::tuple<int&, int&>

If you use the triple-move implementation for std::swap, it won't work either.

Once we implemented the other section about tuple in this paper, it might make the swap version work

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/ctor.other.pass.cpp

58

The constructor is not explicit. see line63 I am testing the implicit conversions

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/eq.pass.cpp

60

sure. the test won't fail with other implementations because I am using LIBCPP_STATIC_ASSERT.

LIBCPP_STATIC_ASSERT is not the verification. It is just to double check I have a sentinel. The tests that testing simple-view-ness is in a different file.

the actual tests here are the lines below which exercise the ==

[huixie90]

add missing private_headers test

[huixie90]

fix CI failure

[var-const]

(Note: I started reviewing this and hope to finish the first pass by end of the week)

[philnik]

This looks really good so far. It's mostly nits from my side.

libcxx/docs/Status/ZipProjects.csv

11–14

Could you add the link to this patch?

libcxx/include/__ranges/zip_view.h

341

435

libcxx/test/std/ranges/range.adaptors/range.zip/borrowing.compile.pass.cpp

36–42

You don't have to put the static_asserts inside a function.

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

34–35

OK, I don't have a strong opinion here. You can leave it as-is if you think it's easier to read.

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

21

It looks like you aren't checking the that zip accepts all the ranges types.

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

21–67

I really like this! Thanks!

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

33

That's also OK.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

29

I think you aren't checking that a custom iter_move is called properly. This should be quite similar to the iter_swap test.

libcxx/test/std/ranges/range.adaptors/range.zip/range.concept.compile.pass.cpp

320 ↗

(On Diff #421125)

Could you add a newline?

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

19–21

This header should only ever be included by the zip tests, right?

[huixie90]

addressed review comments

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

21

added more tests for bidi, random_access, contiguous.
output only ranges are not supported by the zip_view class. There was already a test in range.concept.compile.pass.cpp to check that output_range isn't supported.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

29

Could you please elaborate? The iter_move test looks really similar to iter_swap test

[philnik]

This LGTM. Let's see what @var-const thinks.

libcxx/docs/Status/ZipProjects.csv

11–13

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

29

Yes, sorry. I don't know what I was looking for, but it looks good.

[huixie90]

fix doc

[var-const]

Sorry about the slow review. Thanks a lot for working on this huge patch!

One comment I have that applies throughout most tests -- can you please add a brief comment to each test case to explain what exactly it tests? Even a short description makes things easier to skim through. Additionally, could you please separate the test cases by blank lines? It's a minor nit, but I think it makes it a little easier to see where one test case ends and another one starts.

libcxx/include/__ranges/zip_view.h

85

Is specifying the complicated return type necessary here (i.e., could this function get away with just auto)?

287

Nit: a few of these functions should be formatted so that the opening brace is on the same line as the function name.

342

Nit: can __bs be a little more descriptive?

395

Why is this implementation different from the overload above (and from the Standard)?

430

Hmm, is this equivalent to the Standard's wording?

The exception specification is equivalent to the logical AND of the following expressions:

noexcept(ranges::iter_swap(std::get<i>(l.current_), std::get<i>(r.current_)))

for every integer  `0 ≤ i < sizeof...(Views)`.

472

Optional: since this pattern is used twice (here and in __iterator), consider splitting it into a function (e.g. __tuple_zip_any_of).

514

Hmm, looking at the latest draft, it says

Given a pack of subexpressions `Es...`, the expression `views​::​zip(Es...)` is expression-equivalent to
<...>
(2.2) otherwise, `zip_­view<views​::​all_­t<decltype((Es))>...>(Es...)`.

This does not appear equivalent (missing views::all_t).

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

14

Is a case where neither of the overloads is available? (i.e., is it possible for a type to not satisfy range<const Views> && ... while still satisfying the class constraints?) If yes, can you add a compile-time test to check that case?

libcxx/test/std/ranges/range.adaptors/range.zip/borrowing.compile.pass.cpp

36

Nit: s/borrwed/borrowed/.

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

13

This file should also check piping zip. Can you take a look at test/std/ranges/range.adaptors/range.filter/adaptor.pass.cpp and implement the relevant checks from that test here?

Also, I'd rename it into adaptor.pass.cpp for consistency with other views.

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

33

Consider renaming to NoDefaultCtrView.

42

Hmm, I don't see a constraint on either the default constructor or the class itself that requires Views to be default-constructible. I'm probably missing it -- can you please check?

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

28

Wouldn't std::convertible_to work?

40

Seems like this could be UB? Consider making moves a one-element array.

61

Nit: s/stack/the local variable/ -- the parameter is also on the stack, after all.

67

Optional: these checks are so similar that they could be extracted into a helper function that takes two template arguments for the view types to create. But the current state is also fine since there are only 3 similar cases (extraction would allow you to add more cases easily if you'd like).

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

78

Shouldn't these check v.end() rather than v.begin()? (applies throughout)

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

13

Please specify the constraints (I'd be okay with just writing something like:

// All the arithmetic operators have the constraint `requires all-random-access<Const, Views...>;`,
// except `operator-` which has the constraint `requires (sized_­sentinel_­for<iterator_t<maybe-const<Const, Views>>,
                                   iterator_t<maybe-const<Const, Views>>> && ...);`

(of course, double check the above for correctness if you decide to use it)

35

Nit: this blank line seems extraneous.

64

These checks seem unnecessary -- it's already checked at runtime above (applies below as well).

112

Nit: s/range/the ranges/ (here and below).

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp

35

Question: what does "default" and "non-default" mean in the context of these classes?

48

Similar question to zip_view's default constructor -- where does this constraint come from?

55

Nit: can this be = zip_iter<Default> (or just use zip_iter<Default> without an alias)?

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.other.pass.cpp

13

Missing requires clause.

34

Can you also check the case when the conversion is from non-const to const, but (!convertible_­to<iterator_t<Views>, iterator_t<maybe-const<Const, Views>>> && ...)?

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/decrement.pass.cpp

14

Nit: this synopsis is missing the requires clause.

24

Optional: probably overkill, but it could also check the post-decrement version (using "or").

64

What's the reason to not go from the end like in the previous test case?

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

83

Nit: s/forword/forward/.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

13

Missing the noexcept clause (here and in iter_swap test).

37

Wouldn't it be easier to just create a local variable and use it here instead of declval?

43

Note: there's an ASSERT_NOT_NOEXCEPT macro, but using it is completely optional. I don't really have a preference.

46

iter_move must call ranges::iter_move, which is a customization point object. Can you please check that your specialization of iter_move is found via ADL even if it's in a different namespace (see some other views, e.g. lazy_split_view, for an example)?

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_swap.pass.cpp

44

Check the inverse case as well? (i.e., !noexcept)

47

Same comment re. ADL as iter_move.

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

39

Nit: use PascalCase for consistency with names of the other classes in this file?

73

Can you also test the case when iterator_concept is bidirectional_iterator_tag?

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/subscript.pass.cpp

13

Note: in synopsis, there is no reason to mangle names -- i.e., please s/__n/n/. Can you please check other test files' synopses for similar issues?

14

Please check the constraint as well.

libcxx/test/std/ranges/range.adaptors/range.zip/range.concept.compile.pass.cpp

152 ↗

(On Diff #422885)

Nit: unnecessary blank line.

157 ↗

(On Diff #422885)

Nit: s/static_assert/static_asserts/ (or static assertions).

306 ↗

(On Diff #422885)

Can you use the output iterator from test_iterators.h instead?

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/ctor.other.pass.cpp

35

Nit: s/Converitble/Convertible/.

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/eq.pass.cpp

60

Nit: weird formatting.

80

Question: isn't this checked by the comparisons above?

82

Please add empty lines between the test cases and short comment describing what each test case does.

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp

111

Nit: weird formatting for these concepts (clang-format doesn't support concepts properly, IIRC).

121

Please add short comments describing what each test case does.

libcxx/test/std/ranges/range.adaptors/range.zip/size.pass.cpp

54 ↗

(On Diff #422885)

Same nit re. empty lines and comments for each test case. Looks like it applies throughout the patch.

libcxx/test/std/ranges/range.adaptors/range.zip/types.h

24

Similar comments to join_view -- BufferView would be a more appropriate name, see if you can use std::span instead.

45

Good idea. We have some existing test code that we could simplify this way.

46

Nit: the opening brace goes on the same line as the function name (applies throughout the file, and possibly in other files as well).

310

Nit: extra semicolon.

[var-const]

libcxx/include/__ranges/zip_view.h

241

Is the following section implemented and tested?

If the invocation of any non-const member function of `iterator` exits via an exception, the iterator acquires a singular value.

(http://eel.is/c++draft/range.zip#iterator-3)

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

98

Nit: s/each/each of the/.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

13

Please add the constraints to the synopsis.

22

Also check for the presence of operator==?

24

Same nit as another file: it's a little inconsistent that this class name is in snake_case.

24

Nit: s/smaller/less/ (throughout the file). I think less is more commonly used in the arithmetic context.

34

Question: is defining operator[] necessary?

70

Is this declaration necessary? It seems to go against the purpose of the test, which IIUC verifies that having just operator== is sufficient.

75

Question: do these operators have to be declared?

100

Ultranit: s/SubRange/Subrange/ (the Standard considers it a single word).

111

These checks are verbose and, as far as I can see, same across the test cases -- can you move them to a helper function?

187

Please also check that operator== is unavailable, and ideally all other operators.

[huixie90]

address review comments

libcxx/include/__ranges/zip_view.h

85

I guess I'd have to spell this type in the return statement (currently it is just return {.....}).

241

AFAIK, doing anything with iterator of singular value would result in undefined behaviour (except for very few operations). one question is can we take advantage of the undefined behaviour and not do anything here?

One thing we could do is to value initialise all the underlying iterators. but what if underlying iterators are not default constructible?

287

it is done by clang-format. happy to format manually.

but imo it would be great to come up with a clang-format file that everyone is sort of OK-ish with it. It would save everyone's time

395

isn't this just delegating to the above? (thus same as above?)

430

I think so. In the standard, it basically says all the iter_swap(std::get<i>(l.current_), std::get<i>(r.current_) are noexcept. std::get itself is always noexcept, so the standard basically equivalent to all the ranges::iter_swap are noexcept.

Here the implementation is checking the same thing

514

good catch. added unit test to lock down this. for some reason, I relied on the user defined CTAD (which has the all_t thing, but forgot about the implicit CTAD from copy constructors which don't have all_t)

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

14

I don't think it is possible.
To make non-const overload not exist, all Views have to model simple-view. simple-view implies range<const View>. so the const overload must exist in that case.

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

13

views::zip is not an "adaptor". It is only a CPO. So it doesn't support pipe operation.
Therefore the test is not named as adaptor.pass.cpp but cpo.pass.cpp

The name views​::​zip denotes a customization point object ([customization.point.object]).

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

42

I had the same puzzle before I implemented this and asked sg9. Why there is no "requires (default_initializable<iterator_t<maybe-const<const, views>>> && ...)

The answer is that it is implicitly required by the tuple's constructor. if any of the iterators are not default constructible, zip_iterator's =default would be implicitly deleted.

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

28

My original thought was convertible_to doesn't work for multiple arguments but zip_view constructor can take multiple arguments. so i implemented a multi-args version.
But then I forgot to test the multi-args case.

40

I don't think this is UB. AFAIK, this is how single_view is implemented

https://eel.is/c++draft/range.single#view-5

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

70

This particular test point was suggested by @philnik . His point is that testing "zip_iterator is never calling underlying iterator's >, >=, <=, !=
because the spec says zip_iterator's >= is calling zip_iterator's (not less_than). So tested this way: declare all the operations >, >=, <= etc to make it satisfy random_access iterator concept. but not define them. if the zip_iterator's >,>=, <=, etc isn't implemented as the way standard defined but calling underlying iterator's >,>=,<=, we will get a linker error for runtime tests and non-constant expression for compile time test.

added comments to explain this

75

This particular test point was suggested by @philnik . His point is that testing "zip_iterator is never calling underlying iterator's >, >=, <=, !=
because the spec says zip_iterator's >= is calling zip_iterator's (not less_than). So tested this way: declare all the operations >, >=, <= etc to make it satisfy random_access iterator concept. but not define them. if the zip_iterator's >,>=, <=, etc isn't implemented as the way standard defined but calling underlying iterator's >,>=,<=, we will get a linker error for runtime tests and non-constant expression for compile time test

added comments to explain this

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp

48

this comes implicitly from the tuple's constructor

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/decrement.pass.cpp

64

In this case, zip_view is not a common_range, end returns a sentinel which can't be decremented

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

46

happy to add the extra test.
Just FYI, this is somehow implicitly tested by the #include order. we include <ranges> before the "types.h". If it were not using ADL, it couldn't find our test iterator's iter_move because normal lookup requires the declaration to be seen first.

[huixie90]

addressed comments

[var-const]

Almost LGTM, just a few nits.

libcxx/include/__ranges/zip_view.h

85

I mean, could you rely on CTAD? To be clear, it's just a question -- perhaps CTAD won't work here.

241

Perhaps we should test that the iterator is reassignable/destroyable, but perhaps it's overkill. Let's check with Louis @ldionne.

287

I fully agree, being able to use clang-format would be great (though note that it's not fully straightforward on our code base).

395

It's a little easier to compare when things are close to the Standard text (unless, of course, there's a reason to diverge), but it's a really small thing -- we can keep as is.

428

Very optional: this comment can fit in one line.

430

Sounds reasonable, but I'd ask Louis @ldionne to double-check just in case.

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

52

A word seems to be missing -- "should _be_ at the begin position"?

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

13

Ah, makes sense, never mind.

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

42

Because it's not obvious, can you please add this as a comment?

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

28

Ah, right (you might also want to check that the default constructor is explicit, though it starts going into the overkill territory).

40

Thanks for pointing it out -- it made me find this post that quotes the relevant part of the Standard (updated to the current draft):

When an expression J that has integral type is added to... an expression P of pointer type...

<...>

(4.2) Otherwise, if P points to an array element i of an array object x with n elements ([dcl.array]),70 the expressions P + J and J + P... point to the (possibly-hypothetical) array element i + j of x if 0 ≤ i+j ≤ n...

<...>

70. As specified in [basic.compound], an object that is not an array element is considered to belong to a single-element array for this purpose and a pointer past the last element of an array of n elements is considered to be equivalent to a pointer to a hypothetical array element n for this purpose.

67

(By the way, ignoring optional comments is fine -- that's why they're optional, after all -- but if you decide not to implement an optional suggestion, can you please add a comment to that effect? This would help me understand whether this is something you plan to come back to later or something you decided to push back on. Once again, pushing back is fine -- I just want to make sure I understand the state of the patch, i.e. whether all comments are addressed one way or the other)

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

20

Nit: I think the meaning would be a little more obvious if s/which/which instead/. (I know the current text is my suggestion)

102

Nit: with the new sentence structure, I think this should be sentinels.

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

36

Some nits:

• s/as/in;
• consider in the way defined by the standard;
• I think there should be no comma between defined and but;
• consider s/but/but instead/;
• (ultranit) please add a full stop at the end of the sentence.

130

Nit: s/Opeartors/Operators/.

239

Should it also call inequalityOperatorsDoNotExistTest?

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.other.pass.cpp

48

Is it possible to also add a static_assert to show that the convertible_­to constraint is not satisfied in this case? (Only if it's straightforward, it's basically to "test the test" and to make it a little more obvious what exactly it's testing)

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

46

Thanks for adding the test! Relying implicitly on the include order would be too subtle, IMO.

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

70

Nit: s/shoud/should/.

70

Nit: probably s/ranges/views/? That's the name of the template argument / constructor argument.

147

Nit: s/multiple/of multiple (here and below).

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/eq.pass.cpp

132

Thanks for adding all the comments! Much easier to skim through now.

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp

160

Optional nit: s/minus/subtract/.

[huixie90]

address review comments

libcxx/include/__ranges/zip_view.h

85

Originally I relied on tuple's CTAD, but that crashed gcc 11.2
https://discord.com/channels/636084430946959380/636732894974312448/960574541254496337

Later I tried make_tuple. There are two issues.

1. It is inconsistent with the rest of the code, where in other places, two elements thing are stored in a pair. Although this function is internal only, but still... consistency is good.

2. CTAD/make_tuple decays. In case the function returns references, I would get tuple of values instead of tuple of references. Again, this is not an issue for now, because the usages of this helper function only return values (booleans and integers at the moment). But again, if one day this is used with references, it would become a problem silently.

241

I asked around and people seem to agree on that that paragraph is to empower implementations not to do anything by given less guarantees that things should work. But let's wait until Louis is back

287

cool. I will hand format for now

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

28

The default constructor is not explicit and it is tested already

40

thanks for the explanation

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

34

yes. this is one of the requirement of random_access_iterator

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.other.pass.cpp

48

yes good idea. added static_assert right after the declaration of ConstIterIncompatibleView

[var-const]

LGTM -- thanks a lot for working on this huge patch! I'll leave the final approval for @ldionne.

libcxx/include/__ranges/zip_view.h

85

Oh, interesting, thanks for explaining. It's certainly not worth it to work around compiler bugs and such, the current state is fine.

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

40

Ultranit: capitalize.

[ldionne]

I looked around and it seemed like this had a thorough review already. I just replied to the comments where I was @'ed.

Thanks to everyone involved for the work and especially @huixie90 for authoring the patch. This LGTM with the last few missing comments addressed.

libcxx/include/__ranges/zip_view.h

241

Sorry, I feel I'm missing some context, but it seems to me that a singular iterator should still be destroyable and assignable-to (unless there's something in the spec that contradicts that, but I don't think there is). If that's correct, then we should make sure that works and test it. Please LMK if what I'm saying doesn't make sense, since I'm commenting out of context.

430

Yeah, this sounds reasonable to me.

[huixie90]

added unit test for singular case

[huixie90]

fix CI failure

[huixie90]

I don't have access to push the commits.
Name: Hui Xie
Email: [e-mail]

libcxx/docs/Status/ZipProjects.csv

 Section,Description,Dependencies,Assignee,Complete
 | `[tuple.syn] <https://wg21.link/tuple.syn>`_, "`[tuple] basic_common_reference, common_type <https://reviews.llvm.org/D116538>`_", None, Nikolas Klauser, |Complete|
 | `[tuple.tuple] <https://wg21.link/tuple.tuple>`_, "`[tuple] constructor, assignment and swap overloads <https://reviews.llvm.org/D116621>`_", None, Nikolas Klauser, |In Progress|
 | `[utility.syn] <https://wg21.link/utility.syn>`_, "[pair] basic_common_reference, common_type", None, Nikolas Klauser, |Complete|
 | `[pairs.pair] <https://wg21.link/pairs.pair>`_, "[pair] constructor, assignment and swap overloads", None, Nikolas Klauser, |Not Started|
 "| `[memory.syn] <https://wg21.link/memory.syn>`_
 | `[allocator.uses.construction] <https://wg21.link/allocator.uses.construction>`_", "[pair] uses_allocator_construction_args overloads", None, Unassigned, |Not Started|
 | `[vector.bool] <https://wg21.link/vector.bool>`_, "[vector<bool>::reference] add const operator= overload", None, Nikolas Klauser, |Not Started|
 | `[iterator.concept.winc] <https://wg21.link/iterator.concept.winc>`_, "Update weakly_comparable", None, Unassigned, |Not Started|
 | `[range.zip] <https://wg21.link/ranges.syn>`_, "zip_view", "| `zip_view::iterator`
-| `zip_view::sentinel`", Unassigned, |Not Started|
-| `[range.zip.iterator] <https://wg21.link/range.zip.transform>`_, "zip_view::iterator", None, Unassigned, |Not Started|
-| `[range.zip.sentinel] <https://wg21.link/range.zip.sentinel>`_, "zip_view::sentinel", None, Unassigned, |Not Started|
+| `zip_view::sentinel`", Hui Xie, |In Progress|
+| `[range.zip.iterator] <https://wg21.link/range.zip.transform>`_, "zip_view::iterator", None, Hui Xie, |In Progress|
+| `[range.zip.sentinel] <https://wg21.link/range.zip.sentinel>`_, "zip_view::sentinel", None, Hui Xie, |In Progress|
 | `[range.zip.transform.view] <https://wg21.link/range.zip.transform.view>`_, "zip_transform_view", "| `zip_transform_view::iterator`
 | `zip_transform_view::sentinel`", Unassigned, |Not Started|
 | `[range.zip.transform.iterator] <https://wg21.link/range.zip.transform.iterator>`_, "zip_transform_view::iterator", None, Unassigned, |Not Started|
 | `[range.zip.transform.sentinel] <https://wg21.link/range.zip.transform.sentinel>`_, "zip_transform_view::sentinel", None, Unassigned, |Not Started|
 | `[range.adjacent.view] <https://wg21.link/range.adjacent.view>`_, "adjacent_view", "| `adjacent_view::iterator`
 | `adjacent_view::sentinel`", Unassigned, |Not Started|
 | `[range.adjacent.iterator] <https://wg21.link/range.adjacent.iterator>`_, "adjacent_view::iterator", None, Unassigned, |Not Started|
 | `[range.adjacent.sentinel] <https://wg21.link/range.adjacent.sentinel>`_, "adjacent_view::sentinel", None, Unassigned, |Not Started|
 | `[range.adjacent.transform.view] <https://wg21.link/range.adjacent.transform.view>`_, "adjacent_transform_view", "| `adjacent_transform_view::iterator`,
 | `adjacent_transform_view::sentinel`", Unassigned, |Not Started|
 | `[range.adjacent.transform.iterator] <https://wg21.link/range.adjacent.transform.iterator>`_, "adjacent_transform_view::iterator", None, Unassigned, |Not Started|
 | `[range.adjacent.transform.sentinel] <https://wg21.link/range.adjacent.transform.sentinel>`_, "adjacent_transform_view::sentinel", None, Unassigned, |Not Started|
 | `[ranges.syn] <https://wg21.link/ranges.syn>`_, "enable_borrowed_range zip_view and adjacent_view", "| `zip_view`
 | `adjacent_view`", Unassigned, |Not Started|

libcxx/include/CMakeLists.txt

set(files
   __ranges/reverse_view.h
   __ranges/single_view.h
   __ranges/size.h
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h
+  __ranges/zip_view.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/limits.h
   __support/ibm/locale_mgmt_zos.h

libcxx/include/__ranges/zip_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_ZIP_VIEW_H
+#define _LIBCPP___RANGES_ZIP_VIEW_H
+
+#include <__config>
+
+#include <__algorithm/min.h>
+#include <__compare/three_way_comparable.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/equality_comparable.h>
+#include <__functional/invoke.h>
+#include <__functional/operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/iter_swap.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty_view.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__tuple>
+#include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
+#include <__utility/move.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+namespace ranges {
+
+template <class... _Ranges>
+concept __zip_is_common = (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
+                          (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
+                          ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
+
+template <typename _Tp, typename _Up>
+auto __tuple_or_pair_test() -> pair<_Tp, _Up>;
+
+template <typename... _Ts> requires(sizeof...(_Ts) != 2) 
+auto __tuple_or_pair_test() -> tuple<_Ts...>;
+
+template <class... _Ts>
+using __tuple_or_pair = decltype(__tuple_or_pair_test<_Ts...>());
+
+template <class _Fun, class _Tuple>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_transform(_Fun&& __f, _Tuple&& __tuple) {
+    return apply(
+        [&]<class... _Ts>(_Ts&&... __elements) {
+            return __tuple_or_pair<invoke_result_t<_Fun&, _Ts>...>(
+                std::invoke(__f, std::forward<_Ts>(__elements))...);
+        },
+        std::forward<_Tuple>(__tuple));
+}
+
+template <class _Fun, class _Tuple>
+_LIBCPP_HIDE_FROM_ABI constexpr void __tuple_for_each(_Fun&& __f, _Tuple&& __tuple) {
+    apply([&]<class... _Ts>(
+              _Ts&&... __elements) { (std::invoke(__f, std::forward<_Ts>(__elements)), ...); },
+          std::forward<_Tuple>(__tuple));
+}
+
+
+template <class _Fun, class _Tuple1, class _Tuple2, size_t... Is>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_transform(_Fun&& __f,
+                                                           _Tuple1&& __tuple1,
+                                                           _Tuple2&& __tuple2,
+                                                           index_sequence<Is...>) {
+    return __tuple_or_pair<
+        invoke_result_t<_Fun&, typename tuple_element<Is, remove_cvref_t<_Tuple1>>::type,
+                        typename tuple_element<Is, remove_cvref_t<_Tuple2>>::type>...>{
+        std::invoke(__f, std::get<Is>(std::forward<_Tuple1>(__tuple1)),
+               std::get<Is>(std::forward<_Tuple2>(__tuple2)))...};
+}
+
+template <class _Fun, class _Tuple1, class _Tuple2>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_transform(_Fun&& __f,
+                                                           _Tuple1&& __tuple1,
+                                                           _Tuple2&& __tuple2) {
+    return __tuple_zip_transform(__f, std::forward<_Tuple1>(__tuple1),
+                                 std::forward<_Tuple2>(__tuple2),
+                                 make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+}
+
+template <class _Fun, class _Tuple1, class _Tuple2, size_t... Is>
+_LIBCPP_HIDE_FROM_ABI constexpr void __tuple_zip_for_each(_Fun&& __f,
+                                                          _Tuple1&& __tuple1,
+                                                          _Tuple2&& __tuple2,
+                                                          index_sequence<Is...>) {
+    (std::invoke(__f, std::get<Is>(std::forward<_Tuple1>(__tuple1)),
+            std::get<Is>(std::forward<_Tuple2>(__tuple2))),
+     ...);
+}
+
+template <class _Fun, class _Tuple1, class _Tuple2>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_for_each(_Fun&& __f,
+                                                          _Tuple1&& __tuple1,
+                                                          _Tuple2&& __tuple2) {
+    return __tuple_zip_for_each(__f, std::forward<_Tuple1>(__tuple1),
+                                std::forward<_Tuple2>(__tuple2),
+                                make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+}
+
+// abs in cstdlib is not constexpr
+// TODO : remove __abs once P0533R9 is implemented.
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __abs(_Tp t) {
+    return t < 0 ? -t : t;
+}
+
+template <input_range... _Views>
+    requires(view<_Views>&&...) && (sizeof...(_Views) > 0) 
+class zip_view : public view_interface<zip_view<_Views...>> {
+
+    tuple<_Views...> __views_;
+
+    template <bool>
+    class __iterator;
+
+    template <bool>
+    class __sentinel;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    zip_view() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit zip_view(_Views... __views)
+        : __views_(std::move(__views)...) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto begin() requires(!(__simple_view<_Views> && ...)) {
+        return __iterator<false>(__tuple_transform(ranges::begin, __views_));
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto begin() const requires(range<const _Views>&&...) {
+        return __iterator<true>(__tuple_transform(ranges::begin, __views_));
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() requires(!(__simple_view<_Views> && ...)) {
+        if constexpr (!__zip_is_common<_Views...>) {
+            return __sentinel<false>(__tuple_transform(ranges::end, __views_));
+        } else if constexpr ((random_access_range<_Views> && ...)) {
+            return begin() + iter_difference_t<__iterator<false>>(size());
+        } else {
+            return __iterator<false>(__tuple_transform(ranges::end, __views_));
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto end() const requires(range<const _Views>&&...) {
+        if constexpr (!__zip_is_common<const _Views...>) {
+            return __sentinel<true>(__tuple_transform(ranges::end, __views_));
+        } else if constexpr ((random_access_range<const _Views> && ...)) {
+            return begin() + iter_difference_t<__iterator<true>>(size());
+        } else {
+            return __iterator<true>(__tuple_transform(ranges::end, __views_));
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() requires(sized_range<_Views>&&...) {
+        return apply(
+            [](auto... sizes) {
+                using CT = make_unsigned_t<common_type_t<decltype(sizes)...>>;
+                return (std::min)({CT(sizes)...});
+            },
+            __tuple_transform(ranges::size, __views_));
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto size() const requires(sized_range<const _Views>&&...) {
+        return apply(
+            [](auto... sizes) {
+                using CT = make_unsigned_t<common_type_t<decltype(sizes)...>>;
+                return (std::min)({CT(sizes)...});
+            },
+            __tuple_transform(ranges::size, __views_));
+    }
+};
+
+template <class... _Ranges>
+zip_view(_Ranges&&...) -> zip_view<views::all_t<_Ranges>...>;
+
+template <bool _Const, class... _Views>
+concept __zip_all_random_access = (random_access_range<__maybe_const<_Const, _Views>> && ...);
+
+template <bool _Const, class... _Views>
+concept __zip_all_bidirectional = (bidirectional_range<__maybe_const<_Const, _Views>> && ...);
+
+template <bool _Const, class... _Views>
+concept __zip_all_forward = (forward_range<__maybe_const<_Const, _Views>> && ...);
+
+template <bool _Const, class... _Views>
+consteval auto __zip_view_iterator_concept_test() {
+    if constexpr (__zip_all_random_access<_Const, _Views...>) {
+        return random_access_iterator_tag();
+    } else if constexpr (__zip_all_bidirectional<_Const, _Views...>) {
+        return bidirectional_iterator_tag();
+    } else if constexpr (__zip_all_forward<_Const, _Views...>) {
+        return forward_iterator_tag();
+    } else {
+        return input_iterator_tag();
+    }
+}
+
+template <bool _Const, class... _Views>
+struct __zip_view_iterator_category_base {};
+
+template <bool _Const, class... _Views>
+requires __zip_all_forward<_Const, _Views...> //
+    struct __zip_view_iterator_category_base<_Const, _Views...> {
+    using iterator_category = input_iterator_tag;
+};
+
+template <input_range... _Views>
+    requires(view<_Views>&&...) && (sizeof...(_Views) > 0) //
+template <bool _Const>
+class zip_view<_Views...>::__iterator
+    : public __zip_view_iterator_category_base<_Const, _Views...> {
+
+    __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current_;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __iterator(
+        __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
+        : __current_(std::move(__current)) {}
+
+    template <bool>
+    friend class zip_view<_Views...>::__iterator;
+
+    template <bool>
+    friend class zip_view<_Views...>::__sentinel;
+
+    friend class zip_view<_Views...>;
+
+  public:
+    using iterator_concept = decltype(__zip_view_iterator_concept_test<_Const, _Views...>());
+    using value_type = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
+    using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
+
+    _LIBCPP_HIDE_FROM_ABI
+    __iterator() = default;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator(__iterator<!_Const> __i) requires _Const &&
+        (convertible_to<iterator_t<_Views>, iterator_t<__maybe_const<_Const, _Views>>> && ...)
+        : __current_(std::move(__i.__current_)) {}
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator*() const {
+        return __tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator++() {
+        __tuple_for_each([](auto& __i) { ++__i; }, __current_);
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr void operator++(int) {
+        ++*this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator operator++(int) requires __zip_all_forward<_Const, _Views...> {
+        auto __tmp = *this;
+        ++*this;
+        return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator--() requires __zip_all_bidirectional<_Const, _Views...> {
+        __tuple_for_each([](auto& __i) { --__i; }, __current_);
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator operator--(int) requires __zip_all_bidirectional<_Const, _Views...> {
+        auto __tmp = *this;
+        --*this;
+        return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator+=(difference_type __x) requires
+        __zip_all_random_access<_Const, _Views...> {
+        __tuple_for_each([&]<class _Idx>(_Idx& __i) { __i += iter_difference_t<_Idx>(__x); }, __current_);
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr __iterator& operator-=(difference_type __x) requires
+        __zip_all_random_access<_Const, _Views...> {
+        __tuple_for_each([&]<class _Idx>(_Idx& __i) { __i -= iter_difference_t<_Idx>(__x); }, __current_);
+        return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr auto operator[](difference_type __n) const requires
+        __zip_all_random_access<_Const, _Views...> {
+        return __tuple_transform(
+            [&]<class _Idx>(_Idx& __i) -> decltype(auto) { return __i[iter_difference_t<_Idx>(__n)]; },
+            __current_);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+        requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>>&&...) {
+        if constexpr (__zip_all_bidirectional<_Const, _Views...>) {
+            return __x.__current_ == __y.__current_;
+        } else {
+            const auto __it_equals =
+                __tuple_zip_transform(std::equal_to<>(), __x.__current_, __y.__current_);
+            return apply([](auto... bs) { return (bs || ...); }, __it_equals);
+        }
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator<(const __iterator& __x, const __iterator& __y) requires
+        __zip_all_random_access<_Const, _Views...> {
+        return __x.__current_ < __y.__current_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator>(const __iterator& __x, const __iterator& __y) requires
+        __zip_all_random_access<_Const, _Views...> {
+        return __y < __x;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y) requires
+        __zip_all_random_access<_Const, _Views...> {
+        return !(__y < __x);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y) requires
+        __zip_all_random_access<_Const, _Views...> {
+        return !(__x < __y);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y) requires
+        __zip_all_random_access<_Const, _Views...> &&
+        (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+        // clang-format off
+        return __x.__current_ <=> __y.__current_;
+        // clang-format on
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr __iterator operator+(const __iterator& __i, difference_type __n) requires
+        __zip_all_random_access<_Const, _Views...> {
+        auto __r = __i;
+        __r += __n;
+        return __r;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr __iterator operator+(difference_type __n, const __iterator& __i) requires
+        __zip_all_random_access<_Const, _Views...> {
+        auto __r = __i;
+        __r += __n;
+        return __r;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr __iterator operator-(const __iterator& __i, difference_type __n) requires
+        __zip_all_random_access<_Const, _Views...> {
+        auto __r = __i;
+        __r -= __n;
+        return __r;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+        requires(sized_sentinel_for<iterator_t<__maybe_const<_Const, _Views>>,
+                                    iterator_t<__maybe_const<_Const, _Views>>>&&...) {
+        const auto __diffs = __tuple_zip_transform(std::minus<>(), __x.__current_, __y.__current_);
+        return apply(
+            [](auto... ds) {
+                return (std::min)({difference_type(ds)...},
+                           [](auto x, auto y) { return __abs(x) < __abs(y); });
+            },
+            __diffs);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr auto iter_move(const __iterator& __i) noexcept(
+        (noexcept(ranges::iter_move(declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) &&
+         ...) &&
+        (is_nothrow_move_constructible_v<range_rvalue_reference_t<__maybe_const<_Const, _Views>>> &&
+         ...)) {
+        return __tuple_transform(ranges::iter_move, __i.__current_);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI
+    friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
+        (noexcept(ranges::iter_swap(declval<const iterator_t<__maybe_const<_Const, _Views>>&>(),
+                                    declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) &&
+         ...)) requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>>&&...) {
+        __tuple_zip_for_each(ranges::iter_swap, __l.__current_, __r.__current_);
+    }
+};
+
+template <input_range... _Views>
+    requires(view<_Views>&&...) && (sizeof...(_Views) > 0) //
+template <bool _Const>
+class zip_view<_Views...>::__sentinel {
+
+    __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end_;
+
+    _LIBCPP_HIDE_FROM_ABI
+    constexpr explicit __sentinel(
+        __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end)
+        : __end_(__end) {}
+
+    friend class zip_view<_Views...>;
+
+    // hidden friend cannot access private member of iterator because
+    // they are friends of friends
+    template <bool _OtherConst>
+    _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __iter_current(
+        zip_view<_Views...>::__iterator<_OtherConst> const& __it) {
+        return __it.__current_;
+    }
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI
+    __sentinel() = default;
+    constexpr __sentinel(__sentinel<!_Const> __i) requires _Const &&
+        (convertible_to<sentinel_t<_Views>, sentinel_t<__maybe_const<_Const, _Views>>> && ...)
+        : __end_(std::move(__i.__end_)) {}
+
+    template <bool _OtherConst>
+    requires(sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>,
+                          iterator_t<__maybe_const<_OtherConst, _Views>>>&&...)
+        _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+        operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+        const auto __it_equals =
+            __tuple_zip_transform(std::equal_to<>(), __iter_current(__x), __y.__end_);
+        return apply([](auto... bs) { return (bs || ...); }, __it_equals);
+    }
+
+    template <bool _OtherConst>
+    requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>,
+                                iterator_t<__maybe_const<_OtherConst, _Views>>>&&...)
+        _LIBCPP_HIDE_FROM_ABI
+        friend constexpr common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>
+        operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+        const auto __diffs = __tuple_zip_transform(std::minus<>(), __iter_current(__x), __y.__end_);
+        return apply(
+            [](auto... ds) {
+                using Diff = common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>;
+                return (std::min)({Diff(ds)...}, [](auto x, auto y) { return __abs(x) < __abs(y); });
+            },
+            __diffs);
+    }
+
+    template <bool _OtherConst>
+    requires(sized_sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>,
+                                iterator_t<__maybe_const<_OtherConst, _Views>>>&&...)
+        _LIBCPP_HIDE_FROM_ABI
+        friend constexpr common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>
+        operator-(const __sentinel& __y, const __iterator<_OtherConst>& __x) {
+        return -(__x - __y);
+    }
+};
+
+
+template<class... _Views>
+inline constexpr bool enable_borrowed_range<zip_view<_Views...>> =
+      (enable_borrowed_range<_Views> && ...);
+
+namespace views {
+namespace __zip {
+
+struct __fn {
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()() const noexcept {
+        return empty_view<tuple<>>{};
+    }
+
+    template <class... _Ranges>
+    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... rs) const
+        noexcept(noexcept(zip_view(std::forward<_Ranges>(rs)...)))
+            -> decltype(zip_view(std::forward<_Ranges>(rs)...)) {
+        return zip_view(std::forward<_Ranges>(rs)...);
+    }
+};
+
+} // namespace __zip
+
+inline namespace __cpo {
+inline constexpr auto zip = __zip::__fn{};
+} // namespace __cpo
+
+} // namespace views
+
+} // namespace ranges
+
+
+
+#endif // _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_ZIP_VIEW_H
 No newline at end of file

libcxx/include/module.modulemap

module __ranges {
       module take_view              { private header "__ranges/take_view.h" }
       module transform_view         {
         private header "__ranges/transform_view.h"
         export functional.__functional.bind_back
         export functional.__functional.perfect_forward
       }
       module view_interface         { private header "__ranges/view_interface.h" }
       module views                  { private header "__ranges/views.h" }
+      module zip_view               { private header "__ranges/zip_view.h" }
     }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
     header "regex"

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.zip], zip view
+  template<input_range... Views>
+    requires (view<Views> && ...) && (sizeof...(Views) > 0)
+  class zip_view;
+
+  template<class... Views>
+    inline constexpr bool enable_borrowed_range<zip_view<Views...>> =
+      (enable_borrowed_range<Views> && ...);
+
+  namespace views { inline constexpr unspecified zip = unspecified; }
 }
 
 namespace std {
   namespace views = ranges::views;
 
   template<class T> struct tuple_size;
   template<size_t I, class T> struct tuple_element;
 

 #include <__ranges/reverse_view.h>
 #include <__ranges/single_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/take_view.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/views.h>
+#include <__ranges/zip_view.h>
 #include <__tuple> // TODO: <ranges> has to export std::tuple_size. Replace this, once <tuple> is granularized.
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #endif // _LIBCPP_RANGES

libcxx/test/libcxx/diagnostics/detail.headers/ranges/zip_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/zip_view.h'}}
+#include <__ranges/zip_view.h>

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto begin() requires (!(simple-view<Views> && ...));
+// constexpr auto begin() const requires (range<const Views> && ...);
+
+#include <ranges>
+
+#include <cassert>
+#include <concepts>
+#include <utility>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+#include "types.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  {
+    std::ranges::zip_view v(SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.));
+    auto it = v.begin();
+    assert(*it == std::make_tuple(1, 0, 2.0));
+    assert(&(std::get<0>(*it)) == &buffer[0]);
+    ASSERT_SAME_TYPE(decltype(*it), std::tuple<int&, int, double&>);
+  }
+  {
+    std::ranges::zip_view v(SizedRandomAccessView{buffer}, std::ranges::empty_view<int>());
+    assert(v.begin() == v.end());
+  }
+  {
+    std::ranges::zip_view v(SimpleCommon{buffer}, SimpleCommon{buffer});
+    ASSERT_SAME_TYPE(decltype(v.begin()), decltype(std::as_const(v).begin()));
+  }
+  {
+    std::ranges::zip_view v(SimpleCommon{buffer}, NonSimpleNonCommon{buffer});
+    static_assert(!std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}

libcxx/test/std/ranges/range.adaptors/range.zip/borrowing.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<class... Views>
+// inline constexpr bool enable_borrowed_range<zip_view<Views...>> =
+//      (enable_borrowed_range<Views> && ...);
+
+#include <ranges>
+
+struct Borrowed : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+template <>
+inline constexpr bool std::ranges::enable_borrowed_range<Borrowed> = true;
+
+static_assert(std::ranges::borrowed_range<Borrowed>);
+
+struct NonBorrowed : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+static_assert(!std::ranges::borrowed_range<NonBorrowed>);
+
+void testBorrowedRange() {
+  static_assert(std::ranges::borrowed_range<std::ranges::zip_view<Borrowed>>);
+  static_assert(std::ranges::borrowed_range<std::ranges::zip_view<Borrowed, Borrowed>>);
+  static_assert(!std::ranges::borrowed_range<std::ranges::zip_view<Borrowed, NonBorrowed>>);
+  static_assert(!std::ranges::borrowed_range<std::ranges::zip_view<NonBorrowed>>);
+  static_assert(!std::ranges::borrowed_range<std::ranges::zip_view<NonBorrowed, NonBorrowed>>);
+}

libcxx/test/std/ranges/range.adaptors/range.zip/cpo.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// std::views::zip
+
+#include <ranges>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    auto v = std::views::zip();
+    assert(std::ranges::empty(v));
+    // a bit weird. non 0-arity zipped range's reference is a prvalue tuple
+    ASSERT_SAME_TYPE(std::ranges::range_reference_t<decltype(v)>, std::tuple<>&);
+    ASSERT_SAME_TYPE(decltype(v), std::ranges::empty_view<std::tuple<>>);
+  }
+  {
+    int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto v = std::views::zip(SizedRandomAccessView{buffer});
+    assert(std::ranges::size(v) == 8);
+    ASSERT_SAME_TYPE(std::ranges::range_reference_t<decltype(v)>, std::tuple<int&>);
+    ASSERT_SAME_TYPE(decltype(v), std::ranges::zip_view<SizedRandomAccessView>);
+  }
+  {
+    std::array a{1, 2, 3};
+    auto v = std::views::zip(a);
+    assert(&(std::get<0>(*v.begin())) == &(a[0]));
+    ASSERT_SAME_TYPE(std::ranges::range_reference_t<decltype(v)>, std::tuple<int&>);
+    ASSERT_SAME_TYPE(decltype(v), std::ranges::zip_view<std::ranges::ref_view<std::array<int, 3>>>);
+  }
+  {
+    static_assert(std::is_invocable_v<decltype(std::views::zip)>);
+    static_assert(!std::is_invocable_v<decltype(std::views::zip), int>);
+    static_assert(std::is_invocable_v<decltype(std::views::zip), SizedRandomAccessView>);
+    static_assert(
+        std::is_invocable_v<decltype(std::views::zip), SizedRandomAccessView, std::ranges::iota_view<int, int>>);
+    static_assert(!std::is_invocable_v<decltype(std::views::zip), SizedRandomAccessView, int>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <class... Rs>
+// zip_view(Rs&&...) -> zip_view<views::all_t<Rs>...>;
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <utility>
+
+struct Container {
+  int* begin() const;
+  int* end() const;
+};
+
+struct View : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+void testCTAD() {
+  static_assert(std::same_as<decltype(std::ranges::zip_view(Container{})),
+                             std::ranges::zip_view<std::ranges::owning_view<Container>>>);
+
+  static_assert(std::same_as<decltype(std::ranges::zip_view(Container{}, View{})),
+                             std::ranges::zip_view<std::ranges::owning_view<Container>, View>>);
+
+  Container c{};
+  static_assert(
+      std::same_as<decltype(std::ranges::zip_view(Container{}, View{}, c)),
+                   std::ranges::zip_view<std::ranges::owning_view<Container>, View, std::ranges::ref_view<Container>>>);
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// zip_view() = default;
+
+#include <ranges>
+
+#include <cassert>
+#include <type_traits>
+
+constexpr int buff[] = {1, 2, 3};
+
+struct DefaultConstructibleView : std::ranges::view_base {
+  constexpr DefaultConstructibleView() : begin_(buff), end_(buff + 3) {}
+  constexpr int const* begin() const { return begin_; }
+  constexpr int const* end() const { return end_; }
+
+private:
+  int const* begin_;
+  int const* end_;
+};
+
+struct NoDefaultView : std::ranges::view_base {
+  NoDefaultView() = delete;
+  int* begin() const;
+  int* end() const;
+};
+
+constexpr bool test() {
+  {
+    std::ranges::zip_view<DefaultConstructibleView, DefaultConstructibleView> v;
+    assert(v.size() == 3);
+    auto it = v.begin();
+    using Pair = std::pair<const int&, const int&>;
+    assert(*it++ == Pair(buff[0], buff[0]));
+    assert(*it++ == Pair(buff[1], buff[1]));
+    assert(*it == Pair(buff[2], buff[2]));
+    static_assert(std::is_default_constructible_v<decltype(v)>);
+  }
+  {
+    std::ranges::zip_view<DefaultConstructibleView, DefaultConstructibleView> v{};
+    assert(v.size() == 3);
+  }
+  {
+    using View = std::ranges::zip_view<DefaultConstructibleView, DefaultConstructibleView>;
+    View v = View();
+    assert(v.size() == 3);
+  }
+  static_assert(!std::is_default_constructible_v< std::ranges::zip_view<DefaultConstructibleView, NoDefaultView>>);
+
+  static_assert(!std::is_default_constructible_v<std::ranges::zip_view<NoDefaultView>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/ctor.views.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr explicit zip_view(Views...)
+
+#include <ranges>
+
+#include "types.h"
+
+constexpr bool test() {
+
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  {
+    std::ranges::zip_view v(SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.));
+    auto [i, j, k] = *v.begin();
+    assert(i == 1);
+    assert(j == 0);
+    assert(k == 2.0);
+  }
+
+  {
+    std::ranges::zip_view v{SizedRandomAccessView{buffer}, std::views::iota(0), std::ranges::single_view(2.)};
+    auto [i, j, k] = *v.begin();
+    assert(i == 1);
+    assert(j == 0);
+    assert(k == 2.0);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto end() requires(!(simple-view<Views> && ...))
+// constexpr auto end() const requires(range<const Views>&&...)
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "test_range.h"
+#include "types.h"
+
+constexpr bool test() {
+  int buffer1[5] = {1, 2, 3, 4, 5};
+  int buffer2[1] = {1};
+  int buffer3[3] = {1, 2, 3};
+  {
+    // underlying simple non-common non-sized (zip non-common)
+    std::ranges::zip_view v(SimpleNonCommon{buffer3}, SimpleCommon(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    assert(v.begin() + 3 == v.end());
+    static_assert(std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying simple non-common non-random_access  (zip non-common)
+    std::ranges::zip_view v(SimpleNonCommonNonRandom{buffer2}, SimpleCommon(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    assert(++v.begin() == v.end());
+    static_assert(std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying simple non-common random_access sized (zip common)
+    std::ranges::zip_view v(SimpleNonCommonSized{buffer3}, SimpleCommon(buffer1));
+    static_assert(std::ranges::common_range<decltype(v)>);
+    assert(v.begin() + 3 == v.end());
+    static_assert(std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying simple common non-random_access non-sized (zip common)
+    std::ranges::zip_view v(SimpleCommonNonRandom{buffer2}, SimpleCommon(buffer1));
+    static_assert(std::ranges::common_range<decltype(v)>);
+    assert(++v.begin() == v.end());
+    static_assert(std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying non-simple non-common non-sized (zip non-common)
+    std::ranges::zip_view v(NonSimpleNonCommon{buffer3}, SimpleCommon(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    assert(v.begin() + 3 == v.end());
+    static_assert(!std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying non-simple non-common non-random_access  (zip non-common)
+    std::ranges::zip_view v(NonSimpleNonCommonNonRandom{buffer2}, SimpleCommon(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    assert(++v.begin() == v.end());
+    static_assert(!std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying non-simple non-common random_access sized (zip common)
+    std::ranges::zip_view v(NonSimpleNonCommonSized{buffer3}, SimpleCommon(buffer1));
+    static_assert(std::ranges::common_range<decltype(v)>);
+    assert(v.begin() + 3 == v.end());
+    static_assert(!std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // underlying non-simple ommon non-crandom_access non-sized (zip common)
+    std::ranges::zip_view v(NonSimpleCommonNonRandom{buffer2}, SimpleCommon(buffer1));
+    static_assert(std::ranges::common_range<decltype(v)>);
+    assert(++v.begin() == v.end());
+    static_assert(!std::same_as<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+  }
+  {
+    // end should go to the minimum length
+    std::ranges::zip_view v(std::views::iota(0, 4), std::views::iota(0, 8));
+    auto it = --(v.end());
+    auto [x, y] = *it;
+    assert(x == 3);
+    assert(y == 3);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Some basic examples of how zip_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <ranges>
+
+#include <array>
+#include <vector>
+#include <string>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+int main(int, char**) {
+  {
+    std::ranges::zip_view v{
+        std::array{1, 2},
+        std::vector{4, 5, 6},
+        std::array{7},
+    };
+    assert(std::ranges::size(v) == 1);
+    assert(*v.begin() == std::make_tuple(1, 4, 7));
+  }
+  {
+    using namespace std::string_literals;
+    std::vector v{1, 2, 3, 4};
+    std::array a{"abc"s, "def"s, "gh"s};
+    auto view = std::views::zip(v, a);
+    auto it = view.begin();
+    assert(&(std::get<0>(*it)) == &(v[0]));
+    assert(&(std::get<1>(*it)) == &(a[0]));
+
+    ++it;
+    assert(&(std::get<0>(*it)) == &(v[1]));
+    assert(&(std::get<1>(*it)) == &(a[1]));
+
+    ++it;
+    assert(&(std::get<0>(*it)) == &(v[2]));
+    assert(&(std::get<1>(*it)) == &(a[2]));
+
+    ++it;
+    assert(it == view.end());
+  }
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/arithmetic.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// x += n;
+// x + n;
+// x -= n;
+// x - n;
+// x - y;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+
+  std::array a{1, 2, 3, 4, 5, 6, 7, 8, 9};
+  std::array b{4.1, 3.2, 4.3, 0.1, 0.2};
+  {
+    std::ranges::zip_view v(a, b);
+    auto it1 = v.begin();
+
+    auto it2 = it1 + 3;
+    auto [x2, y2] = *it2;
+    assert(&x2 == &(a[3]));
+    assert(&y2 == &(b[3]));
+
+    it1 += 3;
+    assert(it1 == it2);
+    auto [x1, y1] = *it2;
+    assert(&x1 == &(a[3]));
+    assert(&y1 == &(b[3]));
+  }
+  {
+    std::ranges::zip_view v(a, b);
+    auto it1 = v.end();
+
+    auto it2 = it1 - 3;
+    auto [x2, y2] = *it2;
+    assert(&x2 == &(a[2]));
+    assert(&y2 == &(b[2]));
+
+    it1 -= 3;
+    assert(it1 == it2);
+    auto [x1, y1] = *it2;
+    assert(&x1 == &(a[2]));
+    assert(&y1 == &(b[2]));
+  }
+  {
+    std::ranges::zip_view v(a, b);
+    assert((v.end() - v.begin()) == 5);
+
+    auto it1 = v.begin() + 2;
+    auto it2 = v.end() - 1;
+    assert((it1 - it2) == -2);
+  }
+  {
+    // in this case sentinel is computed by getting each underlying sentinel, so the distance
+    // between begin and end for each underlying iterators can be different
+    int buffer1[5] = {1, 2, 3, 4, 5};
+    int buffer2[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    std::ranges::zip_view v{ForwardSizedView(buffer1), ForwardSizedView(buffer2)};
+    using View = decltype(v);
+    static_assert(std::ranges::common_range<View>);
+    static_assert(!std::ranges::random_access_range<View>);
+
+    auto it1 = v.begin();
+    auto it2 = v.end();
+    // it1 : <buffer1 + 0, buffer2 + 0>
+    // it2 : <buffer1 + 5, buffer2 + 9>
+    assert((it1 - it2) == -5);
+    assert((it2 - it1) == 5);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/compare.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// zip_view::<iterator>::operator{<,>,<=,>=,==,!=,<=>}
+
+#include <ranges>
+#include <compare>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../types.h"
+
+struct ForwardCommonView : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  using iterator = forward_iterator<int*>;
+
+  constexpr iterator begin() const { return iterator(buffer_); }
+  constexpr iterator end() const { return iterator(buffer_ + size_); }
+};
+
+constexpr bool test() {
+  {
+    // Test a new-school iterator with operator<=>; the  iterator should also have operator<=>.
+    using It = three_way_contiguous_iterator<int*>;
+    using SubRange = std::ranges::subrange<It>;
+    static_assert(std::three_way_comparable<It>);
+    using R = std::ranges::zip_view<SubRange, SubRange>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    int a[] = {1, 2, 3, 4};
+    int b[] = {5, 6, 7, 8, 9};
+    auto r = std::views::zip(SubRange(It(a), It(a + 4)), SubRange(It(b), It(b + 5)));
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    assert(!(iter1 < iter1));
+    assert(iter1 < iter2);
+    assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);
+    assert(iter1 <= iter2);
+    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));
+    assert(!(iter1 > iter2));
+    assert(iter2 > iter1);
+    assert(iter1 >= iter1);
+    assert(!(iter1 >= iter2));
+    assert(iter2 >= iter1);
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+    assert(!(iter1 != iter1));
+    assert(iter1 != iter2);
+    assert(!(iter2 != iter2));
+
+    // clang-format off
+        assert((iter1 <=> iter2) == std::strong_ordering::less);
+        assert((iter1 <=> iter1) == std::strong_ordering::equal);
+        assert((iter2 <=> iter1) == std::strong_ordering::greater);
+    // clang-format on
+  }
+
+  {
+    // Test an old-school iterator with no operator<=>; the transform iterator shouldn't have
+    // operator<=> either.
+    using It = random_access_iterator<int*>;
+    using SubRange = std::ranges::subrange<It>;
+    static_assert(!std::three_way_comparable<It>);
+    using R = std::ranges::zip_view<SubRange, SubRange>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    int a[] = {1, 2, 3, 4};
+    int b[] = {5, 6, 7, 8, 9};
+    auto r = std::views::zip(SubRange(It(a), It(a + 4)), SubRange(It(b), It(b + 5)));
+    auto iter1 = r.begin();
+    auto iter2 = iter1 + 1;
+
+    assert(!(iter1 < iter1));
+    assert(iter1 < iter2);
+    assert(!(iter2 < iter1));
+    assert(iter1 <= iter1);
+    assert(iter1 <= iter2);
+    assert(!(iter2 <= iter1));
+    assert(!(iter1 > iter1));
+    assert(!(iter1 > iter2));
+    assert(iter2 > iter1);
+    assert(iter1 >= iter1);
+    assert(!(iter1 >= iter2));
+    assert(iter2 >= iter1);
+    assert(iter1 == iter1);
+    assert(!(iter1 == iter2));
+    assert(iter2 == iter2);
+    assert(!(iter1 != iter1));
+    assert(iter1 != iter2);
+    assert(!(iter2 != iter2));
+  }
+  {
+    // in this case sentinel is computed by getting each underlying sentinel, so only one
+    // underlying iterator is comparing equal
+    int buffer1[1] = {1};
+    int buffer2[2] = {1, 2};
+    std::ranges::zip_view v{ForwardCommonView(buffer1), ForwardCommonView(buffer2)};
+    using View = decltype(v);
+    static_assert(std::ranges::common_range<View>);
+    static_assert(!std::ranges::bidirectional_range<View>);
+
+    auto it1 = v.begin();
+    auto it2 = v.end();
+    assert(it1 != it2);
+
+    ++it1;
+    // it1:  <buffer1 + 1, buffer2 + 1>
+    // it2:  <buffer1 + 1, buffer2 + 2>
+    assert(it1 == it2);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// iterator() = default;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct Default : std::ranges::view_base {
+  int* begin() const;
+  int* end() const;
+};
+
+struct NonDefault : std::ranges::view_base {
+  cpp20_input_iterator<int*> begin() const;
+  sentinel_wrapper<cpp20_input_iterator<int*>> end() const;
+};
+
+template <class... Views>
+using zip_iter = std::ranges::iterator_t<std::ranges::zip_view<Views...>>;
+
+constexpr bool test() {
+  {
+    using It = zip_iter<NonDefault>;
+    static_assert(!std::default_initializable<It>);
+  }
+  {
+    using It = zip_iter<NonDefault, Default>;
+    static_assert(!std::default_initializable<It>);
+  }
+
+  {
+    using It = zip_iter<Default>;
+    [[maybe_unused]] It it;
+    static_assert(std::default_initializable<It>);
+  }
+  {
+    using It = zip_iter<Default, Default>;
+    [[maybe_unused]] It it;
+    static_assert(std::default_initializable<It>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/ctor.other.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator(iterator<!Const> i);
+
+#include <ranges>
+
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buffer[3] = {1, 2, 3};
+
+  std::ranges::zip_view v(NonSimpleCommon{buffer});
+  auto iter1 = v.begin();
+  std::ranges::iterator_t<const decltype(v)> iter2 = iter1;
+  assert(iter1 == iter2);
+
+  static_assert(!std::same_as<decltype(iter1), decltype(iter2)>);
+
+  // We cannot create a non-const iterator from a const iterator.
+  static_assert(!std::constructible_from<decltype(iter1), decltype(iter2)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/decrement.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator--();
+// constexpr iterator operator--(int);
+
+#include <cassert>
+#include <ranges>
+#include <array>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template <class Iter>
+concept canDecrement = requires(Iter it) { --it; };
+
+struct NonBidi : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  using iterator = forward_iterator<int*>;
+  constexpr iterator begin() const { return iterator(buffer_); }
+  constexpr sentinel_wrapper<iterator> end() const { return sentinel_wrapper<iterator>(iterator(buffer_ + size_)); }
+};
+
+constexpr bool test() {
+  std::array a{1, 2, 3, 4};
+  std::array b{4.1, 3.2, 4.3};
+  {
+    // all forward
+    std::ranges::zip_view v(a, b, std::views::iota(0, 5));
+    auto it = v.end();
+    using Iter = decltype(it);
+
+    ASSERT_SAME_TYPE(decltype(--it), Iter&);
+    auto& it_ref = --it;
+    assert(&it_ref == &it);
+
+    assert(&(std::get<0>(*it)) == &(a[2]));
+    assert(&(std::get<1>(*it)) == &(b[2]));
+    assert(std::get<2>(*it) == 2);
+
+    ASSERT_SAME_TYPE(decltype(it--), Iter);
+    it--;
+    assert(&(std::get<0>(*it)) == &(a[1]));
+    assert(&(std::get<1>(*it)) == &(b[1]));
+    assert(std::get<2>(*it) == 1);
+  }
+  {
+    int buffer[3] = {4, 5, 6};
+    std::ranges::zip_view v(a, NonBidi{buffer});
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+    static_assert(!canDecrement<Iter>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/deref.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto operator*() const;
+
+#include <cassert>
+#include <ranges>
+#include <array>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::array a{1, 2, 3, 4};
+  std::array b{4.1, 3.2, 4.3};
+  {
+    std::ranges::zip_view v(a);
+    auto it = v.begin();
+    assert(&(std::get<0>(*it)) == &(a[0]));
+    ASSERT_SAME_TYPE(decltype(*it), std::tuple<int&>);
+  }
+  {
+    std::ranges::zip_view v(a, b);
+    auto it = v.begin();
+    auto [x, y] = *it;
+    assert(&x == &(a[0]));
+    assert(&y == &(b[0]));
+    ASSERT_SAME_TYPE(decltype(*it), std::pair<int&, double&>);
+
+    x = 5;
+    y = 0.1;
+    assert(a[0] == 5);
+    assert(b[0] == 0.1);
+  }
+  {
+    std::ranges::zip_view v(a, b, std::views::iota(0, 5));
+    auto it = v.begin();
+    assert(&(std::get<0>(*it)) == &(a[0]));
+    assert(&(std::get<1>(*it)) == &(b[0]));
+    assert(std::get<2>(*it) == 0);
+    ASSERT_SAME_TYPE(decltype(*it), std::tuple<int&, double&, int>);
+  }
+  {
+    std::ranges::zip_view v(a, std::as_const(a));
+    auto it = v.begin();
+    assert(&(std::get<0>(*it)) == &(a[0]));
+    assert(&(std::get<1>(*it)) == &(a[0]));
+    ASSERT_SAME_TYPE(decltype(*it), std::pair<int&, int const&>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr iterator& operator++();
+// constexpr void operator++(int);
+// constexpr iterator operator++(int) requires all_forward<Const, Views...>;
+
+#include <cassert>
+#include <ranges>
+#include <array>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct InputRange : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  using iterator = cpp20_input_iterator<int*>;
+  constexpr iterator begin() const { return iterator(buffer_); }
+  constexpr sentinel_wrapper<iterator> end() const { return sentinel_wrapper<iterator>(iterator(buffer_ + size_)); }
+};
+
+constexpr bool test() {
+  std::array a{1, 2, 3, 4};
+  std::array b{4.1, 3.2, 4.3};
+  {
+    // all forward
+    std::ranges::zip_view v(a, b, std::views::iota(0, 5));
+    auto it = v.begin();
+    using Iter = decltype(it);
+
+    assert(&(std::get<0>(*it)) == &(a[0]));
+    assert(&(std::get<1>(*it)) == &(b[0]));
+    assert(std::get<2>(*it) == 0);
+
+    ASSERT_SAME_TYPE(decltype(++it), Iter&);
+
+    auto& it_ref = ++it;
+    assert(&it_ref == &it);
+
+    assert(&(std::get<0>(*it)) == &(a[1]));
+    assert(&(std::get<1>(*it)) == &(b[1]));
+    assert(std::get<2>(*it) == 1);
+
+    ASSERT_SAME_TYPE(decltype(it++), Iter);
+    it++;
+    assert(&(std::get<0>(*it)) == &(a[2]));
+    assert(&(std::get<1>(*it)) == &(b[2]));
+    assert(std::get<2>(*it) == 2);
+  }
+  {
+    int buffer[3] = {4, 5, 6};
+    std::ranges::zip_view v(a, InputRange{buffer});
+    auto it = v.begin();
+    using Iter = decltype(it);
+
+    assert(&(std::get<0>(*it)) == &(a[0]));
+    assert(&(std::get<1>(*it)) == &(buffer[0]));
+
+    ASSERT_SAME_TYPE(decltype(++it), Iter&);
+    ++it;
+    assert(&(std::get<0>(*it)) == &(a[1]));
+    assert(&(std::get<1>(*it)) == &(buffer[1]));
+
+    ASSERT_SAME_TYPE(decltype(it++), void);
+    it++;
+    assert(&(std::get<0>(*it)) == &(a[2]));
+    assert(&(std::get<1>(*it)) == &(buffer[2]));
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_move.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr decltype(auto) iter_move(const iterator& i);
+
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct ThrowingMove {
+  ThrowingMove() = default;
+  ThrowingMove(ThrowingMove&&){};
+};
+
+constexpr bool test() {
+  {
+    std::array a1{1, 2, 3, 4};
+    const std::array a2{3.0, 4.0};
+
+    std::ranges::zip_view v(a1, a2, std::views::iota(3L));
+    assert(std::ranges::iter_move(v.begin()) == std::make_tuple(1, 3.0, 3L));
+    ASSERT_SAME_TYPE(decltype(std::ranges::iter_move(v.begin())), std::tuple<int&&, const double&&, long>);
+
+    static_assert(noexcept(std::ranges::iter_move(std::declval<decltype(v.begin())>())));
+  }
+  {
+    auto throwingMoveRange =
+        std::views::iota(0, 2) | std::views::transform([](auto) noexcept { return ThrowingMove{}; });
+    std::ranges::zip_view v(throwingMoveRange);
+    static_assert(!noexcept(std::ranges::iter_move(std::declval<decltype(v.begin())>())));
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/iter_swap.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// friend constexpr void iter_swap(const iterator& x, const iterator& y);
+
+#include <cassert>
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::array a1{1, 2, 3, 4};
+  std::array a2{0.1, 0.2, 0.3};
+  std::ranges::zip_view v(a1, a2);
+  auto iter1 = v.begin();
+  auto iter2 = std::next(v.begin());
+
+  std::ranges::iter_swap(iter1, iter2);
+
+  assert(a1[0] == 2);
+  assert(a1[1] == 1);
+  assert(a2[0] == 0.2);
+  assert(a2[1] == 0.1);
+
+  auto [x1, y1] = *iter1;
+  assert(&x1 == &a1[0]);
+  assert(&y1 == &a2[0]);
+
+  auto [x2, y2] = *iter2;
+  assert(&x2 == &a1[1]);
+  assert(&y2 == &a2[1]);
+
+  static_assert(noexcept(std::ranges::iter_swap(iter1, iter2)));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/member_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, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Iterator traits and member typedefs in zip_view::<iterator>.
+
+#include <ranges>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+#include "../types.h"
+
+template <class T>
+struct ForwardView : std::ranges::view_base {
+  forward_iterator<T*> begin() const;
+  sentinel_wrapper<forward_iterator<T*>> end() const;
+};
+
+template <class T>
+struct InputView : std::ranges::view_base {
+  cpp17_input_iterator<T*> begin() const;
+  sentinel_wrapper<cpp17_input_iterator<T*>> end() const;
+};
+
+template <class T>
+concept HasIterCategory = requires { typename T::iterator_category; };
+
+void test() {
+  {
+    int buffer[4];
+    std::ranges::zip_view v(buffer, buffer);
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+
+    ASSERT_SAME_TYPE(Iter::iterator_concept, std::random_access_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::iterator_category, std::input_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(Iter::value_type, std::pair<int, int>);
+  }
+  {
+    int buffer[4];
+    std::ranges::zip_view v(buffer, buffer, buffer);
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+
+    ASSERT_SAME_TYPE(Iter::iterator_concept, std::random_access_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::iterator_category, std::input_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(Iter::value_type, std::tuple<int, int, int>);
+  }
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::zip_view<ForwardView<int>>>;
+
+    ASSERT_SAME_TYPE(Iter::iterator_concept, std::forward_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::iterator_category, std::input_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(Iter::value_type, std::tuple<int>);
+  }
+  {
+    int buffer[4];
+    std::ranges::zip_view v(buffer, buffer);
+    std::ranges::zip_view v2(buffer, v);
+    using Iter = std::ranges::iterator_t<decltype(v2)>;
+
+    ASSERT_SAME_TYPE(Iter::iterator_concept, std::random_access_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::iterator_category, std::input_iterator_tag);
+    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(Iter::value_type, std::pair<int, std::pair<int, int>>);
+  }
+  {
+    using Iter = std::ranges::iterator_t<std::ranges::zip_view<InputView<int>>>;
+
+    ASSERT_SAME_TYPE(Iter::iterator_concept, std::input_iterator_tag);
+    static_assert(!HasIterCategory<Iter>);
+    ASSERT_SAME_TYPE(Iter::difference_type, std::ptrdiff_t);
+    ASSERT_SAME_TYPE(Iter::value_type, std::tuple<int>);
+  }
+}

libcxx/test/std/ranges/range.adaptors/range.zip/iterator/subscript.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto operator[](difference_type __n) const requires
+//        all_random_access<_Const, _Views...>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  std::ranges::zip_view v(SizedRandomAccessView{buffer}, std::views::iota(0));
+  auto it = v.begin();
+  assert(it[0] == *it);
+  assert(it[2] == *(it + 2));
+  assert(it[4] == *(it + 4));
+
+  ASSERT_SAME_TYPE(decltype(it[2]), std::pair<int&, int>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/ctor.default.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// sentinel() = default;
+
+#include <cassert>
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  using R = std::ranges::zip_view<NonSimpleNonCommon>;
+  using Sentinel = std::ranges::sentinel_t<R>;
+  [[maybe_unused]] Sentinel st1;
+  [[maybe_unused]] Sentinel st2 = {};
+
+  static_assert(!std::same_as<Sentinel, std::ranges::iterator_t<R>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/ctor.other.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr sentinel(sentinel<!Const> s);
+
+#include <cassert>
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template <class T>
+struct convertible_sentinel_wrapper {
+  explicit convertible_sentinel_wrapper() = default;
+  constexpr convertible_sentinel_wrapper(const T& it) : it_(it) {}
+
+  template <class U>
+    requires std::convertible_to<const U&, T>
+  constexpr convertible_sentinel_wrapper(const convertible_sentinel_wrapper<U>& other) : it_(other.it_) {}
+
+  constexpr friend bool operator==(convertible_sentinel_wrapper const& self, const T& other) {
+    return self.it_ == other;
+  }
+  T it_;
+};
+
+struct NonSimpleNonCommonConveritbleView : std::ranges::view_base {
+  int* buffer_;
+  std::size_t size_;
+
+  template <std::size_t N>
+  constexpr NonSimpleNonCommonConveritbleView(int (&b)[N]) : buffer_(b), size_(N) {}
+
+  constexpr int* begin() { return buffer_; }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr convertible_sentinel_wrapper<int*> end() { return convertible_sentinel_wrapper<int*>(buffer_ + size_); }
+  constexpr convertible_sentinel_wrapper<const int*> end() const {
+    return convertible_sentinel_wrapper<const int*>(buffer_ + size_);
+  }
+};
+
+static_assert(!std::ranges::common_range<NonSimpleNonCommonConveritbleView>);
+static_assert(std::ranges::random_access_range<NonSimpleNonCommonConveritbleView>);
+static_assert(!std::ranges::sized_range<NonSimpleNonCommonConveritbleView>);
+static_assert(std::convertible_to<std::ranges::sentinel_t<NonSimpleNonCommonConveritbleView>,
+                                  std::ranges::sentinel_t<NonSimpleNonCommonConveritbleView const>>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommonConveritbleView>);
+
+constexpr bool test() {
+  int buffer1[4] = {1, 2, 3, 4};
+  int buffer2[5] = {1, 2, 3, 4, 5};
+  std::ranges::zip_view v{NonSimpleNonCommonConveritbleView(buffer1), NonSimpleNonCommonConveritbleView(buffer2)};
+  static_assert(!std::ranges::common_range<decltype(v)>);
+  auto sent1 = v.end();
+  std::ranges::sentinel_t<const decltype(v)> sent2 = sent1;
+  static_assert(!std::same_as<decltype(sent1), decltype(sent2)>);
+
+  assert(v.begin() != sent2);
+  assert(std::as_const(v).begin() != sent2);
+  assert(v.begin() + 4 == sent2);
+  assert(std::as_const(v).begin() + 4 == sent2);
+
+  // We cannot create a non-const iterator from a const iterator.
+  static_assert(!std::constructible_from<decltype(sent1), decltype(sent2)>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/eq.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<bool OtherConst>
+//   requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+
+#include <cassert>
+#include <compare>
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+using Iterator = random_access_iterator<int*>;
+using ConstIterator = random_access_iterator<const int*>;
+
+template <bool Const>
+struct ComparableSentinel {
+
+  using Iter = std::conditional_t<Const, ConstIterator, Iterator>;
+  Iter iter_;
+
+  explicit ComparableSentinel() = default;
+  constexpr explicit ComparableSentinel(const Iter& it) : iter_(it) {}
+
+  constexpr friend bool operator==(const Iterator& i, const ComparableSentinel& s) { return base(i) == base(s.iter_); }
+
+  constexpr friend bool operator==(const ConstIterator& i, const ComparableSentinel& s) {
+    return base(i) == base(s.iter_);
+  }
+};
+
+struct ComparableView : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+
+  constexpr auto begin() { return Iterator(buffer_); }
+  constexpr auto begin() const { return ConstIterator(buffer_); }
+  constexpr auto end() { return ComparableSentinel<false>(Iterator(buffer_ + size_)); }
+  constexpr auto end() const { return ComparableSentinel<true>(ConstIterator(buffer_ + size_)); }
+};
+
+constexpr bool test() {
+  int buffer1[4] = {1, 2, 3, 4};
+  int buffer2[5] = {1, 2, 3, 4, 5};
+  int buffer3[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  {
+    std::ranges::zip_view v{SimpleNonCommon(buffer1), SimpleNonCommon(buffer2), SimpleNonCommon(buffer3)};
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<decltype(v)>);
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + 1 != v.end());
+    assert(v.begin() + 2 != v.end());
+    assert(v.begin() + 3 != v.end());
+    assert(v.begin() + 4 == v.end());
+
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+    using Sentinel = std::ranges::sentinel_t<decltype(v)>;
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<Iter, Sentinel>);
+  }
+  {
+    std::ranges::zip_view v{NonSimpleNonCommon(buffer1), SimpleNonCommon(buffer2), SimpleNonCommon(buffer3)};
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + 4 == v.end());
+
+    // const_iterator (const int*) converted to iterator (int*)
+    assert(v.begin() + 4 == std::as_const(v).end());
+
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+    using ConstIter = std::ranges::iterator_t<const decltype(v)>;
+    static_assert(!std::same_as<Iter, ConstIter>);
+    using Sentinel = std::ranges::sentinel_t<decltype(v)>;
+    using ConstSentinel = std::ranges::sentinel_t<const decltype(v)>;
+    static_assert(!std::same_as<Sentinel, ConstSentinel>);
+
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<Iter, Sentinel>);
+    LIBCPP_STATIC_ASSERT(!std::__weakly_equality_comparable_with<ConstIter, Sentinel>);
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<Iter, ConstSentinel>);
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<ConstIter, ConstSentinel>);
+  }
+  {
+
+    std::ranges::zip_view v{ComparableView(buffer1), ComparableView(buffer2)};
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<decltype(v)>);
+
+    assert(v.begin() != v.end());
+    assert(v.begin() + 4 == v.end());
+    assert(std::as_const(v).begin() + 4 == v.end());
+    assert(std::as_const(v).begin() + 4 == std::as_const(v).end());
+    assert(v.begin() + 4 == std::as_const(v).end());
+
+    using Iter = std::ranges::iterator_t<decltype(v)>;
+    using ConstIter = std::ranges::iterator_t<const decltype(v)>;
+    static_assert(!std::same_as<Iter, ConstIter>);
+    using Sentinel = std::ranges::sentinel_t<decltype(v)>;
+    using ConstSentinel = std::ranges::sentinel_t<const decltype(v)>;
+    static_assert(!std::same_as<Sentinel, ConstSentinel>);
+
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<Iter, Sentinel>);
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<ConstIter, Sentinel>);
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<Iter, ConstSentinel>);
+    LIBCPP_STATIC_ASSERT(std::__weakly_equality_comparable_with<ConstIter, ConstSentinel>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/sentinel/minus.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template <bool OtherConst>
+// requires(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+//                             iterator_t<maybe-const<OtherConst, Views>>>&&...)
+// friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
+//  operator-(const iterator<OtherConst>&, const sentinel&)
+//
+// template <bool OtherConst>
+// requires(sized_sentinel_for<sentinel_t<maybe-const<Const, Views>>,
+//                             iterator_t<maybe-const<OtherConst, Views>>>&&...)
+// friend constexpr common_type_t<range_difference_t<maybe-const<OtherConst, Views>>...>
+//   operator-(const sentinel&, const iterator<OtherConst>&)
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "../types.h"
+
+template <class T>
+concept SentinelMinusable = requires(T t) { t.end() - t.begin(); };
+
+constexpr bool test() {
+  int buffer1[5] = {1, 2, 3, 4, 5};
+
+  {
+    std::ranges::zip_view v{ForwardSizedNonCommon(buffer1)};
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    auto it = v.begin();
+    auto st = v.end();
+    assert(st - it == 5);
+    assert(st - std::ranges::next(it, 1) == 4);
+
+    assert(it - st == -5);
+    assert(std::ranges::next(it, 1) - st == -4);
+  }
+
+  {
+    std::ranges::zip_view v(std::views::iota(0, 3), ForwardSizedNonCommon(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    auto it = v.begin();
+    auto st = v.end();
+    assert(st - it == 3);
+    assert(st - std::ranges::next(it, 1) == 2);
+
+    assert(it - st == -3);
+    assert(std::ranges::next(it, 1) - st == -2);
+  }
+
+  {
+    std::ranges::zip_view v(std::views::iota(0), SizedRandomAccessView(buffer1));
+    static_assert(!std::ranges::common_range<decltype(v)>);
+    static_assert(!SentinelMinusable<decltype(v)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/sized.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// constexpr auto size() requires(sized_range<Views>&&...)
+// constexpr auto size() const requires(sized_range<const Views>&&...)
+
+#include <ranges>
+
+#include <cassert>
+#include <utility>
+
+#include "test_iterators.h"
+#include "test_macros.h"
+
+int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+struct View : std::ranges::view_base {
+  std::size_t size_ = 0;
+  constexpr View(std::size_t s) : size_(s) {}
+  constexpr auto begin() const { return buffer; }
+  constexpr auto end() const { return buffer + size_; }
+};
+
+struct SizedNonConst : std::ranges::view_base {
+  using iterator = forward_iterator<int*>;
+  std::size_t size_ = 0;
+  constexpr SizedNonConst(std::size_t s) : size_(s) {}
+  constexpr auto begin() const { return iterator{buffer}; }
+  constexpr auto end() const { return iterator{buffer + size_}; }
+  constexpr std::size_t size() { return size_; }
+};
+
+constexpr bool test() {
+  {
+    std::ranges::zip_view v(View(8));
+    assert(v.size() == 8);
+  }
+  {
+    std::ranges::zip_view v(View(2), View(3));
+    assert(v.size() == 2);
+  }
+  {
+    std::ranges::zip_view v(std::views::iota(0, 500), View(3));
+    assert(v.size() == 3);
+  }
+  {
+    std::ranges::zip_view v(SizedNonConst(2), View(3));
+    assert(v.size() == 2);
+    static_assert(std::ranges::sized_range<decltype(v)>);
+    static_assert(!std::ranges::sized_range<decltype(std::as_const(v))>);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.zip/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_ZIP_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ZIP_TYPES_H
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct IntBuffer {
+  int* buffer_;
+  std::size_t size_;
+
+  template <std::size_t N>
+  constexpr IntBuffer(int (&b)[N]) : buffer_(b), size_(N) {}
+};
+
+template <bool Simple>
+struct Common : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+
+  constexpr int* begin()
+    requires(!Simple)
+  {
+    return buffer_;
+  }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr int* end()
+    requires(!Simple)
+  {
+    return buffer_ + size_;
+  }
+  constexpr const int* end() const { return buffer_ + size_; }
+};
+using SimpleCommon = Common<true>;
+using NonSimpleCommon = Common<false>;
+
+static_assert(std::ranges::common_range<Common<true>>);
+static_assert(std::ranges::random_access_range<SimpleCommon>);
+static_assert(std::ranges::sized_range<SimpleCommon>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleCommon>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleCommon>);
+
+template <bool Simple>
+struct CommonNonRandom : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  using const_iterator = forward_iterator<const int*>;
+  using iterator = forward_iterator<int*>;
+  constexpr iterator begin()
+    requires(!Simple)
+  {
+    return iterator(buffer_);
+  }
+  constexpr const_iterator begin() const { return const_iterator(buffer_); }
+  constexpr iterator end()
+    requires(!Simple)
+  {
+    return iterator(buffer_ + size_);
+  }
+  constexpr const_iterator end() const { return const_iterator(buffer_ + size_); }
+};
+
+using SimpleCommonNonRandom = CommonNonRandom<true>;
+using NonSimpleCommonNonRandom = CommonNonRandom<false>;
+
+static_assert(std::ranges::common_range<SimpleCommonNonRandom>);
+static_assert(!std::ranges::random_access_range<SimpleCommonNonRandom>);
+static_assert(!std::ranges::sized_range<SimpleCommonNonRandom>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleCommonNonRandom>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleCommonNonRandom>);
+
+template <bool Simple>
+struct NonCommon : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  constexpr int* begin()
+    requires(!Simple)
+  {
+    return buffer_;
+  }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr sentinel_wrapper<int*> end()
+    requires(!Simple)
+  {
+    return sentinel_wrapper<int*>(buffer_ + size_);
+  }
+  constexpr sentinel_wrapper<const int*> end() const { return sentinel_wrapper<const int*>(buffer_ + size_); }
+};
+
+using SimpleNonCommon = NonCommon<true>;
+using NonSimpleNonCommon = NonCommon<false>;
+
+static_assert(!std::ranges::common_range<SimpleNonCommon>);
+static_assert(std::ranges::random_access_range<SimpleNonCommon>);
+static_assert(!std::ranges::sized_range<SimpleNonCommon>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleNonCommon>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommon>);
+
+template <bool Simple>
+struct NonCommonSized : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  constexpr int* begin()
+    requires(!Simple)
+  {
+    return buffer_;
+  }
+  constexpr const int* begin() const { return buffer_; }
+  constexpr sentinel_wrapper<int*> end()
+    requires(!Simple)
+  {
+    return sentinel_wrapper<int*>(buffer_ + size_);
+  }
+  constexpr sentinel_wrapper<const int*> end() const { return sentinel_wrapper<const int*>(buffer_ + size_); }
+  constexpr std::size_t size() const { return size_; }
+};
+
+using SimpleNonCommonSized = NonCommonSized<true>;
+using NonSimpleNonCommonSized = NonCommonSized<false>;
+
+static_assert(!std::ranges::common_range<SimpleNonCommonSized>);
+static_assert(std::ranges::random_access_range<SimpleNonCommonSized>);
+static_assert(std::ranges::sized_range<SimpleNonCommonSized>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleNonCommonSized>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommonSized>);
+
+template <bool Simple>
+struct NonCommonNonRandom : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+
+  using const_iterator = forward_iterator<const int*>;
+  using iterator = forward_iterator<int*>;
+
+  constexpr iterator begin()
+    requires(!Simple)
+  {
+    return iterator(buffer_);
+  }
+  constexpr const_iterator begin() const { return const_iterator(buffer_); }
+  constexpr sentinel_wrapper<iterator> end()
+    requires(!Simple)
+  {
+    return sentinel_wrapper<iterator>(iterator(buffer_ + size_));
+  }
+  constexpr sentinel_wrapper<const_iterator> end() const {
+    return sentinel_wrapper<const_iterator>(const_iterator(buffer_ + size_));
+  }
+};
+
+using SimpleNonCommonNonRandom = NonCommonNonRandom<true>;
+using NonSimpleNonCommonNonRandom = NonCommonNonRandom<false>;
+
+static_assert(!std::ranges::common_range<SimpleNonCommonNonRandom>);
+static_assert(!std::ranges::random_access_range<SimpleNonCommonNonRandom>);
+static_assert(!std::ranges::sized_range<SimpleNonCommonNonRandom>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SimpleNonCommonNonRandom>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonCommonNonRandom>);
+
+struct forward_sized_iterator {
+  int* it_ = nullptr;
+
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = int;
+  using difference_type = intptr_t;
+  using pointer = int*;
+  using reference = int&;
+
+  forward_sized_iterator() = default;
+  constexpr forward_sized_iterator(int* it) : it_(it) {}
+
+  constexpr reference operator*() const { return *it_; }
+
+  constexpr forward_sized_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr forward_sized_iterator operator++(int) { return forward_sized_iterator(it_++); }
+
+  friend constexpr bool operator==(const forward_sized_iterator&, const forward_sized_iterator&) = default;
+
+  friend constexpr difference_type operator-(const forward_sized_iterator& x, const forward_sized_iterator& y) {
+    return x.it_ - y.it_;
+  }
+};
+static_assert(std::forward_iterator<forward_sized_iterator>);
+static_assert(std::sized_sentinel_for<forward_sized_iterator, forward_sized_iterator>);
+
+struct ForwardSizedView : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  constexpr forward_sized_iterator begin() const { return buffer_; }
+  constexpr forward_sized_iterator end() const { return buffer_ + size_; }
+};
+
+static_assert(std::ranges::forward_range<ForwardSizedView>);
+static_assert(std::ranges::sized_range<ForwardSizedView>);
+static_assert(std::ranges::common_range<ForwardSizedView>);
+static_assert(!std::ranges::random_access_range<ForwardSizedView>);
+
+struct ForwardSizedNonCommon : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  constexpr forward_sized_iterator begin() const { return buffer_; }
+  constexpr sized_sentinel<forward_sized_iterator> end() const {
+    return sized_sentinel<forward_sized_iterator>(buffer_ + size_);
+  }
+};
+
+static_assert(std::ranges::forward_range<ForwardSizedNonCommon>);
+static_assert(std::ranges::sized_range<ForwardSizedNonCommon>);
+static_assert(!std::ranges::common_range<ForwardSizedNonCommon>);
+static_assert(!std::ranges::random_access_range<ForwardSizedNonCommon>);
+
+struct SizedRandomAccessView : std::ranges::view_base, IntBuffer {
+  using IntBuffer::IntBuffer;
+  using iterator = random_access_iterator<int*>;
+
+  constexpr auto begin() const { return iterator(buffer_); }
+  constexpr auto end() const { return sized_sentinel<iterator>(iterator(buffer_ + size_)); }
+};
+static_assert(std::ranges::view<SizedRandomAccessView>);
+static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
+static_assert(std::ranges::sized_range<SizedRandomAccessView>);
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ZIP_TYPES_H