[libcxx][ranges] Add ranges::take_view.

[zoecarver]

Go through https://libcxx.llvm.org/Contributing.html and fix what needs to be fixed.

Added proper "enable_borrowed_range".

[zoecarver]

libcxx/include/__iterator/counted_iterator.h

58

Review note: this file and the one below (common_view.h) have/will be updated with the changes shown here in other patches.

libcxx/include/__ranges/take_view.h

54

Chris, before you ask, I did try to factor this out into a static member function, but ran into a couple of issues (first, I had to inline size, second, it didn't work well for move only views).

😉

136

We move __end in the other constructor, why not here too? We don't use it later.

[cjdb]

libcxx/include/__ranges/take_view.h

19

Please replace with the specific algorithms you use.

44

Can be const.

54

Now that you've brought it to my attention... ;)

• why did you need to inline size?
• why doesn't it work well for move-only views?

111

Hmm... I just realised that if we're going to be using algorithms here, we should definitely be using ranges overloads. You won't be stepping on my turf if you implement the min/max family.

136

If it's passed by value we should be allowed to do so.

160

Oooooh nice, all_t.

[ldionne]

I have not looked at the tests yet.

libcxx/include/__ranges/take_view.h

35

[[no_unique_address]]

41

requires default_initializable<_View>, and also _LIBCPP_HIDE_FROM_ABI.

74

using _Difference = range_difference_t<const _View>;? (applies above)

111

It seems conforming to me to use std::min here, no?

127

[[no_unique_address]]

133

_LIBCPP_HIDE_FROM_ABI

136

I say we should move it. I don't see a reason either.

155

You could use __rhs.__end_ here, which would avoid making a copy of the sentinel (base() makes a copy). Same applies above.

[zoecarver]

libcxx/include/__ranges/take_view.h

44

__count? I don't really see how that benefits us... it's passed by value...

54

Well, because we really want a static function that we pass __base_ to, otherwise that kind of defeats the purpose of deducing _View vs const _View.

If we're passing __base_ we both lose size and have to move it into the function and then out of the function when we put it back into the member. That seems like an unreasonable cost.

111

I think that's a bit out of scope for my current timeline. Is there an observable difference?

136

Why did the standard do it below and not here, though? Was that just an oversight? CC @tcanens

[zoecarver]

libcxx/include/__ranges/take_view.h

155

That really should be inlined. But fair enough. I'm going to make it public so I can do that for lhs too.

[zoecarver]

Apply review comments.

[ldionne]

LGTM mod comments and passing CI!

libcxx/include/__ranges/take_view.h

54

I think this would work:

template <class _Self>
_LIBCPP_HIDE_FROM_ABI
static constexpr auto __begin(_Self& __self) {
  using _MaybeConstView = _If<is_const_v<_Self>, _View const, _View>;
  if constexpr (sized_range< _MaybeConstView >) {
        if constexpr (random_access_range<_MaybeConstView>) {
          return ranges::begin(__self.__base_);
        } else {
          using _DifferenceT = range_difference_t<_MaybeConstView>;
          auto __size = __self.size();
          return counted_iterator{ranges::begin(__self.__base_), static_cast<_DifferenceT>(__size)};
        }
      } else {
        return counted_iterator{ranges::begin(__self.__base_), __self.__count_};
      }
}

_LIBCPP_HIDE_FROM_ABI
constexpr auto begin() requires (!__simple_view<_View>) {
  return take_view::__begin(*this);
}

// etc...

I'm still not sure whether I like that better than matching the spec 1:1. I'll leave it to you to decide @zoecarver .

77

In all those counted_iterator constructions, the spec uses direct-initialization instead of list-initialization. I don't think this ever matters because there can't be a narrowing conversion from _DifferenceT to the argument of counted_iterator::counted_iterator (both types should always be exactly iter_difference_t<iterator_t<_View>>), but we might as well follow the spec.

155

Depending on what the _View's copy constructor does, it might not be possible to inline it, I think. I would definitely not rely on that, at least.

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

24

Can you make this more minimal? For example, I think you could provide only begin() const as a member function.

Also, since you're using it in a bunch of places, perhaps you could put it in a types.h helper header in this directory? That would be a simple way to remove some duplication.

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

97

Could you add a one-liner to each test to make it very obvious which branch of the if constexpr you're testing? Something as simple as:

// sized_range && random_access

133–143

I'm not sure what coverage this is adding. Consider removing if it doesn't add anything.

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

18

#include <concepts>

46

Alternatively, you could leave at file scope. Whatever you prefer.

libcxx/test/std/ranges/range.adaptors/range.take/ctor.pass.cpp

64

You never actually default-construct an object here. Could you do that? Ideally, you'd then test that base() has been default-initialized, and that the size() is 0 (which you could do best by creating a view that has non-zero size when default-constructed).

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

97

Same comment as for begin() w.r.t. which if branch we're testing.

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

113

You want to test this version (N == size-of-the-range) for const too.

118

You want to test this version (N > size-of-the-range) for non-const too.

[zoecarver]

Apply remaining review comments.

Note: I'm rebasing on main instead of counted_iterator so the CI passes. It's just easier this way.

[zoecarver]

Actually push the change with the addressed feedback :P

[zoecarver]

Move Copyable and ContiguousView into the local header. They were conflicting with types that transform_view uses. I'll move them into test_ranges.h in a later commit.

[cjdb]

Please add range concept conformance tests before merging.

libcxx/include/__ranges/take_view.h

44

If we start by making everything const and then remove it for only the objects we intend to modify, we're better-documenting our intention. Put another way: we shouldn't need a reason to provide const: we should have a good reason to omit const.

54

@ldionne's got what I had in mind. I like it because it keeps the complex logic in one place and makes sure that any bugs only have one source of manifestation.

111

In general: yes, there is an observable difference. std::min requires that its parameters meet Cpp17LessThanComparable, whereas std::ranges::min requires that its parameters model totally_ordered_with. Since we're comparing integers, I don't think it's going to be an observable difference.

Could you please at least add a FIXME so I remember to clean it up one day?

libcxx/test/support/test_iterators.h

701 ↗

(On Diff #361838)

Why is this being deleted?

[zoecarver]

libcxx/test/support/test_iterators.h

701 ↗

(On Diff #361838)

These archetypes are meant to represent the minimum requirements of an iterator. C++20 input iterators are not required to be default constructible, therefore our C++20 input iterator archetype should not be default constructible.

[• Quuxplusone]

libcxx/test/support/test_iterators.h

701 ↗

(On Diff #361838)

@zoecarver: FWIW, your archetype philosophy makes sense to me; but I wish this change to massively shared test code were done in a separate patch, not bundled in with this counted_iterator feature. (IIUC, all our existing tests are completely apathetic to this change: this change is neither required, nor harmful, to any existing test.)

libcxx/test/support/test_range.h

58 ↗

(On Diff #361838)

woot! :) but also, please land this as a separate NFC commit (and you can just go ahead and do that).
Bonus points if you clean up the > > on lines 26, 35, 42, 51, and the spelling mistake on line 17, while you're at it.

[zoecarver]

Add a comment with a TODO for the ranges::min.

Reset the changes to test_range.h.

Rebase on main.

[zoecarver]

Add UNSUPPORTED: libcpp-has-no-incomplete-ranges. Rebase. Add range conformance tests.

libcxx/include/CMakeLists.txt

set(files
   __ranges/copyable_box.h
   __ranges/data.h
   __ranges/drop_view.h
   __ranges/empty_view.h
   __ranges/empty.h
   __ranges/enable_borrowed_range.h
   __ranges/enable_view.h
   __ranges/ref_view.h
+  __ranges/take_view.h
   __ranges/size.h
   __ranges/subrange.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __split_buffer
   __std_stream
   __string
   __support/android/locale_bionic.h

libcxx/include/__iterator/counted_iterator.h

 struct __counted_iterator_category {};
 
 template<__concept_has_iterator_category _Iter>
 struct __counted_iterator_category<_Iter> {
   using iterator_category = typename _Iter::iterator_category;
 };
 
 template<class>
 struct __counted_iterator_value_type {};
 
 template<input_iterator _Iter>
 struct __counted_iterator_value_type<_Iter> {
-  using value_type = typename _Iter::value_type;
+  using value_type = iter_value_t<_Iter>;
 };
 
 template<input_or_output_iterator _Iter>
 class counted_iterator
   : public __counted_iterator_concept<_Iter>
   , public __counted_iterator_category<_Iter>
   , public __counted_iterator_value_type<_Iter>
 {

libcxx/include/__ranges/common_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_COMMON_VIEW_H
 #define _LIBCPP___RANGES_COMMON_VIEW_H
 
 #include <__config>
 #include <__iterator/common_iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
 #include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/size.h>
 #include <__ranges/view_interface.h>
 #include <concepts>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
constexpr auto size() requires sized_range<_View> {
     return ranges::size(__base_);
   }
 
   constexpr auto size() const requires sized_range<const _View> {
     return ranges::size(__base_);
   }
 };
 
-// TODO: use all_t here when it's implemented.
 template<class _Range>
 common_view(_Range&&)
-  -> common_view<decltype(views::all(declval<_Range>()))>;
+  -> common_view<views::all_t<_Range>>;
 
 template<class _View>
 inline constexpr bool enable_borrowed_range<common_view<_View>> = enable_borrowed_range<_View>;
 
 } // namespace ranges
 
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___RANGES_COMMON_VIEW_H

libcxx/include/__ranges/take_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_TAKE_VIEW_H
+#define _LIBCPP___RANGES_TAKE_VIEW_H
+
+#include <__config>
+#include <__iterator/counted_iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/view_interface.h>
+#include <algorithm>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  template<view _View>
+  class take_view : public view_interface<take_view<_View>> {
+    _View __base_ = _View();
+    range_difference_t<_View> __count_ = 0;
+
+    template<bool> class __sentinel;
+
+  public:
+    take_view() = default;
+    constexpr take_view(_View __base, range_difference_t<_View> __count)
+      : __base_(_VSTD::move(__base)), __count_(__count) {}
+
+    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+    constexpr _View base() && { return _VSTD::move(__base_); }
+
+    constexpr auto begin() requires (!__simple_view<_View>) {
+      if constexpr (sized_range<_View>) {
+        if constexpr (random_access_range<_View>) {
+          return ranges::begin(__base_);
+        } else {
+          auto __size = size();
+          return counted_iterator{ranges::begin(__base_), static_cast<range_difference_t<_View>>(__size)};
+        }
+      } else {
+        return counted_iterator{ranges::begin(__base_), __count_};
+      }
+    }
+
+    constexpr auto begin() const requires range<const _View> {
+      if constexpr (sized_range<const _View>) {
+        if constexpr (random_access_range<const _View>) {
+          return ranges::begin(__base_);
+        } else {
+          auto __size = size();
+          return counted_iterator{ranges::begin(__base_), static_cast<range_difference_t<const _View>>(__size)};
+        }
+      } else {
+        return counted_iterator{ranges::begin(__base_), __count_};
+      }
+    }
+
+    constexpr auto end() requires (!__simple_view<_View>) {
+      if constexpr (sized_range<_View>) {
+        if constexpr (random_access_range<_View>) {
+          return ranges::begin(__base_) + size();
+        } else {
+          return default_sentinel;
+        }
+      } else {
+        return __sentinel<false>{ranges::end(__base_)};
+      }
+    }
+
+    constexpr auto end() const requires range<const _View> {
+      if constexpr (sized_range<const _View>) {
+        if constexpr (random_access_range<const _View>) {
+          return ranges::begin(__base_) + size();
+        } else {
+          return default_sentinel;
+        }
+      } else {
+        return __sentinel<true>{ranges::end(__base_)};
+      }
+    }
+
+    constexpr auto size() requires sized_range<_View> {
+      auto __n = ranges::size(__base_);
+      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+    }
+
+    constexpr auto size() const requires sized_range<const _View> {
+      auto __n = ranges::size(__base_);
+      return _VSTD::min(__n, static_cast<decltype(__n)>(__count_));
+    }
+  };
+
+  template<view _View>
+  template<bool _Const>
+  class take_view<_View>::__sentinel {
+    using _Base = __maybe_const<_Const, _View>;
+    template<bool _OtherConst>
+    using _Iter = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
+    sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+
+    template<bool>
+    friend class take_view<_View>::__sentinel;
+
+public:
+    __sentinel() = default;
+
+    constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {} // TODO: why not move this one too?
+    constexpr __sentinel(__sentinel<!_Const> __s)
+      requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+      : __end_(_VSTD::move(__s.__end_)) {}
+
+    constexpr sentinel_t<_Base> base() const { return __end_; }
+
+    friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+      return __lhs.count() == 0 || __lhs.base() == __rhs.base();
+    }
+
+    template<bool _OtherConst = !_Const>
+      requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+    friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+      return __lhs.count() == 0 || __lhs.base() == __rhs.base();
+    }
+  };
+
+  template<class _Range>
+  take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_TAKE_VIEW_H

libcxx/include/ranges

 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/empty.h>
 #include <__ranges/empty_view.h>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/ref_view.h>
+#include <__ranges/take_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/transform_view.h>
 #include <__ranges/view_interface.h>
 #include <compare>          // Required by the standard.
 #include <initializer_list> // Required by the standard.
 #include <iterator>         // Required by the standard.
 #include <type_traits>

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr V base() const& requires copy_constructible<V>;
+// constexpr V base() &&;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool hasLValueQualifiedBase(auto&& view) {
+    return requires { view.base(); };
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+  // TODO naming here
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(tv.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), CopyableView);
+    static_assert(hasLValueQualifiedBase(tv));
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 1);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), ContiguousView);
+    static_assert(!hasLValueQualifiedBase(tv));
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 2);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::move(tv).base().ptr_ == buffer);
+
+    ASSERT_SAME_TYPE(decltype(tv.base()), CopyableView);
+    ASSERT_SAME_TYPE(decltype(std::move(tv).base()), CopyableView);
+    static_assert(hasLValueQualifiedBase(tv));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto begin() requires (!simple-view<V>);
+// constexpr auto begin() const requires range<const V>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedForwardView a sized view.
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedRandomAccessView a sized view.
+constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 4);
+    assert(tv.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 4);
+    assert(tv.begin() == begin(SizedRandomAccessView(buffer)));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), RandomAccessIter);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<ForwardIter>(ForwardIter(buffer), 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<ForwardIter>);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<ForwardIter>(ForwardIter(buffer), 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<ForwardIter>);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 4);
+    assert(tv.begin() == std::counted_iterator<int*>(buffer, 4));
+    ASSERT_SAME_TYPE(decltype(tv.begin()), std::counted_iterator<int*>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.take/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
+
+// template<class R>
+//   take_view(R&&, range_difference_t<R>) -> take_view<views::all_t<R>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_iterators.h"
+
+struct View : std::ranges::view_base {
+  friend int* begin(View&);
+  friend int* begin(View const&);
+  friend sentinel_wrapper<int*> end(View&);
+  friend sentinel_wrapper<int*> end(View const&);
+};
+
+struct Range {
+  friend int* begin(Range&);
+  friend int* begin(Range const&);
+  friend sentinel_wrapper<int*> end(Range&);
+  friend sentinel_wrapper<int*> end(Range const&);
+};
+
+struct BorrowedRange {
+  friend int* begin(BorrowedRange&);
+  friend int* begin(BorrowedRange const&);
+  friend sentinel_wrapper<int*> end(BorrowedRange&);
+  friend sentinel_wrapper<int*> end(BorrowedRange const&);
+};
+
+template<>
+inline constexpr bool std::ranges::enable_borrowed_range<BorrowedRange> = true;
+
+void testCTAD() {
+    View v;
+    Range r;
+    BorrowedRange br;
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(v, 0)),
+        std::ranges::take_view<View>
+    >);
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(r, 0)),
+        std::ranges::take_view<std::ranges::ref_view<Range>>
+    >);
+    // std::ranges::take_view(std::move(r), 0) invalid. RValue range must be borrowed.
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(br, 0)),
+        std::ranges::take_view<std::ranges::ref_view<BorrowedRange>>
+    >);
+    static_assert(std::same_as<
+        decltype(std::ranges::take_view(std::move(br), 0)),
+        std::ranges::take_view<std::ranges::subrange<
+          int *, sentinel_wrapper<int *>, std::ranges::subrange_kind::unsized>>
+    >);
+}

