[libc++][ranges] Implement `ranges::replace_copy{,_if}`.

[var-const]

@philnik Please amend the description in git, should be replace_copy, not replace.

[var-const]

libcxx/include/algorithm

848

Please update the synopsis (you can copy the synopsis lines from the tests).

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

47 ↗

(On Diff #444808)

This looks like an unintended change?

[philnik]

In D129806#3653395, @var-const wrote:

@philnik Please amend the description in git, should be replace_copy, not replace.

What do you mean exactly? The commit message gets updated automatically to the Differential title and description when landing if you mean that.

[var-const]

In D129806#3653412, @philnik wrote:

In D129806#3653395, @var-const wrote:

@philnik Please amend the description in git, should be replace_copy, not replace.

What do you mean exactly? The commit message gets updated automatically to the Differential title and description when landing if you mean that.

Yeah, basically I just meant to make sure the description of the merged patch is correct. If that's the case, never mind.

[huixie90]

libcxx/include/__algorithm/ranges_replace_copy.h

1

could you please update the status csv file?

40–54

puzzle: why does clang-format add two spaces here. I was told don't have spaces here

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges_replace_copy.pass.cpp

68–69

since the signature of the algorithm have OldType and NewType, it would be good to have at least one test to test when the old_value and new_value have different types

[Mordante]

I just looked at it mainly out of curiosity, but I didn't do a in-depth review. But some comments.

libcxx/.clang-format

71 ↗

(On Diff #444808)

Please remove this, it should be in a separate patch. Which I did in D129441 on your request.

libcxx/include/__algorithm/ranges_replace_copy.h

40–54

This is the inner namespace indention clang-format setting. We're considering to remove that.

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp

217

It would be nice to commit the upper and lower bound and search separately.

[philnik]

• Address comments

libcxx/.clang-format

71 ↗

(On Diff #444808)

Yes, sorry. I forgot to revert this change before committing.

[philnik]

• Try to fix CI

[var-const]

All comments are pretty minor.

libcxx/include/__algorithm/ranges_replace_copy_if.h

44

Optional: consider a blank line above this line.

48

Nit: can you add a blank line above this line?

libcxx/include/algorithm

867

Please also add the definitions of the *_result types to the synopsis.

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges_replace_copy.pass.cpp

41

s/RemoveIf/ReplaceCopy/.

82

Should this be replace_copy_result? Also, you might need to update ranges_result_alias_declarations.compile.pass.cpp.

203

Optional: it would be convenient to copy the exact requirement from the standard here.

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges_replace_copy_if.pass.cpp

45

Same as the other file, the name needs to be updated.

58

s/ReplaceCopy/ReplaceCopyIf/.

89

Same nit re. return type.

219

I think you also need to check the number of predicate invocations. There's some prior art in test_support/counting_predicates.h.

[var-const]

• rebase on main;
• add the new algorithms to all the robust test suites;
• address existing feedback;
• add more SFINAE tests;
• test the number of predicate invocations in complexity tests.

[var-const]

Fix forwarding in tests.

libcxx/docs/Status/RangesAlgorithms.csv

 Write,fill_n,Nikolas Klauser,`D123462 <https://llvm.org/D123462>`_,✅
 Write,transform,Nikolas Klauser,`D122173 <https://llvm.org/D122173>`_,✅
 Write,generate,Konstantin Varlamov,`D130552 <https://llvm.org/D130552>`_,✅
 Write,generate_n,Konstantin Varlamov,`D130552 <https://llvm.org/D130552>`_,✅
 Write,remove_copy,Nikolas Klauser,`D130599 <https://llvm.org/D130599>`_,✅
 Write,remove_copy_if,Nikolas Klauser,`D130599 <https://llvm.org/D130599>`_,✅
 Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
-Write,replace_copy,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
-Write,replace_copy_if,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,Under review
+Write,replace_copy,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,✅
+Write,replace_copy_if,Nikolas Klauser,`D129806 <https://llvm.org/D129806>`_,✅
 Write,swap_ranges,Nikolas Klauser,`D116303 <https://llvm.org/D116303>`_,✅
 Write,reverse_copy,Nikolas Klauser,`D127211 <https://llvm.org/D127211>`_,✅
 Write,rotate_copy,Nikolas Klauser,`D127211 <https://llvm.org/D127211>`_,✅
 Write,sample,Not assigned,n/a,Not started
 Write,unique_copy,Hui Xie,`D130404 <https://llvm.org/D130404>`_,✅
 Write,partition_copy,Konstantin Varlamov,`D130070 <https://llvm.org/D130070>`_,✅
 Write,partial_sort_copy,Konstantin Varlamov,`D130532 <https://llvm.org/D130532>`_,✅
 Merge,merge,Hui Xie,`D128611 <https://llvm.org/D128611>`_,✅

libcxx/include/__algorithm/ranges_replace_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_REPLACE_COPY_H
 #define _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_H
 
 #include <__algorithm/in_out_result.h>
-#include <__algorithm/make_projected.h>
-#include <__algorithm/replace_copy.h>
+#include <__algorithm/ranges_replace_copy_if.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
-#include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
-#include <__utility/forward.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 replace_copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __replace_copy {
 
   struct __fn {
-
-  template <input_iterator _InIter, sentinel_for<_InIter> _Sent, class _Type1, class _Type2,
-            output_iterator<const _Type2&> _OutIter, class _Proj = identity>
+    template <input_iterator _InIter,
+              sentinel_for<_InIter> _Sent,
+              class _OldType,
+              class _NewType,
+              output_iterator<const _NewType&> _OutIter,
+              class _Proj = identity>
       requires indirectly_copyable<_InIter, _OutIter> &&
-           indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _Type1*>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  replace_copy_result<_InIter, _OutIter>
-  operator()(_InIter __first, _Sent __last, _OutIter __result, const _Type1& __old_value, const _Type2& __new_value,
+               indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _OldType*>
+    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<_InIter, _OutIter>
+    operator()(_InIter __first,
+               _Sent __last,
+               _OutIter __result,
+               const _OldType& __old_value,
+               const _NewType& __new_value,
                _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__result; (void)__old_value; (void)__new_value; (void)__proj;
-    return {};
+      auto __pred = [&](const auto& __value) { return __value == __old_value; };
+      return ranges::__replace_copy_if_impl(
+          std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
     }
 
-  template <input_range _Range, class _Type1, class _Type2, output_iterator<const _Type2&> _OutIter,
+    template <input_range _Range,
+              class _OldType,
+              class _NewType,
+              output_iterator<const _NewType&> _OutIter,
               class _Proj = identity>
       requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
-           indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type1*>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  replace_copy_result<borrowed_iterator_t<_Range>, _OutIter>
-  operator()(_Range&& __range, _OutIter __result, const _Type1& __old_value, const _Type2& __new_value,
+               indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _OldType*>
+    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<borrowed_iterator_t<_Range>, _OutIter>
+    operator()(_Range&& __range,
+               _OutIter __result,
+               const _OldType& __old_value,
+               const _NewType& __new_value,
                _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__range; (void)__result; (void)__old_value; (void)__new_value; (void)__proj;
-    return {};
+      auto __pred = [&](const auto& __value) { return __value == __old_value; };
+      return ranges::__replace_copy_if_impl(
+          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
     }
-
   };
 
 } // namespace __replace_copy
 
 inline namespace __cpo {
   inline constexpr auto replace_copy = __replace_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_REPLACE_COPY_H

libcxx/include/__algorithm/ranges_replace_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_REPLACE_COPY_IF_H
 #define _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_IF_H
 
 #include <__algorithm/in_out_result.h>
-#include <__algorithm/make_projected.h>
-#include <__algorithm/replace_copy_if.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
-#include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
-#include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
-#include <__utility/forward.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 replace_copy_if_result = in_out_result<_InIter, _OutIter>;
 
+template <class _InIter, class _Sent, class _OutIter, class _Pred, class _Type, class _Proj>
+_LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<_InIter, _OutIter> __replace_copy_if_impl(
+    _InIter __first, _Sent __last, _OutIter __result, _Pred& __pred, const _Type& __new_value, _Proj& __proj) {
+  while (__first != __last) {
+    if (std::invoke(__pred, std::invoke(__proj, *__first)))
+      *__result = __new_value;
+    else
+      *__result = *__first;
+
+    ++__first;
+    ++__result;
+  }
+
+  return {std::move(__first), std::move(__result)};
+}
+
 namespace __replace_copy_if {
 
   struct __fn {
-
-  template <input_iterator _InIter, sentinel_for<_InIter> _Sent, class _Type, output_iterator<const _Type&> _OutIter,
-            class _Proj = identity, indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
+    template <input_iterator _InIter,
+              sentinel_for<_InIter> _Sent,
+              class _Type,
+              output_iterator<const _Type&> _OutIter,
+              class _Proj = identity,
+              indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
       requires indirectly_copyable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  replace_copy_if_result<_InIter, _OutIter>
-  operator()(_InIter __first, _Sent __last, _OutIter __result, _Pred __pred, const _Type& __new_value,
-             _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__result; (void)__pred; (void)__new_value; (void)__proj;
-    return {};
+    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<_InIter, _OutIter> operator()(
+        _InIter __first, _Sent __last, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {})
+        const {
+      return ranges::__replace_copy_if_impl(
+          std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
     }
 
-  template <input_range _Range, class _Type, output_iterator<const _Type&> _OutIter, class _Proj = identity,
+    template <input_range _Range,
+              class _Type,
+              output_iterator<const _Type&> _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
-  replace_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
+    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
     operator()(_Range&& __range, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__range; (void)__result; (void)__pred; (void)__new_value; (void)__proj;
-    return {};
+      return ranges::__replace_copy_if_impl(
+          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
     }
-
   };
 
 } // namespace __replace_copy_if
 
 inline namespace __cpo {
   inline constexpr auto replace_copy_if = __replace_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_REPLACE_COPY_IF_H

libcxx/include/algorithm

template<forward_range R, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
              ranges::less>
     constexpr borrowed_subrange_t<R>
       equal_range(R&& r, const T& value, Comp comp = {}, Proj proj = {});                           // since C++20
 
   template<class I1, class I2, class O>
     using set_union_result = in_in_out_result<I1, I2, O>;                                           // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            weakly_incrementable O, class Comp = ranges::less,
            class Proj1 = identity, class Proj2 = identity>
     requires mergeable<I1, I2, O, Comp, Proj1, Proj2>
     constexpr set_union_result<I1, I2, O>
       set_union(I1 first1, S1 last1, I2 first2, S2 last2, O result, Comp comp = {},
                 Proj1 proj1 = {}, Proj2 proj2 = {});                                                // since C++20
 
   template<input_range R1, input_range R2, weakly_incrementable O,
            class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
     requires mergeable<iterator_t<R1>, iterator_t<R2>, O, Comp, Proj1, Proj2>
     constexpr set_union_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
       set_union(R1&& r1, R2&& r2, O result, Comp comp = {},
                 Proj1 proj1 = {}, Proj2 proj2 = {});                                                // since C++20
 
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            class Proj1 = identity, class Proj2 = identity,
            indirect_strict_weak_order<projected<I1, Proj1>, projected<I2, Proj2>> Comp =
              ranges::less>
     constexpr bool includes(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp = {},
                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
 
   template<input_range R1, input_range R2, class Proj1 = identity,
            class Proj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
     constexpr bool includes(R1&& r1, R2&& r2, Comp comp = {},
                             Proj1 proj1 = {}, Proj2 proj2 = {});                                   // Since C++20
constexpr remove_copy_if_result<I, O>
       remove_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 remove_copy_if_result<borrowed_iterator_t<R>, O>
       remove_copy_if(R&& r, O result, Pred pred, Proj proj = {});                                  // Since C++20
 
+  template<class I, class O>
+      using replace_copy_result = in_out_result<I, O>;                                             // Since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class T1, class T2,
+           output_iterator<const T2&> O, class Proj = identity>
+    requires indirectly_copyable<I, O> &&
+             indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+    constexpr replace_copy_result<I, O>
+      replace_copy(I first, S last, O result, const T1& old_value, const T2& new_value,
+                   Proj proj = {});                                                                // Since C++20
+
+  template<input_range R, class T1, class T2, output_iterator<const T2&> O,
+           class Proj = identity>
+    requires indirectly_copyable<iterator_t<R>, O> &&
+             indirect_binary_predicate<ranges::equal_to,
+                                       projected<iterator_t<R>, Proj>, const T1*>
+    constexpr replace_copy_result<borrowed_iterator_t<R>, O>
+      replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
+                   Proj proj = {});                                                                // Since C++20
+
+  template<class I, class O>
+      using replace_copy_if_result = in_out_result<I, O>;                                          // Since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class T, output_iterator<const T&> O,
+           class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
+    requires indirectly_copyable<I, O>
+    constexpr replace_copy_if_result<I, O>
+      replace_copy_if(I first, S last, O result, Pred pred, const T& new_value,
+                      Proj proj = {});                                                             // Since C++20
+
+  template<input_range R, class T, output_iterator<const T&> O, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    requires indirectly_copyable<iterator_t<R>, O>
+    constexpr replace_copy_if_result<borrowed_iterator_t<R>, O>
+      replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
+                      Proj proj = {});                                                             // 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);

 #include <__algorithm/ranges_partition_point.h>
 #include <__algorithm/ranges_pop_heap.h>
 #include <__algorithm/ranges_push_heap.h>
 #include <__algorithm/ranges_remove.h>
 #include <__algorithm/ranges_remove_copy.h>
 #include <__algorithm/ranges_remove_copy_if.h>
 #include <__algorithm/ranges_remove_if.h>
 #include <__algorithm/ranges_replace.h>
+#include <__algorithm/ranges_replace_copy.h>
+#include <__algorithm/ranges_replace_copy_if.h>
 #include <__algorithm/ranges_replace_if.h>
 #include <__algorithm/ranges_reverse.h>
 #include <__algorithm/ranges_reverse_copy.h>
 #include <__algorithm/ranges_rotate_copy.h>
 #include <__algorithm/ranges_search.h>
 #include <__algorithm/ranges_search_n.h>
 #include <__algorithm/ranges_set_difference.h>
 #include <__algorithm/ranges_set_intersection.h>

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp

#endif
     //(void)std::ranges::prev_permutation(first, last, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::prev_permutation(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::push_heap(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::push_heap(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::remove_copy_if(first, last, first2, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::remove_copy_if(a, first2, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::remove_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::remove_if(a, UnaryTrue(&copies)); assert(copies == 0);
-    //(void)std::ranges::replace_copy_if(first, last, first2, UnaryTrue(&copies), value); assert(copies == 0);
-    //(void)std::ranges::replace_copy_if(a, first2, UnaryTrue(&copies), value); assert(copies == 0);
+    (void)std::ranges::replace_copy_if(first, last, first2, UnaryTrue(&copies), value); assert(copies == 0);
+    (void)std::ranges::replace_copy_if(a, first2, UnaryTrue(&copies), value); assert(copies == 0);
     (void)std::ranges::replace_if(first, last, UnaryTrue(&copies), value); assert(copies == 0);
     (void)std::ranges::replace_if(a, UnaryTrue(&copies), value); assert(copies == 0);
     (void)std::ranges::search(first, last, first2, mid2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::search(a, b, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::search_n(first, last, count, value, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::search_n(a, count, value, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::set_difference(first, mid, mid, last, first2, Less(&copies)); assert(copies == 0);
     (void)std::ranges::set_difference(a, b, first2, Less(&copies)); assert(copies == 0);

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp

#endif
     (void)std::ranges::remove_copy(first, last, first2, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove_copy(a, first2, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove_copy_if(first, last, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove_copy_if(a, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::remove_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::replace_copy(first, last, first2, value, T(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::replace_copy(a, first2, value, T(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::replace_copy_if(first, last, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::replace_copy_if(a, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::replace_copy(first, last, first2, value, T(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::replace_copy(a, first2, value, T(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::replace_copy_if(first, last, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::replace_copy_if(a, first2, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace(first, last, value, T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace(a, value, T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace_if(first, last, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::replace_if(a, UnaryTrue(), T(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::search(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::search(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::search_n(first, last, count, value, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::search_n(a, count, value, Equal(), Proj(&copies)); assert(copies == 0);

 #if TEST_STD_VER > 20
     //(void)std::ranges::starts_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::transform(first, last, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, first2, UnaryTransform(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(first, mid, mid, last, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::transform(a, b, first2, BinaryTransform(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::unique(first, last, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::unique(a, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::unique_copy(first, last, first2, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::unique_copy(a, first2, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::upper_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
 
     return true;
 }
 
 int main(int, char**)
 {
     all_the_algorithms();
     static_assert(all_the_algorithms());
 
     return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges_replace_copy.pass.cpp

 //          class Proj = identity>
 //   requires indirectly_copyable<iterator_t<R>, O> &&
 //            indirect_binary_predicate<ranges::equal_to,
 //                                      projected<iterator_t<R>, Proj>, const T1*>
 //   constexpr replace_copy_result<borrowed_iterator_t<R>, O>
 //     replace_copy(R&& r, O result, const T1& old_value, const T2& new_value,
 //                  Proj proj = {});                                                                // Since C++20
 
-// TODO: synopsis
-
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
+#include <utility>
 
 #include "almost_satisfies_types.h"
+#include "counting_projection.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+template <class Iter, class Sent = sentinel_wrapper<Iter>, class OutIter = int*>
+concept HasReplaceCopyIter =
+  requires(Iter&& first, Sent&& last, OutIter&& result) {
+    std::ranges::replace_copy(
+        std::forward<Iter>(first), std::forward<Sent>(last), std::forward<OutIter>(result), 0, 0);
+};
+
+static_assert(HasReplaceCopyIter<int*>);
+
+// !input_iterator<I>
+static_assert(!HasReplaceCopyIter<InputIteratorNotDerivedFrom>);
+static_assert(!HasReplaceCopyIter<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyIter<InputIteratorNotInputOrOutputIterator>);
+
+// !sentinel_for<S, I>
+static_assert(!HasReplaceCopyIter<int*, SentinelForNotSemiregular>);
+static_assert(!HasReplaceCopyIter<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+// !output_iterator<O, const T2&>
+static_assert(!HasReplaceCopyIter<int*, int*, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyIter<int*, int*, OutputIteratorNotInputOrOutputIterator>);
+
+// !indirectly_copyable<I, O>
+static_assert(!HasReplaceCopyIter<int*, int*, int**>);
+
+// !indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+static_assert(!HasReplaceCopyIter<IndirectBinaryPredicateNotIndirectlyReadable>);
+
+template <class Range, class OutIter = int*>
+concept HasReplaceCopyRange = requires(Range&& range, OutIter&& result) {
+  std::ranges::replace_copy(std::forward<Range>(range), std::forward<OutIter>(result), 0, 0);
+};
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasReplaceCopyRange<R<int*>>);
+
+// !input_range<R>
+static_assert(!HasReplaceCopyRange<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceCopyRange<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyRange<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceCopyRange<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceCopyRange<InputRangeNotSentinelEqualityComparableWith>);
+
+// !output_iterator<O, const T2&>
+static_assert(!HasReplaceCopyRange<R<int*>, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyRange<R<int*>, OutputIteratorNotInputOrOutputIterator>);
+
+// !indirectly_copyable<iterator_t<R>, O>
+static_assert(!HasReplaceCopyRange<R<int*>, R<int**>>);
+
+// !indirect_binary_predicate<ranges::equal_to, projected<iterator_t<T>, Proj>, const T1*>
+static_assert(!HasReplaceCopyRange<R<IndirectBinaryPredicateNotIndirectlyReadable>>);
+
+template <int N>
+struct Data {
+  std::array<int, N> input;
+  int old_value;
+  int new_value;
+  std::array<int, N> expected;
+};
+
+template <class InIter, class Sent, class OutIter, int N>
+constexpr void test(Data<N> d) {
+  { // iterator overload
+    std::array<int, N> output;
+
+    auto first  = InIter(d.input.data());
+    auto last   = Sent(InIter(d.input.data() + d.input.size()));
+    auto result = OutIter(output.data());
+
+    std::same_as<std::ranges::replace_copy_result<InIter, OutIter>> decltype(auto) ret =
+        std::ranges::replace_copy(std::move(first), std::move(last), std::move(result), d.old_value, d.new_value);
+    assert(base(ret.in) == d.input.data() + d.input.size());
+    assert(base(ret.out) == output.data() + output.size());
+    assert(d.expected == output);
+  }
+
+  { // range overload
+    std::array<int, N> output;
+
+    auto range  = std::ranges::subrange(InIter(d.input.data()), Sent(InIter(d.input.data() + d.input.size())));
+    auto result = OutIter(output.data());
+
+    std::same_as<std::ranges::replace_copy_result<InIter, OutIter>> decltype(auto) ret =
+        std::ranges::replace_copy(range, result, d.old_value, d.new_value);
+    assert(base(ret.in) == d.input.data() + d.input.size());
+    assert(base(ret.out) == output.data() + output.size());
+    assert(d.expected == output);
+  }
+}
+
+template <class InIter, class Sent, class OutIter>
+constexpr void tests() {
+  // simple test
+  test<InIter, Sent, OutIter, 4>({.input = {1, 2, 3, 4}, .old_value = 2, .new_value = 5, .expected = {1, 5, 3, 4}});
+  // empty range
+  test<InIter, Sent, OutIter, 0>({.input = {}, .old_value = 2, .new_value = 5, .expected = {}});
+  // all elements match
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .old_value = 1, .new_value = 2, .expected = {2, 2, 2, 2}});
+  // no element matches
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .old_value = 2, .new_value = 3, .expected = {1, 1, 1, 1}});
+  // old_value and new_value are identical - match
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .old_value = 1, .new_value = 1, .expected = {1, 1, 1, 1}});
+  // old_value and new_value are identical - no match
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .old_value = 2, .new_value = 2, .expected = {1, 1, 1, 1}});
+  // more elements
+  test<InIter, Sent, OutIter, 7>(
+      {.input = {1, 2, 3, 4, 5, 6, 7}, .old_value = 2, .new_value = 3, .expected = {1, 3, 3, 4, 5, 6, 7}});
+  // single element - match
+  test<InIter, Sent, OutIter, 1>({.input = {1}, .old_value = 1, .new_value = 5, .expected = {5}});
+  // single element - no match
+  test<InIter, Sent, OutIter, 1>({.input = {2}, .old_value = 1, .new_value = 5, .expected = {2}});
+}
+
+template <class InIter, class Sent>
+constexpr void test_output_iterators() {
+  tests<InIter, Sent, cpp17_output_iterator<int*>>();
+  tests<InIter, Sent, forward_iterator<int*>>();
+  tests<InIter, Sent, bidirectional_iterator<int*>>();
+  tests<InIter, Sent, random_access_iterator<int*>>();
+  tests<InIter, Sent, contiguous_iterator<int*>>();
+  tests<InIter, Sent, int*>();
+}
+
+template <class InIter>
+constexpr void test_sentinels() {
+  test_output_iterators<InIter, InIter>();
+  test_output_iterators<InIter, sentinel_wrapper<InIter>>();
+  test_output_iterators<InIter, sized_sentinel<InIter>>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_output_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
+  test_output_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_sentinels<forward_iterator<int*>>();
+  test_sentinels<bidirectional_iterator<int*>>();
+  test_sentinels<random_access_iterator<int*>>();
+  test_sentinels<contiguous_iterator<int*>>();
+  test_sentinels<int*>();
+  test_sentinels<const int*>();
+
+  { // check that a custom projection works
+    struct S {
+      int i;
+    };
+
+    { // iterator overload
+      S a[] = {{1}, {2}, {3}, {4}};
+      S b[4];
+      auto ret = std::ranges::replace_copy(std::begin(a), std::end(a), std::begin(b), 1, S{2}, &S::i);
+      assert(ret.in == std::end(a));
+      assert(ret.out == std::end(b));
+    }
+
+    { // range overload
+      S a[] = {{1}, {2}, {3}, {4}};
+      S b[4];
+      auto ret = std::ranges::replace_copy(a, std::begin(b), 1, S{2}, &S::i);
+      assert(ret.in == std::end(a));
+      assert(ret.out == std::end(b));
+    }
+  }
+
+  {   // Complexity: exactly `last - first` applications of the corresponding predicate and any projection.
+    { // iterator overload
+      int proj_count = 0;
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy(
+          std::begin(a), std::end(a), std::begin(b), 0, 0, counting_projection(proj_count));
+      assert(proj_count == 4);
+    }
+
+    { // range overload
+      int proj_count = 0;
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy(a, std::begin(b), 0, 0, counting_projection(proj_count));
+      assert(proj_count == 4);
+    }
+  }
+
+  { // using different types for the old and new values works
+    struct S {
+      constexpr operator int() const { return 0; }
+      constexpr bool operator==(const S&) const = default;
+      constexpr bool operator==(int i) const { return i == 0; }
+    };
+    struct T {
+      constexpr operator int() const { return 1; }
+    };
+    {
+      int a[] = {0, 1, 2, 3};
+      int b[4];
+      std::ranges::replace_copy(std::begin(a), std::end(a), std::begin(b), S{}, T{});
+      assert(std::ranges::equal(b, std::array{1, 1, 2, 3}));
+    }
+    {
+      int a[] = {0, 1, 2, 3};
+      int b[4];
+      std::ranges::replace_copy(a, std::begin(b), S{}, T{});
+      assert(std::ranges::equal(b, std::array{1, 1, 2, 3}));
+    }
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/ranges_replace_copy_if.pass.cpp

 //     replace_copy_if(R&& r, O result, Pred pred, const T& new_value,
 //                     Proj proj = {});                                                             // Since C++20
 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
+#include <utility>
 
 #include "almost_satisfies_types.h"
+#include "counting_predicates.h"
+#include "counting_projection.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+struct FalsePredicate {
+  constexpr bool operator()(int) { return false; }
+};
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>, class OutIter = int*>
+concept HasReplaceCopyIfIter = requires(Iter&& first, Sent&& last, OutIter&& result) {
+  std::ranges::replace_copy_if(
+      std::forward<Iter>(first), std::forward<Sent>(last), std::forward<OutIter>(result), FalsePredicate{}, 0);
+};
+
+static_assert(HasReplaceCopyIfIter<int*>);
+
+// !input_iterator<I>
+static_assert(!HasReplaceCopyIfIter<InputIteratorNotDerivedFrom>);
+static_assert(!HasReplaceCopyIfIter<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyIfIter<InputIteratorNotInputOrOutputIterator>);
+
+// !sentinel_for<S, I>
+static_assert(!HasReplaceCopyIfIter<int*, SentinelForNotSemiregular>);
+static_assert(!HasReplaceCopyIfIter<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+// !output_iterator<O, const T2&>
+static_assert(!HasReplaceCopyIfIter<int*, int*, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyIfIter<int*, int*, OutputIteratorNotInputOrOutputIterator>);
+
+// !indirect_unary_predicate<Pred, projected<I, Proj>> Pred>
+static_assert(!HasReplaceCopyIfIter<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasReplaceCopyIfIter<IndirectUnaryPredicateNotPredicate>);
+
+// !indirectly_copyable<I, O>
+static_assert(!HasReplaceCopyIfIter<int*, int*, int**>);
+
+template <class Range, class OutIter = int*>
+concept HasReplaceCopyIfRange = requires(Range&& range, OutIter&& result) {
+  std::ranges::replace_copy_if(std::forward<Range>(range), std::forward<OutIter>(result), FalsePredicate{}, 0);
+};
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasReplaceCopyIfRange<R<int*>>);
+
+// !input_range<R>
+static_assert(!HasReplaceCopyIfRange<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceCopyIfRange<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyIfRange<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceCopyIfRange<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceCopyIfRange<InputRangeNotSentinelEqualityComparableWith>);
+
+// !output_iterator<O, const T2&>
+static_assert(!HasReplaceCopyIfRange<R<int*>, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyIfRange<R<int*>, OutputIteratorNotInputOrOutputIterator>);
+
+// !indirect_unary_predicate<Pred, projected<iterator_t<R>, Proj>> Pred>
+static_assert(!HasReplaceCopyIfRange<R<IndirectUnaryPredicateNotPredicate>>);
+
+// !indirectly_copyable<iterator_t<R>, O>
+static_assert(!HasReplaceCopyIfRange<R<int*>, int**>);
+
+template <int N>
+struct Data {
+  std::array<int, N> input;
+  int cutoff;
+  int new_value;
+  std::array<int, N> expected;
+};
+
+template <class InIter, class Sent, class OutIter, int N>
+constexpr void test(Data<N> d) {
+  { // iterator overload
+    std::array<int, N> output;
+
+    auto first  = InIter(d.input.data());
+    auto last   = Sent(InIter(d.input.data() + d.input.size()));
+    auto result = OutIter(output.data());
+
+    auto pred = [&](int i) { return i < d.cutoff; };
+
+    std::same_as<std::ranges::replace_copy_if_result<InIter, OutIter>> decltype(auto) ret =
+        std::ranges::replace_copy_if(std::move(first), std::move(last), std::move(result), pred, d.new_value);
+    assert(base(ret.in) == d.input.data() + d.input.size());
+    assert(base(ret.out) == output.data() + output.size());
+    assert(d.expected == output);
+  }
+
+  { // range overload
+    std::array<int, N> output;
+
+    auto range  = std::ranges::subrange(InIter(d.input.data()), Sent(InIter(d.input.data() + d.input.size())));
+    auto result = OutIter(output.data());
+
+    auto pred = [&](int i) { return i < d.cutoff; };
+
+    std::same_as<std::ranges::replace_copy_if_result<InIter, OutIter>> decltype(auto) ret =
+        std::ranges::replace_copy_if(range, result, pred, d.new_value);
+    assert(base(ret.in) == d.input.data() + d.input.size());
+    assert(base(ret.out) == output.data() + output.size());
+    assert(d.expected == output);
+  }
+}
+
+template <class InIter, class Sent, class OutIter>
+constexpr void tests() {
+  // simple test
+  test<InIter, Sent, OutIter, 4>({.input = {1, 2, 3, 4}, .cutoff = 2, .new_value = 5, .expected = {5, 2, 3, 4}});
+  // empty range
+  test<InIter, Sent, OutIter, 0>({.input = {}, .cutoff = 2, .new_value = 5, .expected = {}});
+  // all elements match
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .cutoff = 2, .new_value = 2, .expected = {2, 2, 2, 2}});
+  // no element matches
+  test<InIter, Sent, OutIter, 4>({.input = {1, 1, 1, 1}, .cutoff = 1, .new_value = 3, .expected = {1, 1, 1, 1}});
+  // more elements
+  test<InIter, Sent, OutIter, 7>(
+      {.input = {1, 2, 3, 4, 5, 6, 7}, .cutoff = 3, .new_value = 3, .expected = {3, 3, 3, 4, 5, 6, 7}});
+  // single element - match
+  test<InIter, Sent, OutIter, 1>({.input = {1}, .cutoff = 2, .new_value = 5, .expected = {5}});
+  // single element - no match
+  test<InIter, Sent, OutIter, 1>({.input = {2}, .cutoff = 2, .new_value = 5, .expected = {2}});
+}
+
+template <class InIter, class Sent>
+constexpr void test_output_iterators() {
+  tests<InIter, Sent, cpp17_output_iterator<int*>>();
+  tests<InIter, Sent, forward_iterator<int*>>();
+  tests<InIter, Sent, bidirectional_iterator<int*>>();
+  tests<InIter, Sent, random_access_iterator<int*>>();
+  tests<InIter, Sent, contiguous_iterator<int*>>();
+  tests<InIter, Sent, int*>();
+}
+
+template <class InIter>
+constexpr void test_sentinels() {
+  test_output_iterators<InIter, InIter>();
+  test_output_iterators<InIter, sentinel_wrapper<InIter>>();
+  test_output_iterators<InIter, sized_sentinel<InIter>>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_output_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
+  test_output_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_sentinels<forward_iterator<int*>>();
+  test_sentinels<bidirectional_iterator<int*>>();
+  test_sentinels<random_access_iterator<int*>>();
+  test_sentinels<contiguous_iterator<int*>>();
+  test_sentinels<int*>();
+  test_sentinels<const int*>();
+
+  { // check that a custom projection works
+    struct S {
+      int i;
+    };
+
+    { // iterator overload
+      S a[] = {{1}, {2}, {3}, {4}};
+      S b[4];
+      auto ret = std::ranges::replace_copy_if(std::begin(a), std::end(a), std::begin(b), FalsePredicate{}, S{2}, &S::i);
+      assert(ret.in == std::end(a));
+      assert(ret.out == std::end(b));
+      assert(std::ranges::equal(a, b, {}, &S::i, &S::i));
+    }
+
+    { // range overload
+      S a[] = {{1}, {2}, {3}, {4}};
+      S b[4];
+      auto ret = std::ranges::replace_copy_if(a, std::begin(b), FalsePredicate{}, S{2}, &S::i);
+      assert(ret.in == std::end(a));
+      assert(ret.out == std::end(b));
+      assert(std::ranges::equal(a, b, {}, &S::i, &S::i));
+    }
+  }
+
+  {   // Complexity: exactly `last - first` applications of the corresponding predicate and any projection.
+    { // iterator overload
+      int pred_count = 0;
+      int proj_count = 0;
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+
+      std::ranges::replace_copy_if(
+          std::begin(a), std::end(a), std::begin(b),
+          counting_predicate(FalsePredicate{}, pred_count), 0, counting_projection(proj_count));
+      assert(pred_count == 4);
+      assert(proj_count == 4);
+    }
+
+    { // range overload
+      int pred_count = 0;
+      int proj_count = 0;
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+
+      std::ranges::replace_copy_if(a, std::begin(b),
+          counting_predicate(FalsePredicate{}, pred_count), 0, counting_projection(proj_count));
+      assert(pred_count == 4);
+      assert(proj_count == 4);
+    }
+  }
+
+  { // using different types for the old and new values works
+    struct S {
+      constexpr operator int() const { return 1; }
+    };
+    {
+      int a[] = {0, 0, 2, 3};
+      int b[4];
+      std::ranges::replace_copy_if(std::begin(a), std::end(a), std::begin(b), [](int i) { return i < 2; }, S{});
+      assert(std::ranges::equal(b, std::array{1, 1, 2, 3}));
+    }
+
+    {
+      int a[] = {0, 0, 2, 3};
+      int b[4];
+      std::ranges::replace_copy_if(a, std::begin(b), [](int i) { return i < 2; }, S{});
+      assert(std::ranges::equal(b, std::array{1, 1, 2, 3}));
+    }
+  }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/ranges_result_alias_declarations.compile.pass.cpp

 static_assert(std::is_same_v<in_out_result<int, long>, copy_n_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, copy_if_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, copy_backward_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, move_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, move_backward_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, partial_sort_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, remove_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, remove_copy_if_result<int, long>>);
-// static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_result<int, long>>);
-// static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_if_result<int, long>>);
+static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_result<int, long>>);
+static_assert(std::is_same_v<in_out_result<int, long>, replace_copy_if_result<int, long>>);
 // static_assert(std::is_same_v<in_out_result<int, long>, reverse_copy_result<int, long>>);
 // static_assert(std::is_same_v<in_out_result<int, long>, rotate_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, set_difference_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, unary_transform_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_copy_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_copy_n_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_move_result<int, long>>);
 static_assert(std::is_same_v<in_out_result<int, long>, uninitialized_move_n_result<int, long>>);

libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp

constexpr bool test_all() {
   using std::ranges::minmax_result;
   using std::ranges::mismatch_result;
   using std::ranges::move_result;
   using std::ranges::move_backward_result;
   using std::ranges::partial_sort_copy_result;
   using std::ranges::partition_copy_result;
   using std::ranges::remove_copy_result;
   using std::ranges::remove_copy_if_result;
+  using std::ranges::replace_copy_result;
+  using std::ranges::replace_copy_if_result;
   using std::ranges::reverse_copy_result;
   using std::ranges::rotate_copy_result;
   using std::ranges::set_difference_result;
   using std::ranges::set_intersection_result;
   using std::ranges::set_symmetric_difference_result;
   using std::ranges::set_union_result;
   using std::ranges::swap_ranges_result;
   using std::ranges::unary_transform_result;
dangling_1st(std::ranges::fill, in, x);
     dangling_both<binary_transform_result<dangling, dangling, bool*>>(
         std::ranges::transform, in, in2, out_transform.begin(), binary_pred);
   }
   dangling_1st(std::ranges::generate, in, gen);
   dangling_1st<remove_copy_result<dangling, int*>>(std::ranges::remove_copy, in, out, x);
   dangling_1st<remove_copy_if_result<dangling, int*>>(std::ranges::remove_copy_if, in, out, unary_pred);
   dangling_1st(std::ranges::replace, in, x, x);
   dangling_1st(std::ranges::replace_if, in, std::identity{}, x);
-  //dangling_1st(std::ranges::replace_copy, in, out, x, x);
-  //dangling_1st(std::ranges::replace_copy_if, in, out, x, x);
+  dangling_1st<replace_copy_result<dangling, int*>>(std::ranges::replace_copy, in, out, x, x);
+  dangling_1st<replace_copy_if_result<dangling, int*>>(std::ranges::replace_copy_if, in, out, unary_pred, x);
   dangling_1st<swap_ranges_result<dangling, int*>>(std::ranges::swap_ranges, in, in2);
   dangling_2nd<swap_ranges_result<int*, dangling>>(std::ranges::swap_ranges, in, in2);
   dangling_both<swap_ranges_result<dangling, dangling>>(std::ranges::swap_ranges, in, in2);
   dangling_1st<reverse_copy_result<dangling, int*>>(std::ranges::reverse_copy, in, out);
   dangling_1st<rotate_copy_result<dangling, int*>>(std::ranges::rotate_copy, in, mid, out);
   dangling_1st<unique_copy_result<dangling, int*>>(std::ranges::unique_copy, in, out);
   dangling_1st<partition_copy_result<dangling, int*, int*>>(std::ranges::partition_copy, in, out, out2, unary_pred);
   dangling_1st<partial_sort_copy_result<dangling, int*>>(std::ranges::partial_sort_copy, in, in2);

libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.pass.cpp

constexpr bool test_all() {
   test(std::ranges::includes, in, in2, binary_pred);
   test(std::ranges::is_heap, in, binary_pred);
   test(std::ranges::is_heap_until, in, binary_pred);
   //std::ranges::clamp(2, 1, 3, binary_pred);
   //test(std::ranges::is_permutation, in, in2, binary_pred);
   test(std::ranges::copy_if, in, out, unary_pred);
   test(std::ranges::remove_copy_if, in, out, unary_pred);
   test(std::ranges::replace_if, in, unary_pred, x);
-  //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
+  test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   test(std::ranges::unique_copy, in, out, binary_pred);
   test(std::ranges::partition_copy, in, out, out2, unary_pred);
   test(std::ranges::partial_sort_copy, in, in2, binary_pred);
   test(std::ranges::merge, in, in2, out, binary_pred);
   test(std::ranges::set_difference, in, in2, out, binary_pred);
   test(std::ranges::set_intersection, in, in2, out, binary_pred);
   test(std::ranges::set_symmetric_difference, in, in2, out, binary_pred);
   test(std::ranges::set_union, in, in2, out, binary_pred);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp

// `fill` and `fill_n` have neither a projection nor a predicate.
     test(std::ranges::transform, in, out_transform.begin(), &Foo::unary_pred, &Bar::val);
   }
   // Whether `ranges::generate{,_n}` invokes `gen` via `std::invoke` is not observable.
   test(std::ranges::remove_copy, in, out, x, &Bar::val);
   test(std::ranges::remove_copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `replace*` algorithms only use the projection to compare the elements, not to write them.
   test(std::ranges::replace, in, x, a, &Bar::val);
   test(std::ranges::replace_if, in, &Foo::unary_pred, a, &Bar::val);
-  //test(std::ranges::replace_copy, in, out, x, a, &Bar::val);
-  //test(std::ranges::replace_copy_if, in, out, pred, a, &Bar::val);
+  test(std::ranges::replace_copy, in, out, x, a, &Bar::val);
+  test(std::ranges::replace_copy_if, in, out, &Foo::unary_pred, a, &Bar::val);
   // `swap_ranges` has neither a projection nor a predicate.
   // `reverse_copy` has neither a projection nor a predicate.
   // `rotate_copy` has neither a projection nor a predicate.
   // `sample` has no requirement that the given generator be invoked via `std::invoke`.
   test(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
   test(std::ranges::partition_copy, in, out, out2, &Foo::unary_pred, &Bar::val);
   test(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);

libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp

constexpr void run_tests() {
   }
   test(std::ranges::generate, in, gen);
   std::ranges::generate_n(in.begin(), count, gen);
   if constexpr (std::copyable<T>) {
     test(std::ranges::remove_copy, in, out, x);
     test(std::ranges::remove_copy_if, in, out, unary_pred);
     test(std::ranges::replace, in, x, x);
     test(std::ranges::replace_if, in, unary_pred, x);
-    //test(std::ranges::replace_copy, in, out, x, x);
-    //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
+    test(std::ranges::replace_copy, in, out, x, x);
+    test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   }
   test(std::ranges::swap_ranges, in, in2);
   if constexpr (std::copyable<T>) {
     test(std::ranges::reverse_copy, in, out);
     test_mid(std::ranges::rotate_copy, in, mid, out);
     test(std::ranges::unique_copy, in, out);
     test(std::ranges::partition_copy, in, out, out2, unary_pred);
     test(std::ranges::partial_sort_copy, in, in2);

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 static_assert(test(std::ranges::pop_heap, a));
 //static_assert(test(std::ranges::prev_permutation, a));
 static_assert(test(std::ranges::push_heap, a));
 static_assert(test(std::ranges::remove, a, 42));
 static_assert(test(std::ranges::remove_copy, a, a, 42));
 static_assert(test(std::ranges::remove_copy_if, a, a, odd));
 static_assert(test(std::ranges::remove_if, a, odd));
 static_assert(test(std::ranges::replace, a, 42, 43));
-//static_assert(test(std::ranges::replace_copy, a, a, 42, 43));
-//static_assert(test(std::ranges::replace_copy_if, a, a, odd, 43));
+static_assert(test(std::ranges::replace_copy, a, a, 42, 43));
+static_assert(test(std::ranges::replace_copy_if, a, a, odd, 43));
 static_assert(test(std::ranges::replace_if, a, odd, 43));
 static_assert(test(std::ranges::reverse, a));
 static_assert(test(std::ranges::reverse_copy, a, a));
 //static_assert(test(std::ranges::rotate, a, a+5));
 static_assert(test(std::ranges::rotate_copy, a, a+5, a));
 //static_assert(test(std::ranges::sample, a, a, 5));
 static_assert(test(std::ranges::search, a, a));
 static_assert(test(std::ranges::search_n, a, 10, 42));

libcxx/test/support/counting_predicates.h

class counting_predicate {
   Predicate pred_;
   int* count_ = nullptr;
 
 public:
   constexpr counting_predicate() = default;
   constexpr counting_predicate(Predicate pred, int& count) : pred_(std::move(pred)), count_(&count) {}
 
   template <class... Args>
+  constexpr decltype(auto) operator()(Args&& ...args) {
+    ++(*count_);
+    return pred_(std::forward<Args>(args)...);
+  }
+
+  template <class... Args>
   constexpr decltype(auto) operator()(Args&& ...args) const {
     ++(*count_);
     return pred_(std::forward<Args>(args)...);
   }
 };
 
 template <class Predicate>
 counting_predicate(Predicate pred, int& count) -> counting_predicate<Predicate>;
 
 #endif // TEST_STD_VER > 14
 
 #endif // TEST_SUPPORT_COUNTING_PREDICATES_H