[libc++] Implement ranges::copy{, _n, _if, _backward}

[philnik]

• Try to fix CI

[philnik]

• Try to fix GCC

[Mordante]

In general looks good, several small issues.

libcxx/include/__algorithm/copy.h

84

Do we need to have an additional specialization? where

__enable_if_t<is_copy_constructible<_InIter>::value
             && is_copy_constructible<_Sent>::value
             && !is_copy_constructible<_OutIter>::value> >

Just to make sure that a copy of a std::string to a non-copyable output iterator is still unwrapped.
This is will be used in std::format.

libcxx/include/__algorithm/copy_backward.h

56

Did you have a look at the codegen for this change?

libcxx/include/__algorithm/ranges_copy.h

34

_InIter and _OutIter for consistency?

libcxx/include/__algorithm/ranges_copy_backward.h

32

:-) Happy you didn't follow the wording in the Standard.

38

I would suggest to use _Ip and _Op or change the copy_backward_result above.
In general this naming doesn't seem to use the new slightly longer names.

libcxx/include/__algorithm/ranges_copy_if.h

50

The original is correct, but this is closer to the wording of the Standard.

libcxx/include/algorithm

88

Are the copy*result types already in the synopsis?

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/ranges_copy.module.verify.cpp

1 ↗

(On Diff #420109)

These files will no longer be needed after D123028.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp

161

Seems a copy paste.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

14

Please add the synopsis.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_if.pass.cpp

113

Please count the number of invocations the predicated, same for the projection below.

151

I would like to see tests for cpp20_output_iterator.

[var-const]

libcxx/include/__algorithm/copy.h

39–79

Hmm, if I'm reading this correctly, the previous condition supported copying from const T* to T*, whereas the new condition only supports T* to T*. Am I missing something?

44

Can you please add a comment to explain the GCC workaround?

51

Question: what's the advantage of using __builtin_memmove directly?

56

Question: what's the reason to change from _LIBCPP_CONSTEXPR_AFTER_CXX17 to _LIBCPP_CONSTEXPR_AFTER_CXX11?

58

Question: can this simply return std::__copy_impl ...?

95

Nit: move?

libcxx/include/__algorithm/ranges_copy.h

33

Nit: this should probably use longer names.

libcxx/include/__algorithm/ranges_copy_backward.h

38

Nit: looks like these need to be renamed to something like Iter1 or InIter.

42

Nit: move the arguments? (for consistency with ranges_copy.h)

libcxx/include/__algorithm/ranges_copy_if.h

44

Question: why doesn't this algorithm delegate to the non-ranges version (is it to avoid having to deal with the projection)?

libcxx/include/__algorithm/ranges_copy_n.h

27

Nit: there's an extra blank line here (2 in a row).

libcxx/include/algorithm

109

ranges::copy_backward seems to be missing.

[var-const]

libcxx/include/__algorithm/copy.h

88

Question: any reason not to use make_pair?

libcxx/include/__algorithm/copy_backward.h

29

Optional: make_reverse_iterator to omit the type?

38

Optional: I think it would be more readable to create another variable for __result_first or similar instead of calculating it on the fly below.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp

179

Nit: in most of these tests, the ranges version goes after the iterator version.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

26

Nit: for consistency, s/HasCopyIt/HasCopyBackwardIt (throughout the file).

51

I think the current tests always use trivially copyable values -- can we add at least one test case where values are not trivially copyable?

155

Optional: s/next/prev/?

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_if.pass.cpp

115

Nit: can you please add a few more even elements to the array? Currently, only the contiguous range in the beginning matches, which is a bit of a special case. Ideally, the matching elements should be more dispersed.

116

I'd suggest making this array as large as in and relying on the return value to make sure only two elements are copied. Otherwise, it's not clear if the implementation would stop at two elements if the output array was larger.

163

Check the range version as well?

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_n.pass.cpp

99

Question: should this algorithm also check the order in which the elements are copied? (same with copy_if.pass.cpp)

[philnik]

• Address comments

libcxx/include/__algorithm/copy.h

39–79

No, I missed something. I thought the old version said is_same<remove_const<_Tp>::type, _Tp>, which is obviously just is_const.

51

I can't use std::memmove in a constant expression and using __builtin_memmove costs a lot less steps (https://godbolt.org/z/nqb75KGa3).

56

AFAIK the general style is to use the earliest constexpr possible for internal stuff.

84

What would you expect to change between it being wrapped and not? It's not like we can optimize that in any way.

88

I didn't know std::make_pair existed. Thanks!

95

This patch exists in part because we want to avoid this exact extension, so no - this should definitely not be moved. See D122074.

libcxx/include/__algorithm/copy_backward.h

56

What change are you asking for exactly? The change from std::memmove to __builtin_memmove?

libcxx/include/__algorithm/ranges_copy_if.h

44

Why would it? It's a really simple algorithm and has no pitfalls AFAIK.

50

The problem is that your version isn't correct. _Sent doesn't have to be the same type as _InIter.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

51

CopyOnce and OnlyBackwardsCopyable aren't trivial.

155

I thought of it as 'the next copyable value'. I'd rather keep it as-is.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_if.pass.cpp

116

I'd argue that it should be exact. std::ranges::copy_if can't know the size of the range it gets passed, and if it would try to write to more elements than are available this will error during constant evaluation. i.e. an implementation could *(out + 1) = *in and you suggestion wouldn't catch that, while making the array wit the exact size would.

151

I'll do that as soon as you land D122072.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_n.pass.cpp

99

for copy_if and copy_n it isn't specified in which order the elements are copied.

[philnik]

• Remove std::make_reverse_iterator again

libcxx/include/__algorithm/copy_backward.h

29

This isn't available in C++03 and C++11.

[var-const]

libcxx/include/__algorithm/copy.h

44

Sorry about nitpicking, but reading the comment, I think it would be better phrased as a TODO (something like Remove this workaround once GCC supports using __builtin_memmove in constexpr contexts).

libcxx/include/__algorithm/ranges_copy_if.h

44

I don't disagree -- I'm just wondering because it's inconsistent with what ranges::copy does, which is to delegate.

libcxx/include/algorithm

59–60

Hmm, looks accidentally deleted?

196–197

Looks accidentally deleted?

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

51

Yes, but those tests are focused on checking something else. I'd prefer to have a dedicated test for this, even if it's somewhat redundant with the other tests.

[philnik]

libcxx/include/__algorithm/ranges_copy_if.h

44

Yes, because std::copy does a few optimizations and isn't just a simple loop.

libcxx/include/algorithm

59–60

Looks like it, but has nothing to do with this PR. I'll fix it.

196–197

I'll upload a fix.

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

51

What exactly do you want to check just with a non-trivially copyable type? If we do nothing inside the copy constructor/assignment operator there is nothing to check. The implementation could just as well memcpy the whole thing.

[philnik]

• Address comments; try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Try again

[philnik]

• This should fix the CI

[Mordante]

libcxx/include/__algorithm/copy.h

46

Do you know whether this is available in GCC-12?

84

The cpp20 output iterator isn't copy constructible. But std::basic_string<CharT>::iterator can still be unwrapped. So I wondered whether we want an overload for that case. Something like

template <class _InIter, class _Sent, class _OutIter,
           __enable_if_t<is_copy_constructible<_InIter>::value
                      && is_copy_constructible<_Sent>::value> >
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
  pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
  auto __ret = std::__copy_impl(std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::move__result));
  return std::make_pair(std::__rewrap_iter(__first, __ret.first), _ret.second);
}

