[libcxx][ranges] Add `ranges::transform_view`.

[ldionne]

This is awesome work, thanks a lot!

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

Is this used anywhere else other than in transform_view? If not, let's put it in transform_view.h only.

libcxx/include/__ranges/transform_view.h

2

You should update the Ranges tracking paper too.

50–52

You could factor this out into a concept __transform_view_constraints and use that to simplify your declaration of the nested iterator type below? Just a suggestion, I find it kind of annoying to duplicate the whole

requires view<_View> && is_object_v<_Fn> &&
           regular_invocable<_Fn&, range_reference_t<_View>> &&
           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>

spaghetti when defining the iterator.

103

Please add a comment to replace by all_t so we don't forget.

104–119

I think Chris is talking about __deduce_iterator_category. But reading __deduce_iterator_category, I don't think it does what we want.

However, we could rewrite as:

template<class _Tp> struct __iterator_concept;
template<random_access_range _Tp> struct __iterator_concept<_Tp> { using type = random_access_iterator_tag; };
template<bidirectional_range _Tp> struct __iterator_concept<_Tp> { using type = bidirectional_iterator_tag; };
// etc...

However, I would rename it to __transform_view_iterator_concept or something along those lines because other views/iterators are going to have different mappings from the concept of the underlying view to the concept they themselves model.

179

You can line break here?

179

Also, as a conforming extension, we can make this conditionally noexcept. (please add test)

280

The noexcept looks right to me (as we just discussed live), however I think what we want instead is to add noexcept(...) as a conforming extension to operator*, and then make this one become noexcept(noexcept(*__i)).

283

Actually, recording my discussion with Zoe: If *__i is a prvalue and we try to std::move from it, the return type will be deduced to T&&. So we're going to bind the prvalue to an rvalue reference, which will be dangling as soon as the function finishes. So the way it is written right now is definitely correct.

libcxx/include/ranges

86

Please update the synopsis to match the current state of implementation.

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

24

Please don't use auto since we're trying to also validate the return type of the function.

Also, we should add a static_assert(std::is_same<decltype(xxx.base()), ...>);. This ensures that e.g. we're not returning a View const& from the base() function, which I could picture being a mistake.

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

29–31

Can you enclose those into scopes like

{
  std::ranges::transform_view transformView(View{buff}, PlusPlus{});
  assert(transformView.begin().base() == buff);
  assert(*transformView.begin() == 1);
}

etc...

That way, you don't even have to number the variables, and IMO that makes the test easier to read.

Applies here and elsewhere, as you see fit.

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/star.pass.cpp

18 ↗

