[libc++][ranges] Implement P2494R2 (Relaxing range adaptors to allow for move only types)

[yronglin]

Summary

Implement P2494R2 Relaxing range adaptors to allow for move only types

https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2494r2.html#wording-ftm

According to the words in P2494R2, I haven't add new test for drop_while_view, take_while_view and filter_view, because these views has the requirement that the predicate is an indirect_unary_predicate, which requires that the predicate is copy_constructible, so they still can't accept move only types as predicate.

[P2483R0] also suggests future work to relax the requirements on the predicate types stored by standard views. This paper does not perform this relaxation, as the copy constructibility requirement is enshrined in the indirect callable concepts ([indirectcallable.indirectinvocable]). Thus, while this paper modifies the views that currently use copyable-box for user provided predicates, it only does so to apply the rename of the exposition-only type to movable-box; it does not change any of the constraints on those views. It does, however, relax the requirements on invocables accepted by the transform family of views, because those are not constrained using the indirect callable concepts.

[yronglin]

Try fix CI.

[yronglin]

try fix ci

[yronglin]

Fix CI

[yronglin]

Remove extra format change.

[yronglin]

Fix ci.

[yronglin]

ping~

[Mordante]

I mainly glossed over it. I'm not to familiar with the details of these internals of ranges.

libcxx/test/libcxx/ranges/range.adaptors/range.move.wrap/properties.compile.pass.cpp

11 ↗

