[libc++] Implement ranges::replace{, _if}

Reviewed By: var-const, #libc

Spies: libcxx-commits, mgorny

Differential Revision: https://reviews.llvm.org/D126283

libcxx/docs/Status/RangesAlgorithms.csv

@@ -49,8 +49,8 @@ Write,generate,Not assigned,n/a,Not started
 Write,generate_n,Not assigned,n/a,Not started
 Write,remove_copy,Not assigned,n/a,Not started
 Write,remove_copy_if,Not assigned,n/a,Not started
-Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,Under review
-Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,Under review
+Write,replace,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
+Write,replace_if,Nikolas Klauser,`D126283 <https://llvm.org/D126283>`_,✅
 Write,replace_copy,Not assigned,n/a,Not started
 Write,replace_copy_if,Not assigned,n/a,Not started
 Write,swap_ranges,Nikolas Klauser,`D116303 <https://llvm.org/D116303>`_,✅

libcxx/include/CMakeLists.txt

@@ -97,6 +97,8 @@ set(files
   __algorithm/ranges_minmax_element.h
   __algorithm/ranges_mismatch.h
   __algorithm/ranges_none_of.h
+  __algorithm/ranges_replace.h
+  __algorithm/ranges_replace_if.h
   __algorithm/ranges_reverse.h
   __algorithm/ranges_swap_ranges.h
   __algorithm/ranges_transform.h

libcxx/include/__algorithm/ranges_replace.h

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_H
+#define _LIBCPP___ALGORITHM_RANGES_REPLACE_H
+
+#include <__algorithm/ranges_replace_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined (_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __replace {
+struct __fn {
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
+            class _Type1,
+            class _Type2,
+            class _Proj = identity>
+    requires indirectly_writable<_Iter, const _Type2&>
+          && indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type1*>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  _Iter operator()(_Iter __first, _Sent __last,
+                   const _Type1& __old_value,
+                   const _Type2& __new_value,
+                   _Proj __proj = {}) const {
+    auto __pred = [&](const auto& __val) { return __val == __old_value; };
+    return ranges::__replace_if_impl(std::move(__first), std::move(__last), __pred, __new_value, __proj);
+  }
+
+  template <input_range _Range,
+            class _Type1,
+            class _Type2,
+            class _Proj = identity>
+    requires indirectly_writable<iterator_t<_Range>, const _Type2&>
+          && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type1*>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, const _Type1& __old_value, const _Type2& __new_value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __val) { return __val == __old_value; };
+    return ranges::__replace_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __new_value, __proj);
+  }
+
+};
+} // namespace __replace
+
+inline namespace __cpo {
+  inline constexpr auto replace = __replace::__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_H

libcxx/include/__algorithm/ranges_replace_if.h

@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_IF_H
+#define _LIBCPP___ALGORITHM_RANGES_REPLACE_IF_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined (_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Iter, class _Sent, class _Type, class _Proj, class _Pred>
+_LIBCPP_HIDE_FROM_ABI constexpr
+_Iter __replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type& __new_value, _Proj& __proj) {
+  for (; __first != __last; ++__first) {
+    if (std::invoke(__pred, std::invoke(__proj, *__first)))
+      *__first = __new_value;
+  }
+  return __first;
+}
+
+namespace __replace_if {
+struct __fn {
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
+            class _Type,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+    requires indirectly_writable<_Iter, const _Type&>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
+    return ranges::__replace_if_impl(std::move(__first), std::move(__last), __pred, __new_value, __proj);
+  }
+
+  template <input_range _Range,
+            class _Type,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+    requires indirectly_writable<iterator_t<_Range>, const _Type&>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
+    return ranges::__replace_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __new_value, __proj);
+  }
+
+};
+} // namespace __replace_if
+
+inline namespace __cpo {
+  inline constexpr auto replace_if = __replace_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_IF_H

libcxx/include/algorithm

@@ -401,6 +401,29 @@ namespace ranges {
                                      projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
     constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {});  // since C++20
 
+  template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
+    requires indirectly_writable<I, const T2&> &&
+             indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+    constexpr I
+      ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});   // since C++20
+
+  template<input_range R, class T1, class T2, class Proj = identity>
+    requires indirectly_writable<iterator_t<R>, const T2&> &&
+             indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+    constexpr borrowed_iterator_t<R>
+      ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});             // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    requires indirectly_writable<I, const T&>
+    constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
+
+  template<input_range R, class T, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    requires indirectly_writable<iterator_t<R>, const T&>
+    constexpr borrowed_iterator_t<R>
+      ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});                     // since C++20
+
 }
 
     constexpr bool     // constexpr in C++20