(On Diff #354055)

Please add a specific test.

In particular, I'd like to see a test where the function object returns a T, a T& and a T&&, and a confirmation that it works properly. It's also a great place to test the extension of noexcept we'll apply to it.

The same comment applies to operator[] for testing with different ref-qualified types.

Basically, the idea is that if we somehow messed up the return type of operator*, we should have something that catches it.

[zoecarver]

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

Yes, it's used in many views.

[zoecarver]

Apply review comments.

[zoecarver]

Diff off correct commit. Sorry for the noise.

[• Quuxplusone]

Minor drive-by comments.

libcxx/include/CMakeLists.txt

193–194

Tangent: This one isn't alphabetized at the moment.

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

FWIW, I think the libc++ style here would be to name it either __maybe_const_t or _MaybeConst, and then stick it in <type_traits>.

(The otherwise-badly-named _Parent and _Base typedefs repeated below are merely mirroring the Standard exposition-only wording; see Parent and Base in https://en.cppreference.com/w/cpp/ranges/transform_view/sentinel . So even though they're awfully ugly, I think _Parent and _Base are probably following the right course of action.)

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirments.compile.pass.cpp

1 ↗

(On Diff #354376)

This file's name is misspelled.

50 ↗

(On Diff #354376)

Concepts pedantry: If you use 1 instead of 0 here, you'll have one extra defense (0 can be a null pointer constant, 1 can't).

[zoecarver]

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

If you'd rather me put it in type traits that fine with me. But I want to keep the name the same. All of these exposition only concepts and type traits we do a mechanical transformation of concept-or-trait -> __concept_or_trait. Makes it easy to keep track of things, verify correctness, and reduce duplication.

[• Quuxplusone]

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

Ah, I see https://eel.is/c++draft/ranges.syn has the exposition-only maybe-const. Weird that cppreference avoids maybe-const and just does the English description e.g. "const V if Const is true, otherwise V." Anyway, LGTM.

libcxx/include/__ranges/transform_view.h

19

alphabetize plz

74–75

Teeechnically... it's impossible for humans to write noexcept-clauses. ;) Could you test locally with an iterator type like this, and report back if it prints OK!?
https://godbolt.org/z/fvxTo4n1v

99

This const is on the wrong line; ditto on line 79 above; and then please rearrange these getters into any reasonable order (e.g. begin, begin const, end, end const). Right now they're in the order begin const, begin, end, end const, which combined with the lack of trailing const keyword, confused the heck out of me.

339

Either a missing & in const __sentinel, or a superfluous const — please decide which.
(On line 345 you went with the missing-& interpretation.)
Grep your codebase today!

libcxx/include/optional

936 ↗

(On Diff #354376)

These noexcepts look great to me, but perhaps we should add a simple ~five-line test for them in libcxx/test/libcxx/.

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

40

I don't understand what's going on here with std::bind_front, nor the defaulted function argument func = Fn(), but surely our unit tests should not depend on the behavior of rand().
Please switch to e.g. [](int x) { return x + 1; } and remove the bind and default-function-argument stuff.

46

Is the point of this test to verify that x is in fact a reference into the original viewed range, and not a copy? If so, this could be more explicit. If not, then again this seems overly confusing and complicated.

51–55

I assume lines 50-54 were here for polyfill purposes; they can be removed now that enable_view is in master, right?

libcxx/test/support/test_iterators.h

235

This shouldn't be necessary. Not necessarily a bad idea, but unnecessary.

If we're going to noexcept-qualify our test iterators' operator*, operator->, and operator[], that should be done consistently across all of the test iterator types, and it should be done in a separate PR so we can see what effect it has (if any) on the existing test suite.

[zoecarver]

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

31

These have been added. Remove the TODO.

40

The tests in this file are not testing any one thing in particular. They're meant to be a few general use cases that we might see in the wild. I suppose you're right about random, though. I'll find another function.

libcxx/test/support/test_iterators.h

235

Why shouldn't this be necessary? We need some iterators with noexcept methods to be able to test the noexceptness of transform_view.

[zoecarver]

libcxx/include/__ranges/transform_view.h

19

Held over from when it was named semiregular box.

74–75

Yep, it prints OK!. Want me to add a test like this? I think it should be covered by the noexcept tests, but maybe wouldn't hurt.

99

Yes, it's confusing. Which is worse, how it is now, or having it be in a different order from the standard wording?

[zoecarver]

Alphabatize.

Const T -> Const T &.

[• Quuxplusone]

libcxx/test/support/test_iterators.h

235

For testing purposes, I recommend using int* as your "contiguous, nothrow iterator" and contiguous_iterator<int*> as your "contiguous, non-nothrow iterator." Sure, the former is not only nothrow but trivial; but as I think you yourself have pointed out on some review a few months ago, it's not possible for us to provide all of the combinatorial explosion of undreamt-of possibilities here.

(Tangent: We can pretend to do so via templates, but that's just adding another combinatorial dimension: we then miss out on the "specifically non-template, etc. etc. iterator." Which makes a difference in Ranges!, because certain things (I'm thinking of pointer_traits) behave differently depending on whether the iterator type is a template specialization or not.

• I don't yet see a concrete reason to provide either a "specifically random-access, specifically nothrow" iterator (as you propose here) nor a "random-access, specifically non-nothrow" iterator (as we have now in trunk).
• I don't yet see a concrete reason to provide either a "specifically bidirectional, specifically nothrow" iterator (as you don't propose here) nor a "bidirectional, specifically non-nothrow" iterator (as we have now in trunk). Etc.

Alternatively, could your noexceptness test make use of int* (nothrow) and ThrowingIterator (throwing)? I see ThrowingIterator being used in test/std/ranges/range.access/range.access.begin/begin.pass.cpp already.

Anyway, I'm still not philosophically opposed to nothrow-ing our test iterators, but it should be done consistently and in a separate PR, and it should have some rationale in the commit message about why you're noexcept-ing operator* but not operator++ (etc. etc.) What I am philosophically opposed to, is making ad-hoc changes to the signatures of specific test iterators for the subtle benefit of one particular test you want to write. After all, someone else might have already made them non-noexcept for the subtle benefit of some other test, which you would now be quietly nerfing.

Oh, and if you do pursue the separate-PR-consistently idea, I think it should be noexcept(noexcept(reference(*it_))).

[• Quuxplusone]

libcxx/include/__ranges/transform_view.h

74–75

Aw, geez... Try again with this version, please. https://godbolt.org/z/v16bds7o1
Did I mention it's impossible for humans to write noexcept-clauses? :D (I accidentally left the noexcept off of my Foo::begin method.)

99

I'm not asking for different order (I think?). Just to move the const up:

constexpr __sentinel<true> end() const
  noexcept(noexcept(ranges::end(__base_)))
  requires range<const _View> &&

[zoecarver]

libcxx/include/__ranges/transform_view.h

74–75

OK, it still prints OK! :P

99

I'm not asking for different order (I think?)

See above

and then please rearrange these getters into any reasonable order (e.g. begin, begin const, end, end const). Right now they're in the order begin const, begin, end, end const, which combined with the lack of trailing const keyword, confused the heck out of me.

Anyway...

Just to move the const up:

Will do.

libcxx/test/support/test_iterators.h

235

For testing purposes, I recommend using int* as your "contiguous, nothrow iterator" and contiguous_iterator<int*> as your "contiguous, non-nothrow iterator."

Done :)

[zoecarver]

• Move const.
• Use View over RandomAccessView for noexcept.

[zoecarver]

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

46

Marking this and the one above as done. I think I commented elsewhere: the point of this test isn't to test any one thing in particular, it's just to have some general function implemented in ways that this might be used in the wild.

51–55

Unfortunately not yet. We still need to actually use enable_view on main.

[zoecarver]

• Remove todo
• Don't rely on random
• Rename to 'requirements'
• Use 1 over 0 in subscript reqs test.

[ldionne]

libcxx/include/__ranges/transform_view.h

34

Reminder to fix this.

79

Stray whitespace!

87

You added noexcept to several begin() and end() methods, but I don't think they are necessary for your tests anymore if you use declval(), as we discussed offline. For consistency, I wouldn't add those noexcept as conforming extensions.

libcxx/include/optional

909 ↗

(On Diff #354560)

Those need a LIBCPP_STATIC_ASSERT(noexcept(...)) test added somewhere in the test suite.

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

14

This could say something like transform_view::<iterator>::operatorXXX instead to make it clear it's an exposition only type (applies elsewhere too).

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

39

You could use std::declval<std::ranges::iterator_t<transform_view>&>() instead of .begin() to avoid having to mark .begin() as noexcept, can't you?

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/star.pass.cpp

1 ↗

(On Diff #354560)

Filename: deref.pass.cpp instead?

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp

14

Can you spell out which ones you're expecting?

It's useful when e.g. updating tests after those requirements change, if they do.

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

14

This is a ContiguousView, not just a view, right?

20

Why are we making all those operations unconditionally noexcept? I don't think that's part of the spec for a contiguous_range, right? We should keep our archetypes minimal - that's the whole point of archetypes.

128

Maybe call this Increment and use x + 1 instead? It feels a bit weird to use an operation that is typically used to mutate state (in-place increment) in the context of a transform_view.

[zoecarver]

Apply Louis' comments.

[zoecarver]

Rebase on Louis' patch.

[• Quuxplusone]

libcxx/include/__ranges/transform_view.h

61–62

My intuition is that you want to switch these around:

[[no_unique_address]] __copyable_box<_Fn> __func_;
_View __base_ = _View();

However, I remember @tcanens having counterintuitive-but-correct intuitions about field ordering in other reviews. It would be useful to write those down as guidelines, somewhere. I volunteer to blog it, if someone can explain it to me until I remember it. :)

74–75

I forget the punch line now. I hypothesize that my original comment dated back to when this begin() had a noexcept-clause, which is now (fortunately) removed.

81

Nit: These curly braces make me uneasy, just in general. What would go wrong if you changed all the curly braces throughout to parens? Is it worth doing? (I hope that because we control the overload set of __iterator<true>'s constructor, we can be sure that curly braces are safe here. But if we used parens from the get-go, we wouldn't have to be sure.)

259–263

What's the deal with this commented-out operator<=>?

[cjdb]

• Please add a new entry to the module map.
• Please add iterator and range conformance tests (I think you've already completed some of the iterator conformance tests in a roundabout fashion).

libcxx/include/__ranges/transform_view.h

126–142

This should be in __iterator/type_traits.h (or be renamed to something that's transform_view::iterator-specific).

168

I can't remember, but there might be a technical reason why the standard says !Const and not false. cc @tcanens and @CaseyCarter for fact checking.

259–263

D103478 hasn't been merged yet. @zoecarver can you please add a TODO so we remember to come back and uncomment it ASAP?

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

40

If there's a call to bind_front then there needs to be a <functional> inclusion.

51–52

This smells like a bug. std::vector isn't a view and any attempts to treat it as such are IFNDR.

51–55

This is already in main. I suspect you need to rebase.

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

36

Can you add the tests and just have them commented out for now please?

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_minus.pass.cpp

27

Please add a test checking that (iter + n) - n) == iter and (iter - n) + n) == iter.

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp

21–33

Is this not just static_assert(std::bidirectional_iterator<std::ranges::transform_view<BidirectionalView, IncrementConst>>);? Similarly for below with std::random_access_iterator.

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirments.compile.pass.cpp

50 ↗

(On Diff #354376)

We should really be using a variable, not a constant.

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp

25

HasIterConcept implies iterator_concept. Perhaps HasIteratorCategory?

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp

47 ↗

(On Diff #355399)

Can you please move the optional changes to their own commit? I'd prefer to keep this one solely focussed on transform_view.

[CaseyCarter]

libcxx/include/__ranges/transform_view.h

168

Per https://eel.is/c++draft/class.copy.ctor#5, this constructor declaration is ill-formed when Const is false.

[tcanens]

libcxx/include/__ranges/transform_view.h

61–62

After LWG3549 this doesn't really matter.

296

This has been removed by LWG3520.

[• Quuxplusone]

libcxx/include/__ranges/transform_view.h

61–62

I don't think LWG3549 presents an alternative to view_base for non-libc++ programmers, though, does it? "Civilian" (albeit Niebler-level) programmers are still going to be writing classes that derive from view_base, and so if we're making any layout decisions based on that derivation, our decisions should be unaffected by LWG3549.
I'm thinking of concerns like this:
https://godbolt.org/z/nr9sjbqzn
...Or is the idea that civilians should never use view_base, they should always use view_interface<CRTP> instead? (In that case, view_base probably should never have been specified in the standard?)

[tcanens]

libcxx/include/__ranges/transform_view.h

61–62

View adaptors that use view_base are saying "I don't care about the potential extra padding". I don't really care about making a wrapped external thing work better with some other external wrapper - it's trying to save other people from themselves.

view_base is still handy for concrete views (that aren't adaptors).

[zoecarver]

libcxx/include/__ranges/transform_view.h

61–62

I've made both of these no_unique_address and flipped the order. This will open us up to problems, though, if someone has an empty view and empty function where the function is copyable and has a copy ctor with side effects. If they use two transform views that are both marked as no_unique_address and try to assign one of them to the other, it won't actually invoke the copy ctor. I think Louis is addressing this in the copyable box patch, though.

74–75

FWIW: this printed OK both with and without the noexcepts.

127

Rename to __transform_view_iterator_category_base.

168

Marking as complete.

296

Perfect :)

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp

21–33

I updated based on your suggestion. I think it's kind of nice to spell out the exact requirements for each overload, but this is way clearer and simpler, so I think you're right, it is better.

[zoecarver]

Update based on Chris' comments.

[• Quuxplusone]

libcxx/include/__ranges/transform_view.h

61–62

If they use two transform views that are both marked as no_unique_address and try to assign one of them to the other, it won't actually invoke the copy ctor.

I don't understand. Can you show a Godbolt that's as close as possible to what you're talking about? I would also accept a code snippet that displays the problem on libc++-after-this-patch, even if I had to compile it locally.

I wonder if you're talking about the fact that copyable-box defines its assignment operator in terms of a 1990s-flavored if (this != &rhs) test. You're right that that's going to do the wrong thing if we have two distinct copyable-box objects located at the same memory address. However, I think it's probably up to copyable-box to ensure somehow that that doesn't happen (and/or just a QoI issue).

[zoecarver]

libcxx/include/__ranges/transform_view.h

61–62

I wonder if you're talking about the fact that copyable-box defines its assignment operator in terms of a 1990s-flavored if (this != &rhs) test. You're right that that's going to do the wrong thing if we have two distinct copyable-box objects located at the same memory address. However, I think it's probably up to copyable-box to ensure somehow that that doesn't happen (and/or just a QoI issue).

Yes, this is what I'm talking about, and yes I think this is copyable-box's problem (see my comment in that review).

I think we're on the same page now, but if not, I can try to find an example.

[zoecarver]

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp

47 ↗

(On Diff #355399)

Done.

[ldionne]

libcxx/include/__ranges/transform_view.h

61–62

I concur, I think this is copyable_box's problem. I'll address that over there, and add a test so you can see what we're talking about if you're still unsure.

290

As it stands, I believe the Spec has an issue. CC @tcanens . I think iter_move(transform_view::iterator) is never noexcept. It is defined in http://eel.is/c++draft/range.transform.iterator as:

constexpr decltype(auto) iter_move(const transform_view::iterator& i)
    noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_))) {
    if constexpr (is_lvalue_reference_v<decltype(*i)>)
        return std::move(*i);
    else
        return *i;
}

However, *i.parent_->fun_ dereferences the copyable-box holding the function object, but copyable-box is specified to have the same API as std::optional. In the spec, std::optional::operator* is not noexcept, so the whole noexcept(noexcept(invoke(*i.parent_->fun_, *i.current_))) is always noexcept(false) unless the library provides a noexcept std::optional::operator* as an extension.

@tcanens Does that make sense? Is this LWG issue worthy?

(marking as Done since it's not an issue with this review per se).

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

36

Or better, #if !defined(_LIBCPP_VERSION), with a TODO comment.

[ldionne]

LGTM with remaining feedback addressed, CI passing and rebased onto the other patches as required (optional and indirectly_swappable). I don't see any blocking issue once the remaining comments have been addressed.

Please wait for @cjdb 's approval before shipping even once you do all of the above, since he had comments.

[tcanens]

libcxx/include/__ranges/transform_view.h

290

This will be fixed by https://cplusplus.github.io/LWG/issue2762

[zoecarver]

• Add tests for spaceship.

[cjdb]

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

This isn't a range concept (and it's not specific to ranges even if that's the only current client), so I'd put it in <type_traits>. Non-blocking.

libcxx/include/__ranges/transform_view.h

168

Why? It's still ill-formed and needs to be changed to !_Const AIUI.

libcxx/test/std/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp

47 ↗

(On Diff #355399)

I still see optional diffs.

[zoecarver]

libcxx/include/__ranges/concepts.h

108 ↗

(On Diff #354055)

Sure, I'll move it.

libcxx/include/__ranges/transform_view.h

168

Sorry, I thought @CaseyCarter was saying the opposite.

Anyway, can you find an example where there's an observable difference between using false here and !Const?

Here's an example that uses this ctor. I think the requires disabled the overload so the copy constructor is picked:

std::ranges::transform_view<ContiguousView, Increment> transformView;
auto iter = std::move(transformView).begin();
std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>> i2(iter);
(void)i2;

I'll add the above snippet as a test for the iterator ctor.

[• Quuxplusone]

libcxx/include/__ranges/transform_view.h

168

This looks like a Clang bug, going back ages: https://godbolt.org/z/jcaE9hx55
All other compilers agree that you aren't allowed to have a "copy" constructor S(S) that takes by value.
So I don't think libc++ should rely on it.

[zoecarver]

• Update based on Chris' comments.
• Add tests for spaceship.
• Add iterator ctor tests and move maybe_const.

[zoecarver]

libcxx/include/__ranges/transform_view.h

168

Interesting, I see. I thought the requires clause might fix this for us, but it looks like it doesn't (tested on GCC).

I'll fix tomorrow morning.

[zoecarver]

• Fix GCC bots

[zoecarver]

• Remove indirectly_swappable.

[cjdb]

LGTM, pending green CI

[zoecarver]

• Fix GCC for senintel type.
• Change comment.
• Re-format spacing.

[zoecarver]

• Fix GCC: make current iterator public.

[zoecarver]

Rebase on main.

[zoecarver]

• Re order when members are initialized in ctor.

[zoecarver]

Rebase.

[zoecarver]

• Fix ARM and Windows: replace long with auto

[zoecarver]

Rebse.

libcxx/docs/Status/RangesPaper.csv

 `[range.subrange] <http://wg21.link/range.subrange>`_,`ranges::subrange <https://llvm.org/D102006>`_,[view.interface],Zoe Carver,In progress
 `[range.dangling] <http://wg21.link/range.dangling>`_,"| ranges::dangling
 | ranges::borrowed_iterator_t
 | ranges::borrowed_subrange_t","| [range.range]
 | [range.subrange]",Unassigned,Not started
 `[range.all] <http://wg21.link/range.all>`_,`view::all <https://llvm.org/D102028>`_,"[range.subrange], [range.view.ref]",Zoe Carver,In progress
 `[range.view.ref] <http://wg21.link/range.view>`_,`ref-view <https://llvm.org/D102020>`_,[view.interface],Zoe Carver,In progress
 `[range.filter] <http://wg21.link/range.filter>`_,filter_view,[range.all],Louis Dionne,Not started
-`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,In progress
+`[range.transform] <http://wg21.link/range.transform>`_,`transform_view <https://llvm.org/D103056>`_,[range.all],Zoe Carver,✅
 `[range.iota] <http://wg21.link/range.iota>`_,iota_view,[range.all],Louis Dionne,Not started
 `[range.take] <http://wg21.link/range.take>`_,take_view,[range.all],Zoe Carver,Not started
 `[range.join] <http://wg21.link/range.join>`_,join_view,[range.all],Christopher Di Bella,Not started
 `[range.empty] <http://wg21.link/range.empty>`_,`empty_view <https://reviews.llvm.org/D103208>`_,[view.interface],Zoe Carver,✅
 `[range.single] <http://wg21.link/range.single>`_,single_view,[view.interface],Unassigned,Not started
 `[range.split] <http://wg21.link/range.split>`_,split_view,[range.all],Unassigned,Not started
 `[range.counted] <http://wg21.link/range.counted>`_,view::counted,[range.subrange],Unassigned,Not started
 `[range.common] <http://wg21.link/range.common>`_,common_view,[range.all],Zoe Carver,Not started
 `[range.reverse] <http://wg21.link/range.reverse>`_,reverse_view,[range.all],Unassigned,Not started

libcxx/include/CMakeLists.txt

set(files
   __ranges/all.h
   __ranges/concepts.h
   __ranges/copyable_box.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/ref_view.h
   __ranges/size.h
   __ranges/subrange.h
+  __ranges/transform_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/limits.h

libcxx/include/__ranges/drop_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_DROP_VIEW_H
 #define _LIBCPP___RANGES_DROP_VIEW_H
 
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/concepts.h>
+#include <__iterator/next.h>
 #include <__ranges/access.h>
 #include <__ranges/view_interface.h>
 #include <__ranges/all.h>
 #include <type_traits>
 #include <optional>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header

libcxx/include/__ranges/transform_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_TRANSFORM_VIEW_H
+#define _LIBCPP___RANGES_TRANSFORM_VIEW_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_swap.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/copyable_box.h>
+#include <__ranges/empty.h>
+#include <__ranges/view_interface.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+
+template<class _View, class _Fn>
+concept __transform_view_constraints =
+           view<_View> && is_object_v<_Fn> &&
+           regular_invocable<_Fn&, range_reference_t<_View>> &&
+           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>;
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+class transform_view : public view_interface<transform_view<_View, _Fn>> {
+  template<bool> class __iterator;
+  template<bool> class __sentinel;
+
+  [[no_unique_address]] __copyable_box<_Fn> __func_;
+  [[no_unique_address]] _View __base_ = _View();
+
+public:
+  transform_view()
+    requires default_initializable<_View> && default_initializable<_Fn> = default;
+
+  constexpr transform_view(_View __base, _Fn __func)
+    : __func_(_VSTD::in_place, _VSTD::move(__func)), __base_(_VSTD::move(__base)) {}
+
+  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  constexpr _View base() && { return _VSTD::move(__base_); }
+
+  constexpr __iterator<false> begin() {
+    return __iterator<false>{*this, ranges::begin(__base_)};
+  }
+  constexpr __iterator<true> begin() const
+    requires range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __iterator<true>(*this, ranges::begin(__base_));
+  }
+
+  constexpr __sentinel<false> end() {
+    return __sentinel<false>(ranges::end(__base_));
+  }
+  constexpr __iterator<false> end()
+    requires common_range<_View>
+  {
+    return __iterator<false>(*this, ranges::end(__base_));
+  }
+  constexpr __sentinel<true> end() const
+    requires range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __sentinel<true>(ranges::end(__base_));
+  }
+  constexpr __iterator<true> end() const
+    requires common_range<const _View> &&
+             regular_invocable<const _Fn&, range_reference_t<const _View>>
+  {
+    return __iterator<true>(*this, ranges::end(__base_));
+  }
+
+  constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
+  constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
+};
+
+// TODO: replace the decltype with all_t when that's implemented.
+template<class _Range, class _Fn>
+transform_view(_Range&&, _Fn)
+  -> transform_view<decltype(views::all(std::declval<_Range>())), _Fn>;
+
+template<class _View>
+struct __transform_view_iterator_concept { using type = input_iterator_tag; };
+
+template<random_access_range _View>
+struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
+
+template<bidirectional_range _View>
+struct __transform_view_iterator_concept<_View> { using type = bidirectional_iterator_tag; };
+
+template<forward_range _View>
+struct __transform_view_iterator_concept<_View> { using type = forward_iterator_tag; };
+
+template<class, class>
+struct __transform_view_iterator_category_base {};
+
+template<forward_range _View, class _Fn>
+struct __transform_view_iterator_category_base<_View, _Fn> {
+  using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+
+  using iterator_category = conditional_t<
+    is_lvalue_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
+    conditional_t<
+      derived_from<_Cat, contiguous_iterator_tag>,
+      random_access_iterator_tag,
+      _Cat
+    >,
+    input_iterator_tag
+  >;
+};
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__iterator
+  : public __transform_view_iterator_category_base<_View, _Fn> {
+
+  using _Parent = __maybe_const<_Const, transform_view>;
+  using _Base = __maybe_const<_Const, _View>;
+
+  _Parent *__parent_ = nullptr;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__iterator;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+  iterator_t<_Base> __current_ = iterator_t<_Base>();
+
+  using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
+  using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
+  using difference_type = range_difference_t<_Base>;
+
+  __iterator() requires default_initializable<iterator_t<_Base>> = default;
+
+  constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+    : __parent_(_VSTD::addressof(__parent)), __current_(_VSTD::move(__current)) {}
+
+  // Note: `__i` should always be `__iterator<false>`, but directly using
+  // `__iterator<false>` is ill-formed when `_Const` is false
+  // (see http://wg21.link/class.copy.ctor#5).
+  constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+    : __parent_(__i.__parent_), __current_(_VSTD::move(__i.__current_)) {}
+
+  constexpr iterator_t<_Base> base() const&
+    requires copyable<iterator_t<_Base>>
+  {
+    return __current_;
+  }
+
+  constexpr iterator_t<_Base> base() && {
+    return _VSTD::move(__current_);
+  }
+
+  constexpr decltype(auto) operator*() const
+    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, *__current_)))
+  {
+    return _VSTD::invoke(*__parent_->__func_, *__current_);
+  }
+
+  constexpr __iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  constexpr void operator++(int) { ++__current_; }
+
+  constexpr __iterator operator++(int)
+    requires forward_range<_Base>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  constexpr __iterator& operator--()
+    requires bidirectional_range<_Base>
+  {
+    --__current_;
+    return *this;
+  }
+
+  constexpr __iterator operator--(int)
+    requires bidirectional_range<_Base>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  constexpr __iterator& operator+=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ += __n;
+    return *this;
+  }
+
+  constexpr __iterator& operator-=(difference_type __n)
+    requires random_access_range<_Base>
+  {
+    __current_ -= __n;
+    return *this;
+  }
+
+  constexpr decltype(auto) operator[](difference_type __n) const
+    noexcept(noexcept(_VSTD::invoke(*__parent_->__func_, __current_[__n])))
+    requires random_access_range<_Base>
+  {
+    return _VSTD::invoke(*__parent_->__func_, __current_[__n]);
+  }
+
+  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires equality_comparable<iterator_t<_Base>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
+
+  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ < __y.__current_;
+  }
+
+  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ > __y.__current_;
+  }
+
+  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ <= __y.__current_;
+  }
+
+  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires random_access_range<_Base>
+  {
+    return __x.__current_ >= __y.__current_;
+  }
+
+// TODO: Fix this as soon as soon as three_way_comparable is implemented.
+//   friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+//     requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+//   {
+//     return __x.__current_ <=> __y.__current_;
+//   }
+
+  friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ + __n};
+  }
+
+  friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ + __n};
+  }
+
+  friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+    requires random_access_range<_Base>
+  {
+    return __iterator{*__i.__parent_, __i.__current_ - __n};
+  }
+
+  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+    requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+  {
+    return __x.__current_ - __y.__current_;
+  }
+
+  friend constexpr decltype(auto) iter_move(const __iterator& __i)
+    noexcept(noexcept(*__i))
+  {
+    if constexpr (is_lvalue_reference_v<decltype(*__i)>)
+      return _VSTD::move(*__i);
+    else
+      return *__i;
+  }
+};
+
+template<input_range _View, copy_constructible _Fn>
+  requires __transform_view_constraints<_View, _Fn>
+template<bool _Const>
+class transform_view<_View, _Fn>::__sentinel {
+  using _Parent = __maybe_const<_Const, transform_view>;
+  using _Base = __maybe_const<_Const, _View>;
+
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__iterator;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+  __sentinel() = default;
+
+  constexpr explicit __sentinel(sentinel_t<_Base> __end_) : __end_(__end_) {}
+
+  // Note: `__i` should always be `__sentinel<false>`, but directly using
+  // `__sentinel<false>` is ill-formed when `_Const` is false
+  // (see http://wg21.link/class.copy.ctor#5).
+  constexpr __sentinel(__sentinel<!_Const> __i)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+    : __end_(_VSTD::move(__i.__end_)) {}
+
+  constexpr sentinel_t<_Base> base() const { return __end_; }
+
+  template<bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_ == __y.__end_;
+  }
+
+  template<bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__current_ - __y.__end_;
+  }
+
+  template<bool _OtherConst>
+    requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
+    return __x.__end_ - __y.__current_;
+  }
+};
+
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H