libcxx/include/__algorithm/copy_backward.h

56

No the removal of this overload. Does that affect the generated code or not.

libcxx/include/__algorithm/ranges_copy_if.h

50

I trusted the wording of the Standard, but it seems that's wrong ;-)
http://eel.is/c++draft/alg.copy#18.2

{last, result + N} for the overloads in namespace ranges.

Do you want to file an LWG issue?

[var-const]

LGTM once the comment about a missing test case is addressed. Thanks a lot for working on this!

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

51

Right, this is one thing to check -- that the implementation doesn't try to memcpy non-trivial types, for example. But really, all I want to check is that the result is correct, not for any particular kind of problem because too many are possible to consider. Just the fact that it would produce the correct result without crashing is a valuable thing to test, even if it appears trivial. Furthermore, tests are written for the future as well. Even if an algorithm is "obviously" trivial and seemingly cannot be incorrect now, it could change in the future.

[philnik]

• Rebased
• Address comments

[philnik]

libcxx/include/__algorithm/copy.h

46

It's not available in GCC trunk.

84

I think the unwrapping is mostly so that we can do a memmove if we have only raw pointers. I don't think that the unwrapping of only part of the iterators makes any difference. The compiler should still be able to see through the wrapper and optimize it away.

libcxx/include/__algorithm/copy_backward.h

56

The codegen is a bit worse, but I doubt it would even be measurable. It's two instructions more. https://godbolt.org/z/Pb7YbnsK3

libcxx/include/__algorithm/ranges_copy_if.h

50

I'm not sure if this is an oversight or if this is expected. Most ranges algorithms return last according to the standard, while in practice they have to return first + N. It's the same with N itself. The standard says last - first, while in practice it would have to be std::distance(first, last).

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.pass.cpp

51

I don't disagree that it's a valuable test. My problem is that the test you propose is a strict subset of what // check that the range is copied backwards tests IIUC. I don't think the test adds any coverage.

[Mordante]

Something went wrong it seems you accidentally replaced this patch with the contents of D120637.

[philnik]

Thanks @Mordante!

[Mordante]

LGTM!

libcxx/include/__algorithm/copy_backward.h

29

What I've done in the past for similar cases is add __make_reverse_iterator and let make_reverse_iterator call that function. Just something to keep in mind, no need to change it now.

libcxx/include/__algorithm/ranges_copy_n.h

56

How do you feel about moving these iterators for consistency?

libcxx/docs/Status/RangesAlgorithms.csv

 Read-only,is_sorted_unitl,Not assigned,n/a,Not started
 Read-only,includes,Not assigned,n/a,Not started
 Read-only,is_heap,Not assigned,n/a,Not started
 Read-only,is_heap_until,Not assigned,n/a,Not started
 Read-only,clamp,Not assigned,n/a,Not started
 Read-only,is_permutation,Not assigned,n/a,Not started
 Read-only,for_each,Not assigned,n/a,Not started
 Read-only,for_each_n,Not assigned,n/a,Not started
-Write,copy,Not assigned,n/a,Not started
-Write,copy_if,Not assigned,n/a,Not started
-Write,copy_n,Not assigned,n/a,Not started
-Write,copy_backward,Not assigned,n/a,Not started
+Write,copy,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
+Write,copy_if,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
+Write,copy_n,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
+Write,copy_backward,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,move,Not assigned,n/a,Not started
 Write,move_backward,Not assigned,n/a,Not started
 Write,fill,Not assigned,n/a,Not started
 Write,fill_n,Not assigned,n/a,Not started
 Write,transform,Nikolas Klauser,`D122173 <https://llvm.org/D122173>`_,✅
 Write,generate,Not assigned,n/a,Not started
 Write,generate_n,Not assigned,n/a,Not started
 Write,remove_copy,Not assigned,n/a,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort.h
   __algorithm/partial_sort_copy.h
   __algorithm/partition.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
+  __algorithm/ranges_copy.h
+  __algorithm/ranges_copy_backward.h
+  __algorithm/ranges_copy_if.h
+  __algorithm/ranges_copy_n.h
   __algorithm/ranges_find.h
   __algorithm/ranges_find_if.h
   __algorithm/ranges_find_if_not.h
   __algorithm/ranges_max.h
   __algorithm/ranges_max_element.h
   __algorithm/ranges_min.h
   __algorithm/ranges_min_element.h
   __algorithm/ranges_mismatch.h

