[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

14 ↗

(On Diff #470745)

Nit: extraneous blank line.

libcxx/include/__iterator/concepts/input_or_output_iterator.h

16 ↗

(On Diff #470745)

Nit: extraneous blank line.

libcxx/include/__iterator/concepts/weakly_incrementable.h

18 ↗

(On Diff #470745)

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 ↗

(On Diff #470745)

Question: can you explain the idea here?

66 ↗

(On Diff #470745)

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

[philnik]

libcxx/include/__iterator/concepts/can_reference.h

2 ↗

(On Diff #470745)

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

2 ↗

(On Diff #470745)

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

2 ↗

(On Diff #470745)

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

2 ↗

(On Diff #470745)

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 ↗

(On Diff #470745)

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 ↗

(On Diff #470745)

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

49

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

53

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

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

54

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

83

Same nit: s/Ele/Elem/.

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

35

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

112

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

132

Perhaps also check not_equal_to, for completeness' sake?

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

12

Nit: extra semicolon.

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

50

Ultranit: please add a newline before this line.

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

68

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.

68

Optional: consider adding a blank line before this line.

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

52

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

100

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 ↗

(On Diff #470745)

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

53

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

54

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

68

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

53

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

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

54

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

27–31

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

27–31

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

27–31

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/ReleaseNotes.rst

 - P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
   ``from_chars`` for Integral Types in ``<charconv>`` Header
 - P0220R1 - Adopt Library Fundamentals V1 TS Components for C++17
 - P0482R6 - char8_t: A type for UTF-8 characters and strings
 - P2438R2 - ``std::string::substr() &&``
 - P0600R1 - ``nodiscard`` in the library
 - P0339R6 - ``polymorphic_allocator<>`` as a vocabulary type
 - P1169R4 - ``static operator()``
+- P1035R7 - Input Range Adaptors
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

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

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/docs/Status/SpaceshipProjects.csv

 | set",[expos.only.func],Unassigned,|Not Started|
 | `[queue.ops] <https://wg21.link/queue.ops>`_,| queue,None,Unassigned,|Not Started|
 | `[stack.ops] <https://wg21.link/stack.ops>`_,| stack,None,Unassigned,|Not Started|
 | `[reverse.iter.cmp] <https://wg21.link/reverse.iter.cmp>`_,| `reverse_iterator <https://reviews.llvm.org/D113695>`_,None,Mikhail Maltsev,|Complete|
 | `[move.iter.op.comp] <https://wg21.link/move.iter.op.comp>`_,| move_iterator,None,Unassigned,|Not Started|
 | `[counted.iter.cmp] <https://wg21.link/counted.iter.cmp>`_,| counted_iterator,None,Unassigned,|Not Started|
 | `[range.iota.iterator] <https://wg21.link/range.iota.iterator>`_,| `ranges::iota_view::iterator <https://reviews.llvm.org/D110774>`_,[concepts.cmp],Arthur O'Dwyer,|Complete|
 | `[range.transform.iterator] <https://wg21.link/range.transform.iterator>`_,| `ranges::transform_view::iterator <https://reviews.llvm.org/D110774>`_,[concepts.cmp],Arthur O'Dwyer,|Complete|
-| `[range.elements.iterator] <https://wg21.link/range.elements.iterator>`_,| ranges::elements_view::iterator,[concepts.cmp],Unassigned,|Not Started|
+| `[range.elements.iterator] <https://wg21.link/range.elements.iterator>`_,| ranges::elements_view::iterator,[concepts.cmp],Hui Xie,|Complete|
 | `[time.duration.comparisons] <https://wg21.link/time.duration.comparisons>`_, "chrono::duration", None, Mark de Wever, |Not Started|
 | `[time.point.comparisons] <https://wg21.link/time.point.comparisons>`_, "chrono::time_point", None, Mark de Wever, |Not Started|
 "| `[time.cal.day.nonmembers] <https://wg21.link/time.cal.day.nonmembers>`_
 | `[time.cal.month.nonmembers] <https://wg21.link/time.cal.month.nonmembers>`_
 | `[time.cal.year.nonmembers] <https://wg21.link/time.cal.year.nonmembers>`_
 | `[time.cal.md.nonmembers] <https://wg21.link/time.cal.md.nonmembers>`_
 | `[time.cal.mdlast] <https://wg21.link/time.cal.mdlast>`_
 | `[time.cal.ym.nonmembers] <https://wg21.link/time.cal.ym.nonmembers>`_

libcxx/include/CMakeLists.txt

set(files
   __fwd/array.h
   __fwd/get.h
   __fwd/hash.h
   __fwd/memory_resource.h
   __fwd/pair.h
   __fwd/span.h
   __fwd/string.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
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
set(files
   __support/xlocale/__posix_l_fallback.h
   __support/xlocale/__strtonum_fallback.h
   __thread/poll_with_backoff.h
   __thread/timed_backoff_policy.h
   __threading_support
   __tree
   __tuple/apply_cv.h
   __tuple/make_tuple_types.h
+  __tuple/pair_like.h
   __tuple/sfinae_helpers.h
   __tuple/tuple_element.h
   __tuple/tuple_indices.h
   __tuple/tuple_like.h
+  __tuple/tuple_like_ext.h
   __tuple/tuple_size.h
   __tuple/tuple_types.h
   __type_traits/add_const.h
   __type_traits/add_cv.h
   __type_traits/add_lvalue_reference.h
   __type_traits/add_pointer.h
   __type_traits/add_rvalue_reference.h
   __type_traits/add_volatile.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.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/__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 _View, size_t _Np, bool _Const>
+class __elements_view_iterator;
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_sentinel;
+
+template <class _Tp, size_t _Np>
+concept __has_tuple_element = __tuple_like<_Tp> && _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</*_Const=*/false>(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
+    return __iterator</*_Const=*/true>(ranges::begin(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View> && !common_range<_View>)
+  {
+    return __sentinel</*_Const=*/false>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View> && common_range<_View>)
+  {
+    return __iterator</*_Const=*/false>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    return __sentinel</*_Const=*/true>{ranges::end(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires common_range<const _View>
+  {
+    return __iterator</*_Const=*/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 _Const>
+  using __iterator = __elements_view_iterator<_View, _Np, _Const>;
+
+  template <bool _Const>
+  using __sentinel = __elements_view_sentinel<_View, _Np, _Const>;
+
+  _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 <class _View, size_t _Np, bool _Const>
+class __elements_view_iterator : public __elements_view_iterator_category_base<__maybe_const<_Const, _View>, _Np> {
+  template <class, size_t, bool >
+  friend class __elements_view_iterator;
+
+  template <class, size_t, bool >
+  friend class __elements_view_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 _Element = remove_cv_t<tuple_element_t<_Np, range_reference_t<_Base>>>;
+      return static_cast<_Element>(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 __elements_view_iterator()
+    requires default_initializable<iterator_t<_Base>>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __elements_view_iterator(iterator_t<_Base> __current)
+      : __current_(std::move(__current)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator(__elements_view_iterator<_View, _Np, !_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 __elements_view_iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator operator++(int)
+    requires forward_range<_Base>
+  {
+    auto temp = *this;
+    ++__current_;
+    return temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    --__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto temp = *this;
+    --__current_;
+    return temp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_iterator& operator+=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_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 __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires equality_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator<(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ < __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator>(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __y < __x;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator<=(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__y < __x);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator>=(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return !(__x < __y);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto
+  operator<=>(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ <=> __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+  operator+(const __elements_view_iterator& __x, difference_type __y)
+    requires random_access_range<_Base>
+  {
+    return __elements_view_iterator{__x} += __y;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+  operator+(difference_type __x, const __elements_view_iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __y + __x;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __elements_view_iterator
+  operator-(const __elements_view_iterator& __x, difference_type __y)
+    requires random_access_range<_Base>
+  {
+    return __elements_view_iterator{__x} -= __y;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+  operator-(const __elements_view_iterator& __x, const __elements_view_iterator& __y)
+    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+  {
+    return __x.__current_ - __y.__current_;
+  }
+};
+
+template <class _View, size_t _Np, bool _Const>
+class __elements_view_sentinel {
+private:
+  using _Base                                        = __maybe_const<_Const, _View>;
+  _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+  template <class, size_t, bool >
+  friend class __elements_view_sentinel;
+
+  template <bool _AnyConst>
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
+  __get_current(const __elements_view_iterator<_View, _Np, _AnyConst>& __iter) {
+    return (__iter.__current_);
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __elements_view_sentinel() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __elements_view_sentinel(sentinel_t<_Base> __end)
+      : __end_(std::move(__end)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __elements_view_sentinel(__elements_view_sentinel<_View, _Np, !_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 __elements_view_iterator<_View, _Np, _OtherConst>& __x, const __elements_view_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 __elements_view_iterator<_View, _Np, _OtherConst>& __x, const __elements_view_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 __elements_view_sentinel& __x, const __elements_view_iterator<_View, _Np, _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/pair_like.h>
 #include <__tuple/tuple_element.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
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 
 namespace ranges {
   template<class _From, class _To>
   concept __uses_nonqualification_pointer_conversion =
     is_pointer_v<_From> && is_pointer_v<_To> &&
     !convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>;
 
   template<class _From, class _To>
   concept __convertible_to_non_slicing =
     convertible_to<_From, _To> &&
     !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
 
-  template<class _Tp>
-  concept __pair_like =
-    !is_reference_v<_Tp> && requires(_Tp __t) {
-      typename tuple_size<_Tp>::type; // Ensures `tuple_size<T>` is complete.
-      requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
-      typename tuple_element_t<0, remove_const_t<_Tp>>;
-      typename tuple_element_t<1, remove_const_t<_Tp>>;
-      { std::get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
-      { std::get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
-    };
-
   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/pair_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_PAIR_LIKE_H
+#define _LIBCPP___TUPLE_PAIR_LIKE_H
+
+#include <__config>
+#include <__tuple/tuple_like.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/remove_cvref.h>
+
+#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 __pair_like = __tuple_like<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TUPLE_PAIR_LIKE_H

libcxx/include/__tuple/sfinae_helpers.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_SFINAE_HELPERS_H
 #define _LIBCPP___TUPLE_SFINAE_HELPERS_H
 
 #include <__config>
 #include <__fwd/tuple.h>
 #include <__tuple/make_tuple_types.h>
 #include <__tuple/tuple_element.h>
-#include <__tuple/tuple_like.h>
+#include <__tuple/tuple_like_ext.h>
 #include <__tuple/tuple_size.h>
 #include <__tuple/tuple_types.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
struct __tuple_sfinae_base {
   template <class _FromArgs, class _ToArgs>
   using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
   template <class _FromArgs, class _ToArgs>
   using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
 };
 
 // __tuple_convertible
 
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+                                bool = __tuple_like_ext<_Up>::value>
 struct __tuple_convertible
     : public false_type {};
 
 template <class _Tp, class _Up>
 struct __tuple_convertible<_Tp, _Up, true, true>
     : public __tuple_sfinae_base::__convertible<
       typename __make_tuple_types<_Tp>::type
     , typename __make_tuple_types<_Up>::type
     >
 {};
 
 // __tuple_constructible
 
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+                                bool = __tuple_like_ext<_Up>::value>
 struct __tuple_constructible
     : public false_type {};
 
 template <class _Tp, class _Up>
 struct __tuple_constructible<_Tp, _Up, true, true>
     : public __tuple_sfinae_base::__constructible<
       typename __make_tuple_types<_Tp>::type
     , typename __make_tuple_types<_Up>::type
     >
 {};
 
 // __tuple_assignable
 
-template <class _Tp, class _Up, bool = __tuple_like<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like<_Up>::value>
+template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+                                bool = __tuple_like_ext<_Up>::value>
 struct __tuple_assignable
     : public false_type {};
 
 template <class _Tp, class _Up>
 struct __tuple_assignable<_Tp, _Up, true, true>
     : public __tuple_sfinae_base::__assignable<
       typename __make_tuple_types<_Tp>::type
     , typename __make_tuple_types<_Up&>::type

 struct __tuple_like_with_size_imp : false_type {};
 
 template <class _SizeTrait, size_t _Expected>
 struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
     : integral_constant<bool, _SizeTrait::value == _Expected> {};
 
 template <class _Tuple, size_t _ExpectedSize, class _RawTuple = __libcpp_remove_reference_t<_Tuple> >
 using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp<
-                                   __tuple_like<_RawTuple>::value,
+                                   __tuple_like_ext<_RawTuple>::value,
                                    tuple_size<_RawTuple>, _ExpectedSize
                               >;
 
 struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
 
     static constexpr bool __enable_explicit_default() { return false; }
     static constexpr bool __enable_implicit_default() { return false; }
     template <class ...>

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/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 {};
+#if _LIBCPP_STD_VER >= 20
 
-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_impl : false_type {};
 
-#ifndef _LIBCPP_CXX03_LANG
-template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
-#endif
+template <class... _Tp>
+struct __tuple_like_impl<tuple<_Tp...> > : true_type {};
+
+template <class _T1, class _T2>
+struct __tuple_like_impl<pair<_T1, _T2> > : true_type {};
+
+template <class _Tp, size_t _Size>
+struct __tuple_like_impl<array<_Tp, _Size> > : true_type {};
 
-template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
+struct __tuple_like_impl<ranges::subrange<_Ip, _Sp, _Kp> > : true_type {};
 
-template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
+template <class _Tp>
+concept __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>::value;
 
-template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
+#endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TUPLE_TUPLE_LIKE_H

libcxx/include/__tuple/tuple_like_ext.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_EXT_H
+#define _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H
+
+#include <__config>
+#include <__fwd/array.h>
+#include <__fwd/pair.h>
+#include <__fwd/tuple.h>
+#include <__tuple/tuple_types.h>
+#include <__type_traits/integral_constant.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_ext : false_type {};
+
+template <class _Tp> struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp> struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp> struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class... _Tp> struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
+#endif
+
+template <class _T1, class _T2> struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
+
+template <class _Tp, size_t _Size> struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
+
+template <class... _Tp> struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H

libcxx/include/module.modulemap.in

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" }

   }
   module tuple {
     header "tuple"
     export *
 
     module apply_cv         { private header "__tuple/apply_cv.h" }
     module get_fwd          { private header "__fwd/get.h" }
     module make_tuple_types { private header "__tuple/make_tuple_types.h" }
+    module pair_like        { private header "__tuple/pair_like.h" }
     module sfinae_helpers   { private header "__tuple/sfinae_helpers.h" }
     module tuple_element    { private header "__tuple/tuple_element.h" }
     module tuple_fwd        { private header "__fwd/tuple.h" }
     module tuple_indices    { private header "__tuple/tuple_indices.h" }
     module tuple_like       { private header "__tuple/tuple_like.h" }
+    module tuple_like_ext   { private header "__tuple/tuple_like_ext.h" }
     module tuple_size       { private header "__tuple/tuple_size.h" }
     module tuple_types      { private header "__tuple/tuple_types.h" }
   }
   module type_traits {
     header "type_traits"
     export functional.__functional.unwrap_ref
     export *
 

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/include/tuple

 
 template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
     : public __tuple_cat_return_1<
                  typename __tuple_cat_type<
                      tuple<_Types...>,
                      typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
                  >::type,
-                 __tuple_like<__libcpp_remove_reference_t<_Tuple1> >::value,
+                 __tuple_like_ext<__libcpp_remove_reference_t<_Tuple1> >::value,
                  _Tuple1, _Tuples...>
 {
 };
 
 template <class ..._Tuples> struct __tuple_cat_return;
 
 template <class _Tuple0, class ..._Tuples>
 struct __tuple_cat_return<_Tuple0, _Tuples...>
     : public __tuple_cat_return_1<tuple<>,
-         __tuple_like<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
+         __tuple_like_ext<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
                                                                      _Tuples...>
 {
 };
 
 template <>
 struct __tuple_cat_return<>
 {
     typedef _LIBCPP_NODEBUG tuple<> type;

libcxx/test/libcxx/private_headers.verify.cpp

 #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/memory_resource.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/memory_resource.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.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string.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 <__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'}}

 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/apply_cv.h'}}
 #include <__tuple/make_tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/make_tuple_types.h'}}
 #include <__tuple/sfinae_helpers.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/sfinae_helpers.h'}}
 #include <__tuple/tuple_element.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_element.h'}}
 #include <__tuple/tuple_indices.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_indices.h'}}
 #include <__tuple/tuple_like.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_like.h'}}
+#include <__tuple/tuple_like_ext.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_like_ext.h'}}
 #include <__tuple/tuple_size.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_size.h'}}
 #include <__tuple/tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple/tuple_types.h'}}
 #include <__type_traits/add_const.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_const.h'}}
 #include <__type_traits/add_cv.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_cv.h'}}
 #include <__type_traits/add_lvalue_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_lvalue_reference.h'}}
 #include <__type_traits/add_pointer.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_pointer.h'}}
 #include <__type_traits/add_rvalue_reference.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_rvalue_reference.h'}}
 #include <__type_traits/add_volatile.h> // expected-error@*:* {{use of private header from outside its module: '__type_traits/add_volatile.h'}}

libcxx/test/libcxx/ranges/range.adaptors/range.elements/elements_view.no_unique_address.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// clang-cl and cl currently don't support [[no_unique_address]]
+// XFAIL: msvc
+
+// Test the libc++ extension that the base view stored in `std::ranges::elements_view`
+// has been marked as _LIBCPP_NO_UNIQUE_ADDRESS
+
+#include <ranges>
+#include <tuple>
+
+
+struct EmptyView : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  std::tuple<int>* end() const;
+};
+
+using ElementsView = std::ranges::elements_view<EmptyView, 0>;
+
+struct TestClass {
+  [[no_unique_address]] ElementsView view;
+  int i;
+};
+
+static_assert(sizeof(TestClass) == sizeof(int));

libcxx/test/libcxx/ranges/range.adaptors/range.elements/sentinel.no_unique_address.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// clang-cl and cl currently don't support [[no_unique_address]]
+// XFAIL: msvc
+
+// Test the libc++ extension that the sentinel stored in `std::ranges::elements_view::__sentinel`
+// has been marked as _LIBCPP_NO_UNIQUE_ADDRESS
+
+#include <ranges>
+#include <tuple>
+
+struct EmptySentinel {
+  friend bool operator==(std::tuple<int>* iter, EmptySentinel) { return iter; }
+};
+
+struct Range : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  EmptySentinel end() const;
+};
+
+using ElementsView = std::ranges::elements_view<Range, 0>;
+using ElementsSent = std::ranges::sentinel_t<ElementsView>;
+
+struct TestClass {
+  [[no_unique_address]] ElementsSent s;
+  int i;
+};
+
+static_assert(sizeof(TestClass) == sizeof(int));

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 <tuple>
+#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, 3}}, {{4}, {5, 6}}, {{7}, {8, 9}}};
+    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                              = {3, 6, 9};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test views::keys | views::values
+  {
+    std::pair<std::tuple<int, int>, std::tuple<int>> nested[] = {{{1, 2}, {3}}, {{4, 5}, {6}}, {{7, 8}, {9}}};
+    using Result                                              = std::ranges::elements_view<
+        std::ranges::elements_view<std::ranges::ref_view<std::pair<std::tuple<int, int>, std::tuple<int>>[3]>, 0>,
+        1>;
+    auto const partial                         = std::views::keys | std::views::values;
+    std::same_as<Result> decltype(auto) result = nested | partial;
+    auto expected                              = {2, 5, 8};
+    assert(std::ranges::equal(result, expected));
+  }
+
+  // Test views::values | views::keys
+  {
+    std::pair<std::tuple<int>, std::tuple<int, int>> nested[] = {{{1}, {2, 3}}, {{4}, {5, 6}}, {{7}, {8, 9}}};
+    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>,
+        0>;
+    auto const partial                         = std::views::values | std::views::keys;
+    std::same_as<Result> decltype(auto) result = nested | partial;
+    auto expected                              = {2, 5, 8};
+    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/borrowed.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+//
+// template<class T, size_t N>
+//   inline constexpr bool enable_borrowed_range<elements_view<T, N>> =
+//     enable_borrowed_range<T>;
+
+#include <ranges>
+#include <tuple>
+
+struct NonBorrowed : std::ranges::view_base {
+  std::tuple<int>* begin();
+  std::tuple<int>* end();
+};
+
+struct Borrowed : std::ranges::view_base {
+  std::tuple<int>* begin();
+  std::tuple<int>* end();
+};
+
+template <>
+inline constexpr bool std::ranges::enable_borrowed_range<Borrowed> = true;
+
+static_assert(!std::ranges::borrowed_range<std::ranges::elements_view<NonBorrowed, 0>>);
+static_assert(std::ranges::borrowed_range<std::ranges::elements_view<Borrowed, 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 <tuple>
+#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_convertible_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 <iterator>
+#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)>);
+  }
+
+  // LWG 3406 elements_view::begin() and elements_view::end() have incompatible constraints
+  {
+    std::tuple<int, int> x[] = {{0, 0}};
+    std::ranges::subrange r  = {std::counted_iterator(x, 1), std::default_sentinel};
+    auto v                   = r | std::views::elements<0>;
+    assert(v.begin() != v.end());
+  }
+
+  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 <array>
+#include <cassert>
+#include <map>
+#include <ranges>
+#include <string_view>
+#include <tuple>
+#include <utility>
+
+#include "test_iterators.h"
+
+int main(int, char**) {
+  using namespace std::string_view_literals;
+  auto historicalFigures =
+      std::map{std::pair{"Lovelace"sv, 1815}, {"Turing"sv, 1912}, {"Babbage"sv, 1791}, {"Hamilton"sv, 1936}};
+  auto expectedYears = {1791, 1936, 1815, 1912};
+
+  // views::elements<N>
+  {
+    auto names         = historicalFigures | std::views::elements<0>;
+    auto expectedNames = {"Babbage"sv, "Hamilton"sv, "Lovelace"sv, "Turing"sv};
+    assert(std::ranges::equal(names, expectedNames));
+
+    auto birth_years = historicalFigures | std::views::elements<1>;
+    assert(std::ranges::equal(birth_years, expectedYears));
+  }
+
+  // views::keys
+  {
+    auto names         = historicalFigures | std::views::keys;
+    auto expectedNames = {"Babbage"sv, "Hamilton"sv, "Lovelace"sv, "Turing"sv};
+    assert(std::ranges::equal(names, expectedNames));
+  }
+
+  // views::values
+  {
+    auto is_even = [](const auto x) { return x % 2 == 0; };
+    assert(std::ranges::count_if(historicalFigures | std::views::values, is_even) == 2);
+  }
+
+  // array
+  {
+    std::array<int, 3> arrs[] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
+    auto ev                   = arrs | std::views::elements<2>;
+    auto expected             = {3, 6, 9};
+    assert(std::ranges::equal(ev, expected));
+  }
+
+  // pair
+  {
+    std::pair<double, int> ps[] = {{1.0, 2}, {3.0, 4}, {5.0, 6}};
+    auto ev                     = ps | std::views::elements<1>;
+    auto expected               = {2, 4, 6};
+    assert(std::ranges::equal(ev, expected));
+  }
+
+  // tuple
+  {
+    std::tuple<short> tps[] = {{1}, {2}, {3}};
+    auto ev                 = tps | std::views::elements<0>;
+    auto expected           = {1, 2, 3};
+    assert(std::ranges::equal(ev, expected));
+  }
+
+  // subrange
+  {
+    int is[]       = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+    using Iter     = forward_iterator<int*>;
+    using Sent     = sentinel_wrapper<Iter>;
+    using SubRange = std::ranges::subrange<Iter, Sent>;
+    SubRange sr[]  = {
+        {Iter{is}, Sent{Iter{is + 1}}},
+        {Iter{is + 2}, Sent{Iter{is + 5}}},
+        {Iter{is + 6}, Sent{Iter{is + 8}}},
+    };
+
+    auto iters = sr | std::views::elements<0>;
+    static_assert(std::is_same_v<Iter, std::ranges::range_reference_t<decltype(iters)>>);
+    auto expectedIters = {is, is + 2, is + 6};
+    assert(std::ranges::equal(iters | std::views::transform([](auto&& iter) { return base(iter); }), expectedIters));
+
+    auto sentinels = sr | std::views::elements<1>;
+    static_assert(std::is_same_v<Sent, std::ranges::range_reference_t<decltype(sentinels)>>);
+    auto expectedSentinels = {is + 1, is + 5, is + 8};
+    assert(std::ranges::equal(
+        sentinels | std::views::transform([](auto&& st) { return base(base(st)); }), expectedSentinels));
+  }
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr iterator& operator+=(difference_type n)
+//    requires random_access_range<Base>;
+//
+// constexpr iterator& operator-=(difference_type n)
+//   requires random_access_range<Base>;
+//
+// friend constexpr iterator operator+(const iterator& x, difference_type y)
+//     requires random_access_range<Base>;
+//
+// friend constexpr iterator operator+(difference_type x, const iterator& y)
+//   requires random_access_range<Base>;
+//
+// friend constexpr iterator operator-(const iterator& x, difference_type y)
+//   requires random_access_range<Base>;
+//
+// friend constexpr difference_type operator-(const iterator& x, const iterator& y)
+//   requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
+
+#include <ranges>
+
+#include <tuple>
+
+#include "test_iterators.h"
+
+template <class T, class U>
+concept CanPlus = requires(T t, U u) { t + u; };
+
+template <class T, class U>
+concept CanPlusEqual = requires(T t, U u) { t += u; };
+
+template <class T, class U>
+concept CanMinus = requires(T t, U u) { t - u; };
+
+template <class T, class U>
+concept CanMinusEqual = requires(T t, U u) { t -= u; };
+
+template <class BaseRange>
+using ElemIter = std::ranges::iterator_t<std::ranges::elements_view<BaseRange, 0>>;
+
+using RandomAccessRange = std::ranges::subrange<std::tuple<int>*>;
+static_assert(std::ranges::random_access_range<RandomAccessRange>);
+static_assert(std::sized_sentinel_for<std::ranges::iterator_t<RandomAccessRange>, //
+                                      std::ranges::iterator_t<RandomAccessRange>>);
+
+static_assert(CanPlus<ElemIter<RandomAccessRange>, int>);
+static_assert(CanPlus<int, ElemIter<RandomAccessRange>>);
+static_assert(CanPlusEqual<ElemIter<RandomAccessRange>, int>);
+static_assert(CanMinus<ElemIter<RandomAccessRange>, int>);
+static_assert(CanMinus<ElemIter<RandomAccessRange>, ElemIter<RandomAccessRange>>);
+static_assert(CanMinusEqual<ElemIter<RandomAccessRange>, int>);
+
+using BidiRange = std::ranges::subrange<bidirectional_iterator<std::tuple<int>*>>;
+static_assert(!std::ranges::random_access_range<BidiRange>);
+static_assert(!std::sized_sentinel_for<std::ranges::iterator_t<BidiRange>, //
+                                       std::ranges::iterator_t<BidiRange>>);
+
+static_assert(!CanPlus<ElemIter<BidiRange>, int>);
+static_assert(!CanPlus<int, ElemIter<BidiRange>>);
+static_assert(!CanPlusEqual<ElemIter<BidiRange>, int>);
+static_assert(!CanMinus<ElemIter<BidiRange>, int>);
+static_assert(!CanMinus<ElemIter<BidiRange>, ElemIter<BidiRange>>);
+static_assert(!CanMinusEqual<ElemIter<BidiRange>, int>);
+
+constexpr bool test() {
+  std::tuple<int> ts[] = {{1}, {2}, {3}, {4}};
+
+  RandomAccessRange r{&ts[0], &ts[0] + 4};
+  auto ev = r | std::views::elements<0>;
+  {
+    // operator+(x, n) operator+(n,x) and operator+=
+    auto it1 = ev.begin();
+
+    auto it2 = it1 + 3;
+    assert(it2.base() == &ts[3]);
+
+    auto it3 = 3 + it1;
+    assert(it3.base() == &ts[3]);
+
+    it1 += 3;
+    assert(it1 == it2);
+    assert(it1.base() == &ts[3]);
+  }
+
+  {
+    // operator-(x, n) and operator-=
+    auto it1 = ev.end();
+
+    auto it2 = it1 - 3;
+    assert(it2.base() == &ts[1]);
+
+    it1 -= 3;
+    assert(it1 == it2);
+    assert(it1.base() == &ts[1]);
+  }
+
+  {
+    // operator-(x, y)
+    assert((ev.end() - ev.begin()) == 4);
+
+    auto it1 = ev.begin() + 2;
+    auto it2 = ev.end() - 1;
+    assert((it1 - it2) == -1);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/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 const iterator_t<Base>& base() const & noexcept;
+// constexpr iterator_t<Base> base() &&;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+#include "../types.h"
+
+// Test Noexcept
+template <class T>
+concept IsBaseNoexcept =
+    requires {
+      { std::declval<T>().base() } noexcept;
+    };
+
+using BaseView     = std::ranges::subrange<std::tuple<int>*>;
+using ElementsIter = std::ranges::iterator_t<std::ranges::elements_view<BaseView, 0>>;
+
+static_assert(IsBaseNoexcept<const ElementsIter&>);
+static_assert(IsBaseNoexcept<ElementsIter&>);
+static_assert(IsBaseNoexcept<const ElementsIter&&>);
+static_assert(!IsBaseNoexcept<ElementsIter&&>);
+
+constexpr bool test() {
+  std::tuple<int> t{5};
+
+  // const &
+  {
+    const ElementsIter it{&t};
+    decltype(auto) base = it.base();
+    static_assert(std::is_same_v<decltype(base), std::tuple<int>* const&>);
+    assert(base == &t);
+  }
+
+  // &
+  {
+    ElementsIter it{&t};
+    decltype(auto) base = it.base();
+    static_assert(std::is_same_v<decltype(base), std::tuple<int>* const&>);
+    assert(base == &t);
+  }
+
+  // &&
+  {
+    ElementsIter it{&t};
+    decltype(auto) base = std::move(it).base();
+    static_assert(std::is_same_v<decltype(base), std::tuple<int>*>);
+    assert(base == &t);
+  }
+
+  // const &&
+  {
+    const ElementsIter it{&t};
+    decltype(auto) base = std::move(it).base();
+    static_assert(std::is_same_v<decltype(base), std::tuple<int>* const&>);
+    assert(base == &t);
+  }
+
+  // move only
+  {
+    struct MoveOnlyIter : IterBase<MoveOnlyIter> {
+      MoveOnly mo;
+    };
+    struct Sent {
+      constexpr bool operator==(const MoveOnlyIter&) const { return true; }
+    };
+
+    using MoveOnlyElemIter =
+        std::ranges::iterator_t<std::ranges::elements_view<std::ranges::subrange<MoveOnlyIter, Sent>, 0>>;
+
+    MoveOnlyElemIter it{MoveOnlyIter{{}, MoveOnly{5}}};
+    decltype(auto) base = std::move(it).base();
+    static_assert(std::is_same_v<decltype(base), MoveOnlyIter>);
+    assert(base.mo.get() == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// friend constexpr bool operator==(const iterator& x, const iterator& y)
+//   requires equality_comparable<iterator_t<Base>>;
+// friend constexpr bool operator<(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator>(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator<=(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr bool operator>=(const iterator& x, const iterator& y)
+//   requires random_access_range<Base>;
+// friend constexpr auto operator<=>(const iterator& x, const iterator& y)
+//   requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
+
+#include <compare>
+#include <functional>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+constexpr void compareOperatorTest(const auto& iter1, const auto& iter2) {
+  assert(!(iter1 < iter1));
+  assert(iter1 < iter2);
+  assert(!(iter2 < iter1));
+
+  assert(iter1 <= iter1);
+  assert(iter1 <= iter2);
+  assert(!(iter2 <= iter1));
+
+  assert(!(iter1 > iter1));
+  assert(!(iter1 > iter2));
+  assert(iter2 > iter1);
+
+  assert(iter1 >= iter1);
+  assert(!(iter1 >= iter2));
+  assert(iter2 >= iter1);
+
+  assert(iter1 == iter1);
+  assert(!(iter1 == iter2));
+  assert(iter2 == iter2);
+
+  assert(!(iter1 != iter1));
+  assert(iter1 != iter2);
+  assert(!(iter2 != iter2));
+}
+
+constexpr void inequalityOperatorsDoNotExistTest(const auto& iter1, const auto& iter2) {
+  using Iter1 = decltype(iter1);
+  using Iter2 = decltype(iter2);
+  static_assert(!std::is_invocable_v<std::less<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::less_equal<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::greater<>, Iter1, Iter2>);
+  static_assert(!std::is_invocable_v<std::greater_equal<>, Iter1, Iter2>);
+}
+
+constexpr bool test() {
+  std::tuple<int> ts[] = {{1}, {2}, {3}};
+
+  {
+    // Test a new-school iterator with operator<=>; the iterator should also have operator<=>.
+    using It       = three_way_contiguous_iterator<std::tuple<int>*>;
+    using Subrange = std::ranges::subrange<It>;
+    static_assert(std::three_way_comparable<It>);
+    using R = std::ranges::elements_view<Subrange, 0>;
+    static_assert(std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    auto ev    = Subrange{It{&ts[0]}, It{&ts[0] + 3}} | std::views::elements<0>;
+    auto iter1 = ev.begin();
+    auto iter2 = iter1 + 1;
+
+    compareOperatorTest(iter1, iter2);
+
+    assert((iter1 <=> iter2) == std::strong_ordering::less);
+    assert((iter1 <=> iter1) == std::strong_ordering::equal);
+    assert((iter2 <=> iter1) == std::strong_ordering::greater);
+  }
+
+  {
+    // Test an old-school iterator with no operator<=>; the elements view iterator shouldn't have
+    // operator<=> either.
+    using It       = random_access_iterator<std::tuple<int>*>;
+    using Subrange = std::ranges::subrange<It>;
+    static_assert(!std::three_way_comparable<It>);
+    using R = std::ranges::elements_view<Subrange, 0>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    auto ev    = Subrange{It{&ts[0]}, It{&ts[0] + 3}} | std::views::elements<0>;
+    auto iter1 = ev.begin();
+    auto iter2 = iter1 + 1;
+
+    compareOperatorTest(iter1, iter2);
+  }
+
+  {
+    // non random_access_range
+    using It       = bidirectional_iterator<std::tuple<int>*>;
+    using Subrange = std::ranges::subrange<It>;
+    static_assert(!std::ranges::random_access_range<Subrange>);
+    using R = std::ranges::elements_view<Subrange, 0>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    auto ev = Subrange{It{&ts[0]}, It{&ts[0] + 1}} | std::views::elements<0>;
+
+    auto it1 = ev.begin();
+    auto it2 = ev.end();
+
+    assert(it1 == it1);
+    assert(!(it1 != it1));
+    assert(it2 == it2);
+    assert(!(it2 != it2));
+
+    assert(it1 != it2);
+
+    ++it1;
+    assert(it1 == it2);
+
+    inequalityOperatorsDoNotExistTest(it1, it2);
+  }
+
+  {
+    // underlying iterator does not support ==
+    using Iter     = cpp20_input_iterator<std::tuple<int>*>;
+    using Sent     = sentinel_wrapper<Iter>;
+    using Subrange = std::ranges::subrange<Iter, Sent>;
+    using R        = std::ranges::elements_view<Subrange, 0>;
+    static_assert(!std::three_way_comparable<std::ranges::iterator_t<R>>);
+
+    auto ev = Subrange{Iter{&ts[0]}, Sent{Iter{&ts[0] + 1}}} | std::views::elements<0>;
+    auto it = ev.begin();
+
+    using ElemIter = decltype(it);
+    static_assert(!std::invocable<std::equal_to<>, ElemIter, ElemIter>);
+    static_assert(!std::invocable<std::not_equal_to<>, ElemIter, ElemIter>);
+    inequalityOperatorsDoNotExistTest(it, it);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/iterator/ctor.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 explicit iterator(iterator_t<Base> current);
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "../types.h"
+
+// Test explicit
+using BaseIter     = std::tuple<int>*;
+using ElementsIter = std::ranges::iterator_t<std::ranges::elements_view<std::ranges::subrange<BaseIter, BaseIter>, 0>>;
+
+static_assert(std::is_constructible_v<ElementsIter, BaseIter>);
+static_assert(!std::is_convertible_v<BaseIter, ElementsIter>);
+
+struct TracedMoveIter : IterBase<TracedMoveIter>{
+  bool moved = false;
+
+  constexpr TracedMoveIter()                      = default;
+  constexpr TracedMoveIter(const TracedMoveIter&) = default;
+  constexpr TracedMoveIter(TracedMoveIter&&) : moved{true} {}
+  constexpr TracedMoveIter& operator=(TracedMoveIter&&)      = default;
+  constexpr TracedMoveIter& operator=(const TracedMoveIter&) = default;
+};
+
+struct TracedMoveView : std::ranges::view_base {
+  TracedMoveIter begin() const;
+  TracedMoveIter end() const;
+};
+
+constexpr bool test() {
+  using Iter = std::ranges::iterator_t<std::ranges::elements_view<TracedMoveView, 0>>;
+  Iter iter{TracedMoveIter{}};
+  assert(iter.base().moved);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// iterator() requires default_initializable<iterator_t<Base>> = default;
+
+#include <ranges>
+#include <tuple>
+
+#include "../types.h"
+
+struct PODIter : IterBase<PODIter> {
+  int i; // deliberately uninitialised
+};
+
+struct IterDefaultCtrView : std::ranges::view_base {
+  PODIter begin() const;
+  PODIter end() const;
+};
+
+struct IterNoDefaultCtrView : std::ranges::view_base {
+  cpp20_input_iterator<std::tuple<int>*> begin() const;
+  sentinel_wrapper<cpp20_input_iterator<std::tuple<int>*>> end() const;
+};
+
+template <class View, size_t N>
+using ElementsIter = std::ranges::iterator_t<std::ranges::elements_view<View, N>>;
+
+static_assert(!std::default_initializable<ElementsIter<IterNoDefaultCtrView, 0>>);
+static_assert(std::default_initializable<ElementsIter<IterDefaultCtrView, 0>>);
+
+constexpr bool test() {
+  using Iter = ElementsIter<IterDefaultCtrView, 0>;
+  {
+    Iter iter;
+    assert(iter.base().i == 0); // PODIter has to be initialised to have value 0
+  }
+
+  {
+    Iter iter = {};
+    assert(iter.base().i == 0); // PODIter has to be initialised to have value 0
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr iterator(iterator<!Const> i)
+//   requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "../types.h"
+
+template <bool Const>
+struct ConvertibleIter : IterBase<ConvertibleIter<Const>> {
+  using iterator_category = std::random_access_iterator_tag;
+  using value_type        = std::tuple<int>;
+  using difference_type   = intptr_t;
+
+  bool movedFromOtherConst = false;
+  int i                    = 0;
+
+  constexpr ConvertibleIter() = default;
+  constexpr ConvertibleIter(int ii) : i(ii) {}
+  template <bool otherConst>
+    requires(Const != otherConst)
+  constexpr ConvertibleIter(ConvertibleIter<otherConst> it) : movedFromOtherConst(true), i(it.i) {}
+};
+
+template <class Iter, class ConstIter>
+struct BasicView : std::ranges::view_base {
+  Iter begin();
+  Iter end();
+
+  ConstIter begin() const;
+  ConstIter end() const;
+};
+
+template <class View>
+using ElemIter = std::ranges::iterator_t<std::ranges::elements_view<View, 0>>;
+
+template <class View>
+using ConstElemIter = std::ranges::iterator_t<const std::ranges::elements_view<View, 0>>;
+
+using ConvertibleView    = BasicView<ConvertibleIter<false>, ConvertibleIter<true>>;
+using NonConvertibleView = BasicView<forward_iterator<std::tuple<int>*>, bidirectional_iterator<std::tuple<int>*>>;
+
+static_assert(std::is_constructible_v<ConstElemIter<ConvertibleView>, ElemIter<ConvertibleView>>);
+static_assert(!std::is_constructible_v<ElemIter<ConvertibleView>, ConstElemIter<ConvertibleView>>);
+static_assert(!std::is_constructible_v<ConstElemIter<NonConvertibleView>, ElemIter<NonConvertibleView>>);
+static_assert(!std::is_constructible_v<ElemIter<NonConvertibleView>, ConstElemIter<NonConvertibleView>>);
+
+constexpr bool test() {
+  ElemIter<ConvertibleView> iter{ConvertibleIter<false>{5}};
+  ConstElemIter<ConvertibleView> constIter = iter; // implicit
+  assert(constIter.base().movedFromOtherConst);
+  assert(constIter.base().i == 5);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr iterator& operator--() requires bidirectional_range<Base>;
+// constexpr iterator operator--(int) requires bidirectional_range<Base>;
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+template <class Iter>
+concept CanPreDecrement = requires(Iter it) { --it; };
+
+template <class Iter>
+concept CanPostDecrement = requires(Iter it) { it--; };
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+constexpr void testOne() {
+  using Range          = std::ranges::subrange<Iter, Sent>;
+  std::tuple<int> ts[] = {{1}, {2}, {3}};
+  auto ev              = Range{Iter{&ts[0]}, Sent{Iter{&ts[0] + 3}}} | std::views::elements<0>;
+
+  using ElementIter = std::ranges::iterator_t<decltype(ev)>;
+
+  if constexpr (!std::bidirectional_iterator<Iter>) {
+    auto it = ev.begin();
+    static_assert(!CanPreDecrement<decltype(it)>);
+    static_assert(!CanPostDecrement<decltype(it)>);
+  } else {
+    // --i
+    {
+      auto it = ev.begin();
+      static_assert(CanPreDecrement<decltype(it)>);
+
+      ++it;
+      assert(base(it.base()) == &ts[1]);
+
+      decltype(auto) result = --it;
+
+      static_assert(std::is_same_v<decltype(result), ElementIter&>);
+      assert(&result == &it);
+
+      assert(base(it.base()) == &ts[0]);
+    }
+
+    // i--
+    {
+      auto it = ev.begin();
+      static_assert(CanPostDecrement<decltype(it)>);
+
+      ++it;
+      assert(base(it.base()) == &ts[1]);
+
+      decltype(auto) result = it--;
+
+      static_assert(std::is_same_v<decltype(result), ElementIter>);
+
+      assert(base(it.base()) == &ts[0]);
+      assert(base(result.base()) == &ts[1]);
+    }
+  }
+}
+
+constexpr bool test() {
+  using Ptr = std::tuple<int>*;
+  testOne<cpp20_input_iterator<Ptr>>();
+  testOne<forward_iterator<Ptr>>();
+  testOne<bidirectional_iterator<Ptr>>();
+  testOne<random_access_iterator<Ptr>>();
+  testOne<contiguous_iterator<Ptr>>();
+  testOne<Ptr>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr decltype(auto) operator*() const;
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+template <std::size_t N, class T, std::size_t Size>
+constexpr void testReference(T (&ts)[Size]) {
+  auto ev = ts | std::views::elements<N>;
+  auto it = ev.begin();
+
+  decltype(auto) result = *it;
+  using ExpectedType    = decltype(std::get<N>(ts[0]));
+  static_assert(std::is_same_v<decltype(result), ExpectedType>);
+
+  if constexpr (std::is_reference_v<ExpectedType>) {
+    // tuple/array/pair
+    assert(&result == &std::get<N>(ts[0]));
+  } else {
+    // subrange
+    assert(result == std::get<N>(ts[0]));
+  }
+}
+
+// LWG 3502 elements_view should not be allowed to return dangling references
+template <std::size_t N, class T>
+constexpr void testValue(T t) {
+  auto ev = std::views::iota(0, 1) | std::views::transform([&t](int) { return t; }) | std::views::elements<N>;
+  auto it = ev.begin();
+
+  decltype(auto) result = *it;
+  using ExpectedType    = std::remove_cvref_t<decltype(std::get<N>(t))>;
+  static_assert(std::is_same_v<decltype(result), ExpectedType>);
+
+  assert(result == std::get<N>(t));
+}
+
+constexpr bool test() {
+  // test tuple
+  {
+    std::tuple<int, short, long> ts[] = {{1, 2, 3}, {4, 5, 6}};
+    testReference<0>(ts);
+    testReference<1>(ts);
+    testReference<2>(ts);
+    testValue<0>(ts[0]);
+    testValue<1>(ts[0]);
+    testValue<2>(ts[0]);
+  }
+
+  // test pair
+  {
+    std::pair<int, short> ps[] = {{1, 2}, {4, 5}};
+    testReference<0>(ps);
+    testReference<1>(ps);
+    testValue<0>(ps[0]);
+    testValue<1>(ps[0]);
+  }
+
+  // test array
+  {
+    std::array<int, 3> arrs[] = {{1, 2, 3}, {3, 4, 5}};
+    testReference<0>(arrs);
+    testReference<1>(arrs);
+    testReference<2>(arrs);
+    testValue<0>(arrs[0]);
+    testValue<1>(arrs[0]);
+    testValue<2>(arrs[0]);
+  }
+
+  // test subrange
+  {
+    int i                             = 5;
+    std::ranges::subrange<int*> srs[] = {{&i, &i}, {&i, &i}};
+    testReference<0>(srs);
+    testReference<1>(srs);
+    testValue<0>(srs[0]);
+    testValue<1>(srs[0]);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr iterator& operator++();
+// constexpr void operator++(int);
+// constexpr iterator operator++(int) requires forward_range<Base>;
+
+#include <array>
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+constexpr void testOne() {
+  using Range          = std::ranges::subrange<Iter, Sent>;
+  std::tuple<int> ts[] = {{1}, {2}, {3}};
+  auto ev              = Range{Iter{&ts[0]}, Sent{Iter{&ts[0] + 3}}} | std::views::elements<0>;
+
+  using ElementIter = std::ranges::iterator_t<decltype(ev)>;
+
+  // ++i
+  {
+    auto it               = ev.begin();
+    decltype(auto) result = ++it;
+
+    static_assert(std::is_same_v<decltype(result), ElementIter&>);
+    assert(&result == &it);
+
+    assert(base(it.base()) == &ts[1]);
+  }
+
+  // i++
+  {
+    if constexpr (std::forward_iterator<Iter>) {
+      auto it               = ev.begin();
+      decltype(auto) result = it++;
+
+      static_assert(std::is_same_v<decltype(result), ElementIter>);
+
+      assert(base(it.base()) == &ts[1]);
+      assert(base(result.base()) == &ts[0]);
+    } else {
+      auto it = ev.begin();
+      it++;
+
+      static_assert(std::is_same_v<decltype(it++), void>);
+      assert(base(it.base()) == &ts[1]);
+    }
+  }
+}
+
+constexpr bool test() {
+  using Ptr = std::tuple<int>*;
+  testOne<cpp20_input_iterator<Ptr>>();
+  testOne<forward_iterator<Ptr>>();
+  testOne<bidirectional_iterator<Ptr>>();
+  testOne<random_access_iterator<Ptr>>();
+  testOne<contiguous_iterator<Ptr>>();
+  testOne<Ptr>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  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/iterator/subscript.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// constexpr decltype(auto) operator[](difference_type n) const
+//   requires random_access_range<Base>
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "test_iterators.h"
+
+template <class T, class U>
+concept CanSubscript = requires(T t, U u) { t[u]; };
+
+template <class BaseRange>
+using ElemIter = std::ranges::iterator_t<std::ranges::elements_view<BaseRange, 0>>;
+
+using RandomAccessRange = std::ranges::subrange<std::tuple<int>*>;
+static_assert(std::ranges::random_access_range<RandomAccessRange>);
+
+static_assert(CanSubscript<ElemIter<RandomAccessRange>, int>);
+
+using BidiRange = std::ranges::subrange<bidirectional_iterator<std::tuple<int>*>>;
+static_assert(!std::ranges::random_access_range<BidiRange>);
+
+static_assert(!CanSubscript<ElemIter<BidiRange>, int>);
+
+constexpr bool test() {
+  {
+    // reference
+    std::tuple<int> ts[] = {{1}, {2}, {3}, {4}};
+    auto ev              = ts | std::views::elements<0>;
+    auto it              = ev.begin();
+
+    assert(&it[0] == &*it);
+    assert(&it[2] == &*(it + 2));
+
+    static_assert(std::is_same_v<decltype(it[2]), int&>);
+  }
+
+  {
+    // value
+    auto ev = std::views::iota(0, 5) | std::views::transform([](int i) { return std::tuple<int>{i}; }) |
+              std::views::elements<0>;
+    auto it = ev.begin();
+    assert(it[0] == *it);
+    assert(it[2] == *(it + 2));
+    assert(it[4] == *(it + 4));
+
+    static_assert(std::is_same_v<decltype(it[2]), int>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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 <concepts>
+#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(!std::ranges::view<std::array<std::tuple<int>, 1>>);
+static_assert(!HasElementsView<std::array<std::tuple<int>, 1>, 0>);
+
+// !input_range
+static_assert(!std::ranges::input_range<Range<cpp20_output_iterator<std::tuple<int>*>>>);
+static_assert(!HasElementsView<Range<cpp20_output_iterator<std::tuple<int>*>>, 0>);
+
+// !tuple-like
+LIBCPP_STATIC_ASSERT(!std::__tuple_like<int>);
+static_assert(!HasElementsView<Range<int*>, 1>);
+
+// !(N < tuple_size_v<T>)
+static_assert(!(2 < std::tuple_size_v< std::pair<int, int>>));
+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;
+};
+static_assert(!std::move_constructible<NonMovable>);
+
+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/sentinel/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 sentinel_t<Base> base() const;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+struct Sent {
+  int i;
+
+  friend constexpr bool operator==(std::tuple<int>*, const Sent&) { return true; }
+};
+
+constexpr bool test() {
+  using BaseRange = std::ranges::subrange<std::tuple<int>*, Sent>;
+  using EleRange  = std::ranges::elements_view<BaseRange, 0>;
+  using EleSent   = std::ranges::sentinel_t<EleRange>;
+
+  const EleSent st{Sent{5}};
+  std::same_as<Sent> decltype(auto) base = st.base();
+  assert(base.i == 5);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/ctor.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 explicit sentinel(sentinel_t<Base> end);
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+#include <utility>
+
+struct Sent {
+  int i;
+
+  friend constexpr bool operator==(std::tuple<int>*, const Sent&) { return true; }
+};
+
+struct Range : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  Sent end();
+};
+
+// Test explicit
+
+static_assert(std::is_constructible_v<std::ranges::sentinel_t<std::ranges::elements_view<Range, 0>>, Sent>);
+static_assert(!std::is_convertible_v<Sent, std::ranges::sentinel_t<std::ranges::elements_view<Range, 0>>>);
+
+constexpr bool test() {
+  // base is init correctly
+  {
+    using R        = std::ranges::elements_view<Range, 0>;
+    using Sentinel = std::ranges::sentinel_t<R>;
+
+    Sentinel s1(Sent{5});
+    assert(s1.base().i == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.elements/sentinel/ctor.convert.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 sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+#include "../types.h"
+
+struct Sent {
+  int i;
+  constexpr Sent() = default;
+  constexpr Sent(int ii) : i(ii) {}
+  friend constexpr bool operator==(std::tuple<int>*, const Sent&) { return true; }
+};
+
+struct ConstSent {
+  int i;
+  constexpr ConstSent() = default;
+  constexpr ConstSent(int ii) : i(ii) {}
+  constexpr ConstSent(const Sent& s) : i(s.i) {}
+  friend constexpr bool operator==(std::tuple<int>*, const ConstSent&) { return true; }
+};
+
+struct Range : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  Sent end();
+  ConstSent end() const;
+};
+
+struct NonConvertConstSent {
+  int i;
+  constexpr NonConvertConstSent() = default;
+  constexpr NonConvertConstSent(int ii) : i(ii) {}
+  friend constexpr bool operator==(std::tuple<int>*, const NonConvertConstSent&) { return true; }
+};
+
+struct NonConvertConstSentRange : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  Sent end();
+  NonConvertConstSent end() const;
+};
+
+// Test Constraint
+static_assert(std::is_constructible_v<std::ranges::sentinel_t<const std::ranges::elements_view<Range, 0>>,
+                                      std::ranges::sentinel_t<std::ranges::elements_view<Range, 0>>>);
+
+// !Const
+static_assert(!std::is_constructible_v<std::ranges::sentinel_t<std::ranges::elements_view<Range, 0>>,
+                                       std::ranges::sentinel_t<const std::ranges::elements_view<Range, 0>>>);
+
+// !convertible_to<sentinel_t<V>, sentinel_t<Base>>
+static_assert(!std::is_constructible_v<
+              std::ranges::sentinel_t<const std::ranges::elements_view<NonConvertConstSentRange, 0>>,
+              std::ranges::sentinel_t<std::ranges::elements_view<NonConvertConstSentRange, 0>>>);
+
+constexpr bool test() {
+  // base is init correctly
+  {
+    using R             = std::ranges::elements_view<Range, 0>;
+    using Sentinel      = std::ranges::sentinel_t<R>;
+    using ConstSentinel = std::ranges::sentinel_t<const R>;
+    static_assert(!std::same_as<Sentinel, ConstSentinel>);
+
+    Sentinel s1(Sent{5});
+    ConstSentinel s2 = s1;
+    assert(s2.base().i == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// sentinel() = default;
+
+#include <cassert>
+#include <ranges>
+#include <tuple>
+
+struct PODSentinel {
+  int i; // deliberately uninitialised
+
+  friend constexpr bool operator==(std::tuple<int>*, const PODSentinel&) { return true; }
+};
+
+struct Range : std::ranges::view_base {
+  std::tuple<int>* begin() const;
+  PODSentinel end();
+};
+
+constexpr bool test() {
+  using EleView  = std::ranges::elements_view<Range, 0>;
+  using Sentinel = std::ranges::sentinel_t<EleView>;
+  static_assert(!std::is_same_v<Sentinel, std::ranges::iterator_t<EleView>>);
+
+  {
+    Sentinel s;
+    assert(s.base().i == 0);
+  }
+  {
+    Sentinel s = {};
+    assert(s.base().i == 0);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+//  template<bool OtherConst>
+//    requires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+//  friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);
+
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "../types.h"
+
+template <bool Const>
+struct Iter {
+  std::tuple<int>* it_;
+
+  using value_type       = std::tuple<int>;
+  using difference_type  = intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr decltype(auto) operator*() const { return *it_; }
+  constexpr Iter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+};
+
+template <bool Const>
+struct Sent {
+  std::tuple<int>* end_;
+
+  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
+};
+
+template <bool Const>
+struct CrossComparableSent {
+  std::tuple<int>* end_;
+
+  template <bool C>
+  constexpr bool operator==(const Iter<C>& i) const {
+    return i.it_ == end_;
+  }
+};
+
+template <template <bool> typename St>
+struct Range : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+  constexpr Iter<false> begin() { return Iter<false>{buffer_}; }
+  constexpr Iter<true> begin() const { return Iter<true>{buffer_}; }
+  constexpr St<false> end() { return St<false>{buffer_ + size_}; }
+  constexpr St<true> end() const { return St<true>{buffer_ + size_}; }
+};
+
+using R                = Range<Sent>;
+using CrossComparableR = Range<CrossComparableSent>;
+
+// Test Constraint
+template <class I, class S>
+concept HasEqual = requires(const I i, const S s) { i == s; };
+
+using std::ranges::elements_view;
+using std::ranges::iterator_t;
+using std::ranges::sentinel_t;
+
+static_assert(HasEqual<iterator_t<elements_view<R, 0>>, //
+                       sentinel_t<elements_view<R, 0>>>);
+
+static_assert(!HasEqual<iterator_t<const elements_view<R, 0>>, //
+                        sentinel_t<elements_view<R, 0>>>);
+
+static_assert(!HasEqual<iterator_t<elements_view<R, 0>>, //
+                        sentinel_t<const elements_view<R, 0>>>);
+
+static_assert(HasEqual<iterator_t<const elements_view<R, 0>>, //
+                       sentinel_t<const elements_view<R, 0>>>);
+
+static_assert(HasEqual<iterator_t<elements_view<R, 0>>, //
+                       sentinel_t<elements_view<R, 0>>>);
+
+static_assert(HasEqual<iterator_t<const elements_view<CrossComparableR, 0>>, //
+                       sentinel_t<elements_view<CrossComparableR, 0>>>);
+
+static_assert(HasEqual<iterator_t<elements_view<CrossComparableR, 0>>, //
+                       sentinel_t<const elements_view<CrossComparableR, 0>>>);
+
+static_assert(HasEqual<iterator_t<const elements_view<CrossComparableR, 0>>, //
+                       sentinel_t<const elements_view<CrossComparableR, 0>>>);
+
+template <class R, bool ConstIter, bool ConstSent>
+constexpr void testOne() {
+  auto getBegin = [](auto&& rng) {
+    if constexpr (ConstIter) {
+      return std::as_const(rng).begin();
+    } else {
+      return rng.begin();
+    }
+  };
+
+  auto getEnd = [](auto&& rng) {
+    if constexpr (ConstSent) {
+      return std::as_const(rng).end();
+    } else {
+      return rng.end();
+    }
+  };
+
+  // iter == sentinel.base
+  {
+    std::tuple<int> buffer[] = {{1}};
+    R v{buffer};
+    std::ranges::elements_view<R, 0> ev(v);
+    auto iter = getBegin(ev);
+    auto st   = getEnd(ev);
+    ++iter;
+    assert(iter == st);
+  }
+
+  // iter != sentinel.base
+  {
+    std::tuple<int> buffer[] = {{1}};
+    R v{buffer};
+    std::ranges::elements_view<R, 0> ev(v);
+    auto iter = getBegin(ev);
+    auto st   = getEnd(ev);
+    assert(iter != st);
+  }
+
+  // empty range
+  {
+    std::array<std::tuple<int>, 0> arr;
+    R v{arr};
+    std::ranges::elements_view<R, 0> ev(v);
+    auto iter = getBegin(ev);
+    auto sent = getEnd(ev);
+    assert(iter == sent);
+  }
+}
+
+constexpr bool test() {
+  testOne<R, false, false>();
+  testOne<R, true, true>();
+  testOne<CrossComparableR, false, false>();
+  testOne<CrossComparableR, true, true>();
+  testOne<CrossComparableR, true, false>();
+  testOne<CrossComparableR, false, true>();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const iterator<OtherConst>& x, const sentinel& y);
+//
+// template<bool OtherConst>
+//   requires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>
+// friend constexpr range_difference_t<maybe-const<OtherConst, V>>
+//   operator-(const sentinel& x, const iterator<OtherConst>& y);
+
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+#include <tuple>
+
+#include "../types.h"
+
+template <bool Const>
+struct Iter {
+  std::tuple<int>* it_;
+
+  using value_type       = std::tuple<int>;
+  using difference_type  = intptr_t;
+  using iterator_concept = std::input_iterator_tag;
+
+  constexpr decltype(auto) operator*() const { return *it_; }
+  constexpr Iter& operator++() {
+    ++it_;
+    return *this;
+  }
+  constexpr void operator++(int) { ++it_; }
+};
+
+template <bool Const>
+struct Sent {
+  std::tuple<int>* end_;
+
+  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
+};
+
+template <bool Const>
+struct SizedSent {
+  std::tuple<int>* end_;
+
+  constexpr bool operator==(const Iter<Const>& i) const { return i.it_ == end_; }
+
+  friend constexpr auto operator-(const SizedSent& st, const Iter<Const>& it) { return st.end_ - it.it_; }
+
+  friend constexpr auto operator-(const Iter<Const>& it, const SizedSent& st) { return it.it_ - st.end_; }
+};
+
+template <bool Const>
+struct CrossSizedSent {
+  std::tuple<int>* end_;
+
+  template <bool C>
+  constexpr bool operator==(const Iter<C>& i) const {
+    return i.it_ == end_;
+  }
+
+  template <bool C>
+  friend constexpr auto operator-(const CrossSizedSent& st, const Iter<C>& it) {
+    return st.end_ - it.it_;
+  }
+
+  template <bool C>
+  friend constexpr auto operator-(const Iter<C>& it, const CrossSizedSent& st) {
+    return it.it_ - st.end_;
+  }
+};
+
+template <template <bool> class It, template <bool> class St>
+struct Range : TupleBufferView {
+  using TupleBufferView::TupleBufferView;
+
+  using iterator       = It<false>;
+  using sentinel       = St<false>;
+  using const_iterator = It<true>;
+  using const_sentinel = St<true>;
+
+  constexpr iterator begin() { return {buffer_}; }
+  constexpr const_iterator begin() const { return {buffer_}; }
+  constexpr sentinel end() { return sentinel{buffer_ + size_}; }
+  constexpr const_sentinel end() const { return const_sentinel{buffer_ + size_}; }
+};
+
+template <class T, class U>
+concept HasMinus = requires(const T t, const U u) { t - u; };
+
+template <class BaseRange>
+using ElementsView = std::ranges::elements_view<BaseRange, 0>;
+
+template <class BaseRange>
+using ElemIter = std::ranges::iterator_t<ElementsView<BaseRange>>;
+
+template <class BaseRange>
+using EleConstIter = std::ranges::iterator_t<const ElementsView<BaseRange>>;
+
+template <class BaseRange>
+using EleSent = std::ranges::sentinel_t<ElementsView<BaseRange>>;
+
+template <class BaseRange>
+using EleConstSent = std::ranges::sentinel_t<const ElementsView<BaseRange>>;
+
+constexpr void testConstraints() {
+  // base is not sized
+  {
+    using Base = Range<Iter, Sent>;
+    static_assert(!HasMinus<EleSent<Base>, ElemIter<Base>>);
+    static_assert(!HasMinus<ElemIter<Base>, EleSent<Base>>);
+
+    static_assert(!HasMinus<EleSent<Base>, EleConstIter<Base>>);
+    static_assert(!HasMinus<EleConstIter<Base>, EleSent<Base>>);
+
+    static_assert(!HasMinus<EleConstSent<Base>, EleConstIter<Base>>);
+    static_assert(!HasMinus<EleConstIter<Base>, EleConstSent<Base>>);
+
+    static_assert(!HasMinus<EleConstSent<Base>, ElemIter<Base>>);
+    static_assert(!HasMinus<ElemIter<Base>, EleConstSent<Base>>);
+  }
+
+  // base is sized but not cross const
+  {
+    using Base = Range<Iter, SizedSent>;
+    static_assert(HasMinus<EleSent<Base>, ElemIter<Base>>);
+    static_assert(HasMinus<ElemIter<Base>, EleSent<Base>>);
+
+    static_assert(!HasMinus<EleSent<Base>, EleConstIter<Base>>);
+    static_assert(!HasMinus<EleConstIter<Base>, EleSent<Base>>);
+
+    static_assert(HasMinus<EleConstSent<Base>, EleConstIter<Base>>);
+    static_assert(HasMinus<EleConstIter<Base>, EleConstSent<Base>>);
+
+    static_assert(!HasMinus<EleConstSent<Base>, ElemIter<Base>>);
+    static_assert(!HasMinus<ElemIter<Base>, EleConstSent<Base>>);
+  }
+
+  // base is cross const sized
+  {
+    using Base = Range<Iter, CrossSizedSent>;
+    static_assert(HasMinus<EleSent<Base>, ElemIter<Base>>);
+    static_assert(HasMinus<ElemIter<Base>, EleSent<Base>>);
+
+    static_assert(HasMinus<EleSent<Base>, EleConstIter<Base>>);
+    static_assert(HasMinus<EleConstIter<Base>, EleSent<Base>>);
+
+    static_assert(HasMinus<EleConstSent<Base>, EleConstIter<Base>>);
+    static_assert(HasMinus<EleConstIter<Base>, EleConstSent<Base>>);
+
+    static_assert(HasMinus<EleConstSent<Base>, ElemIter<Base>>);
+    static_assert(HasMinus<ElemIter<Base>, EleConstSent<Base>>);
+  }
+}
+
+constexpr bool test() {
+  std::tuple<int> buffer[] = {{1}, {2}, {3}, {4}, {5}};
+
+  // base is sized but not cross const
+  {
+    using Base = Range<Iter, SizedSent>;
+    Base base{buffer};
+    auto ev         = base | std::views::elements<0>;
+    auto iter       = ev.begin();
+    auto const_iter = std::as_const(ev).begin();
+    auto sent       = ev.end();
+    auto const_sent = std::as_const(ev).end();
+
+    assert(iter - sent == -5);
+    assert(sent - iter == 5);
+    assert(const_iter - const_sent == -5);
+    assert(const_sent - const_iter == 5);
+  }
+
+  // base is cross const sized
+  {
+    using Base = Range<Iter, CrossSizedSent>;
+    Base base{buffer};
+    auto ev         = base | std::views::elements<0>;
+    auto iter       = ev.begin();
+    auto const_iter = std::as_const(ev).begin();
+    auto sent       = ev.end();
+    auto const_sent = std::as_const(ev).end();
+
+    assert(iter - sent == -5);
+    assert(sent - iter == 5);
+    assert(iter - const_sent == -5);
+    assert(const_sent - iter == 5);
+    assert(const_iter - sent == -5);
+    assert(sent - const_iter == 5);
+    assert(const_iter - const_sent == -5);
+    assert(const_sent - const_iter == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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>>);
+
+struct OnlyConstSized : 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() const { return size_; }
+  constexpr std::size_t size() = delete;
+};
+
+static_assert(HasSize<const OnlyConstSized>);
+static_assert(HasSize<std::ranges::elements_view<OnlyConstSized, 0>>);
+static_assert(HasSize<const std::ranges::elements_view<OnlyConstSized, 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 <array>
+#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) {}
+
+  template <std::size_t N>
+  constexpr BufferView(std::array<T, N>& arr) : buffer_(arr.data()), 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>);
+
+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>);
+
+template <class Derived>
+struct IterBase {
+  using iterator_concept = std::random_access_iterator_tag;
+  using value_type       = std::tuple<int>;
+  using difference_type  = intptr_t;
+
+  constexpr std::tuple<int> operator*() const { return std::tuple<int>(5); }
+
+  constexpr Derived& operator++() { return *this; }
+  constexpr void operator++(int) {}
+
+  friend constexpr bool operator==(const IterBase&, const IterBase&) = default;
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_ELEMENTS_TYPES_H

llvm/utils/gn/secondary/libcxx/include/BUILD.gn

sources = [
       "__threading_support",
       "__tree",
       "__tuple/apply_cv.h",
       "__tuple/make_tuple_types.h",
       "__tuple/sfinae_helpers.h",
       "__tuple/tuple_element.h",
       "__tuple/tuple_indices.h",
       "__tuple/tuple_like.h",
+      "__tuple/tuple_like_ext.h",
       "__tuple/tuple_size.h",
       "__tuple/tuple_types.h",
       "__type_traits/add_const.h",
       "__type_traits/add_cv.h",
       "__type_traits/add_lvalue_reference.h",
       "__type_traits/add_pointer.h",
       "__type_traits/add_rvalue_reference.h",
       "__type_traits/add_volatile.h",