libcxx/include/ranges

namespace std::ranges {
 
   template<class T>
   concept random_access_range = see below;
 
   template<class T>
   concept contiguous_range = see below;
 
   template <class _Tp>
     concept common_range = see below;
 
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
   class view_interface;
 
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
   class empty_view;
 
   // [range.drop], drop view
   template<view V>
     class drop_view;
 
   template<class T>
     inline constexpr bool enable_borrowed_range<drop_view<T>> = enable_borrowed_range<T>;
+
+  // [range.transform], transform view
+  template<input_range V, copy_constructible F>
+    requires view<V> && is_object_v<F> &&
+             regular_invocable<F&, range_reference_t<V>> &&
+             can-reference<invoke_result_t<F&, range_reference_t<V>>>
+  class transform_view;
+
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/ref_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/type_traits

 #endif
 
 template <class _CharT>
 using _IsCharLikeType = _And<is_standard_layout<_CharT>, is_trivial<_CharT> >;
 
 template<class _Tp>
 using __make_const_lvalue_ref = const typename remove_reference<_Tp>::type&;
 
+#if _LIBCPP_STD_VER > 17
+template<bool _Const, class _Tp>
+using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 // std::byte
 namespace std  // purposefully not versioned
 {
 
 
 }
 #endif
 
 #endif // _LIBCPP_TYPE_TRAITS

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr V base() const& requires copy_constructible<V>
+// constexpr V base() &&
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<ContiguousView, Increment> transformView;
+    ContiguousView base = std::move(transformView).base();
+    ASSERT_SAME_TYPE(ContiguousView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base) == globalBuff);
+  }
+
+  {
+    std::ranges::transform_view<CopyableView, Increment> transformView;
+    CopyableView base1 = transformView.base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+    assert(std::ranges::begin(base1) == globalBuff);
+
+    CopyableView base2 = std::move(transformView).base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base2) == globalBuff);
+  }
+
+  {
+    const std::ranges::transform_view<CopyableView, Increment> transformView;
+    const CopyableView base1 = transformView.base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(transformView.base()));
+    assert(std::ranges::begin(base1) == globalBuff);
+
+    const CopyableView base2 = std::move(transformView).base();
+    ASSERT_SAME_TYPE(CopyableView, decltype(std::move(transformView).base()));
+    assert(std::ranges::begin(base2) == globalBuff);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr iterator<false> begin();
+// constexpr iterator<true> begin() const
+//   requires range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept BeginInvocable = requires(T t) { t.begin(); };
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    assert(transformView.begin().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    std::ranges::transform_view transformView(ForwardView{buff}, Increment{});
+    assert(transformView.begin().base().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    std::ranges::transform_view transformView(InputView{buff}, Increment{});
+    assert(transformView.begin().base().base() == buff);
+    assert(*transformView.begin() == 1);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{buff}, IncrementConst{});
+    assert(*transformView.begin() == 1);
+  }
+
+  static_assert(!BeginInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// CTAD tests.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+static_assert(std::same_as<decltype(std::ranges::transform_view(InputView(), Increment())),
+                           std::ranges::transform_view<InputView, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(std::declval<ForwardRange&>(), Increment())),
+                           std::ranges::transform_view<std::ranges::ref_view<ForwardRange>, Increment>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), Increment())),
+                           std::ranges::transform_view<std::ranges::subrange<int*>, Increment>>);

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr sentinel<false> end();
+// constexpr iterator<false> end() requires common_range<V>;
+// constexpr sentinel<true> end() const
+//   requires range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+// constexpr iterator<true> end() const
+//   requires common_range<const V> &&
+//            regular_invocable<const F&, range_reference_t<const V>>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept EndInvocable = requires(T t) { t.end(); };
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  {
+    std::ranges::transform_view transformView(ForwardView{}, Increment{});
+    assert(transformView.end().base().base() == globalBuff + 8);
+  }
+
+  {
+    std::ranges::transform_view transformView(InputView{}, Increment{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{}, IncrementConst{});
+    assert(transformView.end().base() == globalBuff + 8);
+  }
+
+  static_assert(!EndInvocable<const std::ranges::transform_view<ContiguousView, Increment>>);
+  static_assert( EndInvocable<      std::ranges::transform_view<ContiguousView, Increment>>);
+  static_assert( EndInvocable<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+  static_assert(!EndInvocable<const std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndInvocable<      std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndInvocable<const std::ranges::transform_view<InputView, IncrementConst>>);
+
+  static_assert(!EndIsIter<const std::ranges::transform_view<InputView, IncrementConst>>);
+  static_assert(!EndIsIter<      std::ranges::transform_view<InputView, Increment>>);
+  static_assert( EndIsIter<const std::ranges::transform_view<ContiguousView, IncrementConst>>);
+  static_assert( EndIsIter<      std::ranges::transform_view<ContiguousView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// Some basic examples of how transform_view might be used in the wild. This is a general
+// collection of sample algorithms and functions that try to mock general usage of
+// this view.
+
+#include <ranges>
+
+#include <cctype>
+#include <functional>
+#include <list>
+#include <numeric>
+#include <string>
+#include <vector>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "types.h"
+
+template<std::ranges::range R>
+auto toUpper(R range) {
+  return std::ranges::transform_view(range, [](char c) { return std::toupper(c); });
+}
+
+unsigned badRandom() { return 42; }
+
+template<std::ranges::range R, class Fn = std::plus<std::iter_value_t<R>>>
+auto withRandom(R&& range, Fn func = Fn()) {
+  return std::ranges::transform_view(range, std::bind_front(func, badRandom()));
+}
+
+template<class E1, class E2, size_t N, class Join = std::plus<E1>>
+auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
+  return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
+    auto idx = (&x) - a;
+    return join(x, b[idx]);
+  });
+}
+
+int main(int, char**) {
+  {
+    std::vector vec = {1, 2, 3, 4};
+    auto sortOfRandom = withRandom(vec);
+    std::vector check = {43, 44, 45, 46};
+    assert(std::equal(sortOfRandom.begin(), sortOfRandom.end(), check.begin(), check.end()));
+  }
+
+  {
+    int a[4] = {1, 2, 3, 4};
+    int b[4] = {4, 3, 2, 1};
+    auto out = joinArrays(a, b);
+    int check[4] = {5, 5, 5, 5};
+    assert(std::equal(out.begin(), out.end(), check));
+  }
+
+  {
+    std::string_view str = "Hello, World.";
+    auto upp = toUpper(str);
+    std::string_view check = "HELLO, WORLD.";
+    assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
+  }
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{++,--,+=,-=}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, Increment> transformView;
+  auto iter = std::move(transformView).begin();
+  assert((++iter).base() == globalBuff + 1);
+
+  assert((iter++).base() == globalBuff + 1);
+  assert(iter.base() == globalBuff + 2);
+
+  assert((--iter).base() == globalBuff + 1);
+  assert((iter--).base() == globalBuff + 1);
+  assert(iter.base() == globalBuff);
+
+  // Check that decltype(InputIter++) == void.
+  ASSERT_SAME_TYPE(decltype(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<InputView, Increment>>>()++),
+    void);
+
+  assert((iter += 4).base() == globalBuff + 4);
+  assert((iter -= 3).base() == globalBuff + 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::base
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter.base();
+};
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<ContiguousView, Increment> transformView;
+    auto iter = std::move(transformView).begin();
+    ASSERT_SAME_TYPE(int*, decltype(iter.base()));
+    assert(iter.base() == globalBuff);
+    ASSERT_SAME_TYPE(int*, decltype(std::move(iter).base()));
+    assert(std::move(iter).base() == globalBuff);
+  }
+
+  {
+    std::ranges::transform_view<InputView, Increment> transformView;
+    auto iter = transformView.begin();
+    assert(std::move(iter).base() == globalBuff);
+    ASSERT_SAME_TYPE(cpp20_input_iterator<int *>, decltype(std::move(iter).base()));
+  }
+
+  static_assert(!BaseInvocable<InputView, Increment>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{<,>,<=,>=}
+
+#include <ranges>
+#include <compare>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view<ContiguousView, Increment> transformView1;
+    auto iter1 = std::move(transformView1).begin();
+    std::ranges::transform_view<ContiguousView, Increment> transformView2;
+    auto iter2 = std::move(transformView2).begin();
+    assert(iter1 == iter2);
+    assert(iter1 + 1 != iter2);
+    assert(iter1 + 1 == iter2 + 1);
+
+    assert(iter1 < iter1 + 1);
+    assert(iter1 + 1 > iter1);
+    assert(iter1 <= iter1 + 1);
+    assert(iter1 <= iter2);
+    assert(iter1 + 1 >= iter2);
+    assert(iter1     >= iter2);
+  }
+
+// TODO: when three_way_comparable is implemented and std::is_eq is implemented,
+// uncomment this.
+//   {
+//     std::ranges::transform_view<ThreeWayCompView, Increment> transformView1;
+//     auto iter1 = transformView1.begin();
+//     std::ranges::transform_view<ThreeWayCompView, Increment> transformView2;
+//     auto iter2 = transformView2.begin();
+//
+//     assert(std::is_eq(iter1   <=> iter2));
+//     assert(std::is_lteq(iter1 <=> iter2));
+//     ++iter2;
+//     assert(std::is_neq(iter1  <=> iter2));
+//     assert(std::is_lt(iter1   <=> iter2));
+//     assert(std::is_gt(iter2   <=> iter1));
+//     assert(std::is_gteq(iter2 <=> iter1));
+//
+//     static_assert( std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ThreeWayCompView, Increment>>>);
+//     static_assert(!std::three_way_comparable<std::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>);
+//   }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::transform_view::<iterator>();
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+struct NoDefaultInit {
+    typedef std::random_access_iterator_tag iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef NoDefaultInit                   self;
+
+    NoDefaultInit(int*);
+
+    reference operator*() const;
+    pointer operator->() const;
+    auto operator<=>(const self&) const = default;
+    bool operator==(int *) const;
+
+    self& operator++();
+    self operator++(int);
+
+    self& operator--();
+    self operator--(int);
+
+    self& operator+=(difference_type n);
+    self operator+(difference_type n) const;
+    friend self operator+(difference_type n, self x);
+
+    self& operator-=(difference_type n);
+    self operator-(difference_type n) const;
+    difference_type operator-(const self&) const;
+
+    reference operator[](difference_type n) const;
+};
+
+struct IterNoDefaultInitView : std::ranges::view_base {
+  NoDefaultInit begin() const;
+  int *end() const;
+  NoDefaultInit begin();
+  int *end();
+};
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, IncrementConst> transformView;
+  auto iter = std::move(transformView).begin();
+  std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementConst>> i2(iter);
+  (void)i2;
+  std::ranges::iterator_t<const std::ranges::transform_view<ContiguousView, IncrementConst>> constIter(iter);
+  (void)constIter;
+
+
+  static_assert( std::default_initializable<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementConst>>>);
+  static_assert(!std::default_initializable<std::ranges::iterator_t<std::ranges::transform_view<IterNoDefaultInitView, IncrementConst>>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator*
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+int main(int, char**) {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    assert(*transformView.begin() == 1);
+  }
+
+  static_assert(!noexcept(
+    *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()));
+  static_assert( noexcept(
+    *std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()));
+
+  ASSERT_SAME_TYPE(
+    int,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()));
+  ASSERT_SAME_TYPE(
+    int&,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()));
+  ASSERT_SAME_TYPE(
+    int&&,
+    decltype(*std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()));
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+
+  {
+    std::ranges::transform_view transformView(ContiguousView{buff}, Increment{});
+    auto iter = transformView.begin();
+    static_assert(!noexcept(std::ranges::iter_move(iter)));
+
+    assert(std::ranges::iter_move(iter) == 1);
+    assert(std::ranges::iter_move(iter + 2) == 3);
+
+    ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(iter)));
+    ASSERT_SAME_TYPE(int, decltype(std::ranges::iter_move(std::move(iter))));
+  }
+
+  {
+    static_assert( noexcept(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>&>())));
+    static_assert(!noexcept(std::ranges::iter_move(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>&>())));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/plus_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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator{+,-}
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  std::ranges::transform_view<ContiguousView, Increment> transformView1;
+  auto iter1 = std::move(transformView1).begin();
+  std::ranges::transform_view<ContiguousView, Increment> transformView2;
+  auto iter2 = std::move(transformView2).begin();
+  iter1 += 4;
+  assert((iter1 + 1).base() == globalBuff + 5);
+  assert((1 + iter1).base() == globalBuff + 5);
+  assert((iter1 - 1).base() == globalBuff + 3);
+  assert(iter1 - iter2 == 4);
+  assert((iter1 + 2) - 2 == iter1);
+  assert((iter1 - 2) + 2 == iter1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/requirements.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// The requirements for transform_view::<iterator>'s members.
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+static_assert(std::ranges::bidirectional_range<std::ranges::transform_view<BidirectionalView, IncrementConst>>);
+static_assert(!std::ranges::bidirectional_range<std::ranges::transform_view<ForwardView, IncrementConst>>);
+
+static_assert(std::ranges::random_access_range<std::ranges::transform_view<RandomAccessView, IncrementConst>>);
+static_assert(!std::ranges::random_access_range<std::ranges::transform_view<BidirectionalView, IncrementConst>>);

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/sentinel.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// class transform_view::<sentinel>;
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+constexpr bool test() {
+  std::ranges::transform_view<SizedSentinelView, IncrementConst> transformView1;
+  // Going to const and back.
+  auto sent1 = transformView1.end();
+  std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent2{sent1};
+  std::ranges::sentinel_t<const std::ranges::transform_view<SizedSentinelView, IncrementConst>> sent3{sent2};
+  (void)sent3;
+
+  static_assert(!EndIsIter<decltype(sent1)>);
+  static_assert(!EndIsIter<decltype(sent2)>);
+  assert(sent1.base() == globalBuff + 8);
+
+  std::ranges::transform_view transformView2(SizedSentinelView{4}, IncrementConst());
+  auto sent4 = transformView2.end();
+  auto iter = transformView1.begin();
+  {
+    assert(iter != sent1);
+    assert(iter != sent2);
+    assert(iter != sent4);
+  }
+
+  {
+    assert(iter + 8 == sent1);
+    assert(iter + 8 == sent2);
+    assert(iter + 4 == sent4);
+  }
+
+  {
+    assert(sent1 - iter  == 8);
+    assert(sent4 - iter  == 4);
+    assert(iter  - sent1 == -8);
+    assert(iter  - sent4 == -4);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::operator[]
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+constexpr bool test() {
+  int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+  std::ranges::transform_view transformView1(ContiguousView{buff}, Increment{});
+  auto iter1 = std::move(transformView1).begin() + 1;
+  assert(iter1[0] == 2);
+  assert(iter1[4] == 6);
+
+  static_assert(!noexcept(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, Increment>>>()[0]));
+  static_assert( noexcept(
+    std::declval<std::ranges::iterator_t<std::ranges::transform_view<ContiguousView, IncrementNoexcept>>>()[0]));
+
+  ASSERT_SAME_TYPE(
+    int,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, Increment>>().begin()[0]));
+  ASSERT_SAME_TYPE(
+    int&,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRef>>().begin()[0]));
+  ASSERT_SAME_TYPE(
+    int&&,
+    decltype(std::declval<std::ranges::transform_view<RandomAccessView, IncrementRvalueRef>>().begin()[0]));
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/iterator/types.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// transform_view::<iterator>::difference_type
+// transform_view::<iterator>::value_type
+// transform_view::<iterator>::iterator_category
+// transform_view::<iterator>::iterator_concept
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "../types.h"
+
+template<class V, class F>
+concept HasIterCategory = requires { typename std::ranges::transform_view<V, F>::iterator_category; };
+
+constexpr bool test() {
+  {
+    // Member typedefs for contiguous iterator.
+    static_assert(std::same_as<std::iterator_traits<int*>::iterator_concept, std::contiguous_iterator_tag>);
+    static_assert(std::same_as<std::iterator_traits<int*>::iterator_category, std::random_access_iterator_tag>);
+
+    using TView = std::ranges::transform_view<ContiguousView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for random access iterator.
+    using TView = std::ranges::transform_view<RandomAccessView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for random access iterator/not-lvalue-ref.
+    using TView = std::ranges::transform_view<RandomAccessView, Increment>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::random_access_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::input_iterator_tag>); // Note: this is now input_iterator_tag.
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for bidirectional iterator.
+    using TView = std::ranges::transform_view<BidirectionalView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::bidirectional_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for forward iterator.
+    using TView = std::ranges::transform_view<ForwardView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::forward_iterator_tag>);
+    static_assert(std::same_as<typename TIter::iterator_category, std::forward_iterator_tag>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+  {
+    // Member typedefs for input iterator.
+    using TView = std::ranges::transform_view<InputView, IncrementRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::input_iterator_tag>);
+    static_assert(!HasIterCategory<InputView, IncrementRef>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.transform/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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <ranges>
+
+#include "test_macros.h"
+#include "types.h"
+
+template<class T>
+concept SizeInvocable = requires(T t) { t.size(); };
+
+constexpr bool test() {
+  {
+    std::ranges::transform_view transformView(ContiguousView{}, Increment{});
+    assert(transformView.size() == 8);
+  }
+
+  {
+    const std::ranges::transform_view transformView(ContiguousView{globalBuff, 4}, Increment{});
+    assert(transformView.size() == 4);
+  }
+
+  static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, Increment>>);
+
+  static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+  static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, Increment>>);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+#ifndef TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+#define TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+int globalBuff[8] = {0,1,2,3,4,5,6,7};
+
+template<class T, class F>
+concept ValidDropView = requires { typename std::ranges::transform_view<T, F>; };
+
+struct ContiguousView : std::ranges::view_base {
+  int start_;
+  int *ptr_;
+  constexpr ContiguousView(int* ptr = globalBuff, int start = 0) : start_(start), ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_ + view.start_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_ + view.start_; }
+  constexpr friend int* end(ContiguousView& view) { return view.ptr_ + 8; }
+  constexpr friend int* end(ContiguousView const& view) { return view.ptr_ + 8; }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int start_;
+  constexpr CopyableView(int start = 0) : start_(start) {}
+  constexpr CopyableView(CopyableView const&) = default;
+  constexpr CopyableView& operator=(CopyableView const&) = default;
+  constexpr friend int* begin(CopyableView& view) { return globalBuff + view.start_; }
+  constexpr friend int* begin(CopyableView const& view) { return globalBuff + view.start_; }
+  constexpr friend int* end(CopyableView&) { return globalBuff + 8; }
+  constexpr friend int* end(CopyableView const&) { return globalBuff + 8; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct ForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ForwardView(int* ptr = globalBuff) : ptr_(ptr) {}
+  constexpr ForwardView(ForwardView&&) = default;
+  constexpr ForwardView& operator=(ForwardView&&) = default;
+  constexpr friend ForwardIter begin(ForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(ForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter end(ForwardView& view) { return ForwardIter(view.ptr_ + 8); }
+  constexpr friend ForwardIter end(ForwardView const& view) { return ForwardIter(view.ptr_ + 8); }
+};
+
+using ForwardRange = test_common_range<forward_iterator>;
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct RandomAccessView : std::ranges::view_base {
+  RandomAccessIter begin() const noexcept;
+  RandomAccessIter end() const noexcept;
+  RandomAccessIter begin() noexcept;
+  RandomAccessIter end() noexcept;
+};
+
+using BidirectionalIter = bidirectional_iterator<int*>;
+struct BidirectionalView : std::ranges::view_base {
+  BidirectionalIter begin() const;
+  BidirectionalIter end() const;
+  BidirectionalIter begin();
+  BidirectionalIter end();
+};
+
+struct BorrowableRange {
+  friend int* begin(BorrowableRange const& range);
+  friend int* end(BorrowableRange const&);
+  friend int* begin(BorrowableRange& range);
+  friend int* end(BorrowableRange&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowableRange> = true;
+
+struct InputView : std::ranges::view_base {
+  int *ptr_;
+  constexpr InputView(int* ptr = globalBuff) : ptr_(ptr) {}
+  constexpr cpp20_input_iterator<int*> begin() const { return cpp20_input_iterator<int*>(ptr_); }
+  constexpr int* end() const { return ptr_ + 8; }
+  constexpr cpp20_input_iterator<int*> begin() { return cpp20_input_iterator<int*>(ptr_); }
+  constexpr int* end() { return ptr_ + 8; }
+};
+
+constexpr bool operator==(const cpp20_input_iterator<int*> &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const cpp20_input_iterator<int*> &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelView : std::ranges::view_base {
+  int count_;
+  constexpr SizedSentinelView(int count = 8) : count_(count) {}
+  constexpr RandomAccessIter begin() const { return RandomAccessIter(globalBuff); }
+  constexpr int* end() const { return globalBuff + count_; }
+  constexpr RandomAccessIter begin() { return RandomAccessIter(globalBuff); }
+  constexpr int* end() { return globalBuff + count_; }
+};
+
+constexpr auto operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
+constexpr auto operator- (int* lhs, const RandomAccessIter &rhs) { return lhs - rhs.base(); }
+constexpr bool operator==(const RandomAccessIter &lhs, int* rhs) { return lhs.base() == rhs; }
+constexpr bool operator==(int* lhs, const RandomAccessIter &rhs) { return rhs.base() == lhs; }
+
+struct SizedSentinelNotConstView : std::ranges::view_base {
+  ForwardIter begin() const;
+  int *end() const;
+  ForwardIter begin();
+  int *end();
+  size_t size();
+};
+bool operator==(const ForwardIter &lhs, int* rhs);
+bool operator==(int* lhs, const ForwardIter &rhs);
+
+struct Range {
+  friend int* begin(Range const&);
+  friend int* end(Range const&);
+  friend int* begin(Range&);
+  friend int* end(Range&);
+};
+
+using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
+struct CountedView : std::ranges::view_base {
+  constexpr CountedIter begin() { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
+  constexpr CountedIter end() { return CountedIter(ForwardIter(globalBuff + 8)); }
+  constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
+};
+
+using ThreeWayCompIter = three_way_contiguous_iterator<int*>;
+struct ThreeWayCompView : std::ranges::view_base {
+  constexpr ThreeWayCompIter begin() { return ThreeWayCompIter(globalBuff); }
+  constexpr ThreeWayCompIter begin() const { return ThreeWayCompIter(globalBuff); }
+  constexpr ThreeWayCompIter end() { return ThreeWayCompIter(globalBuff + 8); }
+  constexpr ThreeWayCompIter end() const { return ThreeWayCompIter(globalBuff + 8); }
+};
+
+struct Increment {
+  constexpr int operator()(int x) { return x + 1; }
+};
+
+struct IncrementConst {
+  constexpr int operator()(int x) const { return x + 1; }
+};
+
+struct IncrementRef {
+  constexpr int& operator()(int& x) { return ++x; }
+};
+
+struct IncrementRvalueRef {
+  constexpr int&& operator()(int& x) { return std::move(++x); }
+};
+
+struct IncrementNoexcept {
+  constexpr int operator()(int x) noexcept { return x + 1; }
+};
+
+#endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TRANSFORM_TYPES_H

libcxx/test/support/test_iterators.h

public:
 
     TEST_CONSTEXPR_CXX14 It base() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 random_access_iterator() : it_() {}
     explicit TEST_CONSTEXPR_CXX14 random_access_iterator(It it) : it_(it) {}
     template <class U>
         TEST_CONSTEXPR_CXX14 random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
 
     TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
     TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
 
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator++() {++it_; return *this;}
     TEST_CONSTEXPR_CXX14 random_access_iterator operator++(int)
         {random_access_iterator tmp(*this); ++(*this); return tmp;}
 
     TEST_CONSTEXPR_CXX14 random_access_iterator& operator--() {--it_; return *this;}
     TEST_CONSTEXPR_CXX14 random_access_iterator operator--(int)
public:
   constexpr bool operator==(I const& other) const requires std::equality_comparable<I> {
     return base_ == other;
   }
 
 private:
   I base_ = I();
 };
 
+template <class It>
+class three_way_contiguous_iterator
+{
+    static_assert(std::is_pointer_v<It>, "Things probably break in this case");
+
+    It it_;
+
+    template <class U> friend class three_way_contiguous_iterator;
+public:
+    typedef          std::contiguous_iterator_tag              iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+    typedef typename std::remove_pointer<It>::type             element_type;
+
+    TEST_CONSTEXPR_CXX14 It base() const {return it_;}
+
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator() : it_() {}
+    explicit TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator(It it) : it_(it) {}
+    template <class U>
+        TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator(const three_way_contiguous_iterator<U>& u) : it_(u.it_) {}
+
+    TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
+    TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
+
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator++() {++it_; return *this;}
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator++(int)
+        {three_way_contiguous_iterator tmp(*this); ++(*this); return tmp;}
+
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator--() {--it_; return *this;}
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator--(int)
+        {three_way_contiguous_iterator tmp(*this); --(*this); return tmp;}
+
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator+(difference_type n) const
+        {three_way_contiguous_iterator tmp(*this); tmp += n; return tmp;}
+    friend TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator+(difference_type n, three_way_contiguous_iterator x)
+        {x += n; return x;}
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
+    TEST_CONSTEXPR_CXX14 three_way_contiguous_iterator operator-(difference_type n) const
+        {three_way_contiguous_iterator tmp(*this); tmp -= n; return tmp;}
+
+    TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
+
+    template <class T>
+    void operator,(T const &) DELETE_FUNCTION;
+
+    friend TEST_CONSTEXPR_CXX14
+    difference_type operator-(const three_way_contiguous_iterator& x, const three_way_contiguous_iterator& y) {
+        return x.base() - y.base();
+    }
+
+    friend auto operator<=>(const three_way_contiguous_iterator&, const three_way_contiguous_iterator&) = default;
+};
+
 // clang-format on
 
 #endif // TEST_STD_VER > 17 && defined(__cpp_lib_concepts)
 
 #undef DELETE_FUNCTION
 
 #endif // ITERATORS_H