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

[ldionne]

This is awesome work, thanks a lot!

libcxx/include/__ranges/concepts.h

73

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.

103–118

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)

279

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)).

282

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

73

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

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

23 ↗

(On Diff #354055)

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

28–30 ↗

(On Diff #354055)

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

73

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

46–47

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

libcxx/include/__ranges/concepts.h

73

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

73

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

73

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

39 ↗

(On Diff #354376)

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.

45 ↗

(On Diff #354376)

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.

50–54 ↗

(On Diff #354376)

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

234 ↗

(On Diff #354376)

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

30 ↗

(On Diff #354376)

These have been added. Remove the TODO.

39 ↗

(On Diff #354376)

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

234 ↗

(On Diff #354376)

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

234 ↗

(On Diff #354376)

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

234 ↗

(On Diff #354376)

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

45 ↗

(On Diff #354376)

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.

50–54 ↗

(On Diff #354376)

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

13 ↗

(On Diff #354560)

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

38 ↗

(On Diff #355295)

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

13 ↗

(On Diff #355295)

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

127 ↗

(On Diff #355295)

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.

13 ↗

(On Diff #354560)

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

19 ↗

(On Diff #354560)

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.

[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

50–51 ↗

(On Diff #355399)

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

39 ↗

(On Diff #354376)

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

50–54 ↗

(On Diff #354376)

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

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

35 ↗

(On Diff #355399)

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

26 ↗

(On Diff #355399)

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

20–32 ↗

(On Diff #355399)

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

24 ↗

(On Diff #355399)

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

20–32 ↗

(On Diff #355399)

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

35 ↗

(On Diff #355399)

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

73

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

73

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/include/CMakeLists.txt

set(files
   __mutex_base
   __node_handle
   __nullptr
   __ranges/access.h
   __ranges/all.h
   __ranges/concepts.h
   __ranges/data.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/view.h
   __ranges/semiregular_box.h
   __ranges/size.h
   __ranges/subrange.h
+  __ranges/transform_view.h
   __ranges/ref_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __threading_support
   __tree
   __tuple

libcxx/include/__ranges/concepts.h

namespace ranges {
 
   template <class _Tp>
   concept random_access_range =
       bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp> >;
 
   template<class _Range>
   concept borrowed_range =
       range<_Range> &&
       (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
 
+  template<bool _Const, class _Tp>
+  using __maybe_const = conditional_t<_Const, const _Tp, _Tp>;
+
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 // clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_RANGES_CONCEPTS_H

libcxx/include/__ranges/subrange.h

namespace ranges {
   enum class subrange_kind { unsized, sized };
 
   template<class _Iter, class _Sent, subrange_kind _Kind>
   struct __subrange_base {
     static constexpr bool __store_size = false;
     _Iter __begin = _Iter();
     _Sent __end = _Sent();
 
+    __subrange_base() = default;
     constexpr __subrange_base(_Iter __iter, _Sent __sent)
       : __begin(_VSTD::move(__iter)), __end(__sent) { }
   };
 
   template<class _Iter, class _Sent>
   struct __subrange_base<_Iter, _Sent, subrange_kind::sized> {
     static constexpr bool __store_size = true;
     _Iter __begin = _Iter();
     _Sent __end = _Sent();
     make_unsigned_t<iter_difference_t<_Iter>> __size = 0;
 
+    __subrange_base() = default;
     constexpr __subrange_base(_Iter __iter, _Sent __sent, decltype(__size) __size)
       : __begin(_VSTD::move(__iter)), __end(__sent), __size(__size) { }
   };
 
   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>

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 <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/empty.h>
+#include <__ranges/semiregular_box.h>
+#include <__ranges/view.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)
+
+// REVIEW-NOTE: This is *not* part of the transform_view patch and will be added by a *separate* PR.
+template<class _I1, class _I2 = _I1>
+concept indirectly_swappable =
+    indirectly_readable<_I1> &&
+    indirectly_readable<_I2> &&
+    requires(const _I1 i1, const _I2 i2) {
+        ranges::iter_swap(i1, i1);
+        ranges::iter_swap(i1, i2);
+        ranges::iter_swap(i2, i1);
+        ranges::iter_swap(i2, i2);
+    };
+// END-REVIEW-NOTE.
+
+namespace ranges {
+
+template<input_range _View, copy_constructible _Fn>
+  requires view<_View> && is_object_v<_Fn> &&
+           regular_invocable<_Fn&, range_reference_t<_View>> &&
+           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>
+class transform_view : public view_interface<transform_view<_View, _Fn>> {
+  template<bool> class __iterator;
+  template<bool> class __sentinel;
+
+  _View __base = _View();
+  __semiregular_box<_Fn> __func;
+
+public:
+  transform_view() = default;
+  constexpr transform_view(_View __base, _Fn __func)
+    : __base(_VSTD::move(__base)), __func(_VSTD::move(__func)) {}
+
+  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); }
+};
+
+template<class _Range, class _Fn>
+transform_view(_Range&&, _Fn)
+  -> transform_view<decltype(views::all(std::declval<_Range>())), _Fn>;
+
+template<class _View>
+struct __iterator_concept {
+  using type = conditional_t<
+    random_access_range<_View>,
+    random_access_iterator_tag,
+    conditional_t<
+      bidirectional_range<_View>,
+      bidirectional_iterator_tag,
+      conditional_t<
+        forward_range<_View>,
+        forward_iterator_tag,
+        input_iterator_tag
+      >
+    >
+  >;
+};
+
+template<class, class>
+struct __iterator_category_base {};
+
+template<forward_range _View, class _Fn>
+struct __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 view<_View> && is_object_v<_Fn> &&
+           regular_invocable<_Fn&, range_reference_t<_View>> &&
+           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>
+template<bool _Const>
+class transform_view<_View, _Fn>::__iterator
+  : public __iterator_category_base<_View, _Fn> {
+
+  using _Parent = __maybe_const<_Const, transform_view>;
+  using _Base = __maybe_const<_Const, _View>;
+
+  iterator_t<_Base> __current = iterator_t<_Base>();
+  _Parent *__parent = nullptr;
+
+  template<bool>
+  friend class transform_view<_View, _Fn>::__sentinel;
+
+public:
+  using iterator_concept = typename __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() = default;
+
+  constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+    : __current(_VSTD::move(__current)), __parent(_VSTD::addressof(__parent)) {}
+  constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
+    : __current(_VSTD::move(__i.__current)), __parent(__i.__parent) {}
+
+  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 { 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
+    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;
+  }
+//   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)
+    // TODO: this noexcept looks wrong: why do we care about func's noexceptness?
+    noexcept(noexcept(_VSTD::invoke(*__i.__parent->__func, *__i.__current)))
+  {
+    // TODO: this looks wrong: shouldn't this be the oposite.
+    if constexpr (is_lvalue_reference_v<decltype(*__i)>)
+      return _VSTD::move(*__i);
+    else
+      return *__i;
+  }
+
+  friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
+    noexcept(noexcept(ranges::iter_swap(__x.__current, __y.__current)))
+    requires indirectly_swappable<iterator_t<_Base>>
+  {
+    ranges::iter_swap(__x.__current, __y.__current);
+  }
+};
+
+template<input_range _View, copy_constructible _Fn>
+  requires view<_View> && is_object_v<_Fn> &&
+           regular_invocable<_Fn&, range_reference_t<_View>> &&
+           __referenceable<invoke_result_t<_Fn&, range_reference_t<_View>>>
+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) {}
+  constexpr __sentinel(__sentinel<false> __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 forward_range = see below;
 
   template<class T>
   concept bidirectional_range = see below;
 
   template <class _Tp>
     concept common_range = see below;
 }
 
 */
 
 #include <__config>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/empty.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
+#include <__ranges/transform_view.h>
 #include <__ranges/ref_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>
 

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// class std::ranges::transform_view;
+
+#include <ranges>
+
+#include <vector>
+#include <list>
+#include <numeric>
+#include <string>
+#include <iostream>
+#include <cctype>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+int globalBuff[8] = {0,1,2,3,4,5,6,7};
+
+template<class T, class F>
+concept ValidDropView = requires { typename ranges::transform_view<T, F>; };
+
+struct View : std::ranges::view_base {
+  int start;
+  int *ptr;
+  constexpr View(int* ptr = globalBuff, int start = 0) : start(start), ptr(ptr) {}
+  constexpr View(View&&) = default;
+  constexpr View& operator=(View&&) = default;
+  constexpr friend int* begin(View& view) { return view.ptr + view.start; }
+  constexpr friend int* begin(View const& view) { return view.ptr + view.start; }
+  constexpr friend int* end(View& view) { return view.ptr + 8; }
+  constexpr friend int* end(View 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); }
+};
+
+struct ForwardRange {
+  ForwardIter begin() const;
+  ForwardIter end() const;
+  ForwardIter begin();
+  ForwardIter end();
+};
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct RandomAccessView : std::ranges::view_base {
+  RandomAccessIter begin() const;
+  RandomAccessIter end() const;
+  RandomAccessIter begin();
+  RandomAccessIter end();
+};
+
+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 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 SentinelView : std::ranges::view_base {
+  int count;
+  constexpr SentinelView(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 long operator- (const RandomAccessIter &lhs, int* rhs) { return lhs.base() - rhs; }
+constexpr long 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)); }
+};
+
+struct PlusPlus {
+  constexpr int operator()(int x) { return ++x; }
+};
+
+struct PlusPlusConst {
+  constexpr int operator()(int x) const { return ++x; }
+};
+
+struct PlusPlusRef {
+  constexpr int& operator()(int x) { return ++x; }
+};
+
+template<class T>
+concept BeginInvocable = requires(T t) { t.begin(); };
+
+template<class T>
+concept EndInvocable = requires(T t) { t.end(); };
+
+template<class T>
+concept EndIsIter = requires(T t) { ++t.end(); };
+
+template<class T>
+concept SizeInvocable = requires(T t) { t.size(); };
+
+constexpr void testViewMembers() {
+  {
+    // transform_view::base
+    std::ranges::transform_view<View, PlusPlus> transformView1;
+    auto base1 = std::move(transformView1).base();
+    assert(ranges::begin(base1) == globalBuff);
+
+    std::ranges::transform_view<CopyableView, PlusPlus> transformView2;
+    auto base2 = transformView2.base();
+    assert(ranges::begin(base2) == globalBuff);
+    auto base3 = std::move(transformView2).base();
+    assert(ranges::begin(base3) == globalBuff);
+
+    const std::ranges::transform_view<CopyableView, PlusPlus> transformView3;
+    const auto base4 = transformView3.base();
+    assert(ranges::begin(base4) == globalBuff);
+    const auto base5 = std::move(transformView3).base();
+    assert(ranges::begin(base5) == globalBuff);
+  }
+
+  {
+    // transform_view::begin
+    int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    std::ranges::transform_view transformView1(View{buff}, PlusPlus{});
+    assert(transformView1.begin().base() == buff);
+    assert(*transformView1.begin() == 1);
+
+    std::ranges::transform_view transformView2(ForwardView{buff}, PlusPlus{});
+    assert(transformView2.begin().base().base() == buff);
+    assert(*transformView2.begin() == 1);
+
+    std::ranges::transform_view transformView3(InputView{buff}, PlusPlus{});
+    assert(transformView3.begin().base().base() == buff);
+    assert(*transformView3.begin() == 1);
+
+    const std::ranges::transform_view transformView4(View{buff}, PlusPlusConst{});
+    assert(*transformView4.begin() == 1);
+
+    static_assert(!BeginInvocable<const std::ranges::transform_view<View, PlusPlus>>);
+  }
+
+  {
+    // transform_view::end
+    std::ranges::transform_view transformView1(View{}, PlusPlus{});
+    assert(transformView1.end().base() == globalBuff + 8);
+
+    std::ranges::transform_view transformView2(ForwardView{}, PlusPlus{});
+    assert(transformView2.end().base().base() == globalBuff + 8);
+
+    std::ranges::transform_view transformView3(InputView{}, PlusPlus{});
+    assert(transformView3.end().base() == globalBuff + 8);
+
+    const std::ranges::transform_view transformView4(View{}, PlusPlusConst{});
+    assert(transformView4.end().base() == globalBuff + 8);
+
+    static_assert(!EndInvocable<const std::ranges::transform_view<View, PlusPlus>>);
+    static_assert( EndInvocable<      std::ranges::transform_view<View, PlusPlus>>);
+    static_assert( EndInvocable<const std::ranges::transform_view<View, PlusPlusConst>>);
+    static_assert(!EndInvocable<const std::ranges::transform_view<InputView, PlusPlus>>);
+    static_assert( EndInvocable<      std::ranges::transform_view<InputView, PlusPlus>>);
+    static_assert( EndInvocable<const std::ranges::transform_view<InputView, PlusPlusConst>>);
+
+    static_assert(!EndIsIter<const std::ranges::transform_view<InputView, PlusPlusConst>>);
+    static_assert(!EndIsIter<      std::ranges::transform_view<InputView, PlusPlus>>);
+    static_assert( EndIsIter<const std::ranges::transform_view<View, PlusPlusConst>>);
+    static_assert( EndIsIter<      std::ranges::transform_view<View, PlusPlus>>);
+  }
+
+  {
+    // transform_view::size
+    std::ranges::transform_view transformView1(View{}, PlusPlus{});
+    assert(transformView1.size() == 8);
+
+    const std::ranges::transform_view transformView2(View{globalBuff, 4}, PlusPlus{});
+    assert(transformView2.size() == 4);
+
+    static_assert(!SizeInvocable<std::ranges::transform_view<ForwardView, PlusPlus>>);
+
+    static_assert(SizeInvocable<std::ranges::transform_view<SizedSentinelNotConstView, PlusPlus>>);
+    static_assert(!SizeInvocable<const std::ranges::transform_view<SizedSentinelNotConstView, PlusPlus>>);
+  }
+}
+
+template<class V, class F>
+concept HasIterConcept = requires { typename std::ranges::transform_view<V, F>::iterator_category; };
+
+template<class V, class F>
+concept BaseInvocable = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter.base();
+};
+
+constexpr void testIterator() {
+  // Member typedefs.
+  {
+    // 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<View, PlusPlusRef>;
+    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, PlusPlusRef>;
+    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, PlusPlus>;
+    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, PlusPlusRef>;
+    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, PlusPlusRef>;
+    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, PlusPlusRef>;
+    using TIter = std::ranges::iterator_t<TView>;
+    static_assert(std::same_as<typename TIter::iterator_concept, std::input_iterator_tag>);
+    static_assert(!HasIterConcept<InputView, PlusPlusRef>);
+    static_assert(std::same_as<typename TIter::value_type, int>);
+    static_assert(std::same_as<typename TIter::difference_type, std::ptrdiff_t>);
+  }
+
+  // Members
+  {
+    // __iterator::base
+    std::ranges::transform_view<View, PlusPlus> transformView1;
+    auto iter1 = std::move(transformView1).begin();
+    assert(iter1.base() == globalBuff);
+    assert(std::move(iter1).base() == globalBuff);
+
+    std::ranges::transform_view<InputView, PlusPlus> transformView2;
+    auto iter2 = transformView2.begin();
+    assert(std::move(iter2).base() == globalBuff);
+    static_assert(!BaseInvocable<InputView, PlusPlus>);
+  }
+  // Note: __iterator::operator* tested elsewhere.
+  // Note: member operator requirements tested at the end of the file.
+  {
+    // __iterator::operator{++,--,+=,-=}
+    std::ranges::transform_view<View, PlusPlus> transformView1;
+    auto iter1 = std::move(transformView1).begin();
+    assert((++iter1).base() == globalBuff + 1);
+
+    assert((iter1++).base() == globalBuff + 1);
+    assert(iter1.base() == globalBuff + 2);
+
+    assert((--iter1).base() == globalBuff + 1);
+    assert((iter1--).base() == globalBuff + 1);
+    assert(iter1.base() == globalBuff);
+
+    // Check that decltype(InputIter++) == void.
+    ASSERT_SAME_TYPE(decltype(
+      std::declval<std::ranges::iterator_t<std::ranges::transform_view<InputView, PlusPlus>>>()++),
+      void);
+
+    assert((iter1 += 4).base() == globalBuff + 4);
+    assert((iter1 -= 3).base() == globalBuff + 1);
+  }
+  {
+    // __iterator::operator[]
+    int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    std::ranges::transform_view transformView1(View{buff}, PlusPlus{});
+    auto iter1 = std::move(transformView1).begin() + 1;
+    assert(iter1[0] == 2);
+    assert(iter1[4] == 6);
+  }
+  {
+    // __iterator::operator{<,>,<=,>=}
+    std::ranges::transform_view<View, PlusPlus> transformView1;
+    auto iter1 = std::move(transformView1).begin();
+    std::ranges::transform_view<View, PlusPlus> 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: operator<=> when three_way_comparable is implemented.
+  }
+  {
+    // __iterator::operator{+,-}
+    std::ranges::transform_view<View, PlusPlus> transformView1;
+    auto iter1 = std::move(transformView1).begin();
+    std::ranges::transform_view<View, PlusPlus> 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);
+  }
+  // TODO: I'm not going to test iter_move until the TODOs in transform_view.h are addressed.
+  {
+    // __iterator::iter_swap
+    int buff[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    std::ranges::transform_view transformView1(View{buff}, PlusPlus{});
+    auto iter1 = std::move(transformView1).begin();
+    std::ranges::transform_view transformView2(View{buff}, PlusPlus{});
+    auto iter2 = std::move(transformView2).begin();
+    iter1 += 4;
+    std::ranges::iter_swap(iter1, iter2);
+    assert(*iter1 == 1);
+    assert(*(buff + 4) == 0);
+    assert(*iter2 == 5);
+    assert(*buff == 4);
+    assert(*transformView1.begin() == 5);
+  }
+}
+
+constexpr void testSentinel() {
+  std::ranges::transform_view<SentinelView, PlusPlusConst> transformView1;
+  // Going to const and back.
+  auto sent1 = transformView1.end();
+  std::ranges::sentinel_t<const std::ranges::transform_view<SentinelView, PlusPlusConst>> sent2{sent1};
+  std::ranges::sentinel_t<const std::ranges::transform_view<SentinelView, PlusPlusConst>> sent3{sent2};
+  (void)sent3;
+
+  std::ranges::transform_view transformView2(SentinelView{4}, PlusPlusConst());
+  auto sent4 = transformView2.end();
+
+  static_assert(!EndIsIter<decltype(sent1)>);
+  static_assert(!EndIsIter<decltype(sent2)>);
+  assert(sent1.base() == globalBuff + 8);
+
+  auto iter1 = transformView1.begin();
+  assert(iter1 != sent1);
+  assert(iter1 != sent2);
+  assert(iter1 != sent4);
+  assert(iter1 + 8 == sent1);
+  assert(iter1 + 8 == sent2);
+  assert(iter1 + 4 == sent4);
+
+  assert(sent1 - iter1 == 8);
+  assert(sent4 - iter1 == 4);
+  assert(iter1 - sent1 == -8);
+  assert(iter1 - sent4 == -4);
+}
+
+// CTAD
+static_assert(std::same_as<decltype(std::ranges::transform_view(InputView(), PlusPlus())),
+                           std::ranges::transform_view<InputView, PlusPlus>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(std::declval<ForwardRange&>(), PlusPlus())),
+                           std::ranges::transform_view<std::ranges::ref_view<ForwardRange>, PlusPlus>>);
+static_assert(std::same_as<decltype(std::ranges::transform_view(BorrowableRange(), PlusPlus())),
+                           std::ranges::transform_view<std::ranges::subrange<int*>, PlusPlus>>);
+
+constexpr bool test() {
+  testViewMembers();
+  testIterator();
+  testSentinel();
+
+  return true;
+}
+
+template<std::ranges::range R>
+auto toUpper(R range) {
+  return std::ranges::transform_view(range, [](char c) { return std::toupper(c); });
+}
+
+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, std::rand()));
+}
+
+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]);
+  });
+}
+
+template<>
+constexpr bool ranges::enable_view<std::vector<int>> = true;
+
+template<>
+constexpr bool ranges::enable_view<std::string_view> = true;
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  {
+    std::vector vec = {1,2,3,4};
+    auto sortOfRandom = withRandom(vec);
+    std::vector check = {16808, 16809, 16810, 16811};
+    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;
+}
+
+// The requirements for __iterator:
+template<class V, class F>
+concept IterMinusMinus = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter--;
+};
+static_assert(IterMinusMinus<BidirectionalView, PlusPlusConst>);
+static_assert(!IterMinusMinus<ForwardView, PlusPlusConst>);
+
+template<class V, class F>
+concept MinusMinusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  --iter;
+};
+static_assert(MinusMinusIter<BidirectionalView, PlusPlusConst>);
+static_assert(!MinusMinusIter<ForwardView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterPlusEquals = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter += 1;
+};
+static_assert(IterPlusEquals<RandomAccessView, PlusPlusConst>);
+static_assert(!IterPlusEquals<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterMinusEquals = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter -= 1;
+};
+static_assert(IterMinusEquals<RandomAccessView, PlusPlusConst>);
+static_assert(!IterMinusEquals<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterSubscript = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter[0];
+};
+static_assert(IterSubscript<RandomAccessView, PlusPlusConst>);
+static_assert(!IterSubscript<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterLess = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter < iter;
+};
+static_assert(IterLess<RandomAccessView, PlusPlusConst>);
+static_assert(!IterLess<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterGreater = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter > iter;
+};
+static_assert(IterGreater<RandomAccessView, PlusPlusConst>);
+static_assert(!IterGreater<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterLessEq = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter <= iter;
+};
+static_assert(IterLessEq<RandomAccessView, PlusPlusConst>);
+static_assert(!IterLessEq<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterGreaterEq = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter >= iter;
+};
+static_assert(IterGreaterEq<RandomAccessView, PlusPlusConst>);
+static_assert(!IterGreaterEq<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterPlusN = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter + 1;
+};
+static_assert(IterPlusN<RandomAccessView, PlusPlusConst>);
+static_assert(!IterPlusN<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept NPlusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  std::declval<typename decltype(iter)::difference_type>() + iter;
+};
+static_assert(NPlusIter<RandomAccessView, PlusPlusConst>);
+static_assert(!NPlusIter<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterMinusN = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter - 1;
+};
+static_assert(IterMinusN<RandomAccessView, PlusPlusConst>);
+static_assert(!IterMinusN<BidirectionalView, PlusPlusConst>);
+
+template<class V, class F>
+concept IterMinusIter = requires(std::ranges::iterator_t<std::ranges::transform_view<V, F>> iter) {
+  iter - iter;
+};
+static_assert(IterMinusIter<RandomAccessView, PlusPlusConst>);
+static_assert(!IterMinusIter<BidirectionalView, PlusPlusConst>);