libcxx/include/__algorithm/copy.h

 //===----------------------------------------------------------------------===//
 //
 // 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___ALGORITHM_COPY_H
 #define _LIBCPP___ALGORITHM_COPY_H
 
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #include <cstring>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // copy
 
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_OutputIterator
-__copy_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        *__result = *__first;
-    return __result;
+template <class _InIter, class _Sent, class _OutIter>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_InIter, _OutIter> __copy_impl(_InIter __first, _Sent __last, _OutIter __result) {
+  while (__first != __last) {
+    ++__first;
+    ++__result;
   }
-
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-__copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    return _VSTD::__copy_constexpr(__first, __last, __result);
+  return pair<_InIter, _OutIter>(std::move(__first), std::move(__result));
 }
 
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__copy(_Tp* __first, _Tp* __last, _Up* __result)
-{
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    return __result + __n;
+template <class _InValueT,
+          class _OutValueT,
+          class = __enable_if_t<is_same<typename remove_const<_InValueT>::type, _OutValueT>::value
+                             && is_trivially_copy_assignable<_InValueT>::value> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_InValueT*, _OutValueT*> __copy_impl(_InValueT* __first, _InValueT* __last, _OutValueT* __result) {
+  if (__libcpp_is_constant_evaluated()
+// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
+#ifndef _LIBCPP_COMPILER_GCC
+      && !is_trivially_copyable<_InValueT>::value
+#endif
+     )
+    return std::__copy_impl<_InValueT*, _InValueT*, _OutValueT*>(__first, __last, __result);
+    __builtin_memmove(__result, __first, __n * sizeof(_InValueT));
+  return std::make_pair(__first + __n, __result + __n);
+}
+
+template <class _InValueT,
+          class _OutValueT,
+          class = __enable_if_t<is_same<typename remove_const<_InValueT>::type, _OutValueT>::value
+                             && is_trivially_copy_assignable<_InValueT>::value> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<reverse_iterator<_InValueT*>, reverse_iterator<_OutValueT*> >
+__copy_impl(reverse_iterator<_InValueT*> __first,
+            reverse_iterator<_InValueT*> __last,
+            reverse_iterator<_OutValueT*> __result) {
+  auto __first_base = __first.base();
+  auto __last_base = __last.base();
+  auto __result_base = __result.base();
+  auto __result_first = __result_base - (__first_base - __last_base);
+  std::__copy_impl(__last_base, __first_base, __result_first);
+  return std::make_pair(__last, reverse_iterator<_OutValueT*>(__result_first));
+}
+
+template <class _InIter, class _Sent, class _OutIter>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
+  return std::__copy_impl(std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _InIter, class _Sent, class _OutIter,
+          __enable_if_t<is_copy_constructible<_InIter>::value
+                     && is_copy_constructible<_Sent>::value
+                     && is_copy_constructible<_OutIter>::value> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_InIter, _OutIter> __copy(_InIter __first, _Sent __last, _OutIter __result) {
+  auto __ret = std::__copy_impl(std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result));
+  return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
 }
 
 template <class _InputIterator, class _OutputIterator>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _OutputIterator
-copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    if (__libcpp_is_constant_evaluated()) {
-        return _VSTD::__copy_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__copy(_VSTD::__unwrap_iter(__first),
-                          _VSTD::__unwrap_iter(__last),
-                          _VSTD::__unwrap_iter(__result)));
-    }
+copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+  return std::__copy(__first, __last, __result).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_H

libcxx/include/__algorithm/copy_backward.h

 //===----------------------------------------------------------------------===//
 //
 // 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___ALGORITHM_COPY_BACKWARD_H
 #define _LIBCPP___ALGORITHM_COPY_BACKWARD_H
 
