[libc++][ranges] implement `std::views::elements_view`

[huixie90]

Summary

subrange is also a tuple-like. To avoid the add entire subrange dependencies to tuple-like, we need forward declaration of subrange. However, the class template constraints of subrange currently requires __iterator/concepts.h, which requires <concepts>. The problem is that currently tuple-like is used in several different places, including libc++ extension for pair constructors. we don't want to add <concepts> to pair and other stuff. So this change also created several small headers that subrange's declaration needed inside __iterator/concepts/

[huixie90]

ci

[huixie90]

ci

[huixie90]

subrange forward declaration

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

more tests

[huixie90]

fix CI

[var-const]

Sorry about the very slow review. I have reviewed the code changes but haven't looked at the tests yet. Looking pretty good so far!

libcxx/include/__iterator/concepts/can_reference.h

15

Nit: extraneous blank line.

libcxx/include/__iterator/concepts/input_or_output_iterator.h

17

Nit: extraneous blank line.

libcxx/include/__iterator/concepts/weakly_incrementable.h

19

Nit: unnecessary extra blank line.

libcxx/include/__ranges/elements_view.h

82

Optional: consider using __iterator</*_Const=*/false>. Personally, I find this trick of "annotating" the meaning of literals pretty helpful when reading code.

142

This doesn't need _LIBCPP_HIDE_FROM_ABI because it's consteval?

179

Question: what does _Ele stand for? Abbreviated names like this usually end with a consonant.

184

Optional: I wonder if a generic __get_iterator_concept function that allows setting a "maximum" (most constrained) tag would be useful. This function is mostly the same as the one in ranges_iterator_concept.h, except it can never return a contiguous_iterator. It might be overkill, though -- and in either case, it's just a thought, not something to address in this patch.

336

Would this benefit from no_unique_address?

344

Question: the parentheses are to make sure decltype(auto) deduces a reference, right?

[var-const]

libcxx/include/__tuple/make_tuple_types.h

65

Question: can you explain the idea here?

66

Nit: can you separate these two aliases with a blank line?

[philnik]

libcxx/include/__iterator/concepts/can_reference.h

3

I don't think we should granularize __iterator/concepts.h. Compiling the header takes just ~35ms, 20 of which are including <type_traits>. So we'd save maybe 10ms by granularizing it, which I don't think is worth it. __iterator/concepts.h also isn't very large at ~300 LoC, so it also doesn't increase readability much.

[huixie90]

libcxx/include/__iterator/concepts/can_reference.h

3

I wasn't too concerned about compilation time. Without doing this, we will add public dependency from <tuple> to <concepts> (see description). I'd like to avoid adding dependencies like this so lifted several headers required by subrange's forward declaration

[philnik]

libcxx/include/__iterator/concepts/can_reference.h

3

I'm not sure what exactly you mean. __iterator/concepts.h doesn't include <concepts>. Did this change between the creation of this patch and current trunk?

[huixie90]

libcxx/include/__iterator/concepts/can_reference.h

3

Yes. things changed a lot since the creation of this patch. I think the main change is this patch
https://github.com/llvm/llvm-project/commit/89b356f05ab7aa3d96fc7b68aece6e7a5bdb0db5

After this patch, I guess the dependency is removed. I will try rebase and see what happens in the CI

[huixie90]

rebase

[avogelsgesang]

libcxx/include/__ranges/elements_view.h

297

please also mark elements_view::iterator on https://libcxx.llvm.org/Status/Spaceship.html as done

[huixie90]

address comments

libcxx/include/__ranges/elements_view.h

142

That is my understanding. After all it is a function used only at compile time so it does not have any ABI concerns. Or did I miss anything?

344

yes.

libcxx/include/__tuple/make_tuple_types.h

65

the spec defines subrange is also a tuple-like
https://eel.is/c++draft/tuple.like#concept:tuple-like

Before this patch, libc++ defines tuple-like to be only pair, array and tuple
https://github.com/llvm/llvm-project/blob/main/libcxx/include/__tuple/tuple_like.h

This patch makes subrange also a tuple-like. (see the diff in tuple_like.h)

The file in question is creating some meta functions to create a flat list of underlying types given a tuple-like type, and this function is used in the conversions between tuple-like types. One example would be pair::pair(pair-like auto&&)

You will see the few line above there are several specialisations.

1. for tuple<Ts...> it just produces Ts...
2. for array<T, N> it produces T, T, T, T, ...
3. for pair<First, Second>, it produces First, Second

Now I am adding another one

4. for subrange<Iter, Sent, Kind>, it produces Iter, Sent (note that subrange has a non-type template parameter at the 3rd place, so it won't match any of the existing specialisations.

[var-const]

Sorry about the very slow review. Looks good with just a few nits/comments.

libcxx/include/__ranges/elements_view.h

82

Please apply below as well (with __sentinel, mostly).

134

Does this also need a test?

libcxx/include/__tuple/make_tuple_types.h

65

Thanks for the explanation! In that case, perhaps the variadic __element_type is unnecessary? Would something like this work?

template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
using __apply_quals = __tuple_types<
    typename _ApplyFn::template __apply<_Iter>,
    typename _ApplyFn::template __apply<_Sent>>;

libcxx/test/std/ranges/range.adaptors/range.elements/adaptor.pass.cpp

139

I'd suggest also testing e.g. keys | values, or any other case where the two adaptors use different indices.

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

77

Ultranit: please add a newline before this line.

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

30

This should probably be std::is_convertible_v.

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

31

Nit: I don't feel strongly about using snake_case or camelCase for local variables (I _personally_ use snake case when I can, but I don't think we have a hard rule on that), but it would be better to use one style consistently (currently historical_figures and expectedYears are inconsistent with each other).

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

48 ↗