@@ -1148,6 +1171,8 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/ranges_minmax_element.h>
 #include <__algorithm/ranges_mismatch.h>
 #include <__algorithm/ranges_none_of.h>
+#include <__algorithm/ranges_replace.h>
+#include <__algorithm/ranges_replace_if.h>
 #include <__algorithm/ranges_reverse.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/ranges_transform.h>

libcxx/include/module.modulemap.in

@@ -336,6 +336,8 @@ module std [system] {
       module ranges_minmax_element    { private header "__algorithm/ranges_minmax_element.h" }
       module ranges_mismatch          { private header "__algorithm/ranges_mismatch.h" }
       module ranges_none_of           { private header "__algorithm/ranges_none_of.h" }
+      module ranges_replace           { private header "__algorithm/ranges_replace.h" }
+      module ranges_replace_if        { private header "__algorithm/ranges_replace_if.h" }
       module ranges_reverse           { private header "__algorithm/ranges_reverse.h" }
       module ranges_swap_ranges       { private header "__algorithm/ranges_swap_ranges.h" }
       module ranges_transform         { private header "__algorithm/ranges_transform.h" }

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

@@ -193,8 +193,8 @@ constexpr bool all_the_algorithms()
     //(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_if(first, last, UnaryTrue(&copies), value); assert(copies == 0);
-    //(void)std::ranges::replace_if(a, 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);

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

@@ -182,10 +182,10 @@ constexpr bool all_the_algorithms()
     //(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::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);

libcxx/test/libcxx/private_headers.verify.cpp

@@ -134,6 +134,8 @@ END-SCRIPT
 #include <__algorithm/ranges_minmax_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax_element.h'}}
 #include <__algorithm/ranges_mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}
 #include <__algorithm/ranges_none_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_none_of.h'}}
+#include <__algorithm/ranges_replace.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace.h'}}
+#include <__algorithm/ranges_replace_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace_if.h'}}
 #include <__algorithm/ranges_reverse.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_reverse.h'}}
 #include <__algorithm/ranges_swap_ranges.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_swap_ranges.h'}}
 #include <__algorithm/ranges_transform.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_transform.h'}}

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

@@ -0,0 +1,200 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, class T1, class T2, class Proj = identity>
+//   requires indirectly_writable<I, const T2&> &&
+//            indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
+//   constexpr I
+//     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
+// template<input_range R, class T1, class T2, class Proj = identity>
+//   requires indirectly_writable<iterator_t<R>, const T2&> &&
+//            indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "boolean_testable.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+concept HasReplaceIt = requires(Iter iter, Sent sent) { std::ranges::replace(iter, sent, 0, 0); };
+
+static_assert(HasReplaceIt<int*>);
+static_assert(!HasReplaceIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasReplaceIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasReplaceIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasReplaceIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasReplaceIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasReplaceIt<int**>); // not indirectly_writable
+static_assert(!HasReplaceIt<IndirectBinaryPredicateNotIndirectlyReadable>);
+
+template <class Range>
+concept HasReplaceR = requires(Range range) { std::ranges::replace(range, 0, 0); };
+
+static_assert(HasReplaceR<UncheckedRange<int*>>);
+static_assert(!HasReplaceR<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceR<InputRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasReplaceR<UncheckedRange<int**>>); // not indirectly_writable
+static_assert(!HasReplaceR<InputRangeIndirectBinaryPredicateNotIndirectlyReadable>);
+
+template <int N>
+struct Data {
+  std::array<int, N> input;
+  int oldval;
+  int newval;
+  std::array<int, N> expected;
+};
+
+template <class Iter, class Sent, int N>
+constexpr void test(Data<N> d) {
+  {
+    auto a = d.input;
+    std::same_as<Iter> decltype(auto) ret = std::ranges::replace(Iter(a.data()), Sent(Iter(a.data() + N)),
+                                                                 d.oldval,
+                                                                 d.newval);
+    assert(base(ret) == a.data() + N);
+    assert(a == d.expected);
+  }
+  {
+    auto a = d.input;
+    auto range = std::ranges::subrange(Iter(a.data()), Sent(Iter(a.data() + N)));
+    std::same_as<Iter> decltype(auto) ret = std::ranges::replace(range, d.oldval, d.newval);
+    assert(base(ret) == a.data() + N);
+    assert(a == d.expected);
+  }
+}
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+  // simple test
+  test<Iter, Sent, 4>({.input = {1, 2, 3, 4}, .oldval = 2, .newval = 23, .expected = {1, 23, 3, 4}});
+  // no match
+  test<Iter, Sent, 4>({.input = {1, 2, 3, 4}, .oldval = 5, .newval = 23, .expected = {1, 2, 3, 4}});
+  // all match
+  test<Iter, Sent, 4>({.input = {1, 1, 1, 1}, .oldval = 1, .newval = 23, .expected = {23, 23, 23, 23}});
+  // empty range
+  test<Iter, Sent, 0>({.input = {}, .oldval = 1, .newval = 23, .expected = {}});
+  // single element range
+  test<Iter, Sent, 1>({.input = {1}, .oldval = 1, .newval = 2, .expected = {2}});
+}
+
+constexpr bool test() {
+  test_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
+  test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+  test_iterators<int*>();
+
+  { // check that the projection is used
+    struct S {
+      constexpr S(int i_) : i(i_) {}
+      int i;
+    };
+    {
+      S a[] = {1, 2, 3, 4};
+      std::ranges::replace(a, a + 4, 3, S{0}, &S::i);
+    }
+    {
+      S a[] = {1, 2, 3, 4};
+      std::ranges::replace(a, 3, S{0}, &S::i);
+    }
+  }
+
+  { // check that std::invoke is used
+    struct S {
+      constexpr S(int i_) : i(i_) {}
+      constexpr bool operator==(const S&) const = default;
+      constexpr const S& identity() const { return *this; }
+      int i;
+    };
+    {
+      S a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::replace(std::begin(a), std::end(a), S{1}, S{2}, &S::identity);
+      assert(ret == a + 4);
+    }
+    {
+      S a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::replace(a, S{1}, S{2}, &S::identity);
+      assert(ret == a + 4);
+    }
+  }
+
+  { // check that the implicit conversion to bool works
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace(std::begin(a), std::end(a), 1, 2);
+      assert(ret == std::end(a));
+    }
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace(a, 1, 2);
+      assert(ret == std::end(a));
+    }
+  }
+
+  { // check that T1 and T2 can be different types
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace(std::begin(a), std::end(a), '\0', 2ull);
+      assert(ret == std::end(a));
+    }
+    {
+      StrictComparable<int> a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace(a, '\0', 2ull);
+      assert(ret == std::end(a));
+    }
+  }
+
+  { // check that std::ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
+        std::ranges::replace(std::array {1, 2, 3, 4}, 1, 1);
+  }
+
+  { // check that the complexity requirements are met
+    {
+      auto projectionCount = 0;
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::replace(std::begin(a), std::end(a), 1, 2, proj);
+      assert(ret == a + 5);
+      assert(projectionCount == 5);
+    }
+    {
+      auto projectionCount = 0;
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::replace(a, 1, 2, proj);
+      assert(ret == a + 5);
+      assert(projectionCount == 5);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//   requires indirectly_writable<I, const T&>
+//   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
+// template<input_range R, class T, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//   requires indirectly_writable<iterator_t<R>, const T&>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "boolean_testable.h"
+#include "test_iterators.h"
+
+struct FalsePredicate {
+  bool operator()(auto&&) { return false; }
+};
+
+template <class Iter, class Sent = sentinel_wrapper<Iter>>
+concept HasReplaceIt = requires(Iter iter, Sent sent) { std::ranges::replace_if(iter, sent, FalsePredicate{}, 0); };
+
+static_assert(HasReplaceIt<int*>);
+static_assert(!HasReplaceIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasReplaceIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasReplaceIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasReplaceIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasReplaceIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasReplaceIt<int**>); // not indirectly_writable
+static_assert(!HasReplaceIt<IndirectBinaryPredicateNotIndirectlyReadable>);
+
+template <class Range>
+concept HasReplaceR = requires(Range range) { std::ranges::replace_if(range, FalsePredicate{}, 0); };
+
+static_assert(HasReplaceR<UncheckedRange<int*>>);
+static_assert(!HasReplaceR<InputRangeNotDerivedFrom>);
+static_assert(!HasReplaceR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasReplaceR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasReplaceR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasReplaceR<InputRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasReplaceR<UncheckedRange<int**>>); // not indirectly_writable
+static_assert(!HasReplaceR<InputRangeIndirectBinaryPredicateNotIndirectlyReadable>);
+
+template <class Iter, class Sent, int N, class Pred>
+constexpr void test(std::array<int, N> a_, Pred pred, int val, std::array<int, N> expected) {
+  {
+    auto a = a_;
+    std::same_as<Iter> auto ret = std::ranges::replace_if(Iter(a.data()), Sent(Iter(a.data() + N)),
+                                                          pred,
+                                                          val);
+    assert(base(ret) == a.data() + N);
+    assert(a == expected);
+  }
+  {
+    auto a = a_;
+    auto range = std::ranges::subrange(Iter(a.data()), Sent(Iter(a.data() + N)));
+    std::same_as<Iter> auto ret = std::ranges::replace_if(range, pred, val);
+    assert(base(ret) == a.data() + N);
+    assert(a == expected);
+  }
+}
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+  // simple test
+  test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 3; }, 23, {23, 23, 3, 4});
+  // no match
+  test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 0; }, 23, {1, 2, 3, 4});
+  // all match
+  test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i > 0; }, 23, {23, 23, 23, 23});
+  // empty range
+  test<Iter, Sent, 0>({}, [](int i) { return i > 0; }, 23, {});
+  // single element range
+  test<Iter, Sent, 1>({1}, [](int i) { return i > 0; }, 2, {2});
+}
+
+constexpr bool test() {
+  test_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
+  test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+  test_iterators<int*>();
+
+  { // check that the projection is used
+    struct S {
+      constexpr S(int i_) : i(i_) {}
+      int i;
+    };
+    {
+      S a[] = {1, 2, 3, 4};
+      std::ranges::replace_if(a, a + 4, [](int i) { return i == 3; }, S{0}, &S::i);
+    }
+    {
+      S a[] = {1, 2, 3, 4};
+      std::ranges::replace_if(a, [](int i) { return i == 3; }, S{0}, &S::i);
+    }
+  }
+
+  { // check that std::invoke is used
+    struct S {
+      constexpr S(int i_) : i(i_) {}
+      constexpr bool check() const { return false; }
+      constexpr const S& identity() const { return *this; }
+      int i;
+    };
+    {
+      S a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::replace_if(std::begin(a), std::end(a), &S::check, S{2}, &S::identity);
+      assert(ret == std::end(a));
+    }
+    {
+      S a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::replace_if(a, &S::check, S{2}, &S::identity);
+      assert(ret == std::end(a));
+    }
+  }
+
+  { // check that the implicit conversion to bool works
+    {
+      int a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace_if(std::begin(a), std::end(a), [](int) { return BooleanTestable{false}; }, 2);
+      assert(ret == std::end(a));
+    }
+    {
+      int a[] = {1, 2, 2, 4};
+      auto ret = std::ranges::replace_if(a, [](int) { return BooleanTestable{false}; }, 2);
+      assert(ret == std::end(a));
+    }
+  }
+
+  { // check that std::ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
+        std::ranges::replace_if(std::array {1, 2, 3, 4}, [](int) { return false; }, 1);
+  }
+
+  { // check that the complexity requirements are met
+    {
+      int predicateCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto projectionCount = 0;
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::replace_if(a, a + 5, pred, 1, proj);
+      assert(ret == a + 5);
+      assert(predicateCount == 5);
+      assert(projectionCount == 5);
+    }
+    {
+      int predicateCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto projectionCount = 0;
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::replace_if(a, pred, 1, proj);
+      assert(ret == a + 5);
+      assert(predicateCount == 5);
+      assert(projectionCount == 5);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

@@ -121,10 +121,10 @@ static_assert(test(std::ranges::none_of, a, odd));
 //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, 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_if, 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));

libcxx/test/support/almost_satisfies_types.h

@@ -9,6 +9,7 @@
 #ifndef ALMOST_SATISFIES_TYPES_H
 #define ALMOST_SATISFIES_TYPES_H
 
+#include <functional>
 #include <iterator>
 #include <ranges>
 
@@ -301,4 +302,19 @@ static_assert(!std::indirectly_writable<OutputIteratorNotIndirectlyWritable, int
 static_assert(!std::output_iterator<OutputIteratorNotIndirectlyWritable, int>);
 static_assert(!std::ranges::output_range<OutputIteratorNotIndirectlyWritable, int>);
 
+class IndirectBinaryPredicateNotIndirectlyReadable {
+public:
+  using difference_type = long;
+  using iterator_category = std::input_iterator_tag;
+
+  int& operator++();
+  void operator++(int);
+  const int& operator*() const;
+};
+
+using InputRangeIndirectBinaryPredicateNotIndirectlyReadable
+     = UncheckedRange<cpp20_input_iterator<int*>, IndirectBinaryPredicateNotIndirectlyReadable>;
+
+static_assert(!std::indirect_binary_predicate<std::ranges::equal_to, IndirectBinaryPredicateNotIndirectlyReadable, int*>);
+
 #endif // ALMOST_SATISFIES_TYPES_H