(On Diff #526627)

[yronglin]

Address comments

[yronglin]

Thanks for your review @Mordante !

[var-const]

Thanks for the patch!

libcxx/include/__ranges/filter_view.h

56

For each of these changes to existing views, we need a new test(s) that would fail if not for the change in this patch.

libcxx/include/__ranges/movable_box.h

10 ↗

(On Diff #527399)

The formatting changes make it harder to see things that are relevant to the proposal in this file. Can you clang-format copyable_box.h in a separate patch and rebase this patch on that?

33 ↗

(On Diff #527399)

Is this comment up-to-date?

44 ↗

(On Diff #527399)

Is there a reason not to apply the new behavior to old language versions retroactively? Would this change break any existing code?

(Also tagging @ldionne )

libcxx/include/__ranges/single_view.h

42

Can you please undo the formatting change? It makes it harder to see the parts of the diff that implement the proposal.

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/arrow.pass.cpp

11

s/copyable-box/movable-box/. Applies throughout.

[var-const]

Do you need to also bump #define __cpp_lib_ranges ?

[yronglin]

Sorry for the late reply and thanks a lot for your review! @var-const

libcxx/include/__ranges/movable_box.h

10 ↗

(On Diff #527399)

Ok, I'll rename copyable_box.h -> movable_box.h and formart in a separate patch.

33 ↗

(On Diff #527399)

Oops, It need update.

libcxx/include/__ranges/single_view.h

42

OK, I'll undo format changes,

[yronglin]

In D151629#4392402, @var-const wrote:

Do you need to also bump #define __cpp_lib_ranges ?

Good catch! __cpp_lib_ranges need update to 202207L

[ldionne]

libcxx/include/__ranges/movable_box.h

44 ↗

(On Diff #527399)

https://github.com/cplusplus/papers/issues/1156 is not super clear as to whether this should be treated as a DR.

@jwakely @CaseyCarter what did you folks do here? Did you apply P2494R2 (copyable-box => movable-box) as a DR to C++20, or do you consider it as a C++23 feature?

[jwakely]

libcxx/include/__ranges/movable_box.h

44 ↗

(On Diff #527399)

https://github.com/cplusplus/papers/issues/1156 is not super clear as to whether this should be treated as a DR.

Good, I prefer to leave that to implementors where there's no compelling reason it has to be a DR. IMHO there's no defect here, this is a design change. It's an improvement, but the previous design was sound, not buggy.

@jwakely @CaseyCarter what did you folks do here? Did you apply P2494R2 (copyable-box => movable-box) as a DR to C++20, or do you consider it as a C++23 feature?

We didn't do it yet, but I think it looks harmless to apply the change to C++20 instead of making it conditional.

[yronglin]

Undo format changes and add tests for move only types.

The header file was not renamed, and still __copyable_box.h, this makes the review more convenient, I will rename files and dirs after reviews done or in a separate patch.

Due to the words in P2494R2, I haven't add new test for drop_while_view, take_while_view and filter_view, because these views has the requirement that the predicate is an indirect_unary_predicate, which requires that the predicate is copy_constructible, so they still can't accept move only types as predicate.

[P2483R0] also suggests future work to relax the requirements on the predicate types stored by standard views. This paper does not perform this relaxation, as the copy constructibility requirement is enshrined in the indirect callable concepts ([indirectcallable.indirectinvocable]). Thus, while this paper modifies the views that currently use copyable-box for user provided predicates, it only does so to apply the rename of the exposition-only type to movable-box; it does not change any of the constraints on those views. It does, however, relax the requirements on invocables accepted by the transform family of views, because those are not constrained using the indirect callable concepts.

[yronglin]

Thanks for your review, @var-const @ldionne @jwakely !

[yronglin]

Fix feature test macro

[yronglin]

In D151629#4392402, @var-const wrote:

Do you need to also bump #define __cpp_lib_ranges ?

Thanks, done.

[yronglin]

ping～

[H-G-Hristov]

Normally the "Build Status" looks like this:

Buildable 237942
Build 368504: pre-merge checks
Build 368503: arc lint + arc unit

And here it is missing the last line. Is this some sort of CI issue?

Build Status
Buildable 237526
Build 367796: pre-merge checks

[yronglin]

In D151629#4411417, @H-G-Hristov wrote:

Normally the "Build Status" looks like this:

Buildable 237942
Build 368504: pre-merge checks
Build 368503: arc lint + arc unit

And here it is missing the last line. Is this some sort of CI issue?

Build Status
Buildable 237526
Build 367796: pre-merge checks

This looks weird, and I'm not sure what's going on, but it looks like the test results are looks good https://buildkite.com/llvm-project/diff-checks/builds/177081

[yronglin]

ping~

[CaseyCarter]

libcxx/include/__ranges/movable_box.h

44 ↗

(On Diff #527399)

We did _not_ apply to C++20 (https://github.com/microsoft/STL/pull/2965/files#diff-522242e575c221b356ad37137cf877b2a4b4a5de24333f834cf4f981560dd7ecR49-R56), but I could very easily be convinced that we should.

[yronglin]

libcxx/include/__ranges/movable_box.h

44 ↗

(On Diff #527399)

Ahhh, thanks for your reply! Will you apply this change for c++20 in libstdc++ and microsoft/STL in the future?

[ldionne]

libcxx/include/__ranges/movable_box.h

44 ↗

(On Diff #527399)

Looks like there's no strong reason to do it for C++20. I agree with @jwakely that this is not a "bug fix". So then I recommend we implement it as a new feature for C++23.

We can still rename the class to __movable_box while adding a comment that it actually requires copyability pre C++23.

[yronglin]

Relaxing range adaptors to allow for move only types since C++23.

[yronglin]

Fix ci

[yronglin]

ping～

[var-const]

Almost LGTM. Please also rename copyable_box.h to movable_box.h and I think this patch should be good to go.

libcxx/include/__ranges/copyable_box.h

41

Nit: consider rephrasing this so that it's written from the perspective of the new state, not the previous state. That is, instead of saying "we allow this since C++23", consider saying "this wasn't allowed before C++23". Perhaps something like:

Note: until C++23, `__movable_box` was named `__copyable_box` and required the stored type to be copy-constructible, not just move-constructible; we preserve the old behavior in pre-C++23 modes.

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

102

Nit: we usually rely on the compiler deducing the size of the array from the initializer.

[yronglin]

Rename file name from copyable_box.h to movable_box.h

[yronglin]

In D151629#4439512, @var-const wrote:

Almost LGTM. Please also rename copyable_box.h to movable_box.h and I think this patch should be good to go.

Thanks for your review!

[yronglin]

Try fix ci.

[var-const]

Thank you for working on this!

[yronglin]

Thanks for your review! once the CI green, I'll land this patch.

[yronglin]

fix ci

[yronglin]

NFC

• Rename directory name from range.copy.warp to range.move.warp
• Format

[yronglin]

Fix ci.

[yronglin]

The windows CI failure seems not caused by this patch, I think it caused by D153656

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_list_remove_return_type``             ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_math_constants``                      ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_move_iterator_concept``               ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_polymorphic_allocator``               ``201902L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_ranges``                              ``202106L``
+    ``__cpp_lib_ranges``                              ``202207L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_remove_cvref``                        ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                           ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_shared_ptr_arrays``                   ``201707L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_shift``                               ``201806L``

libcxx/docs/Status/Cxx23Papers.csv

 "`P2419R2 <https://wg21.link/P2419R2>`__","LWG","Clarify handling of encodings in localized formatting of chrono types","July 2022","",""
 "`P2438R2 <https://wg21.link/P2438R2>`__","LWG","``std::string::substr() &&``","July 2022","|Complete|","16.0"
 "`P2445R1 <https://wg21.link/P2445R1>`__","LWG","``forward_like``","July 2022","|Complete|","16.0"
 "`P2446R2 <https://wg21.link/P2446R2>`__","LWG","``views::as_rvalue``","July 2022","|Complete|","16.0","|ranges|"
 "`P2460R2 <https://wg21.link/P2460R2>`__","LWG","Relax requirements on ``wchar_t`` to match existing practices","July 2022","",""
 "`P2465R3 <https://wg21.link/P2465R3>`__","LWG","Standard Library Modules ``std`` and ``std.compat``","July 2022","",""
 "`P2467R1 <https://wg21.link/P2467R1>`__","LWG","Support exclusive mode for ``fstreams``","July 2022","",""
 "`P2474R2 <https://wg21.link/P2474R2>`__","LWG","``views::repeat``","July 2022","","","|ranges|"
-"`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","","","|ranges|"
+"`P2494R2 <https://wg21.link/P2494R2>`__","LWG","Relaxing range adaptors to allow for move only types","July 2022","|Complete|","17.0","|ranges|"
 "`P2499R0 <https://wg21.link/P2499R0>`__","LWG","``string_view`` range constructor should be ``explicit``","July 2022","|Complete|","16.0","|ranges|"
 "`P2502R2 <https://wg21.link/P2502R2>`__","LWG","``std::generator``: Synchronous Coroutine Generator for Ranges","July 2022","","","|ranges|"
 "`P2508R1 <https://wg21.link/P2508R1>`__","LWG","Exposing ``std::basic-format-string``","July 2022","|Complete|","15.0"
 "`P2513R4 <https://wg21.link/P2513R4>`__","LWG","``char8_t`` Compatibility and Portability Fixes","July 2022","",""
 "`P2517R1 <https://wg21.link/P2517R1>`__","LWG","Add a conditional ``noexcept`` specification to ``std::apply``","July 2022","",""
 "`P2520R0 <https://wg21.link/P2520R0>`__","LWG","``move_iterator`` should be a random access iterator","July 2022","|Complete| [#note-P2520R0]_","17.0","|ranges|"
 "`P2540R1 <https://wg21.link/P2540R1>`__","LWG","Empty Product for certain Views","July 2022","","","|ranges|"
 "`P2549R1 <https://wg21.link/P2549R1>`__","LWG","``std::unexpected`` should have ``error()`` as member accessor","July 2022","|Complete|","16.0"

libcxx/include/__ranges/copyable_box.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-// __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into
-// a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state
+// __movable_box allows turning a type that is move-constructible (but maybe not move-assignable) into
+// a type that is both move-constructible and move-assignable. It does that by introducing an empty state
 // and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
 // to handle the case where the copy construction fails after destroying the object.
 //
 // In some cases, we can completely avoid the use of an empty state; we provide a specialization of
-// __copyable_box that does this, see below for the details.
+// __movable_box that does this, see below for the details.
 
 template<class _Tp>
-concept __copy_constructible_object = copy_constructible<_Tp> && is_object_v<_Tp>;
+concept __movable_box_object = move_constructible<_Tp> && is_object_v<_Tp>;
 
 namespace ranges {
   // Primary template - uses std::optional and introduces an empty state in case assignment fails.
-  template<__copy_constructible_object _Tp>
-  class __copyable_box {
+  template<__movable_box_object _Tp>
+  class __movable_box {
     _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
 
   public:
     template<class ..._Args>
       requires is_constructible_v<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
+    constexpr explicit __movable_box(in_place_t, _Args&& ...__args)
       noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
       : __val_(in_place, std::forward<_Args>(__args)...)
     { }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
       requires default_initializable<_Tp>
       : __val_(in_place)
     { }
 
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&) = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other)
+    constexpr __movable_box& operator=(__movable_box const& __other)
       noexcept(is_nothrow_copy_constructible_v<_Tp>)
+      requires copy_constructible<_Tp>
     {
       if (this != std::addressof(__other)) {
         if (__other.__has_value()) __val_.emplace(*__other);
         else                       __val_.reset();
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
+    __movable_box& operator=(__movable_box&&) requires movable<_Tp> = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other)
+    constexpr __movable_box& operator=(__movable_box&& __other)
       noexcept(is_nothrow_move_constructible_v<_Tp>)
     {
       if (this != std::addressof(__other)) {
         if (__other.__has_value()) __val_.emplace(std::move(*__other));
         else                       __val_.reset();
       }
       return *this;
     }
namespace ranges {
   //    directly and avoid using std::optional.
   // 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
   //    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
   //
   // The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
   // nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
   // whenever we can apply any of these optimizations for both the copy assignment and the move assignment
   // operator.
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
 
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
-
-  template<__copy_constructible_object _Tp>
-    requires __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>
-  class __copyable_box<_Tp> {
+  template <class _Tp>
+  concept __doesnt_need_empty_state =
+      (copy_constructible<_Tp>
+          // 1. If copy_constructible<T> is true, movable-box<T> should store only a T if either T models
+          //    copyable, or is_nothrow_move_constructible_v<T> && is_nothrow_copy_constructible_v<T> is true.
+          ? copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Tp>)
+          // 2. Otherwise, movable-box<T> should store only a T if either T models movable or
+          //    is_nothrow_move_constructible_v<T> is true.
+          : movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
+
+  template<__movable_box_object _Tp>
+    requires __doesnt_need_empty_state<_Tp>
+  class __movable_box<_Tp> {
     _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
 
   public:
     template<class ..._Args>
       requires is_constructible_v<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
+    constexpr explicit __movable_box(in_place_t, _Args&& ...__args)
       noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
       : __val_(std::forward<_Args>(__args)...)
     { }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
       requires default_initializable<_Tp>
       : __val_()
     { }
 
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&) = default;
 
     // Implementation of assignment operators in case we perform optimization (1)
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box const&) requires copyable<_Tp> = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box const&) requires copyable<_Tp> = default;
+    _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box&&) requires movable<_Tp> = default;
 
     // Implementation of assignment operators in case we perform optimization (2)
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other) noexcept {
+    constexpr __movable_box& operator=(__movable_box const& __other) noexcept {
       static_assert(is_nothrow_copy_constructible_v<_Tp>);
       if (this != std::addressof(__other)) {
         std::destroy_at(std::addressof(__val_));
         std::construct_at(std::addressof(__val_), __other.__val_);
       }
       return *this;
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
+    constexpr __movable_box& operator=(__movable_box&& __other) noexcept {
       static_assert(is_nothrow_move_constructible_v<_Tp>);
       if (this != std::addressof(__other)) {
         std::destroy_at(std::addressof(__val_));
         std::construct_at(std::addressof(__val_), std::move(__other.__val_));
       }
       return *this;
     }
 

libcxx/include/__ranges/drop_while_view.h

if constexpr (_UseCache) {
       return ranges::find_if_not(__base_, std::cref(*__pred_));
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr auto end() { return ranges::end(__base_); }
 
 private:
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
   static constexpr bool _UseCache = forward_range<_View>;
   using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
   _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 };
 
 template <class _View, class _Pred>
 inline constexpr bool enable_borrowed_range<drop_while_view<_View, _Pred>> = enable_borrowed_range<_View>;

libcxx/include/__ranges/filter_view.h

 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
   template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
     requires view<_View> && is_object_v<_Pred>
   class filter_view : public view_interface<filter_view<_View, _Pred>> {
     _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-    _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+    _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
     // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
     // the underlying range is at least a forward_range.
     static constexpr bool _UseCache = forward_range<_View>;
     using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
     _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 
     class __iterator;

libcxx/include/__ranges/single_view.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<copy_constructible _Tp>
+  template<move_constructible _Tp>
     requires is_object_v<_Tp>
   class single_view : public view_interface<single_view<_Tp>> {
-    __copyable_box<_Tp> __value_;
+    __movable_box<_Tp> __value_;
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     single_view() requires default_initializable<_Tp> = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(const _Tp& __t) : __value_(in_place, __t) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(const _Tp& __t)
+      requires copy_constructible<_Tp>
+        : __value_(in_place, __t) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
 
     template<class... _Args>
       requires constructible_from<_Tp, _Args...>
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit single_view(in_place_t, _Args&&... __args)

libcxx/include/__ranges/take_while_view.h

 
 template <view _View, class _Pred>
   requires input_range<_View> && is_object_v<_Pred> && indirect_unary_predicate<const _Pred, iterator_t<_View>>
 class take_while_view : public view_interface<take_while_view<_View, _Pred>> {
   template <bool>
   class __sentinel;
 
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI take_while_view()
     requires default_initializable<_View> && default_initializable<_Pred>
   = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_while_view(_View __base, _Pred __pred)
       : __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}

libcxx/include/__ranges/transform_view.h

concept __regular_invocable_with_range_ref =
   regular_invocable<_Fn, range_reference_t<_View>>;
 
 template<class _View, class _Fn>
 concept __transform_view_constraints =
   view<_View> && is_object_v<_Fn> &&
   regular_invocable<_Fn&, range_reference_t<_View>> &&
   __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
 
-template<input_range _View, copy_constructible _Fn>
+template<input_range _View, move_constructible _Fn>
   requires __transform_view_constraints<_View, _Fn>
 class transform_view : public view_interface<transform_view<_View, _Fn>> {
   template<bool> class __iterator;
   template<bool> class __sentinel;
 
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Fn> __func_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __func_;
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   transform_view()
     requires default_initializable<_View> && default_initializable<_Fn> = default;
 
   _LIBCPP_HIDE_FROM_ABI
conditional_t<
       derived_from<_Cat, contiguous_iterator_tag>,
       random_access_iterator_tag,
       _Cat
     >,
     input_iterator_tag
   >;
 };
 
-template<input_range _View, copy_constructible _Fn>
+template<input_range _View, move_constructible _Fn>
   requires __transform_view_constraints<_View, _Fn>
 template<bool _Const>
 class transform_view<_View, _Fn>::__iterator
   : public __transform_view_iterator_category_base<_View, _Fn> {
 
   using _Parent = __maybe_const<_Const, transform_view>;
   using _Base = __maybe_const<_Const, _View>;
 
public:
   {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
       return std::move(*__i);
     else
       return *__i;
   }
 };
 
-template<input_range _View, copy_constructible _Fn>
+template<input_range _View, move_constructible _Fn>
   requires __transform_view_constraints<_View, _Fn>
 template<bool _Const>
 class transform_view<_View, _Fn>::__sentinel {
   using _Parent = __maybe_const<_Const, transform_view>;
   using _Base = __maybe_const<_Const, _View>;
 
   sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 

libcxx/include/version

 __cpp_lib_not_fn                                        201603L <functional>
 __cpp_lib_null_iterators                                201304L <iterator>
 __cpp_lib_optional                                      202110L <optional>
                                                         201606L // C++17
 __cpp_lib_out_ptr                                       202106L <memory>
 __cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric>
 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
-__cpp_lib_ranges                                        202106L <algorithm> <functional> <iterator>
+__cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>

 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
 # define __cpp_lib_move_iterator_concept                202207L
 # define __cpp_lib_polymorphic_allocator                201902L
-# define __cpp_lib_ranges                               202106L
+# define __cpp_lib_ranges                               202207L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/arrow.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
 
 // T* <copyable-box>::operator->()
 // const T* <copyable-box>::operator->() const
 
 #include <ranges>
 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>
 constexpr void check() {
   // non-const version
   {
-    std::ranges::__copyable_box<T> x(std::in_place, 10);
+    std::ranges::__movable_box<T> x(std::in_place, 10);
     T* result = x.operator->();
     static_assert(noexcept(x.operator->()));
     assert(result->value == 10);
     assert(x->value == 10);
   }
 
   // const version
   {
-    std::ranges::__copyable_box<T> const x(std::in_place, 10);
+    std::ranges::__movable_box<T> const x(std::in_place, 10);
     const T* result = x.operator->();
     static_assert(noexcept(x.operator->()));
     assert(result->value == 10);
     assert(x->value == 10);
   }
 }
 
 constexpr bool test() {

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/assign.copy.pass.cpp

 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
+    using Box = std::ranges::__movable_box<CopyConstructible>;
     static_assert( std::is_copy_assignable_v<Box>);
     static_assert(!std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
// check self-assignment
       assert(&result == &x);
       assert(x.__has_value());
       assert((*x).value == 5);
     }
   }
 
   // Test optimization #1 for copy-assignment
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
+    using Box = std::ranges::__movable_box<Copyable>;
     static_assert( std::is_copy_assignable_v<Box>);
     static_assert(!std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_copy_assign);
     }
   }
 
   // Test optimization #2 for copy-assignment
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     static_assert(std::is_copy_assignable_v<Box>);
     static_assert(std::is_nothrow_copy_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box const y(std::in_place, 10);
       Box& result = (x = y);
 
constexpr bool test() {
 
   return true;
 }
 
 // Tests for the empty state. Those can't be constexpr, since they are only reached
 // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
 void test_empty_state() {
-  using Box = std::ranges::__copyable_box<ThrowsOnCopy>;
+  using Box = std::ranges::__movable_box<ThrowsOnCopy>;
 
   // assign non-empty to empty
   {
     Box x = create_empty_box();
     Box const y(std::in_place, 10);
     Box& result = (x = y);
 
     assert(&result == &x);

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/assign.move.pass.cpp

 #include <utility> // in_place_t
 
 #include "test_macros.h"
 #include "types.h"
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
+    using Box = std::ranges::__movable_box<CopyConstructible>;
     static_assert( std::is_move_assignable_v<Box>);
     static_assert(!std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
// check self-assignment
       assert(&result == &x);
       assert(x.__has_value());
       assert((*x).value == 5);
     }
   }
 
   // Make sure that we use the native move assignment in the primary template if we can.
   {
-    using Box = std::ranges::__copyable_box<CopyConstructibleMovable>;
+    using Box = std::ranges::__movable_box<CopyConstructibleMovable>;
     static_assert(std::is_move_assignable_v<Box>);
     static_assert(std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<CopyConstructibleMovable>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
// check self-assignment
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #1 for move assignment
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
+    using Box = std::ranges::__movable_box<Copyable>;
     static_assert( std::is_move_assignable_v<Box>);
     static_assert(!std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #1 for move assignment with a type that uses optimization #2 for copy assignment
   {
-    using Box = std::ranges::__copyable_box<MovableNothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<MovableNothrowCopyConstructible>;
     static_assert(std::is_move_assignable_v<Box>);
     static_assert(std::is_nothrow_move_assignable_v<Box> == std::is_nothrow_move_assignable_v<MovableNothrowCopyConstructible>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
// check self-assignment (should use the underlying type's assignment too)
       assert(x.__has_value());
       assert((*x).value == 5);
       assert((*x).did_move_assign);
     }
   }
 
   // Test optimization #2 for move assignment
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     static_assert(std::is_move_assignable_v<Box>);
     static_assert(std::is_nothrow_move_assignable_v<Box>);
 
     {
       Box x(std::in_place, 5);
       Box y(std::in_place, 10);
       Box& result = (x = std::move(y));
 
constexpr bool test() {
 
   return true;
 }
 
 // Tests for the empty state. Those can't be constexpr, since they are only reached
 // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
 void test_empty_state() {
-  using Box = std::ranges::__copyable_box<ThrowsOnCopy>;
+  using Box = std::ranges::__movable_box<ThrowsOnCopy>;
 
   // assign non-empty to empty
   {
     Box x = create_empty_box();
     Box y(std::in_place, 10);
     Box& result = (x = std::move(y));
 
     assert(&result == &x);

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/ctor.default.pass.cpp

 
 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>
-using Box = std::ranges::__copyable_box<T>;
+using Box = std::ranges::__movable_box<T>;
 
 struct NoDefault {
   NoDefault() = delete;
 };
 static_assert(!std::is_default_constructible_v<Box<NoDefault>>);
 
 template<bool Noexcept>
 struct DefaultNoexcept {

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/ctor.in_place.pass.cpp

 template<bool Noexcept>
 struct NothrowConstructible {
   explicit NothrowConstructible(int) noexcept(Noexcept);
 };
 
 constexpr bool test() {
   // Test the primary template
   {
-    using Box = std::ranges::__copyable_box<CopyConstructible>;
+    using Box = std::ranges::__movable_box<CopyConstructible>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
   // Test optimization #1
   {
-    using Box = std::ranges::__copyable_box<Copyable>;
+    using Box = std::ranges::__movable_box<Copyable>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
   // Test optimization #2
   {
-    using Box = std::ranges::__copyable_box<NothrowCopyConstructible>;
+    using Box = std::ranges::__movable_box<NothrowCopyConstructible>;
     Box x(std::in_place, 5);
     assert((*x).value == 5);
 
     static_assert(!std::is_constructible_v<Box, std::in_place_t, UnknownType>);
   }
 
-  static_assert( std::is_nothrow_constructible_v<std::ranges::__copyable_box<NothrowConstructible<true>>, std::in_place_t, int>);
-  static_assert(!std::is_nothrow_constructible_v<std::ranges::__copyable_box<NothrowConstructible<false>>, std::in_place_t, int>);
+  static_assert( std::is_nothrow_constructible_v<std::ranges::__movable_box<NothrowConstructible<true>>, std::in_place_t, int>);
+  static_assert(!std::is_nothrow_constructible_v<std::ranges::__movable_box<NothrowConstructible<false>>, std::in_place_t, int>);
 
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/deref.pass.cpp

 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>
 constexpr void check() {
   // non-const version
   {
-    std::ranges::__copyable_box<T> x(std::in_place, 10);
+    std::ranges::__movable_box<T> x(std::in_place, 10);
     T& result = *x;
     static_assert(noexcept(*x));
     assert(result.value == 10);
   }
 
   // const version
   {
-    std::ranges::__copyable_box<T> const x(std::in_place, 10);
+    std::ranges::__movable_box<T> const x(std::in_place, 10);
     T const& result = *x;
     static_assert(noexcept(*x));
     assert(result.value == 10);
   }
 }
 
 constexpr bool test() {
   check<CopyConstructible>(); // primary template

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/has_value.pass.cpp

 #include <cassert>
 #include <type_traits>
 #include <utility> // in_place_t
 
 #include "types.h"
 
 template<class T>
 constexpr void check() {
-  std::ranges::__copyable_box<T> const x(std::in_place, 10);
+  std::ranges::__movable_box<T> const x(std::in_place, 10);
   assert(x.__has_value());
 }
 
 constexpr bool test() {
   check<CopyConstructible>(); // primary template
   check<Copyable>(); // optimization #1
   check<NothrowCopyConstructible>(); // optimization #2
   return true;
 }
 
 int main(int, char**) {
   assert(test());
   static_assert(test());
 
   // Tests for the empty state. Those can't be constexpr, since they are only reached
   // through throwing an exception.
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
   {
-    std::ranges::__copyable_box<ThrowsOnCopy> x = create_empty_box();
+    std::ranges::__movable_box<ThrowsOnCopy> x = create_empty_box();
     assert(!x.__has_value());
   }
 #endif
 
   return 0;
 }

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/no_unique_address.pass.cpp

 struct Empty {
   Empty() noexcept { }
   Empty(Empty const&) noexcept { copied = true; }
   Empty(Empty&&) noexcept { moved = true; }
   Empty& operator=(Empty const&) = delete;
   Empty& operator=(Empty&&) = delete;
 };
 
-using Box = std::ranges::__copyable_box<Empty>;
+using Box = std::ranges::__movable_box<Empty>;
 
 struct Inherit : Box { };
 
 struct Hold : Box {
   [[no_unique_address]] Inherit member;
 };
 
 int main(int, char**) {

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/properties.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
 
 // Test various properties of <copyable-box>
 
 #include <ranges>
 
 #include <optional>
 
+#include "MoveOnly.h"
 #include "types.h"
 
 template <class T>
-constexpr bool valid_copyable_box = requires {
-  typename std::ranges::__copyable_box<T>;
+constexpr bool valid_movable_box = requires {
+  typename std::ranges::__movable_box<T>;
 };
 
 struct NotCopyConstructible {
   NotCopyConstructible() = default;
   NotCopyConstructible(NotCopyConstructible&&) = default;
   NotCopyConstructible(NotCopyConstructible const&) = delete;
   NotCopyConstructible& operator=(NotCopyConstructible&&) = default;
   NotCopyConstructible& operator=(NotCopyConstructible const&) = default;
 };
 
-static_assert(!valid_copyable_box<void>); // not an object type
-static_assert(!valid_copyable_box<int&>); // not an object type
-static_assert(!valid_copyable_box<NotCopyConstructible>);
+struct NotCopyConstructibleNotMoveConstructible {
+  NotCopyConstructibleNotMoveConstructible() = default;
+  NotCopyConstructibleNotMoveConstructible(NotCopyConstructibleNotMoveConstructible&&) = delete;
+  NotCopyConstructibleNotMoveConstructible(NotCopyConstructibleNotMoveConstructible const&) = delete;
+  NotCopyConstructibleNotMoveConstructible& operator=(NotCopyConstructibleNotMoveConstructible&&) = delete;
+  NotCopyConstructibleNotMoveConstructible& operator=(NotCopyConstructibleNotMoveConstructible const&) = delete;
+};
+
+static_assert(!valid_movable_box<void>); // not an object type
+static_assert(!valid_movable_box<int&>); // not an object type
+static_assert(!valid_movable_box<NotCopyConstructibleNotMoveConstructible>);
+static_assert(valid_movable_box<NotCopyConstructible>);
+
+// [P2494R2] Relaxing range adaptors to allow for move only types.
+static_assert(valid_movable_box<MoveOnly>);
 
 // primary template
-static_assert(sizeof(std::ranges::__copyable_box<CopyConstructible>) == sizeof(std::optional<CopyConstructible>));
+static_assert(sizeof(std::ranges::__movable_box<CopyConstructible>) == sizeof(std::optional<CopyConstructible>));
 
 // optimization #1
-static_assert(sizeof(std::ranges::__copyable_box<Copyable>) == sizeof(Copyable));
-static_assert(alignof(std::ranges::__copyable_box<Copyable>) == alignof(Copyable));
+static_assert(sizeof(std::ranges::__movable_box<Copyable>) == sizeof(Copyable));
+static_assert(alignof(std::ranges::__movable_box<Copyable>) == alignof(Copyable));
 
 // optimization #2
-static_assert(sizeof(std::ranges::__copyable_box<NothrowCopyConstructible>) == sizeof(NothrowCopyConstructible));
-static_assert(alignof(std::ranges::__copyable_box<NothrowCopyConstructible>) == alignof(NothrowCopyConstructible));
+static_assert(sizeof(std::ranges::__movable_box<NothrowCopyConstructible>) == sizeof(NothrowCopyConstructible));
+static_assert(alignof(std::ranges::__movable_box<NothrowCopyConstructible>) == alignof(NothrowCopyConstructible));

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

 
 #include <ranges>
 #include <cassert>
 #include <concepts>
 #include <type_traits>
 
 #include "test_macros.h"
 
-// NOTE: These types are strongly tied to the implementation of __copyable_box. See the documentation
-//       in __copyable_box for the meaning of optimizations #1 and #2.
+// NOTE: These types are strongly tied to the implementation of __movable_box. See the documentation
+//       in __movable_box for the meaning of optimizations #1 and #2.
 
 // Copy constructible, but neither copyable nor nothrow_copy/move_constructible. This uses the primary template.
 struct CopyConstructible {
   constexpr CopyConstructible() = default;
   constexpr explicit CopyConstructible(int x) : value(x) { }
   CopyConstructible(CopyConstructible const&) noexcept(false) = default;
   CopyConstructible& operator=(CopyConstructible const&) = delete;
 
struct ThrowsOnCopy {
   ThrowsOnCopy& operator=(ThrowsOnCopy const&) = delete; // prevent from being copyable
 
   int value = -1;
 };
 
 // Creates an empty box. The only way to do that is to try assigning one box
 // to another and have that fail due to an exception when calling the copy
 // constructor. The assigned-to box will then be in the empty state.
-inline std::ranges::__copyable_box<ThrowsOnCopy> create_empty_box() {
-  std::ranges::__copyable_box<ThrowsOnCopy> box1;
-  std::ranges::__copyable_box<ThrowsOnCopy> box2(std::in_place, THROW_WHEN_COPIED_FROM);
+inline std::ranges::__movable_box<ThrowsOnCopy> create_empty_box() {
+  std::ranges::__movable_box<ThrowsOnCopy> box1;
+  std::ranges::__movable_box<ThrowsOnCopy> box2(std::in_place, THROW_WHEN_COPIED_FROM);
   try {
     box1 = box2; // throws during assignment, which is implemented as a call to the copy ctor
   } catch (...) {
     // now, box1 is empty
     assert(!box1.__has_value());
     return box1;
   }
   assert(false && "should never be reached");
   return box1; // to silence warning about missing return in non-void function
 }
 #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
 
 #endif // TEST_LIBCXX_RANGES_RANGE_ADAPTORS_RANGE_COPY_WRAP_TYPES_H

libcxx/test/std/language.support/support.limits/support.limits.general/algorithm.version.compile.pass.cpp

 // <algorithm>
 
 // Test the feature test macros defined by <algorithm>
 
 /*  Constant                                 Value
     __cpp_lib_clamp                          201603L [C++17]
     __cpp_lib_constexpr_algorithms           201806L [C++20]
     __cpp_lib_parallel_algorithm             201603L [C++17]
-    __cpp_lib_ranges                         202106L [C++20]
+    __cpp_lib_ranges                         202207L [C++20]
     __cpp_lib_ranges_starts_ends_with        202106L [C++23]
     __cpp_lib_robust_nonmodifying_seq_ops    201304L [C++14]
     __cpp_lib_sample                         201603L [C++17]
     __cpp_lib_shift                          201806L [C++20]
 */
 
 #include <algorithm>
 #include "test_macros.h"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_starts_ends_with
 #   error "__cpp_lib_ranges_starts_ends_with should not be defined before c++23"
 # endif
 
 # ifndef __cpp_lib_robust_nonmodifying_seq_ops
 #   error "__cpp_lib_robust_nonmodifying_seq_ops should be defined in c++20"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_starts_ends_with
 #     error "__cpp_lib_ranges_starts_ends_with should be defined in c++23"
 #   endif
 #   if __cpp_lib_ranges_starts_ends_with != 202106L
 #     error "__cpp_lib_ranges_starts_ends_with should have the value 202106L in c++23"

 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_ranges_starts_ends_with
 #     error "__cpp_lib_ranges_starts_ends_with should be defined in c++26"
 #   endif
 #   if __cpp_lib_ranges_starts_ends_with != 202106L
 #     error "__cpp_lib_ranges_starts_ends_with should have the value 202106L in c++26"

libcxx/test/std/language.support/support.limits/support.limits.general/functional.version.compile.pass.cpp

/*  Constant                           Value
     __cpp_lib_bind_back                202202L [C++23]
     __cpp_lib_bind_front               201907L [C++20]
     __cpp_lib_boyer_moore_searcher     201603L [C++17]
     __cpp_lib_constexpr_functional     201907L [C++20]
     __cpp_lib_invoke                   201411L [C++17]
     __cpp_lib_invoke_r                 202106L [C++23]
     __cpp_lib_move_only_function       202110L [C++23]
     __cpp_lib_not_fn                   201603L [C++17]
-    __cpp_lib_ranges                   202106L [C++20]
+    __cpp_lib_ranges                   202207L [C++20]
     __cpp_lib_result_of_sfinae         201210L [C++14]
     __cpp_lib_transparent_operators    201210L [C++14]
                                        201510L [C++17]
     __cpp_lib_unwrap_ref               201811L [C++20]
 */
 
 #include <functional>
 #include "test_macros.h"

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++20"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++20"
 # endif

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++23"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++23"
 # endif

 # endif
 # if __cpp_lib_not_fn != 201603L
 #   error "__cpp_lib_not_fn should have the value 201603L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_result_of_sfinae
 #   error "__cpp_lib_result_of_sfinae should be defined in c++26"
 # endif
 # if __cpp_lib_result_of_sfinae != 201210L
 #   error "__cpp_lib_result_of_sfinae should have the value 201210L in c++26"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.compile.pass.cpp

 /*  Constant                                Value
     __cpp_lib_array_constexpr               201603L [C++17]
                                             201811L [C++20]
     __cpp_lib_constexpr_iterator            201811L [C++20]
     __cpp_lib_make_reverse_iterator         201402L [C++14]
     __cpp_lib_move_iterator_concept         202207L [C++20]
     __cpp_lib_nonmember_container_access    201411L [C++17]
     __cpp_lib_null_iterators                201304L [C++14]
-    __cpp_lib_ranges                        202106L [C++20]
+    __cpp_lib_ranges                        202207L [C++20]
     __cpp_lib_ssize                         201902L [C++20]
 */
 
 #include <iterator>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++20"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++20"
 # endif

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++23"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++23"
 # endif

 # endif
 # if __cpp_lib_null_iterators != 201304L
 #   error "__cpp_lib_null_iterators should have the value 201304L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ssize
 #   error "__cpp_lib_ssize should be defined in c++26"
 # endif
 # if __cpp_lib_ssize != 201902L
 #   error "__cpp_lib_ssize should have the value 201902L in c++26"
 # endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.compile.pass.cpp

/*  Constant                                      Value
     __cpp_lib_assume_aligned                      201811L [C++20]
     __cpp_lib_atomic_value_initialization         201911L [C++20]
     __cpp_lib_constexpr_dynamic_alloc             201907L [C++20]
     __cpp_lib_constexpr_memory                    201811L [C++20]
                                                   202202L [C++23]
     __cpp_lib_enable_shared_from_this             201603L [C++17]
     __cpp_lib_make_unique                         201304L [C++14]
     __cpp_lib_out_ptr                             202106L [C++23]
-    __cpp_lib_ranges                              202106L [C++20]
+    __cpp_lib_ranges                              202207L [C++20]
     __cpp_lib_raw_memory_algorithms               201606L [C++17]
     __cpp_lib_shared_ptr_arrays                   201611L [C++17]
                                                   201707L [C++20]
     __cpp_lib_shared_ptr_weak_type                201606L [C++17]
     __cpp_lib_smart_ptr_for_overwrite             202002L [C++20]
     __cpp_lib_to_address                          201711L [C++20]
     __cpp_lib_transparent_operators               201210L [C++14]
                                                   201510L [C++17]

 
 # ifdef __cpp_lib_out_ptr
 #   error "__cpp_lib_out_ptr should not be defined before c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++20"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++20"
 # endif

 #   ifdef __cpp_lib_out_ptr
 #     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++23"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++23"
 # endif

 #   ifdef __cpp_lib_out_ptr
 #     error "__cpp_lib_out_ptr should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_raw_memory_algorithms
 #   error "__cpp_lib_raw_memory_algorithms should be defined in c++26"
 # endif
 # if __cpp_lib_raw_memory_algorithms != 201606L
 #   error "__cpp_lib_raw_memory_algorithms should have the value 201606L in c++26"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/ranges.version.compile.pass.cpp

 //
 // clang-format off
 
 // <ranges>
 
 // Test the feature test macros defined by <ranges>
 
 /*  Constant                      Value
-    __cpp_lib_ranges              202106L [C++20]
+    __cpp_lib_ranges              202207L [C++20]
     __cpp_lib_ranges_as_rvalue    202207L [C++23]
     __cpp_lib_ranges_chunk        202202L [C++23]
     __cpp_lib_ranges_chunk_by     202202L [C++23]
     __cpp_lib_ranges_join_with    202202L [C++23]
     __cpp_lib_ranges_slide        202202L [C++23]
     __cpp_lib_ranges_zip          202110L [C++23]
 */
 

 #   error "__cpp_lib_ranges_zip should not be defined before c++23"
 # endif
 
 #elif TEST_STD_VER == 20
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"

 #   error "__cpp_lib_ranges_zip should not be defined before c++23"
 # endif
 
 #elif TEST_STD_VER == 23
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++23"
 # endif

 #   endif
 # endif
 
 #elif TEST_STD_VER > 23
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++26"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

/*  Constant                                       Value
     __cpp_lib_not_fn                               201603L [C++17]
     __cpp_lib_null_iterators                       201304L [C++14]
     __cpp_lib_optional                             201606L [C++17]
                                                    202110L [C++23]
     __cpp_lib_out_ptr                              202106L [C++23]
     __cpp_lib_parallel_algorithm                   201603L [C++17]
     __cpp_lib_polymorphic_allocator                201902L [C++20]
     __cpp_lib_quoted_string_io                     201304L [C++14]
-    __cpp_lib_ranges                               202106L [C++20]
+    __cpp_lib_ranges                               202207L [C++20]
     __cpp_lib_ranges_as_rvalue                     202207L [C++23]
     __cpp_lib_ranges_chunk                         202202L [C++23]
     __cpp_lib_ranges_chunk_by                      202202L [C++23]
     __cpp_lib_ranges_iota                          202202L [C++23]
     __cpp_lib_ranges_join_with                     202202L [C++23]
     __cpp_lib_ranges_slide                         202202L [C++23]
     __cpp_lib_ranges_starts_ends_with              202106L [C++23]
     __cpp_lib_ranges_to_container                  202202L [C++23]

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++20"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++20"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++20"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++20"
 # endif
 
 # ifdef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should not be defined before c++23"
 # endif
 
 # ifdef __cpp_lib_ranges_chunk
 #   error "__cpp_lib_ranges_chunk should not be defined before c++23"

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++23"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++23"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++23"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++23"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++23"
 # endif

 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges
 #   error "__cpp_lib_ranges should be defined in c++26"
 # endif
-# if __cpp_lib_ranges != 202106L
-#   error "__cpp_lib_ranges should have the value 202106L in c++26"
+# if __cpp_lib_ranges != 202207L
+#   error "__cpp_lib_ranges should have the value 202207L in c++26"
 # endif
 
 # ifndef __cpp_lib_ranges_as_rvalue
 #   error "__cpp_lib_ranges_as_rvalue should be defined in c++26"
 # endif
 # if __cpp_lib_ranges_as_rvalue != 202207L
 #   error "__cpp_lib_ranges_as_rvalue should have the value 202207L in c++26"
 # endif

libcxx/test/std/ranges/range.adaptors/range.filter/constraints.compile.pass.cpp

 
 #include <ranges>
 
 #include <concepts>
 #include <cstddef>
 #include <iterator>
 #include <type_traits>
 
+#include "MoveOnly.h"
+
 template <class View, class Pred>
 concept can_form_filter_view = requires {
   typename std::ranges::filter_view<View, Pred>;
 };
 
 // filter_view is not valid when the view is not an input_range
 namespace test1 {
   struct View : std::ranges::view_base {

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

 #include <cctype>
 #include <functional>
 #include <list>
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include <cassert>
+#include "MoveOnly.h"
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "types.h"
 
 template<class T, class F>
 concept ValidTransformView = requires { typename std::ranges::transform_view<T, F>; };
 
 struct BadFunction { };

 template<class E1, class E2, std::size_t N, class Join = std::plus<E1>>
 auto joinArrays(E1 (&a)[N], E2 (&b)[N], Join join = Join()) {
   return std::ranges::transform_view(a, [&a, &b, join](auto& x) {
     auto idx = (&x) - a;
     return join(x, b[idx]);
   });
 }
 
+struct MoveOnlyFunction : public MoveOnly {
+  template <class T>
+  constexpr T operator()(T x) const { return x + 42; }
+};
+
 struct NonConstView : std::ranges::view_base {
   explicit NonConstView(int *b, int *e) : b_(b), e_(e) {}
   const int *begin() { return b_; }  // deliberately non-const
   const int *end() { return e_; }    // deliberately non-const
   const int *b_;
   const int *e_;
 };
 
int main(int, char**) {
 
   {
     std::string_view str = "Hello, World.";
     auto upp = toUpper(str);
     std::string_view check = "HELLO, WORLD.";
     assert(std::equal(upp.begin(), upp.end(), check.begin(), check.end()));
   }
 
+  // [P2494R2] Relaxing range adaptors to allow for move only types.
+  // Test transform_view is valid when the function object is a move only type.
+  {
+    int a[] = {1, 2, 3, 4};
+    auto transformed = NonConstView(a, a + 4) | std::views::transform(MoveOnlyFunction());
+    int expected[4] = {43, 44, 45, 46};
+    assert(std::equal(transformed.begin(), transformed.end(), expected, expected + 4));
+  }
+
   return 0;
 }

libcxx/test/std/ranges/range.factories/range.single.view/cpo.pass.cpp

 
 #include <cassert>
 #include <concepts>
 #include <utility>
 #include "MoveOnly.h"
 
 // Can't invoke without arguments.
 static_assert(!std::is_invocable_v<decltype((std::views::single))>);
-// Can't invoke with a move-only type.
-static_assert(!std::is_invocable_v<decltype((std::views::single)), MoveOnly>);
+
+// Can invoke with a move-only type.
+static_assert(std::is_invocable_v<decltype((std::views::single)), MoveOnly>);
 
 constexpr bool test() {
   // Lvalue.
   {
     int x = 42;
     std::same_as<std::ranges::single_view<int>> decltype(auto) v = std::views::single(x);
     assert(v.size() == 1);
     assert(v.front() == x);

libcxx/utils/generate_feature_test_macro_components.py

for x in [
         },
         {
             "name": "__cpp_lib_quoted_string_io",
             "values": {"c++14": 201304},
             "headers": ["iomanip"],
         },
         {
             "name": "__cpp_lib_ranges",
-            "values": {"c++20": 202106},
+            "values": {"c++20": 202207},
             "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],
         },
         {
             "name": "__cpp_lib_ranges_as_rvalue",
             "values": {"c++23": 202207},
             "headers": ["ranges"],
         },
         {