[libcxx][ranges] Add range.subrange.

[zoecarver]

Summary

Basically the title.

[cjdb]

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

I wanna poach this for D101922. WDYT?

[Mordante]

For now I only wanted to comment on the unsigned conversion. ATM I don't have time for a proper review.

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

I would like _LIBCPP_INLINE_VISIBILITY and I dislike the _like suffix. Of course if we remove the _like it duplicates __to_unsigned defined in <charconv>. I start to feel it makes sense to make a header to do some of these signed to unsigned conversions. (I also use them for <format> but there I already require <charconv>. WDYT? (Note <charconv> is available in C++11 as an extension.)
I wouldn't mind to put up a review to make this change.

[cjdb]

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

This is already in main. I'm not sure why it's showing up in the diff.

[Mordante]

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

I see thanks. Any objection to renaming it to __to_unsigned? Since <charconv> already depends on <type_traits> I'll make a patch to let <charconv> reuse this function.

[zoecarver]

Rebase.

[zoecarver]

This is ready for review now.

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

I see thanks. Any objection to renaming it to __to_unsigned? Since <charconv> already depends on <type_traits> I'll make a patch to let <charconv> reuse this function.

That would be great, thanks @Mordante.

[zoecarver]

Fix tests/rebase fallout.

[zoecarver]

Make default ctorable and add a test.

[Mordante]

Please validate the visibility for all types
template classes -> _LIBCPP_TEMPLATE_VIS
enums -> _LIBCPP_ENUM_VIS
inline function -> _LIBCPP_INLINE_VISIBILITY
For now I only looked at the subrange header. Will look at the test at another time.

libcxx/include/__ranges/subrange.h

41

Please __uglify t.
Minor nit, since you use _Range instead of _Tp, how do you feel about using __r instead of __t?

51

The Standard uses not-same-as instead of !same_as.

template<class T, class U>
  concept not-same-as =                         // exposition only
    !same_­as<remove_cvref_t<T>, remove_cvref_t<U>>;

Is there a reason to deviate?

64

Just curious, why these names instead of _Tp, _Up, and _Vp?

71

Why not using a bool as underlying type? The Standard uses enum class subrange_kind : bool { unsized, sized }; .

120

Another case of !same_as vs not-same-as. When using __not_same_as this concept can be used instead of class like in the Standard.
Also look at the other !same_as in this class.

160

Please use NODISCARD_EXT.

162

Can you rename this to __make_unsigned_t?

195

Interesting, hopefully __n will never be std::numeric_limits<iter_difference_t<_Iter>>::min()

libcxx/include/type_traits

2311–2314 ↗

(On Diff #343449)

I've put up D102332.

[zoecarver]

inline function -> _LIBCPP_INLINE_VISIBILITY

I thought this was only for internal functions, because public functions have stable pre/post conditions, is that not correct?

libcxx/include/__ranges/subrange.h

41

Good idea about using __r. I should have documented this more clearly, but I'm going to "properly" add these concepts in a future patch. I just didn't realize they were a prerequisite until too late here, so I just copied them in.

64

I think it's a bit clearer, then you don't have to map T to the caller and try to figure out which argument it is, you can just say, "oh that's supposed to be pair-like."

162

I think this comment got moved. What do you mean?

[zoecarver]

Apply Mark's comments.

[Mordante]

In D102006#2755761, @zoecarver wrote:

inline function -> _LIBCPP_INLINE_VISIBILITY

I thought this was only for internal functions, because public functions have stable pre/post conditions, is that not correct?

AFAIK it's done for all inline functions. (I wouldn't be surprised if there are more functions not having the marker.) If you, for example, look at the <bit> header all functions have this marker. Both the public and internal functions.

Of course it would be nice to have a CI job to catch the issues ;-)

libcxx/include/__ranges/concepts.h

72 ↗

(On Diff #344990)

Why not in the namespace?

libcxx/include/__ranges/subrange.h

64

Thanks for the information.

162

I had another look and this time a make-unsigned-like-t doesn't mean exposition only type but make_unsigned_t depending on conditions. So it seems your code is correct.

[zoecarver]

AFAIK it's done for all inline functions. (I wouldn't be surprised if there are more functions not having the marker.) If you, for example, look at the <bit> header all functions have this marker. Both the public and internal functions.