(On Diff #476744)

Nit: I think ElemIter would be a little better as a name (applies throughout).

52 ↗

(On Diff #476744)

Question: is the empty comment to enforce a certain formatting?

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/base.pass.cpp

53 ↗

(On Diff #476744)

Question: why not use std::same_as<> decltype(auto) on the previous line instead?

82 ↗

(On Diff #476744)

Same nit: s/Ele/Elem/.

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

34 ↗

(On Diff #476744)

Nit: empty lines after each comparison operator would be pretty helpful.

111 ↗

(On Diff #476744)

Optional: check that it1 == it1 and it2 == it2 as well? (Maybe even the same for the != operator)

131 ↗

(On Diff #476744)

Perhaps also check not_equal_to, for completeness' sake?

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.base.pass.cpp

11 ↗

(On Diff #476744)

Nit: extra semicolon.

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

49 ↗

(On Diff #476744)

Ultranit: please add a newline before this line.

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

67 ↗

(On Diff #476744)

Optional: consider switching the order of branches (so that the check becomes if (!std::bidirectional_iterator)). The else branch is much shorter, so if it's close to the condition, it's easy to see both branches at the same time. In the current state it requires a bit of scrolling to find the else.

67 ↗

(On Diff #476744)

Optional: consider adding a blank line before this line.

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

51 ↗

(On Diff #476744)

Optional: consider adding a blank line before this line.

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

46

Optional: would it make sense to also static_assert these conditions? If you think it's overkill, feel free to disregard.

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

99 ↗

(On Diff #476744)

Optional nit: would writing a constraint be slightly more readable? (Maybe not -- feel free to push back)

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

45

Very optional: I think theoretically it's also possible to have a size() const without size() (if you = delete the non-const size), but it's probably too convoluted to test.

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

37

Ultranit: extra space.

91–93

Ultranit: the assignments are slightly unaligned.

[philnik]

libcxx/include/__ranges/elements_view.h

128–132

I know it sucks, but we have to move the iterators and sentinels outside the views.

[var-const]

libcxx/docs/Status/Cxx20Issues.csv

284

Can you also check if this patch addresses https://wg21.link/LWG3302, and if so, mark it as complete as well?

[var-const]

libcxx/docs/Status/Cxx20Issues.csv

284

And also https://cplusplus.github.io/LWG/issue3323 (that one looks like it was superseded by a later revision of the Standard).

[huixie90]

address comments

[huixie90]

libcxx/include/__tuple/make_tuple_types.h

65

Yes that looks much better. I will remove the ....
Thanks for the suggestion

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

52 ↗

(On Diff #476744)

Yes. if you have strong feelings I can remove them and put

// clang-format off
// clang-format on

around them

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/base.pass.cpp

53 ↗

(On Diff #476744)

as of the patch was written (about 2-3 months ago?), Some compilers in the CI which were based on older version of clang has a bug where std::same_as<Foo&> decltype(auto) = ... does not work if the return type is a reference

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

67 ↗

(On Diff #476744)

clang-format will remove that empty line

[huixie90]

CI

[var-const]

Thanks a lot for working on this! Once this lands, we will only have split_view between our current state and a full C++20 implementation of Ranges.

I can do a follow-up to mark some papers and LWG issues that are complete now that elements_view is implemented (there are quite a few!). Feel free to ignore my comments re. papers and issues.

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

52 ↗

(On Diff #476744)

No strong feelings, just making sure it's deliberate.

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/base.pass.cpp

53 ↗

(On Diff #476744)

Ah, in that case, let's keep as is.

[var-const]

libcxx/docs/Status/Cxx20Papers.csv

111

It's a _major_ paper, so it should definitely be added to libcxx/docs/ReleaseNotes.rst.

[var-const]

@huixie90 I did the follow-up to mark papers and issues as done: https://reviews.llvm.org/D139900. Many of those are finished by this patch. If you'd like, feel free to update this patch to mark more papers (I think everything except P2325 is completed by this patch). But otherwise, feel free to submit as-is (except my comment about release notes, although we can do that in a follow-up as well if you'd like).

[ldionne]

libcxx/include/__tuple/tuple_like.h

29–34

Here we seem to be conflating two things:

1. This old __tuple_like extension that I've been trying to get rid of (and did get rid of in std::tuple), and
2. The new tuple-like exposition-only concept that was introduced recently and was retrofitted into std::pair.

I would prefer if we introduced (2) without touching (1), so that we can proceed to the cleanup of (1) and related machinery like __tuple_convertible & friends separately.

It'll end up being nearly equivalent, but what I would do instead is introduce the new tuple-like and pair-like C++20 concepts separately and give them a name like __cpp20_tuple_like. We can then clean up the mess inside <pair>, remove the non-standard extension pre-C++20 and finally rename __cpp20_tuple_like and __cpp20_pair_like to __tuple_like and __pair_like once that's done.

That way, this patch will be completely orthogonal to touching pair, which I think is a good thing.

[philnik]

libcxx/include/__tuple/tuple_like.h

29–34

IMO it would be better to rename the current __tuple_like etc. to something like __tuple_like_ext. Otherwise people will assume that __tuple_like is the standard tuple-like, since that's what our naming scheme normally is.

[huixie90]

Address feedback

[huixie90]

libcxx/include/__tuple/tuple_like.h

29–34

I renamed the exiting __tuple_like to __tuple_like_ext and introduced the new __tuple_like exposition only concept

[huixie90]

CI

[huixie90]

rebase

[huixie90]

rebase

[huixie90]

rebase

[huixie90]

rebase

libcxx/docs/Status/Cxx20Issues.csv

 "`3364 <https://wg21.link/LWG3364>`__","Initialize data members of ranges and their iterators","Prague","","","|ranges|"
 "`3367 <https://wg21.link/LWG3367>`__","Integer-class conversions should not throw","Prague","|Nothing To Do|",""
 "`3369 <https://wg21.link/LWG3369>`__","``span``\ 's deduction-guide for built-in arrays doesn't work","Prague","|Complete|","14.0"
 "`3371 <https://wg21.link/LWG3371>`__","``visit_format_arg``\  and ``make_format_args``\  are not hidden friends","Prague","|Complete|","14.0","|format|"
 "`3372 <https://wg21.link/LWG3372>`__","``vformat_to``\  should not try to deduce ``Out``\  twice","Prague","|Complete|","14.0","|format|"
 "`3373 <https://wg21.link/LWG3373>`__","``{to,from}_chars_result``\  and ``format_to_n_result``\  need the  ""we really mean what we say"" wording","Prague","|Complete|","14.0","|format|"
 "`3374 <https://wg21.link/LWG3374>`__","P0653 + P1006 should have made the other ``std::to_address``\  overload ``constexpr``\ ","Prague","|Complete|","12.0"
 "`3375 <https://wg21.link/LWG3375>`__","``decay``\  in ``viewable_range``\  should be ``remove_cvref``\ ","Prague","|Complete|","15.0","|ranges|"
-"`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague","","","|ranges|"
+"`3377 <https://wg21.link/LWG3377>`__","``elements_view::iterator``\  befriends a specialization of itself","Prague","|Nothing To Do|","","|ranges|"
 "`3379 <https://wg21.link/LWG3379>`__","""``safe``\ "" in several library names is misleading","Prague","|Complete|","15.0","|ranges|"
 "`3380 <https://wg21.link/LWG3380>`__","``common_type``\  and comparison categories","Prague","|Complete|","15.0","|spaceship|"
 "`3381 <https://wg21.link/LWG3381>`__","``begin``\  and ``data``\  must agree for ``contiguous_range``\ ","Prague","|Nothing To Do|","","|ranges|"
 "`3382 <https://wg21.link/LWG3382>`__","NTTP for ``pair``\  and ``array``\ ","Prague","",""
 "`3383 <https://wg21.link/LWG3383>`__","|sect|\ [time.zone.leap.nonmembers] ``sys_seconds``\  should be replaced with ``seconds``\ ","Prague","","","|chrono|"
 "`3384 <https://wg21.link/LWG3384>`__","``transform_view::*sentinel*``\  has an incorrect ``operator-``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3385 <https://wg21.link/LWG3385>`__","``common_iterator``\  is not sufficiently constrained for non-copyable iterators","Prague","|Complete|","15.0","|ranges|"
 "`3387 <https://wg21.link/LWG3387>`__","|sect|\ [range.reverse.view] ``reverse_view<V>``\  unintentionally requires ``range<const V>``\ ","Prague","|Complete|","15.0","|ranges|"

libcxx/docs/Status/Cxx20Papers.csv

 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
 "`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
-"`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors, Todo: elements_view","Cologne","|In Progress|",""
+"`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","|Complete|","16.0"
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","|In Progress|",""
 "`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|Complete|","15.0"
 "`P1424R1 <https://wg21.link/P1424R1>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""

 "`P1963R0 <https://wg21.link/P1963R0>`__","LWG","Fixing US 313","Prague","* *",""
 "`P1964R2 <https://wg21.link/P1964R2>`__","LWG","Wording for boolean-testable","Prague","|Complete|","13.0"
 "`P1970R2 <https://wg21.link/P1970R2>`__","LWG","Consistency for size() functions: Add ranges::ssize","Prague","|Complete|","15.0"
 "`P1973R1 <https://wg21.link/P1973R1>`__","LWG","Rename ""_default_init"" Functions, Rev1","Prague","* *",""
 "`P1976R2 <https://wg21.link/P1976R2>`__","LWG","Fixed-size span construction from dynamic range","Prague","|Complete|","11.0"
 "`P1981R0 <https://wg21.link/P1981R0>`__","LWG","Rename leap to leap_second","Prague","* *",""
 "`P1982R0 <https://wg21.link/P1982R0>`__","LWG","Rename link to time_zone_link","Prague","* *",""
 "`P1983R0 <https://wg21.link/P1983R0>`__","LWG","Wording for GB301, US296, US292, US291, and US283","Prague","|Complete|","15.0"
-"`P1994R1 <https://wg21.link/P1994R1>`__","LWG","elements_view needs its own sentinel","Prague","* *",""
+"`P1994R1 <https://wg21.link/P1994R1>`__","LWG","elements_view needs its own sentinel","Prague","Complete","16.0"
 "`P2002R1 <https://wg21.link/P2002R1>`__","CWG","Defaulted comparison specification cleanups","Prague","* *",""
 "`P2045R1 <https://wg21.link/P2045R1>`__","LWG","Missing Mandates for the standard library","Prague","* *",""
 "`P2085R0 <https://wg21.link/P2085R0>`__","CWG","Consistent defaulted comparisons","Prague","* *",""
 "`P2091R0 <https://wg21.link/P2091R0>`__","LWG","Issues with range access CPOs","Prague","|Complete|","15.0"
 "`P2101R0 <https://wg21.link/P2101R0>`__","LWG","'Models' subsumes 'satisfies' (Wording for US298 and US300)","Prague","* *",""
 "`P2102R0 <https://wg21.link/P2102R0>`__","LWG","Make 'implicit expression variations' more explicit (Wording for US185)","Prague","* *",""
 "`P2106R0 <https://wg21.link/P2106R0>`__","LWG","Alternative wording for GB315 and GB316","Prague","|Complete|","15.0"
 "`P2116R0 <https://wg21.link/P2116R0>`__","LWG","Remove tuple-like protocol support from fixed-extent span","Prague","|Complete|","11.0"

libcxx/docs/Status/Cxx2bIssues.csv

 "`3120 <https://wg21.link/LWG3120>`__","Unclear behavior of ``monotonic_buffer_resource::release()``","November 2020","",""
 "`3170 <https://wg21.link/LWG3170>`__","``is_always_equal`` added to ``std::allocator`` makes the standard library treat derived types as always equal","November 2020","",""
 "`3036 <https://wg21.link/LWG3036>`__","``polymorphic_allocator::destroy`` is extraneous","November 2020","",""
 "`3171 <https://wg21.link/LWG3171>`__","LWG2989 breaks ``directory_entry`` stream insertion","November 2020","|Complete|","14.0"
 "`3306 <https://wg21.link/LWG3306>`__","``ranges::advance`` violates its preconditions","November 2020","|Complete|","14.0","|ranges|"
 "`3403 <https://wg21.link/LWG3403>`__","Domain of ``ranges::ssize(E)`` doesn't ``match ranges::size(E)``","November 2020","","","|ranges|"
 "`3404 <https://wg21.link/LWG3404>`__","Finish removing subrange's conversions from pair-like","November 2020","","","|ranges|"
 "`3405 <https://wg21.link/LWG3405>`__","``common_view``'s converting constructor is bad, too","November 2020","|Complete|","14.0","|ranges|"
-"`3406 <https://wg21.link/LWG3406>`__","``elements_view::begin()`` and ``elements_view::end()`` have incompatible constraints","November 2020","","","|ranges|"
+"`3406 <https://wg21.link/LWG3406>`__","``elements_view::begin()`` and ``elements_view::end()`` have incompatible constraints","November 2020","|Complete|","16.0","|ranges|"
 "`3419 <https://wg21.link/LWG3419>`__","[algorithms.requirements]/15 doesn't reserve as many rights as it intends to","November 2020","|Nothing To Do|",""
 "`3420 <https://wg21.link/LWG3420>`__","cpp17-iterator should check that the type looks like an iterator first","November 2020","|Complete|","14.0","|ranges|"
 "`3421 <https://wg21.link/LWG3421>`__","Imperfect ADL emulation for boolean-testable","November 2020","|Nothing To Do|","","|ranges|"
 "`3425 <https://wg21.link/LWG3425>`__","``condition_variable_any`` fails to constrain its Lock parameters","November 2020","|Nothing To Do|",""
 "`3426 <https://wg21.link/LWG3426>`__","``operator<=>(const unique_ptr<T, D>&, nullptr_t)`` can't get no satisfaction","November 2020","|Complete|","16.0","|spaceship|"
 "`3427 <https://wg21.link/LWG3427>`__","``operator<=>(const shared_ptr<T>&, nullptr_t)`` definition ill-formed","November 2020","|Complete|","16.0","|spaceship|"
 "`3428 <https://wg21.link/LWG3428>`__","``single_view``'s in place constructor should be explicit","November 2020","|Complete|","14.0","|ranges|"
 "`3434 <https://wg21.link/LWG3434>`__","``ios_base`` never reclaims memory for iarray and parray","November 2020","|Nothing To Do|",""

 "`3476 <https://wg21.link/LWG3476>`__","``thread`` and ``jthread`` constructors require that the parameters be move-constructible but never move construct the parameters","November 2020","",""
 "`3477 <https://wg21.link/LWG3477>`__","Simplify constraints for ``semiregular-box``","November 2020","","","|ranges|"
 "`3482 <https://wg21.link/LWG3482>`__","``drop_view``'s const begin should additionally require ``sized_range``","November 2020","|Complete|","14.0","|ranges|"
 "`3483 <https://wg21.link/LWG3483>`__","``transform_view::iterator``'s difference is overconstrained","November 2020","|Complete|","14.0","|ranges|"
 "","","","",""
 "`3391 <https://wg21.link/LWG3391>`__","Problems with ``counted_iterator``/``move_iterator::base() const &``","February 2021","","","|ranges|"
 "`3433 <https://wg21.link/LWG3433>`__","``subrange::advance(n)`` has UB when ``n < 0``","February 2021","|Complete|","14.0","|ranges|"
 "`3490 <https://wg21.link/LWG3490>`__","``ranges::drop_while_view::begin()`` is missing a precondition","February 2021","|Nothing To Do|","","|ranges|"
-"`3492 <https://wg21.link/LWG3492>`__","Minimal improvements to ``elements_view::iterator``","February 2021","","","|ranges|"
+"`3492 <https://wg21.link/LWG3492>`__","Minimal improvements to ``elements_view::iterator``","February 2021","|Complete|","16.0","|ranges|"
 "`3494 <https://wg21.link/LWG3494>`__","Allow ranges to be conditionally borrowed","February 2021","Superseded by `P2017R1 <https://wg21.link/P2017R1>`__","","|ranges|"
 "`3495 <https://wg21.link/LWG3495>`__","``constexpr launder`` makes pointers to inactive members of unions usable","February 2021","|Nothing To Do|",""
 "`3500 <https://wg21.link/LWG3500>`__","``join_view::iterator::operator->()`` is bogus","February 2021","|Complete|","14.0","|ranges|"
-"`3502 <https://wg21.link/LWG3502>`__","``elements_view`` should not be allowed to return dangling reference","February 2021","","","|ranges|"
+"`3502 <https://wg21.link/LWG3502>`__","``elements_view`` should not be allowed to return dangling reference","February 2021","|Complete|","16.0","|ranges|"
 "`3505 <https://wg21.link/LWG3505>`__","``split_view::outer-iterator::operator++`` misspecified","February 2021","","","|ranges|"
 "","","","",""
 `2774 <https://wg21.link/LWG2774>`__,"``std::function`` construction vs assignment","June 2021","",""
 `2818 <https://wg21.link/LWG2818>`__,"``::std::`` everywhere rule needs tweaking","June 2021","|Nothing To Do|",""
 `2997 <https://wg21.link/LWG2997>`__,"LWG 491 and the specification of ``{forward_,}list::unique``","June 2021","",""
 `3410 <https://wg21.link/LWG3410>`__,"``lexicographical_compare_three_way`` is overspecified","June 2021","","","|spaceship|"
 `3430 <https://wg21.link/LWG3430>`__,"``std::fstream`` & co. should be constructible from string_view","June 2021","",""
 `3462 <https://wg21.link/LWG3462>`__,"§[formatter.requirements]: Formatter requirements forbid use of ``fc.arg()``","June 2021","","","|format|"

libcxx/include/CMakeLists.txt

set(files
   __functional/unwrap_ref.h
   __functional/weak_result_type.h
   __fwd/array.h
   __fwd/get.h
   __fwd/hash.h
   __fwd/pair.h
   __fwd/span.h
   __fwd/string_view.h
+  __fwd/subrange.h
   __fwd/tuple.h
   __hash_table
   __ios/fpos.h
   __iterator/access.h
   __iterator/advance.h
   __iterator/back_insert_iterator.h
   __iterator/bounded_iter.h
   __iterator/common_iterator.h
   __iterator/concepts.h
+  __iterator/concepts/can_reference.h
+  __iterator/concepts/input_or_output_iterator.h
+  __iterator/concepts/sentinel_for.h
+  __iterator/concepts/sized_sentinel_for.h
+  __iterator/concepts/weakly_incrementable.h
   __iterator/counted_iterator.h
   __iterator/data.h
   __iterator/default_sentinel.h
   __iterator/distance.h
   __iterator/empty.h
   __iterator/erase_if_container.h
   __iterator/front_insert_iterator.h
   __iterator/incrementable_traits.h
set(files
   __ranges/common_view.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/counted.h
   __ranges/dangling.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/drop_while_view.h
+  __ranges/elements_view.h
   __ranges/empty.h
   __ranges/empty_view.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/filter_view.h
   __ranges/iota_view.h
   __ranges/istream_view.h
   __ranges/join_view.h

libcxx/include/__fwd/get.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 _LIBCPP___FWD_GET_H
 #define _LIBCPP___FWD_GET_H
 
+#include <__concepts/copyable.h>
 #include <__config>
 #include <__fwd/array.h>
 #include <__fwd/pair.h>
+#include <__fwd/subrange.h>
 #include <__fwd/tuple.h>
 #include <__tuple/tuple_element.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 

 get(array<_Tp, _Size>&&) _NOEXCEPT;
 
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
 const _Tp&&
 get(const array<_Tp, _Size>&&) _NOEXCEPT;
 #endif
 
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange);
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange);
+
+} // namespace ranges
+
+using ranges::get;
+
+#endif // _LIBCPP_STD_VER >= 20
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_GET_H

libcxx/include/__fwd/subrange.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 _LIBCPP___FWD_SUBRANGE_H
+#define _LIBCPP___FWD_SUBRANGE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+
+#  include <__iterator/concepts/input_or_output_iterator.h>
+#  include <__iterator/concepts/sentinel_for.h>
+#  include <__iterator/concepts/sized_sentinel_for.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent, subrange_kind _Kind>
+  requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+class _LIBCPP_TEMPLATE_VIS subrange;
+
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20
+
+#endif // _LIBCPP___FWD_SUBRANGE_H

libcxx/include/__iterator/concepts.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___ITERATOR_CONCEPTS_H
 #define _LIBCPP___ITERATOR_CONCEPTS_H
 
 #include <__config>
+#include <__iterator/concepts/input_or_output_iterator.h>
+#include <__iterator/concepts/sentinel_for.h>
+#include <__iterator/concepts/sized_sentinel_for.h>
+#include <__iterator/concepts/weakly_incrementable.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__utility/forward.h>
 #include <concepts>
 #include <type_traits>

 concept indirectly_writable =
   requires(_Out&& __o, _Tp&& __t) {
     *__o = _VSTD::forward<_Tp>(__t);                        // not required to be equality-preserving
     *_VSTD::forward<_Out>(__o) = _VSTD::forward<_Tp>(__t);  // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*__o) = _VSTD::forward<_Tp>(__t);                       // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
   };
 
-// [iterator.concept.winc]
-template<class _Tp>
-concept __integer_like = integral<_Tp> && !same_as<_Tp, bool>;
-
-template<class _Tp>
-concept __signed_integer_like = signed_integral<_Tp>;
-
-template<class _Ip>
-concept weakly_incrementable =
-  // TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).
-  !same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.
-  movable<_Ip> &&
-  requires(_Ip __i) {
-    typename iter_difference_t<_Ip>;
-    requires __signed_integer_like<iter_difference_t<_Ip>>;
-    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
-    __i++;                        // not required to be equality-preserving
-  };
 
 // [iterator.concept.inc]
 template<class _Ip>
 concept incrementable =
   regular<_Ip> &&
   weakly_incrementable<_Ip> &&
   requires(_Ip __i) {
     { __i++ } -> same_as<_Ip>;
   };
 
-// [iterator.concept.iterator]
-template<class _Ip>
-concept input_or_output_iterator =
-  requires(_Ip __i) {
-    { *__i } -> __can_reference;
-  } &&
-  weakly_incrementable<_Ip>;
-
-// [iterator.concept.sentinel]
-template<class _Sp, class _Ip>
-concept sentinel_for =
-  semiregular<_Sp> &&
-  input_or_output_iterator<_Ip> &&
-  __weakly_equality_comparable_with<_Sp, _Ip>;
-
-template<class, class>
-inline constexpr bool disable_sized_sentinel_for = false;
-
-template<class _Sp, class _Ip>
-concept sized_sentinel_for =
-  sentinel_for<_Sp, _Ip> &&
-  !disable_sized_sentinel_for<remove_cv_t<_Sp>, remove_cv_t<_Ip>> &&
-  requires(const _Ip& __i, const _Sp& __s) {
-    { __s - __i } -> same_as<iter_difference_t<_Ip>>;
-    { __i - __s } -> same_as<iter_difference_t<_Ip>>;
-  };
-
 // [iterator.concept.input]
 template<class _Ip>
 concept input_iterator =
   input_or_output_iterator<_Ip> &&
   indirectly_readable<_Ip> &&
   requires { typename _ITER_CONCEPT<_Ip>; } &&
   derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
 

libcxx/include/__iterator/concepts/can_reference.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___ITERATOR_CONCEPTS_CAN_REFERENCE_H
+#define _LIBCPP___ITERATOR_CONCEPTS_CAN_REFERENCE_H
+
+#include <__config>
+
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+using __with_reference = _Tp&;
+
+template <class _Tp>
+concept __can_reference = requires {
+  typename __with_reference<_Tp>;
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_CONCEPTS_CAN_REFERENCE_H

libcxx/include/__iterator/concepts/input_or_output_iterator.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___ITERATOR_CONCEPTS_INPUT_OR_OUTPUT_ITERATOR_H
+#define _LIBCPP___ITERATOR_CONCEPTS_INPUT_OR_OUTPUT_ITERATOR_H
+
+#include <__config>
+#include <__iterator/concepts/can_reference.h>
+#include <__iterator/concepts/weakly_incrementable.h>
+
+
+// [iterator.concept.iterator]
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template<class _Ip>
+concept input_or_output_iterator =
+  requires(_Ip __i) {
+    { *__i } -> __can_reference;
+  } &&
+  weakly_incrementable<_Ip>;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_CONCEPTS_INPUT_OR_OUTPUT_ITERATOR_H

libcxx/include/__iterator/concepts/sentinel_for.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___ITERATOR_CONCEPTS_SENTINEL_FOR_H
+#define _LIBCPP___ITERATOR_CONCEPTS_SENTINEL_FOR_H
+
+#include <__concepts/equality_comparable.h>
+#include <__concepts/semiregular.h>
+#include <__config>
+#include <__iterator/concepts/input_or_output_iterator.h>
+
+// [iterator.concept.sentinel]
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template<class _Sp, class _Ip>
+concept sentinel_for =
+  semiregular<_Sp> &&
+  input_or_output_iterator<_Ip> &&
+  __weakly_equality_comparable_with<_Sp, _Ip>;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_CONCEPTS_SENTINEL_FOR_H

libcxx/include/__iterator/concepts/sized_sentinel_for.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___ITERATOR_CONCEPTS_SIZED_SENTINEL_FOR_H
+#define _LIBCPP___ITERATOR_CONCEPTS_SIZED_SENTINEL_FOR_H
+
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__iterator/concepts/sentinel_for.h>
+#include <__iterator/incrementable_traits.h>
+#include <__type_traits/remove_cv.h>
+
+// [iterator.concept.sizedsentinel]
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template<class, class>
+inline constexpr bool disable_sized_sentinel_for = false;
+
+template<class _Sp, class _Ip>
+concept sized_sentinel_for =
+  sentinel_for<_Sp, _Ip> &&
+  !disable_sized_sentinel_for<remove_cv_t<_Sp>, remove_cv_t<_Ip>> &&
+  requires(const _Ip& __i, const _Sp& __s) {
+    { __s - __i } -> same_as<iter_difference_t<_Ip>>;
+    { __i - __s } -> same_as<iter_difference_t<_Ip>>;
+  };
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_CONCEPTS_SIZED_SENTINEL_FOR_H

libcxx/include/__iterator/concepts/weakly_incrementable.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___ITERATOR_CONCEPTS_WEAKLY_INCREMENTABLE_H
+#define _LIBCPP___ITERATOR_CONCEPTS_WEAKLY_INCREMENTABLE_H
+
+#include <__concepts/arithmetic.h>
+#include <__concepts/movable.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__iterator/incrementable_traits.h>
+
+
+// [iterator.concept.winc]
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template<class _Tp>
+concept __integer_like = integral<_Tp> && !same_as<_Tp, bool>;
+
+template<class _Tp>
+concept __signed_integer_like = signed_integral<_Tp>;
+
+template<class _Ip>
+concept weakly_incrementable =
+  // TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).
+  !same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.
+  movable<_Ip> &&
+  requires(_Ip __i) {
+    typename iter_difference_t<_Ip>;
+    requires __signed_integer_like<iter_difference_t<_Ip>>;
+    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
+    __i++;                        // not required to be equality-preserving
+  };
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_CONCEPTS_WEAKLY_INCREMENTABLE_H

libcxx/include/__iterator/incrementable_traits.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___ITERATOR_INCREMENTABLE_TRAITS_H
 #define _LIBCPP___ITERATOR_INCREMENTABLE_TRAITS_H
 
+#include <__concepts/arithmetic.h>
 #include <__config>
 #include <__type_traits/is_primary_template.h>
-#include <concepts>
 #include <cstddef>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/include/__iterator/iter_move.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___ITERATOR_ITER_MOVE_H
 #define _LIBCPP___ITERATOR_ITER_MOVE_H
 
 #include <__concepts/class_or_enum.h>
 #include <__config>
+#include <__iterator/concepts/can_reference.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__iterator/iterator_traits.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___ITERATOR_ITERATOR_TRAITS_H
 #define _LIBCPP___ITERATOR_ITERATOR_TRAITS_H
 
 #include <__config>
 #include <__fwd/pair.h>
+#include <__iterator/concepts/can_reference.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/readable_traits.h>
 #include <concepts>
 #include <cstddef>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
-template <class _Tp>
-using __with_reference = _Tp&;
-
-template <class _Tp>
-concept __can_reference = requires {
-  typename __with_reference<_Tp>;
-};
 
 template <class _Tp>
 concept __dereferenceable = requires(_Tp& __t) {
   { *__t } -> __can_reference; // not required to be equality-preserving
 };
 
 // [iterator.traits]
 template<__dereferenceable _Tp>

libcxx/include/__ranges/elements_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_ELEMENTS_VIEW_H
+#define _LIBCPP___RANGES_ELEMENTS_VIEW_H
+
+#include <__compare/three_way_comparable.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/equality_comparable.h>
+#include <__config>
+#include <__fwd/get.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/size.h>
+#include <__ranges/view_interface.h>
+#include <__tuple/tuple_element.h>
+#include <__tuple/tuple_like.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/maybe_const.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace ranges {
+
+template <class _Tp, size_t _Np>
+concept __has_tuple_element = __tuple_like<_Tp>::value && _Np < tuple_size<_Tp>::value;
+
+template <class _Tp, size_t _Np>
+concept __returnable_element = is_reference_v<_Tp> || move_constructible<tuple_element_t<_Np, _Tp>>;
+
+template <input_range _View, size_t _Np>
+  requires view<_View> && __has_tuple_element<range_value_t<_View>, _Np> &&
+           __has_tuple_element<remove_reference_t<range_reference_t<_View>>, _Np> &&
+           __returnable_element<range_reference_t<_View>, _Np>
+class elements_view : public view_interface<elements_view<_View, _Np>> {
+public:
+  _LIBCPP_HIDE_FROM_ABI elements_view()
+    requires default_initializable<_View>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit elements_view(_View __base) : __base_(std::move(__base)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
+    return __iterator<false>(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
+    return __iterator<true>(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View> && !common_range<_View>)
+  {
+    return __sentinel<false>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View> && common_range<_View>)
+  {
+    return __iterator<false>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    return __sentinel<true>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires common_range<const _View>
+  {
+    return __iterator<true>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+
+private:
+  template <bool>
+  class __iterator;
+
+  template <bool>
+  class __sentinel;
+
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+};
+
+template <class, size_t>
+struct __elements_view_iterator_category_base {};
+
+template <forward_range _Base, size_t _Np>
+struct __elements_view_iterator_category_base<_Base, _Np> {
+  static consteval auto __get_iterator_category() {
+    using _Result = decltype(std::get<_Np>(*std::declval<iterator_t<_Base>>()));
+    using _Cat    = typename iterator_traits<iterator_t<_Base>>::iterator_category;
+
+    if constexpr (!is_lvalue_reference_v<_Result>) {
+      return input_iterator_tag{};
+    } else if constexpr (derived_from<_Cat, random_access_iterator_tag>) {
+      return random_access_iterator_tag{};
+    } else {
+      return _Cat{};
+    }
+  }
+
+  using iterator_category = decltype(__get_iterator_category());
+};
+
+template <input_range _View, size_t _Np>
+  requires view<_View> && __has_tuple_element<range_value_t<_View>, _Np> &&
+           __has_tuple_element<remove_reference_t<range_reference_t<_View>>, _Np> &&
+           __returnable_element<range_reference_t<_View>, _Np>
+template <bool _Const>
+class elements_view<_View, _Np>::__iterator
+    : public __elements_view_iterator_category_base<__maybe_const<_Const, _View>, _Np> {
+  template <bool>
+  friend class elements_view<_View, _Np>::__sentinel;
+
+  using _Base = __maybe_const<_Const, _View>;
+
+  iterator_t<_Base> __current_ = iterator_t<_Base>();
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __get_element(const iterator_t<_Base>& __i) {
+    if constexpr (is_reference_v<range_reference_t<_Base>>) {
+      return std::get<_Np>(*__i);
+    } else {
+      using _Ele = remove_cv_t<tuple_element_t<_Np, range_reference_t<_Base>>>;
+      return static_cast<_Ele>(std::get<_Np>(*__i));
+    }
+  }
+
+  static consteval auto __get_iterator_concept() {
+    if constexpr (random_access_range<_Base>) {
+      return random_access_iterator_tag{};
+    } else if constexpr (bidirectional_range<_Base>) {
+      return bidirectional_iterator_tag{};
+    } else if constexpr (forward_range<_Base>) {
+      return forward_iterator_tag{};
+    } else {
+      return input_iterator_tag{};
+    }
+  }
+
+public:
+  using iterator_concept = decltype(__get_iterator_concept());
+  using value_type       = remove_cvref_t<tuple_element_t<_Np, range_value_t<_Base>>>;
+  using difference_type  = range_difference_t<_Base>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires default_initializable<iterator_t<_Base>>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(iterator_t<_Base> __current) : __current_(std::move(__current)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+      : __current_(std::move(__i.__current_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __current_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() && { return std::move(__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return __get_element(__current_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires forward_range<_Base>
+  {
+    auto temp = *this;
+    ++__current_;
+    return temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    --__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto temp = *this;
+    --__current_;
+    return temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ -= __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
+    requires random_access_range<_Base>
+  {
+    return __get_element(__current_ + __n);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires equality_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ < __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __y < __x;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__y < __x);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__x < __y);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ <=> __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __x, difference_type __y)
+    requires random_access_range<_Base>
+  {
+    return __iterator{__x} += __y;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __y + __x;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __x, difference_type __y)
+    requires random_access_range<_Base>
+  {
+    return __iterator{__x} -= __y;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+  {
+    return __x.current_ - __y.current_;
+  }
+};
+
+template <input_range _View, size_t _Np>
+  requires view<_View> && __has_tuple_element<range_value_t<_View>, _Np> &&
+           __has_tuple_element<remove_reference_t<range_reference_t<_View>>, _Np> &&
+           __returnable_element<range_reference_t<_View>, _Np>
+template <bool _Const>
+class elements_view<_View, _Np>::__sentinel {
+private:
+  using _Base              = __maybe_const<_Const, _View>;
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+  template <bool _AnyConst>
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
+  __get_current(const elements_view<_View, _Np>::__iterator<_AnyConst>& __iter) {
+    return (__iter.__current_);
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __other)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+      : __end_(std::move(__other.__end_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
+
+  template <bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __get_current(__x) == __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __get_current(__x) - __y.__end_;
+  }
+
+  template <bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
+    return __x.__end_ - __get_current(__y);
+  }
+};
+
+template <class _Tp, size_t _Np>
+inline constexpr bool enable_borrowed_range<elements_view<_Tp, _Np>> = enable_borrowed_range<_Tp>;
+
+template <class _Tp>
+using keys_view = elements_view<_Tp, 0>;
+template <class _Tp>
+using values_view = elements_view<_Tp, 1>;
+
+namespace views {
+namespace __elements {
+
+template <size_t _Np>
+struct __fn : __range_adaptor_closure<__fn<_Np>> {
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      /**/ noexcept(noexcept(elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range))))
+      /*------*/ -> decltype(elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range))) {
+    /*-------------*/ return elements_view<all_t<_Range&&>, _Np>(std::forward<_Range>(__range));
+  }
+};
+} // namespace __elements
+
+inline namespace __cpo {
+template <size_t _Np>
+inline constexpr auto elements = __elements::__fn<_Np>{};
+inline constexpr auto keys     = elements<0>;
+inline constexpr auto values   = elements<1>;
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_ELEMENTS_VIEW_H

libcxx/include/__ranges/subrange.h

 #include <__assert>
 #include <__concepts/constructible.h>
 #include <__concepts/convertible_to.h>
 #include <__concepts/copyable.h>
 #include <__concepts/derived_from.h>
 #include <__concepts/different_from.h>
 #include <__config>
 #include <__fwd/get.h>
+#include <__fwd/subrange.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <__tuple/tuple_element.h>
+#include <__tuple/tuple_like.h>
 #include <__tuple/tuple_size.h>
 #include <__utility/move.h>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
namespace ranges {
 
   template<class _Pair, class _Iter, class _Sent>
   concept __pair_like_convertible_from =
     !range<_Pair> && __pair_like<_Pair> &&
     constructible_from<_Pair, _Iter, _Sent> &&
     __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
     convertible_to<_Sent, tuple_element_t<1, _Pair>>;
 
-  enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
-
   template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
            subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
              ? subrange_kind::sized
              : subrange_kind::unsized>
     requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
   class _LIBCPP_TEMPLATE_VIS subrange
     : public view_interface<subrange<_Iter, _Sent, _Kind>>
   {

libcxx/include/__tuple/make_tuple_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 _LIBCPP___TUPLE_MAKE_TUPLE_TYPES_H
 #define _LIBCPP___TUPLE_MAKE_TUPLE_TYPES_H
 
 #include <__config>
 #include <__fwd/array.h>
+#include <__fwd/subrange.h>
 #include <__fwd/tuple.h>
 #include <__tuple/apply_cv.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_size.h>
 #include <__tuple/tuple_types.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_reference.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
   template <size_t>
   using __value_type = _Vt;
   template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
   using __apply_quals = __tuple_types<
       typename _ApplyFn::template __apply<__value_type<_Idx>>...
     >;
 };
 
+#  if _LIBCPP_STD_VER >= 20
+template <class _Iter, class _Sent, ranges::subrange_kind _Kind, size_t... _Idx>
+struct __make_tuple_types_flat<ranges::subrange<_Iter, _Sent, _Kind>, __tuple_indices<_Idx...>> {
+  template <size_t _Index>
+  using __element_type = std::conditional_t<_Index == 0, _Iter, _Sent>;
+  template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>>
+  using __apply_quals = __tuple_types< typename _ApplyFn::template __apply<__element_type<_Idx>>... >;
+};
+#  endif // _LIBCPP_STD_VER >= 20
+
 template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
           size_t _Sp = 0,
           bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp> >::value)>
 struct __make_tuple_types
 {
     static_assert(_Sp <= _Ep, "__make_tuple_types input error");
     using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
     using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;

libcxx/include/__tuple/tuple_like.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 _LIBCPP___TUPLE_TUPLE_LIKE_H
 #define _LIBCPP___TUPLE_TUPLE_LIKE_H
 
 #include <__config>
 #include <__fwd/array.h>
 #include <__fwd/pair.h>
+#include <__fwd/subrange.h>
 #include <__fwd/tuple.h>
 #include <__tuple/tuple_types.h>
-#include <__type_traits/integral_constant.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cvref.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __tuple_like : false_type {};
+template <class _Tp, class = void> struct __tuple_like : false_type {};
 
-template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
+template <class _Tp>
+struct __tuple_like<_Tp, __enable_if_t<!is_same<_Tp, __remove_cvref_t<_Tp>>::value>>
+  : public __tuple_like<__remove_cvref_t<_Tp>> {};
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
 #endif
 
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
 
 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
 
 template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
 
+#if _LIBCPP_STD_VER >= 20
+
+template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct __tuple_like<ranges::subrange<_Ip, _Sp, _Kp>> : true_type {};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+// `subrange` specialization is defined in __ranges/subrange.h,
+// because the forward declaration of `subrange` would introduce
+// too many dependencies due to its complex requirements of the type.
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TUPLE_TUPLE_LIKE_H

libcxx/include/module.modulemap.in

module iterator {
     export *
 
     module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               { private header "__iterator/advance.h" }
       module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
       module bounded_iter          { private header "__iterator/bounded_iter.h" }
       module common_iterator       { private header "__iterator/common_iterator.h" }
-      module concepts              { private header "__iterator/concepts.h" }
+      module concepts              {
+        private header "__iterator/concepts.h"
+
+        module can_reference {
+          private header "__iterator/concepts/can_reference.h"
+        }
+
+        module input_or_output_iterator {
+          private header "__iterator/concepts/input_or_output_iterator.h"
+        }
+
+        module sentinel_for {
+          private header "__iterator/concepts/sentinel_for.h"
+        }
+
+        module sized_sentinel_for {
+          private header "__iterator/concepts/sized_sentinel_for.h"
+        }
+
+        module weakly_incrementable {
+          private header "__iterator/concepts/weakly_incrementable.h"
+        }
+      }
       module counted_iterator      { private header "__iterator/counted_iterator.h" }
       module data                  { private header "__iterator/data.h" }
       module default_sentinel      { private header "__iterator/default_sentinel.h" }
       module distance              { private header "__iterator/distance.h" }
       module empty                 { private header "__iterator/empty.h" }
       module erase_if_container    { private header "__iterator/erase_if_container.h" }
       module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
       module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
module __ranges {
       module counted                {
         private header "__ranges/counted.h"
         export span
       }
       module dangling               { private header "__ranges/dangling.h" }
       module data                   { private header "__ranges/data.h" }
       module drop_view              { private header "__ranges/drop_view.h" }
       module drop_while_view        { private header "__ranges/drop_while_view.h" }
+      module elements_view          { private header "__ranges/elements_view.h" }
       module empty                  { private header "__ranges/empty.h" }
       module empty_view             { private header "__ranges/empty_view.h" }
       module enable_borrowed_range  { private header "__ranges/enable_borrowed_range.h" }
       module enable_view            { private header "__ranges/enable_view.h" }
       module filter_view            { private header "__ranges/filter_view.h" }
       module iota_view              { private header "__ranges/iota_view.h" }
       module istream_view           {
         @requires_LIBCXX_ENABLE_LOCALIZATION@
         private header "__ranges/istream_view.h"
       }
       module join_view              { private header "__ranges/join_view.h" }
       module lazy_split_view        { private header "__ranges/lazy_split_view.h" }
       module non_propagating_cache  { private header "__ranges/non_propagating_cache.h" }
       module owning_view            { private header "__ranges/owning_view.h" }
       module range_adaptor          { private header "__ranges/range_adaptor.h" }
       module rbegin                 { private header "__ranges/rbegin.h" }
       module ref_view               { private header "__ranges/ref_view.h" }
       module rend                   { private header "__ranges/rend.h" }
       module reverse_view           { private header "__ranges/reverse_view.h" }
       module single_view            { private header "__ranges/single_view.h" }
       module size                   { private header "__ranges/size.h" }
-      module subrange               { private header "__ranges/subrange.h" }
+      module subrange               {
+        private header "__ranges/subrange.h"
+
+        module subrange_fwd { private header "__fwd/subrange.h" }
+      }
       module take_view              { private header "__ranges/take_view.h" }
       module take_while_view        { private header "__ranges/take_while_view.h" }
       module transform_view         {
         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" }

libcxx/include/ranges

namespace std::ranges {
   struct dangling;
 
   template<range R>
     using borrowed_iterator_t = see below;
 
   template<range R>
     using borrowed_subrange_t = see below;
 
+  // [range.elements], elements view
+  template<input_range V, size_t N>
+    requires see below
+  class elements_view;
+
+  template<class T, size_t N>
+    inline constexpr bool enable_borrowed_range<elements_view<T, N>> =
+      enable_borrowed_range<T>;
+
+  template<class R>
+    using keys_view = elements_view<R, 0>;
+  template<class R>
+    using values_view = elements_view<R, 1>;
+
+  namespace views {
+    template<size_t N>
+      inline constexpr unspecified elements = unspecified;
+    inline constexpr auto keys = elements<0>;
+    inline constexpr auto values = elements<1>;
+  }
+
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
   class empty_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<empty_view<T>> = true;
 

 #include <__ranges/all.h>
 #include <__ranges/common_view.h>
 #include <__ranges/concepts.h>
 #include <__ranges/counted.h>
 #include <__ranges/dangling.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/drop_while_view.h>
+#include <__ranges/elements_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/filter_view.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/join_view.h>
 #include <__ranges/lazy_split_view.h>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__functional/unwrap_ref.h> // expected-error@*:* {{use of private header from outside its module: '__functional/unwrap_ref.h'}}
 #include <__functional/weak_result_type.h> // expected-error@*:* {{use of private header from outside its module: '__functional/weak_result_type.h'}}
 #include <__fwd/array.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/array.h'}}
 #include <__fwd/get.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/get.h'}}
 #include <__fwd/hash.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/hash.h'}}
 #include <__fwd/pair.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/pair.h'}}
 #include <__fwd/span.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/span.h'}}
 #include <__fwd/string_view.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string_view.h'}}
+#include <__fwd/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/subrange.h'}}
 #include <__fwd/tuple.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/tuple.h'}}
 #include <__ios/fpos.h> // expected-error@*:* {{use of private header from outside its module: '__ios/fpos.h'}}
 #include <__iterator/access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/access.h'}}
 #include <__iterator/advance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/advance.h'}}
 #include <__iterator/back_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/back_insert_iterator.h'}}
 #include <__iterator/bounded_iter.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/bounded_iter.h'}}
 #include <__iterator/common_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/common_iterator.h'}}
 #include <__iterator/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts.h'}}
+#include <__iterator/concepts/can_reference.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts/can_reference.h'}}
+#include <__iterator/concepts/input_or_output_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts/input_or_output_iterator.h'}}
+#include <__iterator/concepts/sentinel_for.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts/sentinel_for.h'}}
+#include <__iterator/concepts/sized_sentinel_for.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts/sized_sentinel_for.h'}}
+#include <__iterator/concepts/weakly_incrementable.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts/weakly_incrementable.h'}}
 #include <__iterator/counted_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/counted_iterator.h'}}
 #include <__iterator/data.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/data.h'}}
 #include <__iterator/default_sentinel.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/default_sentinel.h'}}
 #include <__iterator/distance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/distance.h'}}
 #include <__iterator/empty.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/empty.h'}}
 #include <__iterator/erase_if_container.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/erase_if_container.h'}}
 #include <__iterator/front_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/front_insert_iterator.h'}}
 #include <__iterator/incrementable_traits.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/incrementable_traits.h'}}

 #include <__ranges/common_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/common_view.h'}}
 #include <__ranges/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/concepts.h'}}
 #include <__ranges/copyable_box.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/copyable_box.h'}}
 #include <__ranges/counted.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/counted.h'}}
 #include <__ranges/dangling.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/dangling.h'}}
 #include <__ranges/data.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/data.h'}}
 #include <__ranges/drop_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_view.h'}}
 #include <__ranges/drop_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/drop_while_view.h'}}
+#include <__ranges/elements_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/elements_view.h'}}
 #include <__ranges/empty.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty.h'}}
 #include <__ranges/empty_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/empty_view.h'}}
 #include <__ranges/enable_borrowed_range.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_borrowed_range.h'}}
 #include <__ranges/enable_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/enable_view.h'}}
 #include <__ranges/filter_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/filter_view.h'}}
 #include <__ranges/iota_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/iota_view.h'}}
 #include <__ranges/istream_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/istream_view.h'}}
 #include <__ranges/join_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/join_view.h'}}

libcxx/test/std/ranges/range.adaptors/range.elements/adaptor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// std::views::elements<N>
+// std::views::keys
+// std::views::values
+
+#include <algorithm>
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+template <class T>
+struct View : std::ranges::view_base {
+  T* begin() const;
+  T* end() const;
+};
+
+static_assert(!std::is_invocable_v<decltype((std::views::elements<0>))>);
+static_assert(!std::is_invocable_v<decltype((std::views::elements<0>)), View<int>>);
+static_assert(std::is_invocable_v<decltype((std::views::elements<0>)), View<std::pair<int, int>>>);
+static_assert(std::is_invocable_v<decltype((std::views::elements<0>)), View<std::tuple<int>>>);
+static_assert(!std::is_invocable_v<decltype((std::views::elements<5>)), View<std::tuple<int>>>);
+
+static_assert(!std::is_invocable_v<decltype((std::views::keys))>);
+static_assert(!std::is_invocable_v<decltype((std::views::keys)), View<int>>);
+static_assert(std::is_invocable_v<decltype((std::views::keys)), View<std::pair<int, int>>>);
+static_assert(std::is_invocable_v<decltype((std::views::keys)), View<std::tuple<int>>>);
+
+static_assert(!std::is_invocable_v<decltype((std::views::values))>);
+static_assert(!std::is_invocable_v<decltype((std::views::values)), View<int>>);
+static_assert(std::is_invocable_v<decltype((std::views::values)), View<std::pair<int, int>>>);
+static_assert(!std::is_invocable_v<decltype((std::views::values)), View<std::tuple<int>>>);
+
+template <class View, class T>
+concept CanBePiped =
+    requires(View&& view, T&& t) {
+      { std::forward<View>(view) | std::forward<T>(t) };
+    };
+
+static_assert(!CanBePiped<View<int>, decltype((std::views::elements<0>))>);
+static_assert(CanBePiped<View<std::pair<int, int>>, decltype((std::views::elements<0>))>);
+static_assert(CanBePiped<View<std::tuple<int>>, decltype((std::views::elements<0>))>);
+static_assert(!CanBePiped<View<std::tuple<int>>, decltype((std::views::elements<5>))>);
+
+static_assert(!CanBePiped<View<int>, decltype((std::views::keys))>);
+static_assert(CanBePiped<View<std::pair<int, int>>, decltype((std::views::keys))>);
+static_assert(CanBePiped<View<std::tuple<int>>, decltype((std::views::keys))>);
+
+static_assert(!CanBePiped<View<int>, decltype((std::views::values))>);
+static_assert(CanBePiped<View<std::pair<int, int>>, decltype((std::views::values))>);
+static_assert(!CanBePiped<View<std::tuple<int>>, decltype((std::views::values))>);
+
+constexpr bool test() {
+  std::pair<int, int> buff[] = {{1, 2}, {3, 4}, {5, 6}};
+
+  // Test `views::elements<N>(v)`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 0>;
+    std::same_as<Result> decltype(auto) result = std::views::elements<0>(buff);
+    auto expected                              = {1, 3, 5};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test `views::keys(v)`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 0>;
+    std::same_as<Result> decltype(auto) result = std::views::keys(buff);
+    auto expected                              = {1, 3, 5};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test `views::values(v)`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 1>;
+    std::same_as<Result> decltype(auto) result = std::views::values(buff);
+    auto expected                              = {2, 4, 6};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test `v | views::elements<N>`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 1>;
+    std::same_as<Result> decltype(auto) result = buff | std::views::elements<1>;
+    auto expected                              = {2, 4, 6};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test `v | views::keys`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 0>;
+    std::same_as<Result> decltype(auto) result = buff | std::views::keys;
+    auto expected                              = {1, 3, 5};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test `v | views::values`
+  {
+    using Result = std::ranges::elements_view<std::ranges::ref_view<std::pair<int, int>[3]>, 1>;
+    std::same_as<Result> decltype(auto) result = buff | std::views::values;
+    auto expected                              = {2, 4, 6};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test views::elements<0> | views::elements<0>
+  {
+    std::pair<std::tuple<int>, std::tuple<int>> nested[] = {{{1}, {2}}, {{3}, {4}}, {{5}, {6}}};
+    using Result                                         = std::ranges::elements_view<
+        std::ranges::elements_view<std::ranges::ref_view<std::pair<std::tuple<int>, std::tuple<int>>[3]>, 0>,
+        0>;
+    auto const partial                         = std::views::elements<0> | std::views::elements<0>;
+    std::same_as<Result> decltype(auto) result = nested | partial;
+    auto expected                              = {1, 3, 5};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test views::keys | views::keys
+  {
+    std::pair<std::tuple<int>, std::tuple<int>> nested[] = {{{1}, {2}}, {{3}, {4}}, {{5}, {6}}};
+    using Result                                         = std::ranges::elements_view<
+        std::ranges::elements_view<std::ranges::ref_view<std::pair<std::tuple<int>, std::tuple<int>>[3]>, 0>,
+        0>;
+    auto const partial                         = std::views::keys | std::views::keys;
+    std::same_as<Result> decltype(auto) result = nested | partial;
+    auto expected                              = {1, 3, 5};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test views::values | views::values
+  {
+    std::pair<std::tuple<int>, std::tuple<int, int>> nested[] = {{{1}, {2, 2}}, {{3}, {4, 4}}, {{5}, {6, 6}}};
+    using Result                                              = std::ranges::elements_view<
+        std::ranges::elements_view<std::ranges::ref_view<std::pair<std::tuple<int>, std::tuple<int, int>>[3]>, 1>,
+        1>;
+    auto const partial                         = std::views::values | std::views::values;
+    std::same_as<Result> decltype(auto) result = nested | partial;
+    auto expected                              = {2, 4, 6};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

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

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+//  constexpr auto begin() requires (!simple-view<V>)
+//  constexpr auto begin() const requires range<const V>
+
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+#include "types.h"
+
+template <class T>
+concept HasConstBegin = requires(const T ct) { ct.begin(); };
+
+template <class T>
+concept HasBegin = requires(T t) { t.begin(); };
+
+template <class T>
+concept HasConstAndNonConstBegin =
+    HasConstBegin<T> &&
+    // because const begin and non-const begin returns different types (iterator<true>, iterator<false>)
+    requires(T t, const T ct) { requires !std::same_as<decltype(t.begin()), decltype(ct.begin())>; };
+
+template <class T>
+concept HasOnlyNonConstBegin = HasBegin<T> && !HasConstBegin<T>;
+
+template <class T>
+concept HasOnlyConstBegin = HasConstBegin<T> && !HasConstAndNonConstBegin<T>;
+
+struct NoConstBeginView : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  constexpr std::tuple<int>* begin() { return buffer_; }
+  constexpr std::tuple<int>* end() { return buffer_ + size_; }
+};
+
+// simple-view<V>
+static_assert(HasOnlyConstBegin<std::ranges::elements_view<SimpleCommon, 0>>);
+
+// !simple-view<V> && range<const V>
+static_assert(HasConstAndNonConstBegin<std::ranges::elements_view<NonSimpleCommon, 0>>);
+
+// !range<const V>
+static_assert(HasOnlyNonConstBegin<std::ranges::elements_view<NoConstBeginView, 0>>);
+
+constexpr bool test() {
+  std::tuple<int> buffer[] = {{1}, {2}};
+  {
+    // underlying iterator should be pointing to the first element
+    auto ev   = std::views::elements<0>(buffer);
+    auto iter = ev.begin();
+    assert(&(*iter) == &std::get<0>(buffer[0]));
+  }
+
+  {
+    // underlying range models simple-view
+    auto v = std::views::elements<0>(SimpleCommon{buffer});
+    static_assert(std::is_same_v<decltype(v.begin()), decltype(std::as_const(v).begin())>);
+    assert(v.begin() == std::as_const(v).begin());
+    auto&& r = *std::as_const(v).begin();
+    assert(&r == &std::get<0>(buffer[0]));
+  }
+
+  {
+    // underlying const R is not a range
+    auto v   = std::views::elements<0>(NoConstBeginView{buffer});
+    auto&& r = *v.begin();
+    assert(&r == &std::get<0>(buffer[0]));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr explicit elements_view(V base);
+
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+
+struct View : std::ranges::view_base {
+  MoveOnly mo;
+  std::tuple<int>* begin() const;
+  std::tuple<int>* end() const;
+};
+
+// Test Explicit
+static_assert(std::is_constructible_v<std::ranges::elements_view<View, 0>, View>);
+static_assert(!std::is_constructible_v<View, std::ranges::elements_view<View, 0>>);
+
+constexpr bool test() {
+  {
+    std::ranges::elements_view<View, 0> ev{View{{}, MoveOnly{5}}};
+    assert(std::move(ev).base().mo.get() == 5);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr auto end() requires (!simple-view<V> && !common_range<V>)
+// constexpr auto end() requires (!simple-view<V> && common_range<V>)
+// constexpr auto end() const requires range<const V>
+// constexpr auto end() const requires common_range<const V>
+
+#include <cassert>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+
+#include "types.h"
+
+// | simple | common |      v.end()     | as_const(v)
+// |        |        |                  |   .end()
+// |--------|--------|------------------|---------------
+// |   Y    |   Y    |  iterator<true>  | iterator<true>
+// |   Y    |   N    |  sentinel<true>  | sentinel<true>
+// |   N    |   Y    |  iterator<false> | iterator<true>
+// |   N    |   N    |  sentinel<false> | sentinel<true>
+
+// !range<const V>
+template <class T>
+concept HasEnd = requires(T t) { t.end(); };
+
+template <class T>
+concept HasConstEnd = requires(const T ct) { ct.end(); };
+
+struct NoConstEndView : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  constexpr std::tuple<int>* begin() { return buffer_; }
+  constexpr std::tuple<int>* end() { return buffer_ + size_; }
+};
+
+static_assert(HasEnd<std::ranges::elements_view<NoConstEndView, 0>>);
+static_assert(!HasConstEnd<std::ranges::elements_view<NoConstEndView, 0>>);
+
+constexpr bool test() {
+  std::tuple<int> buffer[] = {{1}, {2}, {3}};
+
+  // simple-view && common_view
+  {
+    SimpleCommon v{buffer};
+    auto ev            = std::views::elements<0>(v);
+
+    auto it = ev.begin();
+    decltype(auto) st = ev.end();
+    assert(st == it + 3);
+
+    auto const_it = std::as_const(ev).begin();
+    decltype(auto) const_st = std::as_const(ev).end();
+    assert(const_st == const_it + 3);
+
+    // Both iterator<true>
+    static_assert(std::same_as<decltype(st), decltype(const_st)>);
+    static_assert(std::same_as<decltype(st), decltype(it)>);
+    static_assert(std::same_as<decltype(const_st), decltype(const_it)>);
+  }
+
+  // simple-view && !common_view
+  {
+    SimpleNonCommon v{buffer};
+    auto ev            = std::views::elements<0>(v);
+
+    auto it = ev.begin();
+    decltype(auto) st = ev.end();
+    assert(st == it + 3);
+
+    auto const_it = std::as_const(ev).begin();
+    decltype(auto) const_st = std::as_const(ev).end();
+    assert(const_st == const_it + 3);
+
+    // Both iterator<true>
+    static_assert(std::same_as<decltype(st), decltype(const_st)>);
+    static_assert(!std::same_as<decltype(st), decltype(it)>);
+    static_assert(!std::same_as<decltype(const_st), decltype(const_it)>);
+  }
+
+  // !simple-view && common_view
+  {
+    NonSimpleCommon v{buffer};
+    auto ev            = std::views::elements<0>(v);
+
+    auto it = ev.begin();
+    decltype(auto) st = ev.end();
+    assert(st == it + 3);
+
+    auto const_it = std::as_const(ev).begin();
+    decltype(auto) const_st = std::as_const(ev).end();
+    assert(const_st == const_it + 3);
+
+    // iterator<false> and iterator<true>
+    static_assert(!std::same_as<decltype(st), decltype(const_st)>);
+    static_assert(std::same_as<decltype(st), decltype(it)>);
+    static_assert(std::same_as<decltype(const_st), decltype(const_it)>);
+  }
+
+  // !simple-view && !common_view
+  {
+    NonSimpleNonCommon v{buffer};
+    auto ev            = std::views::elements<0>(v);
+
+    auto it = ev.begin();
+    decltype(auto) st = ev.end();
+    assert(st == it + 3);
+
+    auto const_it = std::as_const(ev).begin();
+    decltype(auto) const_st = std::as_const(ev).end();
+    assert(const_st == const_it + 3);
+
+    // sentinel<false> and sentinel<true>
+    static_assert(!std::same_as<decltype(st), decltype(const_st)>);
+    static_assert(!std::same_as<decltype(st), decltype(it)>);
+    static_assert(!std::same_as<decltype(const_st), decltype(const_it)>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// Some basic examples of how elements_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <algorithm>
+#include <cassert>
+#include <map>
+#include <ranges>
+#include <string_view>
+#include <utility>
+
+#include <iostream>
+
+int main(int, char**) {
+  using namespace std::string_view_literals;
+  auto historical_figures =
+      std::map{std::pair{"Lovelace"sv, 1815}, {"Turing"sv, 1912}, {"Babbage"sv, 1791}, {"Hamilton"sv, 1936}};
+
+  auto names         = historical_figures | std::views::elements<0>;
+  auto expectedNames = {"Babbage"sv, "Hamilton"sv, "Lovelace"sv, "Turing"sv};
+  std::ranges::equal(names, expectedNames);
+
+  auto birth_years   = historical_figures | std::views::elements<1>;
+  auto expectedYears = {1791, 1936, 1815, 1912};
+  std::ranges::equal(birth_years, expectedYears);
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/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
+
+// Member typedefs in elements_view<V, N>::iterator.
+
+#include <concepts>
+#include <ranges>
+#include <tuple>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+
+template <class Iter>
+using Range = std::ranges::subrange<Iter, sentinel_wrapper<Iter>>;
+
+template <class Range, size_t N = 0>
+using ElementsIter = std::ranges::iterator_t<std::ranges::elements_view<Range, N>>;
+
+// using iterator_concept = see below;
+static_assert(std::same_as<ElementsIter<Range<cpp20_input_iterator<std::tuple<int>*>>>::iterator_concept,
+                           std::input_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<forward_iterator<std::tuple<int>*>>>::iterator_concept, //
+                           std::forward_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<bidirectional_iterator<std::tuple<int>*>>>::iterator_concept,
+                           std::bidirectional_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<random_access_iterator<std::tuple<int>*>>>::iterator_concept,
+                           std::random_access_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<contiguous_iterator<std::tuple<int>*>>>::iterator_concept,
+                           std::random_access_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<std::tuple<int>*>>::iterator_concept, //
+                           std::random_access_iterator_tag>);
+
+// using iterator_category = see below;   // not always present
+template <class T>
+concept HasIterCategory = requires { typename T::iterator_category; };
+
+static_assert(!HasIterCategory<ElementsIter<Range<cpp20_input_iterator<std::tuple<int>*>>>>);
+static_assert(HasIterCategory<ElementsIter<Range<forward_iterator<std::tuple<int>*>>>>);
+
+static_assert(std::same_as<ElementsIter<Range<forward_iterator<std::tuple<int>*>>>::iterator_category,
+                           std::forward_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<bidirectional_iterator<std::tuple<int>*>>>::iterator_category,
+                           std::bidirectional_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<random_access_iterator<std::tuple<int>*>>>::iterator_category,
+                           std::random_access_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<contiguous_iterator<std::tuple<int>*>>>::iterator_category,
+                           std::random_access_iterator_tag>);
+
+static_assert(std::same_as<ElementsIter<Range<std::tuple<int>*>>::iterator_category, //
+                           std::random_access_iterator_tag>);
+
+using Generator = decltype(std::views::iota(0, 1) | std::views::transform([](int) {
+                             return std::pair<int, short>{1, 1};
+                           }));
+static_assert(std::ranges::random_access_range<Generator>);
+
+static_assert(std::same_as<ElementsIter<Generator>::iterator_category, //
+                           std::input_iterator_tag>);
+
+// using value_type = remove_cvref_t<tuple_element_t<N, range_value_t<Base>>>;
+static_assert(std::same_as<ElementsIter<Range<std::tuple<int, long>*>, 0>::value_type, int>);
+
+static_assert(std::same_as<ElementsIter<Range<std::tuple<int, long>*>, 1>::value_type, long>);
+
+static_assert(std::same_as<ElementsIter<Generator, 0>::value_type, int>);
+
+static_assert(std::same_as<ElementsIter<Generator, 1>::value_type, short>);
+
+// using difference_type = range_difference_t<Base>;
+static_assert(std::same_as<ElementsIter<Range<std::tuple<int, long>*>>::difference_type,
+                           std::ranges::range_difference_t<Range<std::tuple<int, long>*>>>);
+
+static_assert(std::same_as<ElementsIter<Generator>::difference_type, //
+                           std::ranges::range_difference_t<Generator>>);

libcxx/test/std/ranges/range.adaptors/range.elements/range.concept.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
+
+// concept checking
+//
+// template<class T, size_t N>
+// concept has-tuple-element =
+//   tuple-like<T> && N < tuple_size_v<T>;
+//
+// template<class T, size_t N>
+// concept returnable-element =
+//   is_reference_v<T> || move_constructible<tuple_element_t<N, T>>;
+//
+// template<input_range V, size_t N>
+//   requires view<V> && has-tuple-element<range_value_t<V>, N> &&
+//            has-tuple-element<remove_reference_t<range_reference_t<V>>, N> &&
+//            returnable-element<range_reference_t<V>, N>
+// class elements_view;
+
+#include <array>
+#include <tuple>
+#include <ranges>
+#include <utility>
+
+#include "test_iterators.h"
+
+template <class It>
+using Range = std::ranges::subrange<It, sentinel_wrapper<It>>;
+
+template <class V, size_t N>
+concept HasElementsView = requires { typename std::ranges::elements_view<V, N>; };
+
+static_assert(HasElementsView<Range<std::ranges::subrange<int*>*>, 0>);
+static_assert(HasElementsView<Range<std::pair<int, int>*>, 1>);
+static_assert(HasElementsView<Range<std::tuple<int, int, int>*>, 2>);
+static_assert(HasElementsView<Range<std::array<int, 4>*>, 3>);
+
+// !view<V>
+static_assert(!HasElementsView<std::array<std::tuple<int>, 1>, 0>);
+
+// !input_range
+static_assert(!HasElementsView<Range<cpp20_output_iterator<std::tuple<int>*>>, 0>);
+
+// !tuple-like
+static_assert(!HasElementsView<Range<int*>, 1>);
+
+// !(N > tuple_size_v<T>)
+static_assert(!HasElementsView<Range<std::pair<int, int>*>, 2>);
+
+// ! (is_reference_v<T> || move_constructible<tuple_element_t<N, T>>)
+struct NonMovable {
+  NonMovable(int) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+using NonMovableGenerator =
+    decltype(std::views::iota(0, 1) | std::views::transform([](int) {
+               return std::pair<NonMovable, int>{1, 1};
+             }));
+
+static_assert(!HasElementsView<NonMovableGenerator, 0>);
+static_assert( HasElementsView<NonMovableGenerator, 1>);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+#include "types.h"
+
+template <class T>
+concept HasSize = requires(T t) { t.size(); };
+
+static_assert(HasSize<std::ranges::elements_view<SimpleCommon, 0>>);
+static_assert(HasSize<const std::ranges::elements_view<SimpleCommon, 0>>);
+
+struct NonSized : std::ranges::view_base {
+  using iterator = forward_iterator<std::tuple<int>*>;
+  iterator begin() const;
+  iterator end() const;
+};
+static_assert(!std::ranges::sized_range<NonSized>);
+static_assert(!std::ranges::sized_range<const NonSized>);
+
+static_assert(!HasSize<std::ranges::elements_view<NonSized, 0>>);
+static_assert(!HasSize<const std::ranges::elements_view<NonSized, 0>>);
+
+struct SizedNonConst : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+
+  using iterator = forward_iterator<std::tuple<int>*>;
+  constexpr auto begin() const { return iterator{buffer_}; }
+  constexpr auto end() const { return iterator{buffer_ + size_}; }
+  constexpr std::size_t size() { return size_; }
+};
+
+static_assert(HasSize<std::ranges::elements_view<SizedNonConst, 0>>);
+static_assert(!HasSize<const std::ranges::elements_view<SizedNonConst, 0>>);
+
+constexpr bool test() {
+  std::tuple<int> buffer[] = {{1}, {2}, {3}};
+
+  // non-const and const are sized
+  {
+    auto ev = std::views::elements<0>(buffer);
+    assert(ev.size() == 3);
+    assert(std::as_const(ev).size() == 3);
+  }
+
+  {
+    // const-view non-sized range
+    auto ev = std::views::elements<0>(SizedNonConst{buffer});
+    assert(ev.size() == 3);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/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_ELEMENTS_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ELEMENTS_TYPES_H
+
+#include <functional>
+#include <ranges>
+#include <tuple>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+template <class T>
+struct BufferView : std::ranges::view_base {
+  T* buffer_;
+  std::size_t size_;
+
+  template <std::size_t N>
+  constexpr BufferView(T (&b)[N]) : buffer_(b), size_(N) {}
+};
+
+using TupleBufferView = BufferView<std::tuple<int>>;
+
+template <bool Simple>
+struct Common :  TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+
+  constexpr std::tuple<int>* begin()
+    requires(!Simple)
+  {
+    return buffer_;
+  }
+  constexpr const std::tuple<int>* begin() const { return buffer_; }
+  constexpr std::tuple<int>* end()
+    requires(!Simple)
+  {
+    return buffer_ + size_;
+  }
+  constexpr const std::tuple<int>* end() const { return buffer_ + size_; }
+};
+using SimpleCommon = Common<true>;
+using NonSimpleCommon = Common<false>;
+
+using SimpleCommonRandomAccessSized = SimpleCommon;
+using NonSimpleCommonRandomAccessSized = NonSimpleCommon;
+
+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>);
+#if 0
+template <bool Simple>
+struct CommonNonRandom : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  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>);
+#endif
+
+template <bool Simple>
+struct NonCommon : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  constexpr std::tuple<int>* begin()
+    requires(!Simple) {
+    return buffer_;
+  }
+  constexpr const std::tuple<int>* begin() const { return buffer_; }
+  constexpr sentinel_wrapper<std::tuple<int>*> end()
+    requires(!Simple) {
+    return sentinel_wrapper<std::tuple<int>*>(buffer_ + size_);
+  }
+  constexpr sentinel_wrapper<const std::tuple<int>*> end() const { return sentinel_wrapper<const std::tuple<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>);
+
+#if 0
+template <bool Simple>
+struct NonCommonSized : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  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 SimpleNonCommonRandomAcessSized = SimpleNonCommonSized;
+using NonSimpleNonCommonSized = NonCommonSized<false>;
+using NonSimpleNonCommonRandomAcessSized = NonSimpleNonCommonSized;
+
+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 : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+
+  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>);
+
+template <class Iter, class Sent = Iter, class NonConstIter = Iter, class NonConstSent = Sent>
+struct BasicView : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+
+  constexpr NonConstIter begin()
+    requires(!std::is_same_v<Iter, NonConstIter>) {
+    return NonConstIter(buffer_);
+  }
+  constexpr Iter begin() const { return Iter(buffer_); }
+
+  constexpr NonConstSent end()
+    requires(!std::is_same_v<Sent, NonConstSent>) {
+    if constexpr (std::is_same_v<NonConstIter, NonConstSent>) {
+      return NonConstIter(buffer_ + size_);
+    } else {
+      return NonConstSent(NonConstIter(buffer_ + size_));
+    }
+  }
+
+  constexpr Sent end() const {
+    if constexpr (std::is_same_v<Iter, Sent>) {
+      return Iter(buffer_ + size_);
+    } else {
+      return Sent(Iter(buffer_ + size_));
+    }
+  }
+};
+
+template <class Base = int*>
+struct forward_sized_iterator {
+  Base it_ = nullptr;
+
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = int;
+  using difference_type = intptr_t;
+  using pointer = Base;
+  using reference = decltype(*Base{});
+
+  forward_sized_iterator() = default;
+  constexpr forward_sized_iterator(Base 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<>>);
+
+using ForwardSizedView = BasicView<forward_sized_iterator<>>;
+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>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<ForwardSizedView>);
+
+using NonSimpleForwardSizedView = BasicView<forward_sized_iterator<const int*>, forward_sized_iterator<const int*>,
+                                            forward_sized_iterator<int*>, forward_sized_iterator<int*>>;
+static_assert(std::ranges::forward_range<NonSimpleForwardSizedView>);
+static_assert(std::ranges::sized_range<NonSimpleForwardSizedView>);
+static_assert(std::ranges::common_range<NonSimpleForwardSizedView>);
+static_assert(!std::ranges::random_access_range<NonSimpleForwardSizedView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardSizedView>);
+
+using ForwardSizedNonCommon = BasicView<forward_sized_iterator<>, sized_sentinel<forward_sized_iterator<>>>;
+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>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<ForwardSizedNonCommon>);
+
+using NonSimpleForwardSizedNonCommon =
+    BasicView<forward_sized_iterator<const int*>, sized_sentinel<forward_sized_iterator<const int*>>,
+              forward_sized_iterator<int*>, sized_sentinel<forward_sized_iterator<int*>>>;
+static_assert(std::ranges::forward_range<NonSimpleForwardSizedNonCommon>);
+static_assert(std::ranges::sized_range<NonSimpleForwardSizedNonCommon>);
+static_assert(!std::ranges::common_range<NonSimpleForwardSizedNonCommon>);
+static_assert(!std::ranges::random_access_range<NonSimpleForwardSizedNonCommon>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleForwardSizedNonCommon>);
+
+struct SizedRandomAccessView : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  using iterator = random_access_iterator<int*>;
+
+  constexpr auto begin() const { return iterator(buffer_); }
+  constexpr auto end() const { return sized_sentinel<iterator>(iterator(buffer_ + size_)); }
+
+  constexpr decltype(auto) operator[](std::size_t n) const { return *(begin() + n); }
+};
+static_assert(std::ranges::view<SizedRandomAccessView>);
+static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
+static_assert(std::ranges::sized_range<SizedRandomAccessView>);
+
+using NonSizedRandomAccessView =
+    BasicView<random_access_iterator<int*>, sentinel_wrapper<random_access_iterator<int*>>>;
+static_assert(!std::ranges::contiguous_range<NonSizedRandomAccessView>);
+static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
+static_assert(!std::ranges::common_range<NonSizedRandomAccessView>);
+static_assert(!std::ranges::sized_range<NonSizedRandomAccessView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<NonSizedRandomAccessView>);
+
+using NonSimpleNonSizedRandomAccessView =
+    BasicView<random_access_iterator<const int*>, sentinel_wrapper<random_access_iterator<const int*>>,
+              random_access_iterator<int*>, sentinel_wrapper<random_access_iterator<int*>> >;
+static_assert(!std::ranges::contiguous_range<NonSimpleNonSizedRandomAccessView>);
+static_assert(std::ranges::random_access_range<NonSimpleNonSizedRandomAccessView>);
+static_assert(!std::ranges::common_range<NonSimpleNonSizedRandomAccessView>);
+static_assert(!std::ranges::sized_range<NonSimpleNonSizedRandomAccessView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleNonSizedRandomAccessView>);
+
+using ContiguousCommonView = BasicView<int*>;
+static_assert(std::ranges::contiguous_range<ContiguousCommonView>);
+static_assert(std::ranges::common_range<ContiguousCommonView>);
+static_assert(std::ranges::sized_range<ContiguousCommonView>);
+
+using ContiguousNonCommonView = BasicView<int*, sentinel_wrapper<int*>>;
+static_assert(std::ranges::contiguous_range<ContiguousNonCommonView>);
+static_assert(!std::ranges::common_range<ContiguousNonCommonView>);
+static_assert(!std::ranges::sized_range<ContiguousNonCommonView>);
+
+using ContiguousNonCommonSized = BasicView<int*, sized_sentinel<int*>>;
+
+static_assert(std::ranges::contiguous_range<ContiguousNonCommonSized>);
+static_assert(!std::ranges::common_range<ContiguousNonCommonSized>);
+static_assert(std::ranges::sized_range<ContiguousNonCommonSized>);
+
+template <class Base = int*>
+struct common_input_iterator {
+  Base it_;
+
+  using value_type = int;
+  using difference_type = std::intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr common_input_iterator() = default;
+  constexpr explicit common_input_iterator(Base it) : it_(it) {}
+
+  constexpr common_input_iterator& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+
+  constexpr int& operator*() const { return *it_; }
+
+  friend constexpr bool operator==(common_input_iterator const&, common_input_iterator const&) = default;
+};
+
+using InputCommonView = BasicView<common_input_iterator<>>;
+static_assert(std::ranges::input_range<InputCommonView>);
+static_assert(!std::ranges::forward_range<InputCommonView>);
+static_assert(std::ranges::common_range<InputCommonView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InputCommonView>);
+
+using NonSimpleInputCommonView = BasicView<common_input_iterator<const int*>, common_input_iterator<const int*>,
+                                           common_input_iterator<int*>, common_input_iterator<int*>>;
+static_assert(std::ranges::input_range<NonSimpleInputCommonView>);
+static_assert(!std::ranges::forward_range<NonSimpleInputCommonView>);
+static_assert(std::ranges::common_range<NonSimpleInputCommonView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleInputCommonView>);
+
+using InputNonCommonView = BasicView<common_input_iterator<>, sentinel_wrapper<common_input_iterator<>>>;
+static_assert(std::ranges::input_range<InputNonCommonView>);
+static_assert(!std::ranges::forward_range<InputNonCommonView>);
+static_assert(!std::ranges::common_range<InputNonCommonView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<InputNonCommonView>);
+
+using NonSimpleInputNonCommonView =
+    BasicView<common_input_iterator<const int*>, sentinel_wrapper<common_input_iterator<const int*>>,
+              common_input_iterator<int*>, sentinel_wrapper<common_input_iterator<int*>>>;
+static_assert(std::ranges::input_range<InputNonCommonView>);
+static_assert(!std::ranges::forward_range<InputNonCommonView>);
+static_assert(!std::ranges::common_range<InputNonCommonView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleInputNonCommonView>);
+
+using BidiCommonView = BasicView<bidirectional_iterator<int*>>;
+static_assert(!std::ranges::sized_range<BidiCommonView>);
+static_assert(std::ranges::bidirectional_range<BidiCommonView>);
+static_assert(!std::ranges::random_access_range<BidiCommonView>);
+static_assert(std::ranges::common_range<BidiCommonView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<BidiCommonView>);
+
+using NonSimpleBidiCommonView = BasicView<bidirectional_iterator<const int*>, bidirectional_iterator<const int*>,
+                                          bidirectional_iterator<int*>, bidirectional_iterator<int*>>;
+static_assert(!std::ranges::sized_range<NonSimpleBidiCommonView>);
+static_assert(std::ranges::bidirectional_range<NonSimpleBidiCommonView>);
+static_assert(!std::ranges::random_access_range<NonSimpleBidiCommonView>);
+static_assert(std::ranges::common_range<NonSimpleBidiCommonView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleBidiCommonView>);
+
+struct SizedBidiCommon : BidiCommonView {
+  using BidiCommonView::BidiCommonView;
+  std::size_t size() const { return base(end()) - base(begin()); }
+};
+static_assert(std::ranges::sized_range<SizedBidiCommon>);
+static_assert(std::ranges::bidirectional_range<SizedBidiCommon>);
+static_assert(!std::ranges::random_access_range<SizedBidiCommon>);
+static_assert(std::ranges::common_range<SizedBidiCommon>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SizedBidiCommon>);
+
+struct NonSimpleSizedBidiCommon : NonSimpleBidiCommonView {
+  using NonSimpleBidiCommonView::NonSimpleBidiCommonView;
+  std::size_t size() const { return base(end()) - base(begin()); }
+};
+static_assert(std::ranges::sized_range<NonSimpleSizedBidiCommon>);
+static_assert(std::ranges::bidirectional_range<NonSimpleSizedBidiCommon>);
+static_assert(!std::ranges::random_access_range<NonSimpleSizedBidiCommon>);
+static_assert(std::ranges::common_range<NonSimpleSizedBidiCommon>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleSizedBidiCommon>);
+
+using BidiNonCommonView = BasicView<bidirectional_iterator<int*>, sentinel_wrapper<bidirectional_iterator<int*>>>;
+static_assert(!std::ranges::sized_range<BidiNonCommonView>);
+static_assert(std::ranges::bidirectional_range<BidiNonCommonView>);
+static_assert(!std::ranges::random_access_range<BidiNonCommonView>);
+static_assert(!std::ranges::common_range<BidiNonCommonView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<BidiNonCommonView>);
+
+using NonSimpleBidiNonCommonView =
+    BasicView<bidirectional_iterator<const int*>, sentinel_wrapper<bidirectional_iterator<const int*>>,
+              bidirectional_iterator<int*>, sentinel_wrapper<bidirectional_iterator<int*>>>;
+static_assert(!std::ranges::sized_range<NonSimpleBidiNonCommonView>);
+static_assert(std::ranges::bidirectional_range<NonSimpleBidiNonCommonView>);
+static_assert(!std::ranges::random_access_range<NonSimpleBidiNonCommonView>);
+static_assert(!std::ranges::common_range<NonSimpleBidiNonCommonView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleBidiNonCommonView>);
+
+using SizedBidiNonCommonView = BasicView<bidirectional_iterator<int*>, sized_sentinel<bidirectional_iterator<int*>>>;
+static_assert(std::ranges::sized_range<SizedBidiNonCommonView>);
+static_assert(std::ranges::bidirectional_range<SizedBidiNonCommonView>);
+static_assert(!std::ranges::random_access_range<SizedBidiNonCommonView>);
+static_assert(!std::ranges::common_range<SizedBidiNonCommonView>);
+LIBCPP_STATIC_ASSERT(std::ranges::__simple_view<SizedBidiNonCommonView>);
+
+using NonSimpleSizedBidiNonCommonView =
+    BasicView<bidirectional_iterator<const int*>, sized_sentinel<bidirectional_iterator<const int*>>,
+              bidirectional_iterator<int*>, sized_sentinel<bidirectional_iterator<int*>>>;
+static_assert(std::ranges::sized_range<NonSimpleSizedBidiNonCommonView>);
+static_assert(std::ranges::bidirectional_range<NonSimpleSizedBidiNonCommonView>);
+static_assert(!std::ranges::random_access_range<NonSimpleSizedBidiNonCommonView>);
+static_assert(!std::ranges::common_range<NonSimpleSizedBidiNonCommonView>);
+LIBCPP_STATIC_ASSERT(!std::ranges::__simple_view<NonSimpleSizedBidiNonCommonView>);
+
+namespace adltest{
+struct iter_move_swap_iterator {
+
+  std::reference_wrapper<int> iter_move_called_times;
+  std::reference_wrapper<int> iter_swap_called_times;
+  int i = 0;
+
+  using iterator_category = std::input_iterator_tag;
+  using value_type = int;
+  using difference_type = intptr_t;
+
+  constexpr int operator*() const { return i; }
+
+  constexpr iter_move_swap_iterator& operator++() {
+    ++i;
+    return *this;
+  }
+  constexpr void operator++(int) { ++i; }
+
+  friend constexpr bool operator==(const iter_move_swap_iterator& x, std::default_sentinel_t) { return x.i == 5; }
+
+  friend constexpr int iter_move(iter_move_swap_iterator const& it) {
+    ++it.iter_move_called_times;
+    return it.i;
+  }
+  friend constexpr void iter_swap(iter_move_swap_iterator const& x, iter_move_swap_iterator const& y) {
+    ++x.iter_swap_called_times;
+    ++y.iter_swap_called_times;
+  }
+};
+
+struct IterMoveSwapRange {
+  int iter_move_called_times = 0;
+  int iter_swap_called_times = 0;
+  constexpr auto begin() { return iter_move_swap_iterator{iter_move_called_times, iter_swap_called_times}; }
+  constexpr auto end() const { return std::default_sentinel; }
+};
+} // namespace adltest
+
+#endif
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ELEMENTS_TYPES_H