libcxx/test/std/ranges/range.adaptors/range.take/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
+
+// take_view() requires default_initializable<V> = default;
+// constexpr take_view(V base, range_difference_t<V> count);
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+template<bool IsDefaultCtorable>
+struct DefaultConstructible : std::ranges::view_base {
+  DefaultConstructible() requires IsDefaultCtorable = default;
+  DefaultConstructible(int*);
+  int* begin();
+  sentinel_wrapper<int*> end();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( std::default_initializable<DefaultConstructible<true>>);
+    static_assert(!std::default_initializable<DefaultConstructible<false>>);
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
+    assert(tv.base().ptr_ == buffer);
+    assert(tv.begin() == tv.end()); // Checking we have correct size.
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 1);
+    assert(std::move(tv).base().ptr_ == buffer);
+    assert(std::ranges::next(tv.begin(), 1) == tv.end()); // Checking we have correct size.
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 2);
+    assert(tv.base().ptr_ == buffer);
+    assert(std::ranges::next(tv.begin(), 2) == tv.end()); // Checking we have correct size.
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto end() requires (!simple-view<V>)
+// constexpr auto end() const requires range<const V>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedForwardView a sized view.
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedRandomAccessView a sized view.
+constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 0);
+    assert(tv.end() == std::ranges::next(tv.begin(), 0));
+    ASSERT_SAME_TYPE(decltype(tv.end()), RandomAccessIter);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 1);
+    assert(tv.end() == std::ranges::next(tv.begin(), 1));
+    ASSERT_SAME_TYPE(decltype(tv.end()), RandomAccessIter);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 2);
+    assert(tv.end() == std::ranges::next(tv.begin(), 2));
+    ASSERT_SAME_TYPE(decltype(tv.end()), std::default_sentinel_t);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 3);
+    assert(tv.end() == std::ranges::next(tv.begin(), 3));
+    ASSERT_SAME_TYPE(decltype(tv.end()), std::default_sentinel_t);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.end() == std::ranges::next(tv.begin(), 4));
+
+    // The <sentinel> type.
+    static_assert(!std::same_as<decltype(tv.end()), std::default_sentinel_t>);
+    static_assert(!std::same_as<decltype(tv.end()), int*>);
+  }
+
+  {
+    const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 5);
+    assert(tv.end() == std::ranges::next(tv.begin(), 5));
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
+    assert(tv.end() == std::ranges::next(tv.begin(), 6));
+  }
+
+  {
+    const std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 7);
+    assert(tv.end() == std::ranges::next(tv.begin(), 7));
+  }
+
+  // Just to cover the case where count == 8.
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 8);
+    assert(tv.end() == std::ranges::next(tv.begin(), 8));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/base.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+  auto sw = sentinel_wrapper<int *>(buffer + 8); // Note: not 4, but that's OK.
+
+  {
+    const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.end().base().base() == sw.base());
+    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(tv.end().base().base() == sw.base());
+    ASSERT_SAME_TYPE(decltype(tv.end().base()), sentinel_wrapper<int *>);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/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
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    // Test the default ctor.
+    std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+    assert(decltype(tv.end()){} == std::ranges::next(tv.begin(), 4));
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> nonConst(ContiguousView{buffer}, 5);
+    const std::ranges::take_view<ContiguousView> tvConst(ContiguousView{buffer}, 5);
+    auto sent1 = nonConst.end();
+    // Convert to const. Note, we cannot go the other way.
+    std::remove_cv_t<decltype(tvConst.end())> sent2 = sent1;
+
+    assert(sent1 == std::ranges::next(tvConst.begin(), 5));
+    assert(sent2 == std::ranges::next(tvConst.begin(), 5));
+  }
+
+  {
+    std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 6);
+    auto sw = sentinel_wrapper<int *>(buffer + 6);
+    using Sent = decltype(tv.end());
+    Sent sent = Sent(sw);
+    assert(sent.base().base() == sw.base());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/ranges/range.adaptors/range.take/sentinel/eq.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
+
+// sentinel() = default;
+// constexpr explicit sentinel(sentinel_t<Base> end);
+// constexpr sentinel(sentinel<!Const> s)
+//   requires Const && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct ContiguousView : std::ranges::view_base {
+  int *ptr_;
+  constexpr ContiguousView(int* ptr) : ptr_(ptr) {}
+  constexpr ContiguousView(ContiguousView&&) = default;
+  constexpr ContiguousView& operator=(ContiguousView&&) = default;
+  constexpr friend int* begin(ContiguousView& view) { return view.ptr_; }
+  constexpr friend int* begin(ContiguousView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(ContiguousView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    {
+      const std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+      assert(tv.end() == std::ranges::next(tv.begin(), 4));
+      assert(std::ranges::next(tv.begin(), 4) == tv.end());
+    }
+
+    {
+      std::ranges::take_view<ContiguousView> tv(ContiguousView{buffer}, 4);
+      assert(tv.end() == std::ranges::next(tv.begin(), 4));
+      assert(std::ranges::next(tv.begin(), 4) == tv.end());
+    }
+  }
+
+  {
+    std::ranges::take_view<ContiguousView> tvNonConst(ContiguousView{buffer}, 4);
+    const std::ranges::take_view<ContiguousView> tvConst(ContiguousView{buffer}, 4);
+    assert(tvNonConst.end() == std::ranges::next(tvConst.begin(), 4));
+    assert(std::ranges::next(tvConst.begin(), 4) == tvNonConst.end());
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// constexpr auto size() requires sized_range<V>
+// constexpr auto size() const requires sized_range<const V>
+
+#include <ranges>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+struct CopyableView : std::ranges::view_base {
+  int *ptr_;
+  constexpr CopyableView(int* ptr) : ptr_(ptr) {}
+  constexpr friend int* begin(CopyableView& view) { return view.ptr_; }
+  constexpr friend int* begin(CopyableView const& view) { return view.ptr_; }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+  constexpr friend sentinel_wrapper<int*> end(CopyableView const& view) {
+    return sentinel_wrapper<int*>{view.ptr_ + 8};
+  }
+};
+
+using ForwardIter = forward_iterator<int*>;
+struct SizedForwardView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedForwardView(int* ptr) : ptr_(ptr) {}
+  constexpr friend ForwardIter begin(SizedForwardView& view) { return ForwardIter(view.ptr_); }
+  constexpr friend ForwardIter begin(SizedForwardView const& view) { return ForwardIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<ForwardIter> end(SizedForwardView const& view) {
+    return sentinel_wrapper<ForwardIter>{ForwardIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedForwardView a sized view.
+constexpr auto operator-(sentinel_wrapper<ForwardIter> sent, ForwardIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(ForwardIter iter, sentinel_wrapper<ForwardIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+using RandomAccessIter = random_access_iterator<int*>;
+struct SizedRandomAccessView : std::ranges::view_base {
+  int *ptr_;
+  constexpr SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend RandomAccessIter begin(SizedRandomAccessView const& view) { return RandomAccessIter(view.ptr_); }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+  constexpr friend sentinel_wrapper<RandomAccessIter> end(SizedRandomAccessView const& view) {
+    return sentinel_wrapper<RandomAccessIter>{RandomAccessIter(view.ptr_ + 8)};
+  }
+};
+// Required to make SizedRandomAccessView a sized view.
+constexpr auto operator-(sentinel_wrapper<RandomAccessIter> sent, RandomAccessIter iter) {
+  return sent.base().base() - iter.base();
+}
+constexpr auto operator-(RandomAccessIter iter, sentinel_wrapper<RandomAccessIter> sent) {
+  return iter.base() - sent.base().base();
+}
+
+template<class T>
+concept SizeEnabled = requires(const std::ranges::take_view<T>& tv) {
+  tv.size();
+};
+
+constexpr bool test() {
+  int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+
+  {
+    static_assert( SizeEnabled<SizedRandomAccessView>);
+    static_assert(!SizeEnabled<CopyableView>);
+  }
+
+  {
+    std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 0);
+    assert(tv.size() == 0);
+  }
+
+  {
+    const std::ranges::take_view<SizedRandomAccessView> tv(SizedRandomAccessView{buffer}, 2);
+    assert(tv.size() == 2);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 4);
+    assert(tv.size() == 4);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 6);
+    assert(tv.size() == 6);
+  }
+
+  {
+    std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 8);
+    assert(tv.size() == 8);
+  }
+
+  {
+    const std::ranges::take_view<SizedForwardView> tv(SizedForwardView{buffer}, 10);
+    assert(tv.size() == 8);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}