+#include <__algorithm/copy.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <cstring>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_OutputIterator
-__copy_backward_constexpr(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
-{
-    while (__first != __last)
-        *--__result = *--__last;
-    return __result;
-}
-
-template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-__copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
-{
-    return _VSTD::__copy_backward_constexpr(__first, __last, __result);
-}
-
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
-    _Up*
->::type
-__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
-{
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-    {
-        __result -= __n;
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    }
-    return __result;
+template <class _Iter1, class _Sent1, class _Iter2>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_Iter1, _Iter2> __copy_backward_impl(_Iter1 __first, _Sent1 __last, _Iter2 __result) {
+  auto __ret = std::__copy(reverse_iterator<_Iter1>(__last),
+                           reverse_iterator<_Sent1>(__first),
+                           reverse_iterator<_Iter2>(__result));
+  return pair<_Iter1, _Iter2>(__ret.first.base(), __ret.second.base());
+}
+
+template <class _Iter1, class _Sent1, class _Iter2>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_Iter1, _Iter2> __copy_backward(_Iter1 __first, _Sent1 __last, _Iter2 __result) {
+  auto __ret = std::__copy_backward_impl(std::__unwrap_iter(__first),
+                                         std::__unwrap_iter(__last),
+                                         std::__unwrap_iter(__result));
+  return pair<_Iter1, _Iter2>(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
 _BidirectionalIterator2
-copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
-              _BidirectionalIterator2 __result)
-{
-    if (__libcpp_is_constant_evaluated()) {
-        return _VSTD::__copy_backward_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__copy_backward(_VSTD::__unwrap_iter(__first),
-                                   _VSTD::__unwrap_iter(__last),
-                                   _VSTD::__unwrap_iter(__result)));
-    }
+copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) {
+  return std::__copy_backward(__first, __last, __result).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_COPY_BACKWARD_H

libcxx/include/__algorithm/ranges_copy.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_COPY_H
+#define _LIBCPP___ALGORITHM_RANGES_COPY_H
+
+#include <__algorithm/copy.h>
+#include <__algorithm/in_out_result.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__iterator/concepts.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _InIter, class _OutIter>
+using copy_result = in_out_result<_InIter, _OutIter>;
+
+namespace __copy {
+struct __fn {
+
+  template <input_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
+    requires indirectly_copyable<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+    auto __ret = std::__copy(std::move(__first), std::move(__last), std::move(__result));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+
+  template <input_range _Range, weakly_incrementable _OutIter>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __r, _OutIter __result) const {
+    auto __ret = std::__copy(ranges::begin(__r), ranges::end(__r), std::move(__result));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+};
+} // namespace __copy
+
+inline namespace __cpo {
+  inline constexpr auto copy = __copy::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_COPY_H

libcxx/include/__algorithm/ranges_copy_backward.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_COPY_BACKWARD_H
+#define _LIBCPP___ALGORITHM_RANGES_COPY_BACKWARD_H
+
+#include <__algorithm/copy_backward.h>
+#include <__algorithm/in_out_result.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/reverse_iterator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template<class _Ip, class _Op>
+using copy_backward_result = in_out_result<_Ip, _Op>;
+
+namespace __copy_backward {
+struct __fn {
+
+  template <bidirectional_iterator _InIter1, sentinel_for<_InIter1> _Sent1, bidirectional_iterator _InIter2>
+    requires indirectly_copyable<_InIter1, _InIter2>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_backward_result<_InIter1, _InIter2> operator()(_InIter1 __first, _Sent1 __last, _InIter2 __result) const {
+    auto __ret = std::__copy_backward(std::move(__first), std::move(__last), std::move(__result));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+
+  template <bidirectional_range _Range, bidirectional_iterator _Iter>
+    requires indirectly_copyable<iterator_t<_Range>, _Iter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_backward_result<borrowed_iterator_t<_Range>, _Iter> operator()(_Range&& __r, _Iter __result) const {
+    auto __ret = std::__copy_backward(ranges::begin(__r),
+                                      ranges::end(__r),
+                                      std::move(__result));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+};
+} // namespace __copy_backward
+
+inline namespace __cpo {
+  inline constexpr auto copy_backward = __copy_backward::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_COPY_BACKWARD_H

libcxx/include/__algorithm/ranges_copy_if.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_COPY_IF_H
+#define _LIBCPP___ALGORITHM_RANGES_COPY_IF_H
+
+#include <__algorithm/in_out_result.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template<class _Ip, class _Op>
+using copy_if_result = in_out_result<_Ip, _Op>;
+
+namespace __copy_if {
+struct __fn {
+
+  template <class _InIter, class _Sent, class _OutIter, class _Proj, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI static constexpr
+  copy_if_result <_InIter, _OutIter>
+  __copy_if_impl(_InIter __first, _Sent __last, _OutIter __result, _Pred& __pred, _Proj& __proj) {
+    for (; __first != __last; ++__first) {
+      if (std::invoke(__pred, std::invoke(__proj, *__first))) {
+        *__result = *__first;
+        ++__result;
+      }
+    }
+    return {std::move(__first), std::move(__result)};
+  }
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, weakly_incrementable _OutIter, class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+    requires indirectly_copyable<_Iter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_if_result<_Iter, _OutIter>
+  operator()(_Iter __first, _Sent __last, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
+    return __copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
+  }
+
+  template <input_range _Range, weakly_incrementable _OutIter, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __r, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
+    return __copy_if_impl(ranges::begin(__r), ranges::end(__r), std::move(__result), __pred, __proj);
+  }
+};
+} // namespace __copy_if
+
+inline namespace __cpo {
+  inline constexpr auto copy_if = __copy_if::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_COPY_IF_H

libcxx/include/__algorithm/ranges_copy_n.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_COPY_N_H
+#define _LIBCPP___ALGORITHM_RANGES_COPY_N_H
+
+#include <__algorithm/copy.h>
+#include <__algorithm/in_out_result.h>
+#include <__algorithm/ranges_copy.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <__iterator/unreachable_sentinel.h>
+#include <__iterator/wrap_iter.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+namespace ranges {
+
+template <class _Ip, class _Op>
+using copy_n_result = in_out_result<_Ip, _Op>;
+
+namespace __copy_n {
+struct __fn {
+
+  template <class _InIter, class _DiffType, class _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  copy_n_result<_InIter, _OutIter> __go(_InIter __first, _DiffType __n, _OutIter __result) {
+    while (__n != 0) {
+      *__result = *__first;
+      ++__first;
+      ++__result;
+      --__n;
+    }
+    return {std::move(__first), std::move(__result)};
+  }
+
+  template <random_access_iterator _InIter, class _DiffType, random_access_iterator _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  copy_n_result<_InIter, _OutIter> __go(_InIter __first, _DiffType __n, _OutIter __result) {
+    auto __ret = std::__copy(__first, __first + __n, __result);
+    return {__ret.first, __ret.second};
+  }
+
+  template <input_iterator _Ip, weakly_incrementable _Op>
+    requires indirectly_copyable<_Ip, _Op>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  copy_n_result<_Ip, _Op> operator()(_Ip __first, iter_difference_t<_Ip> __n, _Op __result) const {
+    return __go(std::move(__first), __n, std::move(__result));
+  }
+};
+} // namespace __copy_n
+
+inline namespace __cpo {
+  inline constexpr auto copy_n = __copy_n::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_RANGES_COPY_N_H

libcxx/include/__algorithm/unwrap_iter.h

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 decltype(_Impl::__apply(declval<_Iter>()))
 __unwrap_iter(_Iter __i) _NOEXCEPT
 {
     return _Impl::__apply(__i);
 }
 
 template<class _OrigIter>
-_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 _OrigIter __rewrap_iter(_OrigIter, _OrigIter __result)
 {
     return __result;
 }
 
 template<class _OrigIter, class _UnwrappedIter>
-_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 _OrigIter __rewrap_iter(_OrigIter __first, _UnwrappedIter __result)
 {
     // Precondition: __result is reachable from __first
     // Precondition: _OrigIter is a contiguous iterator
     return __first + (__result - _VSTD::__unwrap_iter(__first));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H

libcxx/include/algorithm

namespace ranges {
   constexpr mismatch_result<_I1, _I2>
   mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
 
   template <input_range R1, input_range R2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
   mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                           // since C++20
 
     requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
     constexpr I find(I first, S last, const T& value, Proj proj = {});              // since C++20
 
   template<input_range R, class T, class Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
     constexpr borrowed_iterator_t<R>
       find(R&& r, const T& value, Proj proj = {});                                  // since C++20
 
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
namespace ranges {
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr borrowed_iterator_t<R>
       find_if_not(R&& r, Pred pred, Proj proj = {});                                // since C++20
 
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr T min(initializer_list<T> r, Comp comp = {}, Proj proj = {});         // since C++20
 
  template<input_range R, class Proj = identity,
           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
    requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
    constexpr range_value_t<R>
      min(R&& r, Comp comp = {}, Proj proj = {});                                    // since C++20
 
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr const T& max(const T& a, const T& b, Comp comp = {}, Proj proj = {}); // since C++20
 
   template<copyable T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr T max(initializer_list<T> r, Comp comp = {}, Proj proj = {});         // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<R>, range_value_t<R>*>
     constexpr range_value_t<R>
       max(R&& r, Comp comp = {}, Proj proj = {});                                   // since C++20
 
   template<class I, class O>
     using unary_transform_result = in_out_result<I, O>;                             // since C++20
 
   template<class I1, class I2, class O>
template<input_range R, class Proj = identity,
 
   template<input_range R1, input_range R2, weakly_incrementable O,
            copy_constructible F, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_writable<O, indirect_result_t<F&, projected<iterator_t<R1>, Proj1>,
                                            projected<iterator_t<R2>, Proj2>>>
     constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
       transform(R1&& r1, R2&& r2, O result,
                         F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {});           // since C++20
+
+  template<class I, class O>
+      using copy_result = in_out_result<I, O>;                                              // since C++20
+
+    template<class I, class O>
+      using copy_n_result = in_out_result<I, O>;                                            // since C++20
+
+  template<class I, class O>
+    using copy_if_result = in_out_result<I, O>;                                             // since C++20
+
+  template<class I1, class I2>
+    using copy_backward_result = in_out_result<I1, I2>;                                     // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+    requires indirectly_copyable<I, O>
+    constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);            // since C++20
+
+  template<input_range R, weakly_incrementable O>
+    requires indirectly_copyable<iterator_t<R>, O>
+    constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20
+
+  template<input_iterator I, weakly_incrementable O>
+    requires indirectly_copyable<I, O>
+    constexpr ranges::copy_n_result<I, O>
+      ranges::copy_n(I first, iter_difference_t<I> n, O result);                            // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    requires indirectly_copyable<I, O>
+    constexpr ranges::copy_if_result<I, O>
+      ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {});                // since C++20
+
+  template<input_range R, weakly_incrementable O, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    requires indirectly_copyable<iterator_t<R>, O>
+    constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
+      ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});                          // since C++20
+
+  template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+    requires indirectly_copyable<I1, I2>
+    constexpr ranges::copy_backward_result<I1, I2>
+      ranges::copy_backward(I1 first, S1 last, I2 result);                                  // since C++20
+
+  template<bidirectional_range R, bidirectional_iterator I>
+    requires indirectly_copyable<iterator_t<R>, I>
+    constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
+      ranges::copy_backward(R&& r, I result);                                               // since C++20
 }
 
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     any_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20

 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_copy.h>
+#include <__algorithm/ranges_copy_backward.h>
+#include <__algorithm/ranges_copy_if.h>
+#include <__algorithm/ranges_copy_n.h>
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_if.h>
 #include <__algorithm/ranges_find_if_not.h>
 #include <__algorithm/ranges_max.h>
 #include <__algorithm/ranges_max_element.h>
 #include <__algorithm/ranges_min.h>
 #include <__algorithm/ranges_min_element.h>
 #include <__algorithm/ranges_mismatch.h>

libcxx/include/module.modulemap

module __algorithm {
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       module partition_point          { private header "__algorithm/partition_point.h" }
       module pop_heap                 { private header "__algorithm/pop_heap.h" }
       module prev_permutation         { private header "__algorithm/prev_permutation.h" }
       module push_heap                { private header "__algorithm/push_heap.h" }
+      module ranges_copy              { private header "__algorithm/ranges_copy.h" }
+      module ranges_copy_backward     { private header "__algorithm/ranges_copy_backward.h" }
+      module ranges_copy_if           { private header "__algorithm/ranges_copy_if.h" }
+      module ranges_copy_n            { private header "__algorithm/ranges_copy_n.h" }
       module ranges_find              { private header "__algorithm/ranges_find.h" }
       module ranges_find_if           { private header "__algorithm/ranges_find_if.h" }
       module ranges_find_if_not       { private header "__algorithm/ranges_find_if_not.h" }
       module ranges_max               { private header "__algorithm/ranges_max.h" }
       module ranges_max_element       { private header "__algorithm/ranges_max_element.h" }
       module ranges_min               { private header "__algorithm/ranges_min.h" }
       module ranges_min_element       { private header "__algorithm/ranges_min_element.h" }
       module ranges_mismatch          { private header "__algorithm/ranges_mismatch.h" }

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__algorithm/partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort.h'}}
 #include <__algorithm/partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort_copy.h'}}
 #include <__algorithm/partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition.h'}}
 #include <__algorithm/partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_copy.h'}}
 #include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}}
 #include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}}
 #include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}}
 #include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}}
+#include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}}
+#include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}}
+#include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}}
+#include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
 #include <__algorithm/ranges_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
 #include <__algorithm/ranges_find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
 #include <__algorithm/ranges_find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
 #include <__algorithm/ranges_max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max.h'}}
 #include <__algorithm/ranges_max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max_element.h'}}
 #include <__algorithm/ranges_min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min.h'}}
 #include <__algorithm/ranges_min_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min_element.h'}}
 #include <__algorithm/ranges_mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+//   requires indirectly_copyable<I, O>
+//   constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);
+// template<input_range R, weakly_incrementable O>
+//   requires indirectly_copyable<iterator_t<R>, O>
+//   constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
+concept HasCopyIt = requires(In in, Sent sent, Out out) { std::ranges::copy(in, sent, out); };
+
+static_assert(HasCopyIt<int*>);
+static_assert(!HasCopyIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasCopyIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasCopyIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasCopyIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyCopyable {};
+static_assert(!HasCopyIt<int*, NotIndirectlyCopyable*>);
+static_assert(!HasCopyIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasCopyIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range, class Out>
+concept HasCopyR = requires(Range range, Out out) { std::ranges::copy(range, out); };
+
+static_assert(HasCopyR<std::array<int, 10>, int*>);
+static_assert(!HasCopyR<InputRangeNotDerivedFrom, int*>);
+static_assert(!HasCopyR<InputRangeNotIndirectlyReadable, int*>);
+static_assert(!HasCopyR<InputRangeNotInputOrOutputIterator, int*>);
+static_assert(!HasCopyR<WeaklyIncrementableNotMovable, int*>);
+static_assert(!HasCopyR<UncheckedRange<NotIndirectlyCopyable*>, int*>);
+static_assert(!HasCopyR<InputRangeNotSentinelSemiregular, int*>);
+static_assert(!HasCopyR<InputRangeNotSentinelEqualityComparableWith, int*>);
+
+static_assert(std::is_same_v<std::ranges::copy_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      std::array in {1, 2, 3, 4};
+      std::array<int, 4> out;
+      std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
+        std::ranges::copy(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data()));
+      assert(in == out);
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+    {
+      std::array in {1, 2, 3, 4};
+      std::array<int, 4> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      std::same_as<std::ranges::in_out_result<In, Out>> auto ret = std::ranges::copy(range, Out(out.data()));
+      assert(in == out);
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+  }
+
+  { // check that an empty range works
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto ret = std::ranges::copy(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data()));
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      auto ret = std::ranges::copy(range, Out(out.data()));
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+  }
+}
+
+template <class Out>
+constexpr void test_in_iterators() {
+  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>, Out>();
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+}
+
+constexpr bool test() {
+  test_in_iterators<cpp20_input_iterator<int*>>();
+  test_in_iterators<forward_iterator<int*>>();
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+
+  { // check that ranges::dangling is returned
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> auto ret =
+      std::ranges::copy(std::array {1, 2, 3, 4}, out.data());
+    assert(ret.out == out.data() + 4);
+    assert((out == std::array{1, 2, 3, 4}));
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    std::array in {1, 2, 3, 4};
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<int*, int*>> auto ret = std::ranges::copy(std::views::all(in), out.data());
+    assert(ret.in == in.data() + 4);
+    assert(ret.out == out.data() + 4);
+    assert(in == out);
+  }
+
+  { // check that every element is copied exactly once
+    struct CopyOnce {
+      bool copied = false;
+      constexpr CopyOnce() = default;
+      constexpr CopyOnce(const CopyOnce& other) = delete;
+      constexpr CopyOnce& operator=(const CopyOnce& other) {
+        assert(!other.copied);
+        copied = true;
+        return *this;
+      }
+    };
+    {
+      std::array<CopyOnce, 4> in {};
+      std::array<CopyOnce, 4> out {};
+      auto ret = std::ranges::copy(in.begin(), in.end(), out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.copied; }));
+    }
+    {
+      std::array<CopyOnce, 4> in {};
+      std::array<CopyOnce, 4> out {};
+      auto ret = std::ranges::copy(in, out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.copied; }));
+    }
+  }
+
+  { // check that the range is copied forwards
+    struct OnlyForwardsCopyable {
+      OnlyForwardsCopyable* next = nullptr;
+      bool canCopy = false;
+      OnlyForwardsCopyable() = default;
+      constexpr OnlyForwardsCopyable& operator=(const OnlyForwardsCopyable&) {
+        assert(canCopy);
+        if (next != nullptr)
+          next->canCopy = true;
+        return *this;
+      }
+    };
+    {
+      std::array<OnlyForwardsCopyable, 3> in {};
+      std::array<OnlyForwardsCopyable, 3> out {};
+      out[0].next = &out[1];
+      out[1].next = &out[2];
+      out[0].canCopy = true;
+      auto ret = std::ranges::copy(in.begin(), in.end(), out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].canCopy);
+      assert(out[1].canCopy);
+      assert(out[2].canCopy);
+    }
+    {
+      std::array<OnlyForwardsCopyable, 3> in {};
+      std::array<OnlyForwardsCopyable, 3> out {};
+      out[0].next = &out[1];
+      out[1].next = &out[2];
+      out[0].canCopy = true;
+      auto ret = std::ranges::copy(in, out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].canCopy);
+      assert(out[1].canCopy);
+      assert(out[2].canCopy);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_backward.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+
+// template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+//   requires indirectly_copyable<I1, I2>
+//   constexpr ranges::copy_backward_result<I1, I2>
+//     ranges::copy_backward(I1 first, S1 last, I2 result);
+// template<bidirectional_range R, bidirectional_iterator I>
+//   requires indirectly_copyable<iterator_t<R>, I>
+//   constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
+//     ranges::copy_backward(R&& r, I result);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
+concept HasCopyBackwardIt = requires(In in, Sent sent, Out out) { std::ranges::copy_backward(in, sent, out); };
+
+static_assert(HasCopyBackwardIt<int*>);
+static_assert(!HasCopyBackwardIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasCopyBackwardIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasCopyBackwardIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasCopyBackwardIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyCopyable {};
+static_assert(!HasCopyBackwardIt<int*, NotIndirectlyCopyable*>);
+static_assert(!HasCopyBackwardIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasCopyBackwardIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range, class Out>
+concept HasCopyBackwardR = requires(Range range, Out out) { std::ranges::copy_backward(range, out); };
+
+static_assert(HasCopyBackwardR<std::array<int, 10>, int*>);
+static_assert(!HasCopyBackwardR<InputRangeNotDerivedFrom, int*>);
+static_assert(!HasCopyBackwardR<InputRangeNotIndirectlyReadable, int*>);
+static_assert(!HasCopyBackwardR<InputRangeNotInputOrOutputIterator, int*>);
+static_assert(!HasCopyBackwardR<WeaklyIncrementableNotMovable, int*>);
+static_assert(!HasCopyBackwardR<UncheckedRange<NotIndirectlyCopyable*>, int*>);
+static_assert(!HasCopyBackwardR<InputRangeNotSentinelSemiregular, int*>);
+static_assert(!HasCopyBackwardR<InputRangeNotSentinelEqualityComparableWith, int*>);
+
+static_assert(std::is_same_v<std::ranges::copy_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      std::array in {1, 2, 3, 4};
+      std::array<int, 4> out;
+      std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
+        std::ranges::copy_backward(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data() + out.size()));
+      assert(in == out);
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+    {
+      std::array in {1, 2, 3, 4};
+      std::array<int, 4> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
+          std::ranges::copy_backward(range, Out(out.data() + out.size()));
+      assert(in == out);
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+  }
+
+  { // check that an empty range works
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto ret =
+          std::ranges::copy_backward(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data() + out.size()));
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      auto ret = std::ranges::copy_backward(range, Out(out.data()));
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+  }
+}
+
+template <class Out>
+constexpr void test_in_iterators() {
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+}
+
+constexpr bool test() {
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+
+  { // check that ranges::dangling is returned
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> auto ret =
+      std::ranges::copy_backward(std::array {1, 2, 3, 4}, out.data() + out.size());
+    assert(ret.out == out.data());
+    assert((out == std::array{1, 2, 3, 4}));
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    std::array in {1, 2, 3, 4};
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<int*, int*>> auto ret =
+        std::ranges::copy_backward(std::views::all(in), out.data() + out.size());
+    assert(ret.in == in.data());
+    assert(ret.out == out.data());
+    assert(in == out);
+  }
+
+  { // check that every element is copied exactly once
+    struct CopyOnce {
+      bool copied = false;
+      constexpr CopyOnce() = default;
+      constexpr CopyOnce(const CopyOnce& other) = delete;
+      constexpr CopyOnce& operator=(const CopyOnce& other) {
+        assert(!other.copied);
+        copied = true;
+        return *this;
+      }
+    };
+    {
+      std::array<CopyOnce, 4> in {};
+      std::array<CopyOnce, 4> out {};
+      auto ret = std::ranges::copy_backward(in.begin(), in.end(), out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.copied; }));
+    }
+    {
+      std::array<CopyOnce, 4> in {};
+      std::array<CopyOnce, 4> out {};
+      auto ret = std::ranges::copy_backward(in, out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.copied; }));
+    }
+  }
+
+  { // check that the range is copied backwards
+    struct OnlyBackwardsCopyable {
+      OnlyBackwardsCopyable* next = nullptr;
+      bool canCopy = false;
+      OnlyBackwardsCopyable() = default;
+      constexpr OnlyBackwardsCopyable& operator=(const OnlyBackwardsCopyable&) {
+        assert(canCopy);
+        if (next != nullptr)
+          next->canCopy = true;
+        return *this;
+      }
+    };
+    {
+      std::array<OnlyBackwardsCopyable, 3> in {};
+      std::array<OnlyBackwardsCopyable, 3> out {};
+      out[1].next = &out[0];
+      out[2].next = &out[1];
+      out[2].canCopy = true;
+      auto ret = std::ranges::copy_backward(in, out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(out[0].canCopy);
+      assert(out[1].canCopy);
+      assert(out[2].canCopy);
+    }
+    {
+      std::array<OnlyBackwardsCopyable, 3> in {};
+      std::array<OnlyBackwardsCopyable, 3> out {};
+      out[1].next = &out[0];
+      out[2].next = &out[1];
+      out[2].canCopy = true;
+      auto ret = std::ranges::copy_backward(in.begin(), in.end(), out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(out[0].canCopy);
+      assert(out[1].canCopy);
+      assert(out[2].canCopy);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_if.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//   requires indirectly_copyable<I, O>
+//   constexpr ranges::copy_if_result<I, O>
+//     ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {});
+// template<input_range R, weakly_incrementable O, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//   requires indirectly_copyable<iterator_t<R>, O>
+//   constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
+//     ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct Functor {
+  bool operator()(int);
+};
+
+template <class In, class Out = In, class Sent = sentinel_wrapper<In>, class Func = Functor>
+concept HasCopyIfIt = requires(In first, Sent last, Out result) { std::ranges::copy_if(first, last, result, Func{}); };
+
+static_assert(HasCopyIfIt<int*>);
+static_assert(!HasCopyIfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasCopyIfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasCopyIfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasCopyIfIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyCopyable {};
+static_assert(!HasCopyIfIt<int*, NotIndirectlyCopyable*>);
+static_assert(!HasCopyIfIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasCopyIfIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+static_assert(!HasCopyIfIt<int*, int*, int*, IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasCopyIfIt<int*, int*, int*, IndirectUnaryPredicateNotPredicate>);
+
+template <class Range, class Out, class Func = Functor>
+concept HasCopyIfR = requires(Range range, Out out) { std::ranges::copy_if(range, out, Func{}); };
+
+static_assert(HasCopyIfR<std::array<int, 10>, int*>);
+static_assert(!HasCopyIfR<InputRangeNotDerivedFrom, int*>);
+static_assert(!HasCopyIfR<InputRangeNotIndirectlyReadable, int*>);
+static_assert(!HasCopyIfR<InputRangeNotInputOrOutputIterator, int*>);
+static_assert(!HasCopyIfR<WeaklyIncrementableNotMovable, int*>);
+static_assert(!HasCopyIfR<UncheckedRange<NotIndirectlyCopyable*>, int*>);
+static_assert(!HasCopyIfR<InputRangeNotSentinelSemiregular, int*>);
+static_assert(!HasCopyIfR<InputRangeNotSentinelEqualityComparableWith, int*>);
+
+static_assert(std::is_same_v<std::ranges::copy_if_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      std::array in = {1, 2, 3, 4};
+      std::array<int, 4> out;
+      std::same_as<std::ranges::copy_if_result<In, Out>> auto ret =
+          std::ranges::copy_if(In(in.data()),
+                               Sent(In(in.data() + in.size())),
+                               Out(out.data()),
+                               [](int) { return true; });
+      assert(in == out);
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+    {
+      std::array in = {1, 2, 3, 4};
+      std::array<int, 4> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      std::same_as<std::ranges::copy_if_result<In, Out>> auto ret =
+          std::ranges::copy_if(range, Out(out.data()), [](int) { return true; });
+      assert(in == out);
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+  }
+
+  { // check that an empty range works
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto ret = std::ranges::copy_if(In(in.data()), Sent(In(in.data())), Out(out.data()), [](int) { return true; });
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+    {
+      std::array<int, 0> in;
+      std::array<int, 0> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data())));
+      auto ret = std::ranges::copy_if(range, Out(out.data()), [](int) { return true; });
+      assert(base(ret.in) == in.data());
+      assert(base(ret.out) == out.data());
+    }
+  }
+
+  { // check that the predicate is used
+    {
+      std::array in = {4, 6, 87, 3, 88, 44, 45, 9};
+      std::array<int, 4> out;
+      auto ret = std::ranges::copy_if(In(in.data()),
+                                      Sent(In(in.data() + in.size())),
+                                      Out(out.data()),
+                                      [](int i) { return i % 2 == 0; });
+      assert((out == std::array{4, 6, 88, 44}));
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+    {
+      std::array in = {4, 6, 87, 3, 88, 44, 45, 9};
+      std::array<int, 4> out;
+      auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+      auto ret = std::ranges::copy_if(range, Out(out.data()), [](int i) { return i % 2 == 0; });
+      assert((out == std::array{4, 6, 88, 44}));
+      assert(base(ret.in) == in.data() + in.size());
+      assert(base(ret.out) == out.data() + out.size());
+    }
+  }
+}
+
+template <class Out>
+constexpr bool test_in_iterators() {
+  test_iterators<cpp17_input_iterator<int*>, Out, sentinel_wrapper<cpp17_input_iterator<int*>>>();
+  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>, Out>();
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+  test_iterators<int*, Out>();
+
+  return true;
+}
+
+constexpr bool test() {
+  test_in_iterators<cpp17_output_iterator<int*>>();
+  test_in_iterators<cpp20_output_iterator<int*>>();
+  test_in_iterators<forward_iterator<int*>>();
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+  test_in_iterators<int*>();
+
+  { // check that std::invoke is used
+    {
+      struct S { int val; int other; };
+      std::array<S, 4> in = {{{4, 2}, {1, 3}, {3, 4}, {3, 5}}};
+      std::array<S, 2> out;
+      auto ret = std::ranges::copy_if(in.begin(), in.end(), out.begin(), [](int i) { return i == 3; }, &S::val);
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].val == 3);
+      assert(out[0].other == 4);
+      assert(out[1].val == 3);
+      assert(out[1].other == 5);
+    }
+    {
+      struct S { int val; int other; };
+      std::array<S, 4> in = {{{4, 2}, {1, 3}, {3, 4}, {3, 5}}};
+      std::array<S, 2> out;
+      auto ret = std::ranges::copy_if(in, out.begin(), [](int i) { return i == 3; }, &S::val);
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].val == 3);
+      assert(out[0].other == 4);
+      assert(out[1].val == 3);
+      assert(out[1].other == 5);
+    }
+  }
+
+  { // check that the complexity requirements are met
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int i) { ++predicateCount; return i != 0; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+
+      int a[] = {5, 4, 3, 2, 1};
+      int b[5];
+      std::ranges::copy_if(a, a + 5, b, pred, proj);
+      assert(predicateCount == 5);
+      assert(projectionCount == 5);
+    }
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int i) { ++predicateCount; return i != 0; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+
+      int a[] = {5, 4, 3, 2, 1};
+      int b[5];
+      std::ranges::copy_if(a, b, pred, proj);
+      assert(predicateCount == 5);
+      assert(projectionCount == 5);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy_n.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, weakly_incrementable O>
+//   requires indirectly_copyable<I, O>
+//   constexpr ranges::copy_n_result<I, O>
+//     ranges::copy_n(I first, iter_difference_t<I> n, O result);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class In, class Out = In, class Count = size_t>
+concept HasCopyNIt = requires(In in, Count count, Out out) { std::ranges::copy_n(in, count, out); };
+
+static_assert(HasCopyNIt<int*>);
+static_assert(!HasCopyNIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasCopyNIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasCopyNIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasCopyNIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyCopyable {};
+static_assert(!HasCopyNIt<int*, NotIndirectlyCopyable*>);
+static_assert(!HasCopyNIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasCopyNIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+static_assert(std::is_same_v<std::ranges::copy_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  { // simple test
+    std::array in {1, 2, 3, 4};
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<In, Out>> auto ret =
+      std::ranges::copy_n(In(in.data()), in.size(), Out(out.data()));
+    assert(in == out);
+    assert(base(ret.in) == in.data() + in.size());
+    assert(base(ret.out) == out.data() + out.size());
+  }
+
+  { // check that an empty range works
+    std::array<int, 0> in;
+    std::array<int, 0> out;
+    auto ret = std::ranges::copy_n(In(in.data()), in.size(), Out(out.begin()));
+    assert(base(ret.in) == in.data());
+    assert(base(ret.out) == out.data());
+  }
+}
+
+template <class Out>
+constexpr void test_in_iterators() {
+  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>, Out>();
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+}
+
+constexpr bool test() {
+  test_in_iterators<cpp20_input_iterator<int*>>();
+  test_in_iterators<forward_iterator<int*>>();
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+
+  { // check that every element is copied exactly once
+    struct CopyOnce {
+      bool copied = false;
+      constexpr CopyOnce() = default;
+      constexpr CopyOnce(const CopyOnce& other) = delete;
+      constexpr CopyOnce& operator=(const CopyOnce& other) {
+        assert(!other.copied);
+        copied = true;
+        return *this;
+      }
+    };
+    std::array<CopyOnce, 4> in {};
+    std::array<CopyOnce, 4> out {};
+    auto ret = std::ranges::copy_n(in.data(), in.size(), out.begin());
+    assert(ret.in == in.end());
+    assert(ret.out == out.end());
+    assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.copied; }));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}