_LIBCPP_INLINE_VISIBILITY is synonymous for _LIBCPP_HIDE_FROM_ABI, right? (Side-note: are we trying to move to using the latter?) Anyway, I think it's just used to inline things so they're hidden from the ABI (i.e., the function goes away so there's nothing to get baked into the ABI). However, we don't want or need public functions to be hidden from the ABI. In fact, we probably don't want them to be hidden from the ABI, so that we can still have the benefits of ABI stability, and reduced code-size.

libcxx/include/__ranges/concepts.h

72 ↗

(On Diff #344990)

I figured this is a more general utility. Not just for ranges.

But this makes me think: it would probably be better to move this to <concepts>, actually.

[cjdb]

I'll review the tests later today, but I anticipate some of my feedback might shape the existing tests.
I'd also appreciate if we can split this test set into multiple files, similar to how test/std/containers/sequences/vector/ is broken down.

libcxx/include/__ranges/concepts.h

72 ↗

(On Diff #344990)

Yes, please move to <concepts>.

libcxx/include/__ranges/subrange.h

49–52

Checking that the comment isn't the opposite of what the code wants is a bit convoluted. I suggest making a named concept out of this bit to improve readability.

57

I think the standard-provided comment is useful in improving readability.

116–120

I believe you also need an overload for when __store_size == false.

135

You'll probably need to guard on !__store_size && sized_range<R>, since it's possible for both to be true, thus creating an ambiguity. Please add a test for this very case.

142

If we already have a make_unsigned_like_t, please use that. Otherwise, carry on.

144

Standard uses braces for this one.

147

Should be __not_same_as.

155

Regardless of how the _LIBCPP_NODISCARD_EXT discussion plays out, this one should be [[nodiscard]].

172

Regardless of how the _LIBCPP_NODISCARD_EXT discussion plays out, this one should be [[nodiscard]].

179

Regardless of how the _LIBCPP_NODISCARD_EXT discussion plays out, this one should be [[nodiscard]].

184

Regardless of how the _LIBCPP_NODISCARD_EXT discussion plays out, this one should be [[nodiscard]].

[tcanens]

libcxx/include/__ranges/subrange.h

144

Standard uses braces for this one.

For ranges wording, wherever braces have behavior different from parens, the use of braces is almost certainly a defect. P2367R0 is expected to fix all such occurrences. https://github.com/cplusplus/draft/issues/4593 deals with the rest.

147

Who came up with the idea to have a exposition-only concept named not-same-as that's not not same_as?

[zoecarver]

libcxx/include/__ranges/subrange.h

116–120

Other than the one on L112?

135

Hmm, I think you're right. So that would be the case where !sized_sentinel_for but it had a size member or something?

142

I don't see one.

144

Is there an observable difference/do we care? If there's no difference I try to use parens, because that shows there's no difference (if I use braces, a reader might ask "is there a reason we have to use braces here?").

[zoecarver]

libcxx/include/__ranges/subrange.h

147

This is the most annoying thing...

[zoecarver]

libcxx/include/__ranges/subrange.h

135

For posterity: this is actually the opposite of what we need to guard on, we need to guard on __store_size && sized_range<R>.

Because for this overload:

constexpr subrange(R&& r) requires (!StoreSize || sized_­range<R>);

We do

• subrange(r, size) when StoreSize
• subrange(begin, end) when !StoreSize

However, it was just easier to write it as two overloads where we do

• subrange(begin, end) when !StoreSize
• subrange(r, size) when sized_range

The problem is that didn't catch the case (as I said above) where both sized_range and !StoreSize are true, in which case it would be ambiguous. I fixed it and added DifferentSentienlWithSizeMember as a regression test.

[zoecarver]

Address review comments.

[Mordante]

I think we're getting close. There still seem to be some open review comments and some comments marked as done, which aren't done. I added comment to them, be please verify whether I didn't overlook any. I still wonder about the visibility macros, but let's discuss that on Discord.

libcxx/include/__ranges/subrange.h

41

Can you address this issue?

147

I agree, I also dislike this idea. Can you use the __not_as_as?

184

Agreed, these 3 require [[nodiscard]] according to the Standard. (No idea why this empty() doesn't need it.)

libcxx/test/std/ranges/range.utility/range.subrange/access.pass.cpp

13

Is this msvc work-around still required. IIRC it was due to some __ugly_macro_conflicts.
Likewise for the other newly added unit tests.

libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp

27

Please add some linebreaks to keep this readable. Same for the other places with these overly long lines. IIRC our current maximum column width is 120.

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp

31

Nice comment!

[zoecarver]

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp

31

Thanks :)

[zoecarver]

• Rebase.
• Address all comments.

[Mordante]

LGTM, except for the [[nodiscard]] on empty(). Please make sure the build passes CI before committing.

libcxx/include/__ranges/subrange.h

160

This one shouldn't be [[nodiscard]] according to the Standard.

[zoecarver]

Sorry for the slow reply. Thanks @Mordante.

@cjdb how's this look now?

libcxx/include/__ranges/subrange.h

160

I think we decided that members named "empty" are sufficiently vexing because users something think it will empty the container (or in this case sub range).

[zoecarver]

Rebase.

Note: I'm going to land this when the tests pass.

[Mordante]

libcxx/include/__ranges/subrange.h

160

Oke wasn't aware we decided that. But I agree calling size() and discarding the result is most likely a bug.

[ldionne]

General note for the tests - can we split tests so that we test one overload (as documented in the Standard) per file? This is what we do elsewhere and it makes it easier to make sure we're testing everything correctly. If a function is only a very tiny derivative of another one, then it's OK to test both in one shot, of course.

libcxx/include/__ranges/subrange.h

47

This is *so* weird - I would have expected something like tuple_size<_Tp>::value == 2 instead. But leave as-is, that's how the Standard does it.

65

For a static like that, I'd use _StoreSize instead.

Re: using _Iter instead of _Tp, I strongly agree -- using _Iter is a lot clearer than what the Standard uses.

66

__begin_? (same for other member variables)

75

Here, we're going to store the size if _Kind == subrange_kind::sized even if _Sent is a sized sentinel for _Iter. We should not be storing it when _Sent is a sized sentinel.

98–100

Instead, you could use this->member when referring to a member in the dependent base, and _Base::__store_size when referring to the static. IMO that's easier to follow and more idiomatic, WDYT?

143

I'm surprised they didn't make this _Iter begin() && instead to make sure we can only call this on a xvalue.

149

See, I'm very curious to understand why the Standard didn't mark this one as [[nodiscard]]. It can't be an oversight, since they marked a bunch of methods around it [[nodiscard]]. Just curious to understand what the motivation was.

libcxx/test/std/ranges/range.utility/range.subrange/access.pass.cpp

89

testPrimitives?

libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp

22

namespace ranges = std::ranges or something like that, but we frown upon importing names.

[zoecarver]

libcxx/include/__ranges/subrange.h

65

The style I try to use is that variables are always __snake_case or camelCase (regardless of staticness) and the former at least seems to be the existing style. This way, _TitleCase or TitleCase is reserved for types (also matches current style and is my personal preference).

66

In recent commits, at least, I tend not to suffix with an underscore. Historically in libc++ we seem to do both. If you feel strongly, let's add some docs/style guid and I'll fix it.

81

Nit: no constexpr.

98–100

This is all personal preference, but the way I see it, there's no confusion as to what __begin is referring to and it's unconditionally a member. If someone went looking for the definition, they'd find this which would lead them to it.

In fact, there might be an argument that saying this->member adds confusion, because someone might say "why do we need to use this->" or try to remove that.

For me it really comes down to simplicity/brevity. Writing __begin is simply fewer characters.

143

This is odd and does not seem to be inline with most views.

[• Quuxplusone]

libcxx/include/__ranges/subrange.h

50–51

Check whether these should be ADL or std::get, and then (if the ADL is intentional) let's please figure out a way to document that in the code long-term.
I'm almost amenable to making a macro like #define _LIBCPP_ADL(x) x just to tag intentional ADLs. That'd be a bigger change than this PR, obviously. For this PR, if the ADL is intentional, I think it'd suffice to just leave a comment // intentional ADL.

66

FWIW, I feel strongly: libc++ should follow libc++ style, which is "data members get underscore-suffixed."

98–100

FWIW, I agree with @ldionne: using-declarations (and their effect on name lookup) are significantly more confusing for the reader/maintainer than the plain old this->__member_ expression syntax we're all familiar with.

143

Tangential, but yeah: it wouldn't make sense to require the caller to write std::move(myRange).begin(), because then how would you ever get at the end-sentinel? You couldn't write again std::move(myRange).end(), because that would trigger all your static-analyzer's "double-moved-from" checks.

184

this->__size_ += _VSTD::__to_unsigned_like(-__n);
(The ADL-proofing of __to_unsigned_like actually doesn't matter because the lookup of operator- will be ADL anyway; but let's be consistent in our "ADL-proof by default" style.)
Ditto line 190 below.

Orthogonally: Is the whole point of __store_size_ just to keep track of whether __size_ exists? Could we just do

if constexpr (requires { this->__size_; })
    this->__size_ += ...;

instead, throughout? Or would that not-work for some technical reason?

209–210

Formatting nit: the -> belongs on the second line. Lines 199-200 above do it right AFAIC.

libcxx/test/std/ranges/range.utility/range.subrange/access.pass.cpp

59

Definitely just write out std::ptrdiff_t in the like two places it appears.

74

Formatting nit: friend constexpr

libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp

22

(moving my comment from the previous file after seeing Louis's)
Looking through this test file, I don't think skipping the std:: on lines 89–163 is really buying you anything. Strongly consider just writing out std::ranges::whatever everywhere it needs to be. (The benefit is greppability.)

27

One way to clean this up is to introduce an array of int a and a typedef FI:

int a[10];
using FI = forward_iterator<int*>;
static_assert(std::same_as<decltype(subrange(FI(a), FI(a))),
    subrange<FI, FI, std::ranges::subrange_kind::unsized>>);
static_assert(std::same_as<decltype(subrange(FI(a), FI(a), 0)),
    subrange<FI, FI, std::ranges::subrange_kind::sized>>);
static_assert(std::same_as<decltype(subrange(a, a)),
    subrange<int*, int*, std::ranges::subrange_kind::unsized>>);
static_assert(std::same_as<decltype(subrange(a, a, 0)),
    subrange<int*, int*, std::ranges::subrange_kind::sized>>);
static_assert(std::same_as<decltype(subrange(a, nullptr)),
    subrange<int*, std::nullptr_t, std::ranges::subrange_kind::unsized>>);
static_assert(std::same_as<decltype(subrange(a, nullptr, 0)),
    subrange<int*, std::nullptr_t, std::ranges::subrange_kind::sized>>);

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp

49

base_

84

value_ (but actually, I think you should just call this base_ — see? the underscore has a purpose! :))

128–129

I think there is not. (Also you wrote unsized for unsigned)

165

s/enl/nel/g
Also s/Foward/Forward/g below, and probably some others; do a typo-checking pass on this file.

libcxx/test/std/ranges/range.utility/range.subrange/general.compile.pass.cpp

24

Formatting nit: class... Args with a space.
(Also, as above, please don't namespace ranges =; you never even use it in this test file!)

[ldionne]

libcxx/include/__ranges/subrange.h

65

Ack.

66

@zoecarver If you haven't been using underscores lately, then it's simply an oversight in the code review. libc++ has been using trailing underscores for members forever, this isn't something new. We could definitely benefit from documenting the coding style we want, however fixing the issue in this review shouldn't be gated on that.

98–100

Arthur's comment is specifically why I requested that change.

[zoecarver]

libcxx/include/__ranges/subrange.h

49–52

I think it's important to make sure this is the same as the standard naming. Luckily the standard changed this for us.

50–51

I've been informed that these are not ADL. Fixed.

66

OK I'll update these. Also, I'll add to my list of things I probably won't ever find time for: configure the clang tidy rule for this.

116–120

@cjdb Ping.

149

I'm just guessing here, but maybe LWG didn't think that empty was sufficiently vexing. As I've already discussed, it makes sense to mark next/prev nodiscard because there are multiple APIs that do different things there, and begin needs to be nodiscard because it's moving the iterator. Empty doesn't have anything "special" (and reason to mark it nodiscard) other than a confusing name.

184

Any reason for this-> over _Base::?

Or would that not-work for some technical reason?

Pretty sure there's a clang bug that doesn't allow us to use inline-requires like this.

libcxx/test/std/ranges/range.utility/range.subrange/ctad.compile.pass.cpp

27

Did something similar, it's a bit better now.

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp

128–129

Removed. Thanks.

[zoecarver]

libcxx/test/std/ranges/range.utility/range.subrange/ctor.pass.cpp

165

I'm bad at spotting these, so if you see others let me know and I'll fix them.

[zoecarver]

Apply review comments.

[ldionne]

LGTM with my comments.

libcxx/include/__ranges/subrange.h

164

Can we add tests that check that those methods are [[nodiscard]], since those are mandated by the standard?

184

Any reason for this-> over _Base::?

Nope, either way's fine as far as I'm concerned.

[ldionne]

(I'd like @cjdb to take a final look at this and give the green light if he's fine with it, since he had a previous requires-changes)

[• Quuxplusone]

libcxx/include/__ranges/subrange.h

184

I strongly prefer this->__size_. Don't use weird syntax unless there's a technical reason for it.

[cjdb]

Thanks for working hard on this!

libcxx/include/__ranges/subrange.h

98–100

I'm with Zoe on this one. We have an underscore-suffix-for-members convention, so it should be clear that __member_ is shorthand for this->__member_, and _Base::__member_ is for the base's member. Whether or not it's an instance member or a static member feels largely irrelevant to me?

116–120

Ah, yes, I missed that, sorry.

144

Yes. Tim's GH link has all the relevant info.

[cjdb]

Please update according to the recent changes made by P2325.

[zoecarver]

Apply review comments.

Will land when bots are green.

[zoecarver]

The above update:

• Split tests into multiple files.
• Rebased onto D102468 and applied changes from Barry's paper.

[zoecarver]

Rebase.

libcxx/include/CMakeLists.txt

set(files
   __nullptr
   __ranges/access.h
   __ranges/concepts.h
   __ranges/data.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/view.h
   __ranges/size.h
+  __ranges/subrange.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __threading_support
   __tree
   __tuple
   __undef_macros

libcxx/include/__ranges/subrange.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_SUBRANGE_H
+#define _LIBCPP___RANGES_SUBRANGE_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/primitives.h>
+#include <__ranges/access.h>
+#include <__ranges/enable_borrowed_range.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)
+
+// clang-format off
+namespace ranges {
+  template<class _From, class _To>
+  concept __convertible_to_non_slicing =
+    convertible_to<_From, _To> &&
+    // If they're both pointers, they must have the same element type.
+    !(is_pointer_v<decay_t<_From>> &&
+      is_pointer_v<decay_t<_To>> &&
+      __not_same_as<remove_pointer_t<decay_t<_From>>, remove_pointer_t<decay_t<_To>>>);
+
+  template<class _Tp>
+  concept __pair_like =
+    !is_reference_v<_Tp> && requires(_Tp __t) {
+      typename tuple_size<_Tp>::type; // Ensures `tuple_size<T>` is complete.
+      requires derived_from<tuple_size<_Tp>, integral_constant<size_t, 2>>;
+      typename tuple_element_t<0, remove_const_t<_Tp>>;
+      typename tuple_element_t<1, remove_const_t<_Tp>>;
+      { get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Tp>&>;
+      { get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Tp>&>;
+    };
+
+  template<class _Pair, class _Iter, class _Sent>
+  concept __pair_like_convertible_from =
+    !range<_Pair> && __pair_like<_Pair> &&
+    constructible_from<_Pair, _Iter, _Sent> &&
+    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
+    convertible_to<_Sent, tuple_element_t<1, _Pair>>;
+
+  enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
+
+  template<class _Iter, class _Sent, subrange_kind _Kind>
+  struct __subrange_base {
+    static constexpr bool __store_size = false;
+    _Iter __begin = _Iter();
+    _Sent __end = _Sent();
+
+    constexpr __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;
+
+    constexpr __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>
+    requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+  struct _LIBCPP_TEMPLATE_VIS subrange
+    : public view_interface<subrange<_Iter, _Sent, _Kind>>,
+      private __subrange_base<_Iter, _Sent, _Kind> {
+
+    constexpr subrange() = default;
+
+    using _Base = __subrange_base<_Iter, _Sent, _Kind>;
+    using _Base::__store_size;
+    using _Base::__begin;
+    using _Base::__end;
+
+    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
+      requires (!__store_size)
+      : _Base(_VSTD::move(__iter), __sent) {}
+
+    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
+                       make_unsigned_t<iter_difference_t<_Iter>> __n)
+      requires (_Kind == subrange_kind::sized)
+      : _Base(_VSTD::move(__iter), __sent, __n) { }
+
+    template<__not_same_as<subrange> _Range>
+      requires borrowed_range<_Range> &&
+               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+               convertible_to<sentinel_t<_Range>, _Sent>
+    constexpr subrange(_Range&& __range)
+      requires (!__store_size)
+      : subrange(ranges::begin(__range), ranges::end(__range)) { }
+
+    template<__not_same_as<subrange> _Range>
+      requires borrowed_range<_Range> &&
+               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+               convertible_to<sentinel_t<_Range>, _Sent>
+    constexpr subrange(_Range&& __range)
+      requires __store_size && sized_range<_Range>
+      : subrange(__range, ranges::size(__range)) { }
+
+
+    template<borrowed_range _Range>
+      requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+               convertible_to<sentinel_t<_Range>, _Sent>
+    constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
+      requires (_Kind == subrange_kind::sized)
+      : subrange(ranges::begin(__range), ranges::end(__range), __n) { }
+
+    template<__not_same_as<subrange> _Pair>
+      requires __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
+    constexpr operator _Pair() const { return _Pair(__begin, __end); }
+
+    constexpr _Iter begin() const requires copyable<_Iter> {
+      return __begin;
+    }
+
+    [[nodiscard]] constexpr _Iter begin() requires (!copyable<_Iter>) {
+      return _VSTD::move(__begin);
+    }
+
+    constexpr _Sent end() const { return __end; }
+
+    [[nodiscard]] constexpr bool empty() const { return __begin == __end; }
+
+    constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
+      requires (_Kind == subrange_kind::sized)
+    {
+      if constexpr (__store_size)
+        return _Base::__size;
+      else
+        return __to_unsigned_like(__end - __begin);
+    }
+
+    [[nodiscard]] constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+      requires forward_iterator<_Iter> {
+      auto __tmp = *this;
+      __tmp.advance(__n);
+      return __tmp;
+    }
+
+    [[nodiscard]] constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+      advance(__n);
+      return _VSTD::move(*this);
+    }
+
+    [[nodiscard]] constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+      requires bidirectional_iterator<_Iter> {
+      auto __tmp = *this;
+      __tmp.advance(-__n);
+      return __tmp;
+    }
+
+    constexpr subrange& advance(iter_difference_t<_Iter> __n) {
+      if constexpr (bidirectional_iterator<_Iter>) {
+        if (__n < 0) {
+          ranges::advance(__begin, __n);
+          if constexpr (__store_size)
+            _Base::__size += __to_unsigned_like(-__n);
+          return *this;
+        }
+      }
+
+      auto __d = __n - ranges::advance(__begin, __n, __end);
+      if constexpr (__store_size)
+        _Base::__size -= __to_unsigned_like(__d);
+      return *this;
+    }
+  };
+
+  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+  subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
+
+  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+  subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>)
+    -> subrange<_Iter, _Sent, subrange_kind::sized>;
+
+  template<borrowed_range _Range>
+  subrange(_Range&&) -> subrange<iterator_t<_Range>, sentinel_t<_Range>,
+                                 (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
+                                   ? subrange_kind::sized : subrange_kind::unsized>;
+
+  template<borrowed_range _Range>
+  subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>) ->
+    subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
+
+  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+    requires (_Index < 2)
+  constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
+    if constexpr (_Index == 0)
+      return __subrange.begin();
+    else
+      return __subrange.end();
+  }
+
+  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+    requires (_Index < 2)
+  constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
+    if constexpr (_Index == 0)
+      return __subrange.begin();
+    else
+      return __subrange.end();
+  }
+} // namespace ranges
+
+using ranges::get;
+
+// clang-format off
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_SUBRANGE_H

libcxx/include/concepts

 // [concept.equiv]
 template<class _Rp, class _Tp, class _Up>
 concept equivalence_relation = relation<_Rp, _Tp, _Up>;
 
 // [concept.strictweakorder]
 template<class _Rp, class _Tp, class _Up>
 concept strict_weak_order = relation<_Rp, _Tp, _Up>;
 
+template<class _Tp, class _Up>
+concept __not_same_as = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CONCEPTS

libcxx/include/ranges

 #include <__config>
 #include <__ranges/access.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/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/test/std/ranges/range.utility/range.subrange/access.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::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+// Note: begin and end tested in range.subrange.ctor.pass.cpp.
+
+int globalBuff[8];
+
+struct MoveOnlyForwardIter {
+    typedef std::forward_iterator_tag       iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef MoveOnlyForwardIter             self;
+
+    int *base = nullptr;
+
+    MoveOnlyForwardIter() = default;
+    MoveOnlyForwardIter(MoveOnlyForwardIter &&) = default;
+    MoveOnlyForwardIter &operator=(MoveOnlyForwardIter&&) = default;
+    MoveOnlyForwardIter(MoveOnlyForwardIter const&) = delete;
+    constexpr MoveOnlyForwardIter(int *ptr) : base(ptr) { }
+
+    friend bool operator==(const self&, const self&);
+    constexpr friend bool operator==(const self& lhs, int* rhs) { return lhs.base == rhs; }
+
+    reference operator*() const;
+    pointer operator->() const;
+    self& operator++();
+    self operator++(int);
+    self& operator--();
+    self operator--(int);
+
+    constexpr operator pointer() const { return base; }
+};
+
+using ForwardIter = forward_iterator<int*>;
+
+using std::ptrdiff_t;
+struct SizedSentinelForwardIter {
+    typedef std::forward_iterator_tag       iterator_category;
+    typedef int                             value_type;
+    typedef ptrdiff_t                       difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef std::make_unsigned_t<ptrdiff_t> udifference_type;
+    typedef SizedSentinelForwardIter        self;
+
+    int *base;
+
+    SizedSentinelForwardIter() = default;
+    constexpr SizedSentinelForwardIter(int *ptr) : base(ptr) { }
+
+    constexpr friend bool operator==(const self& lhs, const self& rhs) { return lhs.base == rhs.base; }
+
+    reference operator*() const;
+    pointer operator->() const;
+    self& operator++();
+    self operator++(int);
+    self& operator--();
+    self operator--(int);
+
+    constexpr friend difference_type operator-(SizedSentinelForwardIter const&a,
+                                               SizedSentinelForwardIter const&b) {
+      return a.base - b.base;
+    }
+};
+
+constexpr bool testPrimatives() {
+  ranges::subrange<MoveOnlyForwardIter, int*> a(MoveOnlyForwardIter(globalBuff), globalBuff + 8, 8);
+  assert(a.begin().base == globalBuff);
+  assert(!a.empty());
+  assert(a.size() == 8);
+
+  ranges::subrange<ForwardIter> b(ForwardIter(nullptr), ForwardIter(nullptr));
+  assert(b.empty());
+
+  ranges::subrange<ForwardIter> c{ForwardIter(globalBuff), ForwardIter(globalBuff)};
+  assert(c.empty());
+
+  ranges::subrange<ForwardIter> d(ForwardIter(globalBuff), ForwardIter(globalBuff + 1));
+  assert(!d.empty());
+
+  ranges::subrange<SizedSentinelForwardIter> e(SizedSentinelForwardIter(globalBuff),
+                                               SizedSentinelForwardIter(globalBuff + 8), 8);
+  assert(!e.empty());
+  assert(e.size() == 8);
+
+  return true;
+}
+
+using InputIter = cpp17_input_iterator<int*>;
+
+using BidirIter = bidirectional_iterator<int*>;
+
+constexpr bool testAdvance() {
+  ranges::subrange<int*> a(globalBuff, globalBuff + 8, 8);
+  auto a1 = a.next();
+  assert(a1.begin() == globalBuff + 1);
+  assert(a1.size() == 7);
+  auto a5 = a.next(5);
+  assert(a5.begin() == globalBuff + 5);
+  assert(a5.size() == 3);
+  auto a4 = a5.prev();
+  assert(a4.begin() == globalBuff + 4);
+  assert(a4.size() == 4);
+
+  ranges::subrange<InputIter> b(InputIter(globalBuff), InputIter(globalBuff + 8));
+  auto b1 = std::move(b).next();
+  assert(b1.begin().base() == globalBuff + 1);
+
+  ranges::subrange<BidirIter> c(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
+  auto c1 = c.prev();
+  assert(c1.begin().base() == globalBuff + 3);
+  auto c2 = c.prev(4);
+  assert(c2.begin().base() == globalBuff);
+
+  ranges::subrange<BidirIter> d(BidirIter(globalBuff + 4), BidirIter(globalBuff + 8));
+  auto d1 = d.advance(4);
+  assert(d1.begin().base() == globalBuff + 8);
+  assert(d1.empty());
+  auto d2 = d1.advance(-4);
+  assert(d2.begin().base() == globalBuff + 4);
+
+  return true;
+}
+
+template<size_t I, class S>
+concept GetInvocable = requires {
+  std::get<I>(std::declval<S>());
+};
+
+static_assert( GetInvocable<0, ranges::subrange<int*>>);
+static_assert( GetInvocable<1, ranges::subrange<int*>>);
+static_assert(!GetInvocable<2, ranges::subrange<int*>>);
+static_assert(!GetInvocable<3, ranges::subrange<int*>>);
+
+constexpr bool testGet() {
+  ranges::subrange<int*> a(globalBuff, globalBuff + 8, 8);
+  assert(std::get<0>(a) == a.begin());
+  assert(std::get<1>(a) == a.end());
+
+  assert(a.begin() == std::get<0>(std::move(a)));
+  ranges::subrange<int*> b(globalBuff, globalBuff + 8, 8);
+  assert(b.end() == std::get<1>(std::move(b)));
+
+  return true;
+}
+
+int main(int, char**) {
+  testPrimatives();
+  static_assert(testPrimatives());
+
+  testAdvance();
+  static_assert(testAdvance());
+
+  testGet();
+  static_assert(testGet());
+
+  return 0;
+}

libcxx/test/std/ranges/range.utility/range.subrange/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
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+using std::ranges::subrange;
+
+static_assert(std::same_as<decltype(subrange(forward_iterator<int*>(nullptr), forward_iterator<int*>(nullptr))),
+                           subrange<forward_iterator<int*>, forward_iterator<int*>, std::ranges::subrange_kind::unsized>>);
+static_assert(std::same_as<decltype(subrange(static_cast<int*>(nullptr), static_cast<int*>(nullptr), 0)),
+                           subrange<int*, int*, std::ranges::subrange_kind::sized>>);
+static_assert(std::same_as<decltype(subrange(static_cast<int*>(nullptr), nullptr, 0)),
+                           subrange<int*, nullptr_t, std::ranges::subrange_kind::sized>>);
+
+struct ForwardRange {
+  forward_iterator<int*> begin() const;
+  forward_iterator<int*> end() const;
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<ForwardRange> = true;
+
+struct SizedRange {
+  int *begin();
+  int *end();
+};
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<SizedRange> = true;
+
+static_assert(std::same_as<decltype(subrange(ForwardRange())),
+                           subrange<forward_iterator<int*>, forward_iterator<int*>, std::ranges::subrange_kind::unsized>>);
+static_assert(std::same_as<decltype(subrange(SizedRange())),
+                           subrange<int*, int*, std::ranges::subrange_kind::sized>>);
+static_assert(std::same_as<decltype(subrange(SizedRange(), 8)),
+                           subrange<int*, int*, std::ranges::subrange_kind::sized>>);

libcxx/test/std/ranges/range.utility/range.subrange/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
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include <tuple>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+// convertible-to-non-slicing cases:
+//   1. Not convertible (fail)
+//   2. Only one is a pointer (succeed)
+//   3. Both are not pointers (succeed)
+//   4. Pointer elements are different types (fail)
+//   5. Pointer elements are same type (succeed)
+
+int globalBuff[8];
+
+struct Empty {};
+
+using ForwardIter = forward_iterator<int*>;
+using FowardSubrange = ranges::subrange<ForwardIter, ForwardIter, std::ranges::subrange_kind::unsized>;
+
+static_assert(std::is_default_constructible_v<FowardSubrange>);
+
+struct ConvertibleForwardIter {
+    typedef std::forward_iterator_tag       iterator_category;
+    typedef int                             value_type;
+    typedef std::ptrdiff_t                  difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef ConvertibleForwardIter          self;
+
+    int *base = nullptr;
+
+    constexpr ConvertibleForwardIter() = default;
+    constexpr explicit ConvertibleForwardIter(int *ptr) : base(ptr) { }
+
+    friend bool operator==(const self&, const self&);
+
+    reference operator*() const;
+    pointer operator->() const;
+    self& operator++();
+    self operator++(int);
+    self& operator--();
+    self operator--(int);
+
+    constexpr operator pointer() const { return base; }
+
+    // Explicitly deleted so this doesn't model sized_sentinel_for.
+    friend constexpr difference_type operator-(int *, self const&) = delete;
+    friend constexpr difference_type operator-(self const&, int*) = delete;
+};
+using ConvertibleFowardSubrange = ranges::subrange<ConvertibleForwardIter, int*,
+                                                   std::ranges::subrange_kind::unsized>;
+static_assert(std::is_convertible_v<ConvertibleForwardIter, int*>);
+
+using std::ptrdiff_t;
+template<bool EnableConvertible>
+struct SizedSentinelForwardIterBase {
+    typedef std::forward_iterator_tag       iterator_category;
+    typedef int                             value_type;
+    typedef ptrdiff_t                       difference_type;
+    typedef int*                            pointer;
+    typedef int&                            reference;
+    typedef std::make_unsigned_t<ptrdiff_t> udifference_type;
+    typedef SizedSentinelForwardIterBase    self;
+
+    int *value = nullptr;
+
+    constexpr SizedSentinelForwardIterBase() = default;
+    constexpr explicit SizedSentinelForwardIterBase(int *ptr) : value(ptr) {}
+
+    constexpr int *base() const { return value; }
+
+    friend bool operator==(const self&, const self&);
+
+    reference operator*() const;
+    pointer operator->() const;
+    self& operator++();
+    self operator++(int);
+    self& operator--();
+    self operator--(int);
+
+    template<bool E = EnableConvertible>
+      requires E
+    constexpr operator pointer() const { return value; }
+};
+using SizedSentinelForwardIter = SizedSentinelForwardIterBase<false>;
+using SizedSentinelFowardSubrange = ranges::subrange<SizedSentinelForwardIter,
+                                                     SizedSentinelForwardIter,
+                                                     std::ranges::subrange_kind::sized>;
+using ConvertibleSizedSentinelForwardIter = SizedSentinelForwardIterBase<true>;
+using ConvertibleSizedSentinelForwardSubrange = ranges::subrange<ConvertibleSizedSentinelForwardIter, int*,
+                                                                 std::ranges::subrange_kind::sized>;
+
+using SizedIntPtrSubrange = ranges::subrange<int*, int*, std::ranges::subrange_kind::sized>;
+
+// !StoreSize ctor.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardIter, ForwardIter>); // Default case.
+static_assert(!std::is_constructible_v<FowardSubrange, Empty, ForwardIter>); // 1.
+static_assert( std::is_constructible_v<ConvertibleFowardSubrange, ConvertibleForwardIter, int*>); // 2.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardIter, ForwardIter>); // 3. (Same as default case.)
+// 4. and 5. must be sized.
+
+// Sized ctor.
+static_assert( std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // Default case.
+static_assert(!std::is_constructible_v<SizedSentinelFowardSubrange, Empty, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // 1.
+static_assert( std::is_constructible_v<ConvertibleSizedSentinelForwardSubrange, ConvertibleSizedSentinelForwardIter, int*, ConvertibleSizedSentinelForwardIter::udifference_type>); // 2.
+static_assert( std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::udifference_type>); // 3. (Same as default case.)
+static_assert(!std::is_constructible_v<SizedIntPtrSubrange, long*, int*, size_t>); // 4.
+static_assert( std::is_constructible_v<SizedIntPtrSubrange, int*, int*, size_t>); // 5.
+// TODO: is there any integral type that is not convertible to an unsized type?
+// static_assert(!std::is_constructible_v<SizedSentinelFowardSubrange, SizedSentinelForwardIter, SizedSentinelForwardIter, SizedSentinelForwardIter::difference_type>); // Not unsigned.
+
+struct ForwardBorrowedRange {
+  constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
+  constexpr ForwardIter end() const { return ForwardIter(globalBuff + 8); }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ForwardBorrowedRange> = true;
+
+struct ForwardRange {
+  ForwardIter begin() const;
+  ForwardIter end() const;
+};
+
+struct ConvertibleForwardBorrowedRange {
+  constexpr ConvertibleForwardIter begin() const { return ConvertibleForwardIter(globalBuff); }
+  constexpr int *end() const { return globalBuff + 8; }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ConvertibleForwardBorrowedRange> = true;
+
+struct ForwardBorrowedRangeDifferentSentienl {
+  struct sentinel {
+    int *value;
+    friend bool operator==(sentinel s, ForwardIter i) { return s.value == i.base(); }
+  };
+
+  constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
+  constexpr sentinel end() const { return sentinel{globalBuff + 8}; }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<ForwardBorrowedRangeDifferentSentienl> = true;
+
+using DifferentSentienlSubrange = ranges::subrange<ForwardIter,
+                                                   ForwardBorrowedRangeDifferentSentienl::sentinel,
+                                                   std::ranges::subrange_kind::unsized>;
+
+struct DifferentSentienlWithSizeMember {
+  struct sentinel {
+    int *value;
+    friend bool operator==(sentinel s, ForwardIter i) { return s.value == i.base(); }
+  };
+
+  constexpr ForwardIter begin() const { return ForwardIter(globalBuff); }
+  constexpr sentinel end() const { return sentinel{globalBuff + 8}; }
+  constexpr size_t size() const { return 8; }
+};
+
+template<>
+inline constexpr bool ranges::enable_borrowed_range<DifferentSentienlWithSizeMember> = true;
+
+using DifferentSentienlWithSizeMemberSubrange = ranges::subrange<ForwardIter,
+                                                                 DifferentSentienlWithSizeMember::sentinel,
+                                                                 std::ranges::subrange_kind::unsized>;
+
+// Range ctor.
+static_assert( std::is_constructible_v<FowardSubrange, ForwardBorrowedRange>); // Default case.
+static_assert(!std::is_constructible_v<FowardSubrange, ForwardRange>); // Not borrowed.
+// Iter convertible to sentinel (pointer) type.
+static_assert( std::is_constructible_v<ConvertibleFowardSubrange, ConvertibleForwardBorrowedRange>);
+// Where neither iter or sentinel are pointers, but they are different.
+static_assert( std::is_constructible_v<DifferentSentienlSubrange, ForwardBorrowedRangeDifferentSentienl>);
+static_assert( std::is_constructible_v<DifferentSentienlWithSizeMemberSubrange, DifferentSentienlWithSizeMember>);
+
+// Pair like conversion.
+static_assert( std::is_convertible_v<FowardSubrange, std::pair<ForwardIter, ForwardIter>>);
+static_assert( std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter>>);
+static_assert(!std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter>&>);
+static_assert(!std::is_convertible_v<FowardSubrange, std::tuple<ForwardIter, ForwardIter, ForwardIter>>);
+static_assert( std::is_convertible_v<ConvertibleFowardSubrange, std::tuple<ConvertibleForwardIter, int*>>);
+static_assert(!std::is_convertible_v<SizedIntPtrSubrange, std::tuple<long*, int*>>);
+static_assert( std::is_convertible_v<SizedIntPtrSubrange, std::tuple<int*, int*>>);
+
+constexpr bool test() {
+  FowardSubrange a(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
+  assert(a.begin().base() == globalBuff);
+  assert(a.end().base() == globalBuff + 8);
+
+  ConvertibleFowardSubrange b(ConvertibleForwardIter(globalBuff), globalBuff + 8);
+  assert(b.begin() == globalBuff);
+  assert(b.end() == globalBuff + 8);
+
+  SizedSentinelFowardSubrange d(SizedSentinelForwardIter(globalBuff), SizedSentinelForwardIter(globalBuff + 8), 8);
+  assert(d.begin().base() == globalBuff);
+  assert(d.end().base() == globalBuff + 8);
+  assert(d.size() == 8);
+
+  ConvertibleSizedSentinelForwardSubrange e(ConvertibleSizedSentinelForwardIter(globalBuff), ConvertibleSizedSentinelForwardIter(globalBuff + 8), 8);
+  assert(e.begin() == globalBuff);
+  assert(e.end() == globalBuff + 8);
+  assert(e.size() == 8);
+
+  SizedIntPtrSubrange f(globalBuff, globalBuff + 8, 8);
+  assert(f.begin() == globalBuff);
+  assert(f.end() == globalBuff + 8);
+  assert(f.size() == 8);
+
+  FowardSubrange g{ForwardBorrowedRange()};
+  assert(g.begin().base() == globalBuff);
+  assert(g.end().base() == globalBuff + 8);
+
+  ConvertibleFowardSubrange h{ConvertibleForwardBorrowedRange()};
+  assert(h.begin() == globalBuff);
+  assert(h.end() == globalBuff + 8);
+
+  DifferentSentienlSubrange i{ForwardBorrowedRangeDifferentSentienl()};
+  assert(i.begin().base() == globalBuff);
+  assert(i.end().value == globalBuff + 8);
+
+  FowardSubrange j(ForwardIter(globalBuff), ForwardIter(globalBuff + 8));
+  std::pair<ForwardIter, ForwardIter> jPair = j;
+  assert(jPair.first.base() == globalBuff);
+  assert(jPair.second.base() == globalBuff + 8);
+  std::tuple<ForwardIter, ForwardIter> jTuple = j;
+  assert(get<0>(jTuple).base() == globalBuff);
+  assert(get<1>(jTuple).base() == globalBuff + 8);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.utility/range.subrange/general.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
+
+// class std::ranges::subrange;
+
+#include <ranges>
+
+#include <cassert>
+#include "test_macros.h"
+#include "test_iterators.h"
+
+namespace ranges = std::ranges;
+
+template<std::ranges::subrange_kind K, class...Args>
+concept ValidSubrangeKind = requires { typename std::ranges::subrange<Args..., K>; };
+
+template<class...Args>
+concept ValidSubrange = requires { typename std::ranges::subrange<Args...>; };
+
+static_assert( ValidSubrange<forward_iterator<int*>>);
+static_assert( ValidSubrange<forward_iterator<int*>, forward_iterator<int*>>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::unsized, forward_iterator<int*>, forward_iterator<int*>>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::sized, forward_iterator<int*>, forward_iterator<int*>>);
+// Wrong sentinel type.
+static_assert(!ValidSubrange<forward_iterator<int*>, int*>);
+static_assert( ValidSubrange<int*>);
+static_assert( ValidSubrange<int*, int*>);
+// Must be sized.
+static_assert(!ValidSubrangeKind<std::ranges::subrange_kind::unsized, int*, int*>);
+static_assert( ValidSubrangeKind<std::ranges::subrange_kind::sized, int*, int*>);
+// Wrong sentinel type.
+static_assert(!ValidSubrange<int*, forward_iterator<int*>>);
+// Not an iterator.
+static_assert(!ValidSubrange<int>);