[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

718

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

66–67

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

222

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.

47

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

libcxx/include/algorithm

737

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

39

s/RemoveIf/ReplaceCopy/.

80

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

170

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

42

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

55

s/ReplaceCopy/ReplaceCopyIf/.

86

Same nit re. return type.

186

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,Nikolas Klauser,n/a,Not started
 Write,generate_n,Nikolas Klauser,n/a,Not started
 Write,remove_copy,Nikolas Klauser,n/a,Not started
 Write,remove_copy_if,Nikolas Klauser,n/a,Not started
 Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
-Write,replace_copy,Nikolas Klauser,n/a,Not started
-Write,replace_copy_if,Nikolas Klauser,n/a,Not started
+Write,replace_copy,Nikolas Klauser,`D126283 <https://llvm.org/D129806>`_,✅
+Write,replace_copy_if,Nikolas Klauser,`D126283 <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,Not assigned,n/a,Not started
 Write,partition_copy,Not assigned,n/a,Not started
 Write,partial_sort_copy,Not assigned,n/a,Not started
 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<input_range R1, input_range R2, class Pred = ranges::equal_to,
   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_symmetric_difference_result<I1, I2, O>
       set_symmetric_difference(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_symmetric_difference_result<borrowed_iterator_t<R1>,
                                                       borrowed_iterator_t<R2>, O>
       set_symmetric_difference(R1&& r1, R2&& r2, O result, Comp comp = {},
                                Proj1 proj1 = {}, Proj2 proj2 = {});                                 // 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 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<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_move_backward.h>
 #include <__algorithm/ranges_none_of.h>
 #include <__algorithm/ranges_nth_element.h>
 #include <__algorithm/ranges_pop_heap.h>
 #include <__algorithm/ranges_push_heap.h>
 #include <__algorithm/ranges_remove.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);
#endif
     (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 "almost_satisfies_types.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+template <class Iter, class Sent = sentinel_wrapper<Iter>, class OutIter = int*>
+concept HasRemoveIfIt =
+    requires(Iter first, Sent last, OutIter result) { std::ranges::replace_copy(first, last, result, 0, 0); };
+
+static_assert(HasRemoveIfIt<int*>);
+static_assert(!HasRemoveIfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasRemoveIfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasRemoveIfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasRemoveIfIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasRemoveIfIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasRemoveIfIt<int*, int*, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasRemoveIfIt<int*, int*, OutputIteratorNotInputOrOutputIterator>);
+
+template <class Range, class OutIter = int*>
+concept HasReplaceCopyR = requires(Range range, OutIter result) { std::ranges::replace_copy(range, result, 0, 0); };
+
+static_assert(HasReplaceCopyR<UncheckedRange<int*>>);
+static_assert(!HasReplaceCopyR<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceCopyR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceCopyR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceCopyR<InputRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasReplaceCopyR<UncheckedRange<int*>, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyR<UncheckedRange<int*>, OutputIteratorNotInputOrOutputIterator>);
+
+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::in_out_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::in_out_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));
+    }
+  }
+
+  {   // check complexity requirements
+    { // iterator overload
+      int proj_count = 0;
+      auto proj      = [&](int i) {
+        ++proj_count;
+        return i;
+      };
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy(std::begin(a), std::end(a), std::begin(b), 0, 0, proj);
+      assert(proj_count == 4);
+    }
+    { // range overload
+      int proj_count = 0;
+      auto proj      = [&](int i) {
+        ++proj_count;
+        return i;
+      };
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy(a, std::begin(b), 0, 0, proj);
+      assert(proj_count == 4);
+    }
+  }
+
+  { // using different types the old and new value 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

 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
 
 #include "almost_satisfies_types.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 HasRemoveIfIt = requires(
+    Iter first, Sent last, OutIter result) { std::ranges::replace_copy_if(first, last, result, FalsePredicate{}, 0); };
+
+static_assert(HasRemoveIfIt<int*>);
+static_assert(!HasRemoveIfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasRemoveIfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasRemoveIfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasRemoveIfIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasRemoveIfIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasRemoveIfIt<int*, int*, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasRemoveIfIt<int*, int*, OutputIteratorNotInputOrOutputIterator>);
+
+template <class Range, class OutIter = int*>
+concept HasReplaceCopyR =
+    requires(Range range, OutIter result) { std::ranges::replace_copy_if(range, result, FalsePredicate{}, 0); };
+
+static_assert(HasReplaceCopyR<UncheckedRange<int*>>);
+static_assert(!HasReplaceCopyR<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceCopyR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceCopyR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceCopyR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceCopyR<InputRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasReplaceCopyR<UncheckedRange<int*>, OutputIteratorNotIndirectlyWritable>);
+static_assert(!HasReplaceCopyR<UncheckedRange<int*>, OutputIteratorNotInputOrOutputIterator>);
+
+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::in_out_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::in_out_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));
+    }
+  }
+
+  {   // check complexity requirements
+    { // iterator overload
+      int proj_count = 0;
+      auto proj      = [&](int i) {
+        ++proj_count;
+        return i;
+      };
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy_if(std::begin(a), std::end(a), std::begin(b), FalsePredicate{}, 0, proj);
+      assert(proj_count == 4);
+    }
+    { // range overload
+      int proj_count = 0;
+      auto proj      = [&](int i) {
+        ++proj_count;
+        return i;
+      };
+      int a[] = {1, 2, 3, 4};
+      int b[4];
+      std::ranges::replace_copy_if(a, std::begin(b), FalsePredicate{}, 0, proj);
+      assert(proj_count == 4);
+    }
+  }
+
+  { // using different types the old and new value 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_robust_against_nonbool_predicates.compile.pass.cpp

void test_all() {
   //in2_pred(std::ranges::is_permutation, in, in2, binary_pred);
   in_out_pred(std::ranges::copy_if, in, out, unary_pred);
   //in_out_pred(std::ranges::remove_copy_if, in, out, unary_pred);
 
   // replace_if
   //std::ranges::replace_if(in.begin(), in.end(), unary_pred, x);
   //std::ranges::replace_if(in, unary_pred, x);
   // replace_copy_if
-  //std::ranges::replace_copy_if(in.begin(), in.end(), out, unary_pred, x);
-  //std::ranges::replace_copy_if(in, out, unary_pred, x);
+  std::ranges::replace_copy_if(in.begin(), in.end(), out, unary_pred, x);
+  std::ranges::replace_copy_if(in, out, unary_pred, x);
 
   //in_out_pred(std::ranges::unique_copy, in, out, binary_pred);
   // partition_copy
   //std::ranges::partition_copy(in.begin(), in.end(), out, out2, unary_pred);
   //std::ranges::partition_copy(in, out, out2, unary_pred);
   //in2_pred(std::ranges::partial_sort_copy, in, in2, binary_pred);
   in2_out_pred(std::ranges::merge, in, in2, out, binary_pred);
   in2_out_pred(std::ranges::set_difference, in, in2, out, binary_pred);

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

void test_all() {
   // `replace*` algorithms only use the projection to compare the elements, not to write them.
   // replace
   std::ranges::replace(in.begin(), in.end(), x, a, &Bar::val);
   std::ranges::replace(in, x, a, &Bar::val);
   // replace_if
   std::ranges::replace_if(in.begin(), in.end(), &Foo::unary_pred, a, &Bar::val);
   std::ranges::replace_if(in, &Foo::unary_pred, a, &Bar::val);
   // replace_copy
-  //std::ranges::replace_copy(in.begin(), in.end(), out, x, a, &Bar::val);
-  //std::ranges::replace_copy(in, out, x, a, &Bar::val);
+  std::ranges::replace_copy(in.begin(), in.end(), out, x, a, &Bar::val);
+  std::ranges::replace_copy(in, out, x, a, &Bar::val);
   // replace_copy_if
-  //std::ranges::replace_copy_if(in.begin(), in.end(), out, pred, a, &Bar::val);
-  //std::ranges::replace_copy_if(in, out, pred, a, &Bar::val);
+  std::ranges::replace_copy_if(in.begin(), in.end(), out, &Foo::unary_pred, a, &Bar::val);
+  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`.
   //in_out_pred(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
   // partition_copy
   //std::ranges::partition_copy(in.begin(), in.end(), out, out2, &Foo::unary_pred, &Bar::val);
   //std::ranges::partition_copy(in, out, out2, &Foo::unary_pred, &Bar::val);