[libc++][ranges] Implement ranges::find{, _if, _if_not}

[• Quuxplusone]

Thanks, LGTM % comments. That was some quick turnaround time!

libcxx/include/__algorithm/ranges_find.h

40

(1) https://eel.is/c++draft/algorithms#alg.find-1.4 says __e == __value, which agrees with my prejudices too (thankfully). I believe this is observable by the user. Consider adding a regression test.
Ditto throughout.

(2) What you've got now is attractive, but it "flattens" the type of *__first into const auto&, which might unexpectedly const-qualify and/or lvalue-qualify it, which might(?) affect the resolution of operator==. Can you investigate whether this is OK (due to the requirements of indirect_binary_predicate)? You might need to use auto&& here. (@tcanens, thoughts?)
...Actually, you've already started using auto&& in find_if_not, implying maybe you found a regression test? Please add a similar test for find and find_if.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

50

Please also test bidirectional_iterator<int*>, int*, and const int*.
Ditto throughout.

62

IIUC, you meant this one to use the range overload. I wonder if this works, or if it's ambiguous...

69

86

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if.pass.cpp

35

This isn't a valid predicate; also I don't understand the point of doing c++ here anyway. Are you just trying to make sure the predicate is called non-const? In that case, you could just [](int x) mutable { return x == 2; } — the mutable makes the type not const-callable.

69

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if_not.pass.cpp

69

[ldionne]

libcxx/docs/Status/RangesAlgorithms.csv

5–8

libcxx/include/__algorithm/ranges_find.h

49

I don't like that we are reaching into __find_if::__fn here. Instead, we should have something like this in find_if.h:

template <class _Ip, class _Sp, class _Pred, class _Proj>
_LIBCPP_HIDE_FROM_ABI constexpr
_Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
    for (; __first != __last; ++__first) {
        if (std::invoke(__pred, std::invoke(__proj, *__first)))
            break;
    }
    return __first;
}

This provides a slightly (but not much) cleaner interface between the two headers, at least. TBH, I would support implementing this as ranges::find_if(ranges::begin(__r), ranges::end(__r), __pred, std::move(__proj)); (and similarly for the iterator/sentinel version), even though I understand this will lead to additional moves over the current approach. In practice, I don't think this is likely to matter, since iterators should be cheap to copy (and hence to move), and same for projections.

So, I have a slight preference for implementation simplicity despite it causing additional moves, but if you want to keep it as-is, please use a namespace scope function at least (and add a libc++ specific test for the no-move behavior).

libcxx/include/algorithm

48–71

This looks weirdly formatted -- please try to indent the return types consistently, etc.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

55–59

These projection tests are really clever. Something like this would be easier to read:

struct Point { int x; int y; };
Point points[] = {....};
auto ret = std::ranges::find(points, points + 4, 3, [](Point const& p) { return p.x; });
assert(ret == ....);

[philnik]

• Address comments

libcxx/include/__algorithm/ranges_find.h

49

@Quuxplusone wants to add the tests in another PR.

libcxx/include/algorithm

48–71

I'm not sure what you are asking for. The return types are all indented the same, and this is copied 1:1 from the standard (excluding the // since C++20).

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

69

I get why you want to avoid CTAD in template code, but what's wrong with it here? std::array {1, 2} is definitely easier to read than std::array<int, 2> {1, 2} and there is no chance that it deduces the wrong type.

[• Quuxplusone]

libcxx/include/algorithm

48–71

philnik's code is consistent with the standard's own weird formatting, which we do use in plenty of synopsis comments:

template<class T>
  constexpr R
    function_name(Args);

But immediately above this new stuff, the older stuff seems to be doing more libc++-code-style formatting:

template<class T>
constexpr R function_name(Args);

and immediately below, the really old stuff seems to be doing yet a third thing:

template<class T>
    constexpr R
    function_name(Args);

I personally don't mind the discrepancy, although it would be nice to make everything consistent one way or another.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

55–59

I agree it's hard to read, but part of the point of the projection test is to verify that we're calling the projection specifically on *first, never on a copy of *first. So "this projection returns the address of the argument" is important to the test.
However, we could do this:

assert(std::ranges::find(a, a + 4, 3, [](int& i) { return &i - a; }) == a + 3);

to avoid passing a, a + 4, a + 3 in close proximity.

69

Just for simplicity... Ah, but I see, I was forgetting that std::array<int>{1, 2} doesn't work, it needs to be std::array<int, 2>{1, 2}, which is indeed another step uglier.
In that case, I'll settle for std::array{1, 2} with no space between the type name and the brace. :)

[var-const]

libcxx/docs/Status/RangesAlgorithms.csv

5–7

Ultranit: please use the emoji checkmark, for consistency and better "visibility".

libcxx/include/__algorithm/ranges_find.h

49

Question: does __r need to be forwarded?

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

30

Similar to other algorithm patches, I think this needs more SFINAE tests.

34

Consider adding the following test cases (in all 3 files):

• empty range;
• no element satisfies the predicate;
• all elements satisfy the predicate (also check that it is the first equivalent element that is returned).

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if.pass.cpp

128

This should be find_if, right? (same in find_if_not.pass.cpp)

[var-const]

@philnik Thanks a lot for working on this!

[philnik]

• Rebased
• Address comments

libcxx/include/__algorithm/ranges_find.h

49

Definitely not the first one, and I also don't think the second one. We still need our range for the iterators to be valid, so conceptually it doesn't make sense to forward them (and makes probably no practical difference).

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

34

no elements satisfying the predicate is already checked with // check that std::invoke is used and all elements satisfy the predicate should effectively be checked by // count invocations of the projection, since that checks that there are exactly two projections. Or do you want to check for something more that I'm not seeing?

[• Quuxplusone]

libcxx/include/__algorithm/ranges_find.h

40

As in find_if_not's lambda, you need to std::forward __e here. (Economist's $100 bill — be consistent!)

49

Right, you never forward ranges. The Ranges idiom is "Take by forwarding reference, pass by lvalue." Because Ranges uses rvalueness to signify short lifetime, rather than pilferability; see
https://quuxplusone.github.io/blog/2022/02/02/look-what-they-need/#if-you-see-code-using-std-forwar
(See also Tristan Brindle's response https://tristanbrindle.com/posts/ranges-and-forwarding-references , which is kind of a prequel to that sentence of my post: it explains that Ranges uses constness to signify nothing rather than not-gonna-modify-it-ness, which explains why non-modifying algorithms can't just use const T& and have to use T&& in the first place.)

libcxx/include/__algorithm/ranges_find_if.h

33–41

(1) @ldionne, I disagree that this should be a standalone free function. Reaching into ranges::__foobar::__fn::__go doesn't strike me as any more confusing than reaching into ranges::__foobar_impl; all it does is add yet another layer of indirection for the gamedevs to complain about. It also implies code churn: as we implement new algorithms in terms of older ones, you're asking us to go back and pull out the old algorithm's guts from the existing __fn::__go into __foobar_impl. (I don't think you're asking for the pulling-out to be done preemptively on every algorithm, are you? It would be ad-hoc?) In short, I fairly strongly recommend putting this back the way it was; but I think @ldionne has the final say, so my job is to convince him. :)

(2) If this is kept: please add a blank line after namespace ranges { for readability.

(3) In fact, I would even recommend closing and reopening the namespace. My mental model is that we have this one helper in namespace ranges, and then further down in the file we have the essentially unrelated stuff in namespace ranges::__find_if. "Zeroing" in between is good practice IMHO: it makes it easier to see at a glance what namespace we're inside, because you don't have to keep a mental stack of the entire file but only back as far as the last "zero" point.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

62

For the record, ranges::find(a, a+3, proj) is not ambiguous, because proj is not equality-comparable-with int. But if you make it equality-comparable...
https://godbolt.org/z/88K1d1PKh
(Notice the non-explicit operator bool here; that's a code smell. So this isn't a real pitfall for users.)
@philnik, I think it would be cute, and perhaps even useful, to add this godbolt as a test case. It does probably somewhat constrain our possible implementation strategies for this overload set.

[var-const]

libcxx/include/__algorithm/ranges_find.h

49

Thanks a lot for the explanation and the links.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

34

I think each test case should have a single focus -- it makes it easier to read and better protects against future changes. If someone were to remove a test case that says // No element satisfies the predicate, it should be pretty obvious that test coverage is reduced. On the other hand, if someone were to modify // check that std::invoke is used so that it no longer covers the "no match" case, it's not immediately clear that this case may no longer be checked at all (and reading through every single test case to see if it's covered elsewhere is impractical).

34

(The new tests apply to all 3 algorithms. AFAICT, the new empty range test still needs to be added to find_if.pass.cpp and find_if_not.pass.cpp)

[• Quuxplusone]

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

34

I think each test case should have a single focus -- it makes it easier to read and better protects against future changes. If someone were to remove a test case that says // No element satisfies the predicate, it should be pretty obvious that test coverage is reduced. On the other hand, if someone were to modify // check that std::invoke is used so that it no longer covers the "no match" case, it's not immediately clear that this case may no longer be checked at all

+1. Of course one way around this would be to tag the single test case with both comments. But writing one-for-one test cases produces the side benefit of "more test coverage." E.g. maybe the std::invoke test case should take two lines and test both the "found" and "not found" codepaths; and maybe the not-found test case should also assert that in that situation the predicate is called exactly N times. (Or maybe that's just reintroducing the exact issue var-const objected to. That's fair. :)) Anyway, +1 to "one focus, one comment, one test case" from me. :)

[philnik]

• Rebased
• Address comments

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

34

Thanks, I must have forgotten to copy it.

[philnik]

• Add version guards

[philnik]

• Add more SFINAE tests

[ldionne]

LGTM -- I stand by my comment of using find_if_impl instead of a helper function inside the struct. It's a minor difference but IMO it's important.

Leaving last approval to @var-const, who had requested changes.

libcxx/include/__algorithm/ranges_find.h

49

If you want, you should also be able to write

auto __pred = [&]<class _Ep>(_Ep&& __e) { return std::forward<_Ep>(__e) == __value; };

[var-const]

LGTM (except the sentinel_for check -- sorry, I know it's tedious to add all those checks).

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if_not.pass.cpp

15

I think the sentinel_for constraint is still untested (if I'm not seeing it, please let me know). Sorry, I know it's annoying. Just a single pair of types where I satisfies input_iterator but not sentinel_for<I, S> is sufficient.

libcxx/test/support/almost_satisfies_types.h

41

Note: I think this type is sufficient for checking the input_iterator requirement -- i.e., a type that is an input_or_output_iterator but not input_iterator is perfect, but whether it satisfies indirectly_readable starts going into the "testing input_iterator" territory. So I'm not against also having InputIteratorNotIndirectlyReadable and InputIteratorNotInputOrOutputIterator, but IMO just InputIteratorNotDerivedFrom is sufficient.

97

Nit: can you add a closing comment? (// ALMOST_SATISFIES_TYPES_H)

[philnik]

• Rebased
• Address comments

[var-const]

Thanks for addressing all the feedback! LGTM when the CI is green.

libcxx/test/support/almost_satisfies_types.h

116

Ultranit: s/an/a (here and above).

125

Same note here: I'm not against having this type, but I also think that InputRangeNotSentinelSemiregular is sufficient.

[philnik]

• Remove lambdas in unevaluated contexts

[tcanens]

libcxx/include/__algorithm/ranges_find.h

40

The only requirement on the result of == is that it is boolean-testable, so these lambdas need to explicitly return bool - boolean-testable only guarantees that the exact expression can be used boolean-ish-ly in situ.

(1) https://eel.is/c++draft/algorithms#alg.find-1.4 says __e == __value, which agrees with my prejudices too (thankfully). I believe this is observable by the user. Consider adding a regression test.
Ditto throughout.

Since ranges::equal_to requires equality_comparable_with, this is not observable (we don't say that it compares this way; we say that it returns something for which the comparison yields true if compared that way).

(2) What you've got now is attractive, but it "flattens" the type of *__first into const auto&, which might unexpectedly const-qualify and/or lvalue-qualify it, which might(?) affect the resolution of operator==. Can you investigate whether this is OK (due to the requirements of indirect_binary_predicate)? You might need to use auto&& here. (@tcanens, thoughts?)
...Actually, you've already started using auto&& in find_if_not, implying maybe you found a regression test? Please add a similar test for find and find_if.

equality_comparable_with requires implicit expression variations, so turning into const& should be fine.

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

85

None of these model equality_comparable, so using them with ranges::find is IFNDR.

[ldionne]

libcxx/include/__algorithm/ranges_find.h

40

@philnik We need to address the -> bool in the lambda.

You should add a test: operator== returns something that can be converted to bool, but that can't be moved or copied. With the current implementation, it should fail cause you're returning it from the lambda. If you switch to -> bool, there would be an implicit conversion to bool and it should work.

[ldionne]

libcxx/include/__algorithm/ranges_find.h

40

Update: we don't need to change anything, we added tests for this in D122011 and no code changes are necessary.

libcxx/docs/Status/RangesAlgorithms.csv

 Category,Algorithm,Assignee,CL,Complete
 Search,any_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
 Search,all_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
 Search,none_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
-Search,find,Christopher Di Bella,`D105456 <https://llvm.org/D105456>`_
-Search,find_if,Christopher Di Bella,`D105792 <https://llvm.org/D105792>`_
-Search,find_if_not,Christopher Di Bella,`D105792 <https://llvm.org/D105792>`_
+Search,find,Nikolas Klauser,`D121248 <https://reviews.llvm.org/D121248>`_,✅
+Search,find_if,Nikolas Klauser,`D121248 <https://reviews.llvm.org/D121248>`_,✅
+Search,find_if_not,Nikolas Klauser,`D121248 <https://reviews.llvm.org/D121248>`_,✅
 Search,find_first_of,Not assigned,n/a,Not started
 Search,adjacent_find,Not assigned,n/a,Not started
 Search,mismatch,Nikolas Klauser,`D117817 <https://llvm.org/D117817>`,Complete
 Search,equal,Not assigned,n/a,Not started
 Search,lexicographical_compare,Not assigned,n/a,Not started
 Search,partition_point,Christopher Di Bella,`D105794 <https://llvm.org/D105794>`_,Under review
 Search,lower_bound,Christopher Di Bella,`D105795 <https://llvm.org/D105795>`_,Under review
 Search,upper_bound,Christopher Di Bella,`D105795 <https://llvm.org/D105795>`_,Under review
 Search,equal_range,Christopher Di Bella,n/a,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort.h
   __algorithm/partial_sort_copy.h
   __algorithm/partition.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
+  __algorithm/ranges_find.h
+  __algorithm/ranges_find_if.h
+  __algorithm/ranges_find_if_not.h
   __algorithm/ranges_max_element.h
   __algorithm/ranges_min_element.h
   __algorithm/ranges_mismatch.h
   __algorithm/ranges_swap_ranges.h
   __algorithm/remove.h
   __algorithm/remove_copy.h
   __algorithm/remove_copy_if.h
   __algorithm/remove_if.h

libcxx/include/__algorithm/ranges_find.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_FIND_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_H
+
+#include <__algorithm/ranges_find_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.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/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 {
+namespace __find {
+struct __fn {
+  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  _Ip operator()(_Ip __first, _Sp __last, const _Tp& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
+    return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <input_range _Rp, class _Tp, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rp>, _Proj>, const _Tp*>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, const _Tp& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __e) { return std::forward<decltype(__e)>(__e) == __value; };
+    return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
+  }
+};
+} // namespace __find
+
+inline namespace __cpo {
+  inline constexpr auto find = __find::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_H

libcxx/include/__algorithm/ranges_find_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_FIND_IF_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_IF_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.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 {
+
+template <class _Ip, class _Sp, class _Pred, class _Proj>
+_LIBCPP_HIDE_FROM_ABI static constexpr
+_Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
+  for (; __first != __last; ++__first) {
+    if (std::invoke(__pred, std::invoke(__proj, *__first)))
+      break;
+  }
+  return __first;
+}
+
+namespace __find_if {
+struct __fn {
+
+  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+            indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  _Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <input_range _Rp, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
+  }
+};
+} // namespace __find_if
+
+inline namespace __cpo {
+  inline constexpr auto find_if = __find_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_FIND_IF_H

libcxx/include/__algorithm/ranges_find_if_not.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_FIND_IF_NOT_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H
+
+#include <__algorithm/ranges_find_if.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.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/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 {
+namespace __find_if_not {
+struct __fn {
+  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+            indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  _Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+    return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred2, __proj);
+  }
+
+  template <input_range _Rp, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+    return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred2, __proj);
+  }
+};
+} // namespace __find_if_not
+
+inline namespace __cpo {
+  inline constexpr auto find_if_not = __find_if_not::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H

libcxx/include/algorithm

namespace ranges {
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>             // since C++20
   constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
 
   template<forward_range R, class Proj = identity,
     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
   constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
 
   template <input_iterator I1, sentinel_for<_I1> S1, input_iterator I2, sentinel_for<_I2> S2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
   constexpr mismatch_result<_I1, _I2>
   mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
 
   template <input_range R1, input_range R2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
   constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
   mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                           // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+    constexpr I find(I first, S last, const T& value, Proj proj = {});              // since C++20
+
+  template<input_range R, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    constexpr borrowed_iterator_t<R>
+      find(R&& r, const T& value, Proj proj = {});                                  // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr I find_if(I first, S last, Pred pred, Proj proj = {});                // since C++20
+
+  template<input_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_iterator_t<R>
+      find_if(R&& r, Pred pred, Proj proj = {});                                    // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr I find_if_not(I first, S last, Pred pred, Proj proj = {});            // since C++20
+
+  template<input_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_iterator_t<R>
+      find_if_not(R&& r, Pred pred, Proj proj = {});                                // since C++20
 }
 
 template <class InputIterator, class Predicate>
     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

 #include <__algorithm/partial_sort.h>
 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
+#include <__algorithm/ranges_find.h>
+#include <__algorithm/ranges_find_if.h>
+#include <__algorithm/ranges_find_if_not.h>
 #include <__algorithm/ranges_max_element.h>
 #include <__algorithm/ranges_min_element.h>
 #include <__algorithm/ranges_mismatch.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>

libcxx/include/module.modulemap

module __algorithm {
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       module partition_point          { private header "__algorithm/partition_point.h" }
       module pop_heap                 { private header "__algorithm/pop_heap.h" }
       module prev_permutation         { private header "__algorithm/prev_permutation.h" }
       module push_heap                { private header "__algorithm/push_heap.h" }
+      module ranges_find              { private header "__algorithm/ranges_find.h" }
+      module ranges_find_if           { private header "__algorithm/ranges_find_if.h" }
+      module ranges_find_if_not       { private header "__algorithm/ranges_find_if_not.h" }
       module ranges_max_element       { private header "__algorithm/ranges_max_element.h" }
       module ranges_min_element       { private header "__algorithm/ranges_min_element.h" }
       module ranges_mismatch          { private header "__algorithm/ranges_mismatch.h" }
       module ranges_swap_ranges       { private header "__algorithm/ranges_swap_ranges.h" }
       module remove                   { private header "__algorithm/remove.h" }
       module remove_copy              { private header "__algorithm/remove_copy.h" }
       module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
       module remove_if                { private header "__algorithm/remove_if.h" }

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
+#include <__algorithm/ranges_find.h>

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
+#include <__algorithm/ranges_find_if.h>

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

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
+#include <__algorithm/ranges_find_if_not.h>

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+//   requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+//   constexpr I ranges::find(I first, S last, const T& value, Proj proj = {});
+// template<input_range R, class T, class Proj = identity>
+//   requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::find(R&& r, const T& value, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct NotEqualityComparable {};
+
+template <class It, class Sent = It>
+concept HasFindIt = requires(It it, Sent sent) { std::ranges::find(it, sent, *it); };
+static_assert(HasFindIt<int*>);
+static_assert(!HasFindIt<NotEqualityComparable*>);
+static_assert(!HasFindIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIt<int*, int>);
+static_assert(!HasFindIt<int, int*>);
+
+template <class Range, class ValT>
+concept HasFindR = requires(Range r) { std::ranges::find(r, ValT{}); };
+static_assert(HasFindR<std::array<int, 1>, int>);
+static_assert(!HasFindR<int, int>);
+static_assert(!HasFindR<std::array<NotEqualityComparable, 1>, NotEqualityComparable>);
+static_assert(!HasFindR<InputRangeNotDerivedFrom, int>);
+static_assert(!HasFindR<InputRangeNotIndirectlyReadable, int>);
+static_assert(!HasFindR<InputRangeNotInputOrOutputIterator, int>);
+static_assert(!HasFindR<InputRangeNotSentinelSemiregular, int>);
+static_assert(!HasFindR<InputRangeNotSentinelEqualityComparableWith, int>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  {
+    int a[] = {1, 2, 3, 4};
+    std::same_as<It> auto ret = std::ranges::find(It(a), Sent(It(a + 4)), 4);
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+  {
+    int a[] = {1, 2, 3, 4};
+    auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+    std::same_as<It> auto ret = std::ranges::find(range, 4);
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+}
+
+struct OneWayComparable {
+  bool isLeft;
+  friend constexpr bool operator==(OneWayComparable l, OneWayComparable) { return l.isLeft; }
+};
+
+struct NonConstComparableLValue {
+  friend constexpr bool operator==(const NonConstComparableLValue&, const NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, const NonConstComparableLValue&) { return true; }
+};
+
+struct NonConstComparableRValue {
+  friend constexpr bool operator==(const NonConstComparableRValue&, const NonConstComparableRValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableRValue&&, const NonConstComparableRValue&&) { return false; }
+  friend constexpr bool operator==(NonConstComparableRValue&&, NonConstComparableRValue&&) { return false; }
+  friend constexpr bool operator==(NonConstComparableRValue&&, const NonConstComparableRValue&) { return true; }
+};
+
+constexpr bool test() {
+  test_iterators<int*>();
+  test_iterators<const int*>();
+  test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+
+  {
+    // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find(a, a + 4, a + 3, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find(a, a + 3, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+  }
+
+  { // check that the first element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find(a, 0, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find(a, a + 3, 0, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+  }
+
+  { // check that end + 1 iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find(a, a + 3, 0);
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find(a, 0);
+      assert(ret == a + 3);
+    }
+  }
+
+  {
+    // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find(std::array{1, 2}, 3);
+  }
+
+  {
+    // check that an iterator is returned with a borrowing range
+    int a[] = {1, 2, 3, 4};
+    std::same_as<int*> auto ret = std::ranges::find(std::views::all(a), 1);
+    assert(ret == a);
+    assert(*ret == 1);
+  }
+
+  {
+    // check that std::invoke is used
+    struct S { int i; };
+    S a[] = { S{1}, S{3}, S{2} };
+    std::same_as<S*> auto ret = std::ranges::find(a, 4, &S::i);
+    assert(ret == a + 3);
+  }
+
+  {
+    // count invocations of the projection
+    {
+      int a[] = {1, 2, 3, 4};
+      int projection_count = 0;
+      auto ret = std::ranges::find(a, a + 4, 2, [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(projection_count == 2);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      int projection_count = 0;
+      auto ret = std::ranges::find(a, 2, [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(projection_count == 2);
+    }
+  }
+
+  {
+    // check comparison order
+    {
+      OneWayComparable a[] = { OneWayComparable{true} };
+      auto ret = std::ranges::find(a, a + 1, OneWayComparable{false});
+      assert(ret == a);
+    }
+    {
+      OneWayComparable a[] = { OneWayComparable{true} };
+      auto ret = std::ranges::find(a, OneWayComparable{false});
+      assert(ret == a);
+    }
+  }
+
+  {
+    // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find(a, a + 1, NonConstComparableLValue{});
+      assert(ret == a);
+    }
+    {
+      using It = std::move_iterator<NonConstComparableRValue*>;
+      NonConstComparableRValue a[] = { NonConstComparableRValue{} };
+      auto ret = std::ranges::find(It(a), It(a + 1), NonConstComparableRValue{});
+      assert(ret.base() == a);
+    }
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find(a, NonConstComparableLValue{});
+      assert(ret == a);
+    }
+    {
+      using It = std::move_iterator<NonConstComparableRValue*>;
+      NonConstComparableRValue a[] = { NonConstComparableRValue{} };
+      auto range = std::ranges::subrange(It(a), It(a + 1));
+      auto ret = std::ranges::find(range, NonConstComparableRValue{});
+      assert(ret.base() == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int ,0> a = {};
+      auto ret = std::ranges::find(a.begin(), a.end(), 1);
+      assert(ret == a.begin());
+    }
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find(a, 1);
+      assert(ret == a.begin());
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//   constexpr I ranges::find_if(I first, S last, Pred pred, Proj proj = {});
+// template<input_range R, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::find_if(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct Predicate {
+  bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindIfIt = requires(It it, Sent sent) { std::ranges::find_if(it, sent, Predicate{}); };
+static_assert(HasFindIfIt<int*>);
+static_assert(!HasFindIfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIfIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIfIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIfIt<int*, int>);
+static_assert(!HasFindIfIt<int, int*>);
+
+template <class Pred>
+concept HasFindIfPred = requires(int* it, Pred pred) {std::ranges::find_if(it, it, pred); };
+
+static_assert(!HasFindIfPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindIfPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindIfR = requires(R r) { std::ranges::find_if(r, Predicate{}); };
+static_assert(HasFindIfR<std::array<int, 0>>);
+static_assert(!HasFindIfR<int>);
+static_assert(!HasFindIfR<InputRangeNotDerivedFrom>);
+static_assert(!HasFindIfR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasFindIfR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasFindIfR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasFindIfR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  {
+    int a[] = {1, 2, 3, 4};
+    std::same_as<It> auto ret = std::ranges::find_if(It(a), Sent(It(a + 4)), [](int x) mutable { return x == 4; });
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+  {
+    int a[] = {1, 2, 3, 4};
+    auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+    std::same_as<It> auto ret = std::ranges::find_if(range, [](int x) mutable { return x == 4; });
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+}
+
+struct NonConstComparable {
+  friend constexpr bool operator==(const NonConstComparable&, const NonConstComparable&) { return false; }
+  friend constexpr bool operator==(NonConstComparable&, NonConstComparable&) { return false; }
+  friend constexpr bool operator==(const NonConstComparable&, NonConstComparable&) { return false; }
+  friend constexpr bool operator==(NonConstComparable&, const NonConstComparable&) { return true; }
+};
+
+constexpr bool test() {
+  test_iterators<int*>();
+  test_iterators<const int*>();
+  test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+
+  {
+    // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_if(a, a + 4, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_if(a, [&](int* i) { return i == a + 3; }, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+  }
+
+  {
+    // check that the first element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_if(a, [](int i){ return i == 0; }, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_if(a, a + 3, [](int i) { return i == 0; }, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+  }
+
+  {
+    // check that end + 1 iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_if(a, a + 3, [](int) { return false; });
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_if(a, [](int){ return false; });
+      assert(ret == a + 3);
+    }
+  }
+
+  {
+    // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find_if(std::array{1, 2}, [](int){ return false; });
+  }
+
+  {
+    // check that an iterator is returned with a borrowing range
+    int a[] = {1, 2, 3, 4};
+    std::same_as<int*> auto ret = std::ranges::find_if(std::views::all(a), [](int){ return true; });
+    assert(ret == a);
+    assert(*ret == 1);
+  }
+
+  {
+    // check that std::invoke is used
+    struct S { int i; };
+    S a[] = { S{1}, S{3}, S{2} };
+    std::same_as<S*> auto ret = std::ranges::find_if(a, [](int) { return false; }, &S::i);
+    assert(ret == a + 3);
+  }
+
+  {
+    // count projection and predicate invocation count
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_if(a, a + 4,
+                                      [&](int i) { ++predicate_count; return i == 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(predicate_count == 2);
+      assert(projection_count == 2);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_if(a,
+                                      [&](int i) { ++predicate_count; return i == 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(predicate_count == 2);
+      assert(projection_count == 2);
+    }
+  }
+
+  {
+    // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparable a[] = { NonConstComparable{} };
+      auto ret = std::ranges::find_if(a, a + 1, [](auto&& e) { return e == NonConstComparable{}; });
+      assert(ret == a);
+    }
+    {
+      NonConstComparable a[] = { NonConstComparable{} };
+      auto ret = std::ranges::find_if(a, [](auto&& e) { return e == NonConstComparable{}; });
+      assert(ret == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int ,0> a = {};
+      auto ret = std::ranges::find_if(a.begin(), a.end(), [](int) { return true; });
+      assert(ret == a.begin());
+    }
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find_if(a, [](int) { return true; });
+      assert(ret == a.begin());
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/ranges.find_if_not.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_unary_predicate<projected<I, Proj>> Pred>
+//   constexpr I ranges::find_if_not(I first, S last, Pred pred, Proj proj = {});
+// template<input_range R, class Proj = identity,
+//          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::find_if_not(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct Predicate {
+  bool operator()(int);
+};
+
+template <class It, class Sent = It>
+concept HasFindIfNotIt = requires(It it, Sent sent) { std::ranges::find_if_not(it, sent, Predicate{}); };
+static_assert(HasFindIfNotIt<int*>);
+static_assert(!HasFindIfNotIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasFindIfNotIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasFindIfNotIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasFindIfNotIt<cpp20_input_iterator<int*>, SentinelForNotSemiregular>);
+static_assert(!HasFindIfNotIt<cpp20_input_iterator<int*>, InputRangeNotSentinelEqualityComparableWith>);
+
+static_assert(!HasFindIfNotIt<int*, int>);
+static_assert(!HasFindIfNotIt<int, int*>);
+
+template <class Pred>
+concept HasFindIfNotPred = requires(int* it, Pred pred) {std::ranges::find_if_not(it, it, pred); };
+
+static_assert(!HasFindIfNotPred<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasFindIfNotPred<IndirectUnaryPredicateNotPredicate>);
+
+template <class R>
+concept HasFindIfNotR = requires(R r) { std::ranges::find_if_not(r, Predicate{}); };
+static_assert(HasFindIfNotR<std::array<int, 0>>);
+static_assert(!HasFindIfNotR<int>);
+static_assert(!HasFindIfNotR<InputRangeNotDerivedFrom>);
+static_assert(!HasFindIfNotR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasFindIfNotR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasFindIfNotR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasFindIfNotR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  {
+    int a[] = {1, 2, 3, 4};
+    std::same_as<It> auto ret = std::ranges::find_if_not(It(a), Sent(It(a + 4)), [c = 0](int) mutable { return c++ <= 2; });
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+  {
+    int a[] = {1, 2, 3, 4};
+    auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+    std::same_as<It> auto ret = std::ranges::find_if_not(range, [c = 0](int) mutable { return c++ <= 2; });
+    assert(base(ret) == a + 3);
+    assert(*ret == 4);
+  }
+}
+
+struct NonConstComparableLValue {
+  friend constexpr bool operator==(const NonConstComparableLValue&, const NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(const NonConstComparableLValue&, NonConstComparableLValue&) { return false; }
+  friend constexpr bool operator==(NonConstComparableLValue&, const NonConstComparableLValue&) { return true; }
+};
+
+constexpr bool test() {
+  test_iterators<int*>();
+  test_iterators<const int*>();
+  test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<bidirectional_iterator<int*>>();
+  test_iterators<forward_iterator<int*>>();
+  test_iterators<random_access_iterator<int*>>();
+  test_iterators<contiguous_iterator<int*>>();
+
+  { // check that projections are used properly and that they are called with the iterator directly
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_if_not(a, a + 4, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto ret = std::ranges::find_if_not(a, [&](int* i) { return i != a + 3; }, [](int& i) { return &i; });
+      assert(ret == a + 3);
+    }
+  }
+
+  {
+    // check that the first element is returned
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_if_not(a, [](int i){ return i != 0; }, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+    {
+      struct S {
+        int comp;
+        int other;
+      };
+      S a[] = { {0, 0}, {0, 2}, {0, 1} };
+      auto ret = std::ranges::find_if_not(a, a + 3, [](int i) { return i != 0; }, &S::comp);
+      assert(ret == a);
+      assert(ret->comp == 0);
+      assert(ret->other == 0);
+    }
+  }
+
+  {
+    // check that end + 1 iterator is returned with no match
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_if(a, a + 3, [](int) { return false; });
+      assert(ret == a + 3);
+    }
+    {
+      int a[] = {1, 1, 1};
+      auto ret = std::ranges::find_if(a, [](int){ return false; });
+      assert(ret == a + 3);
+    }
+  }
+
+  { // check that ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> auto ret =
+      std::ranges::find_if_not(std::array{1, 2}, [](int){ return true; });
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    int a[] = {1, 2, 3, 4};
+    std::same_as<int*> auto ret = std::ranges::find_if_not(std::views::all(a), [](int){ return false; });
+    assert(ret == a);
+    assert(*ret == 1);
+  }
+
+  { // check that std::invoke is used
+    struct S { int i; };
+    S a[] = { S{1}, S{3}, S{2} };
+    std::same_as<S*> auto ret = std::ranges::find_if_not(a, [](int) { return true; }, &S::i);
+    assert(ret == a + 3);
+  }
+
+  { // count projection and predicate invocation count
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_if_not(a, a + 4,
+                                      [&](int i) { ++predicate_count; return i != 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(predicate_count == 2);
+      assert(projection_count == 2);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      int predicate_count = 0;
+      int projection_count = 0;
+      auto ret = std::ranges::find_if_not(a,
+                                      [&](int i) { ++predicate_count; return i != 2; },
+                                      [&](int i) { ++projection_count; return i; });
+      assert(ret == a + 1);
+      assert(*ret == 2);
+      assert(predicate_count == 2);
+      assert(projection_count == 2);
+    }
+  }
+
+  { // check that the return type of `iter::operator*` doesn't change
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_if_not(a, a + 1, [](auto&& e) { return e != NonConstComparableLValue{}; });
+      assert(ret == a);
+    }
+    {
+      NonConstComparableLValue a[] = { NonConstComparableLValue{} };
+      auto ret = std::ranges::find_if_not(a, [](auto&& e) { return e != NonConstComparableLValue{}; });
+      assert(ret == a);
+    }
+  }
+
+  {
+    // check that an empty range works
+    {
+      std::array<int ,0> a = {};
+      auto ret = std::ranges::find_if_not(a.begin(), a.end(), [](int) { return true; });
+      assert(ret == a.begin());
+    }
+    {
+      std::array<int, 0> a = {};
+      auto ret = std::ranges::find_if_not(a, [](int) { return true; });
+      assert(ret == a.begin());
+    }
+  }
+
+  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

constexpr bool test(CPO& o, Args&&...) {
   static_assert(std::invocable<T, Args...>);
   static_assert(std::invocable<const T, Args...>);
 
   return true;
 }
 
 int *p;
 int a[10];
-//auto odd = [](int x) { return x % 2 != 0; };
+auto odd = [](int x) { return x % 2 != 0; };
 //auto triple = [](int x) { return 3*x; };
 //auto plus = [](int x, int y) { return x == y; };
 //std::mt19937 g;
 
 // [algorithm.syn]
 
 //static_assert(test(std::ranges::adjacent_find, a));
 //static_assert(test(std::ranges::all_of, a, odd));
 //static_assert(test(std::ranges::any_of, a, odd));
 //static_assert(test(std::ranges::binary_search, a, 42));
 //static_assert(test(std::ranges::clamp, 42, 42, 42));
 //static_assert(test(std::ranges::copy, a, a));
 //static_assert(test(std::ranges::copy_backward, a, a));
 //static_assert(test(std::ranges::copy_if, a, a, odd));
 //static_assert(test(std::ranges::copy_n, a, 10, a));
 //static_assert(test(std::ranges::count, a, 42));
 //static_assert(test(std::ranges::count_if, a, odd));
 //static_assert(test(std::ranges::ends_with, a, a));
 //static_assert(test(std::ranges::equal, a, a));
 //static_assert(test(std::ranges::equal_range, a, 42));
 //static_assert(test(std::ranges::fill, a, 42));
 //static_assert(test(std::ranges::fill_n, a, 10, 42));
-//static_assert(test(std::ranges::find, a, 42));
+static_assert(test(std::ranges::find, a, 42));
 //static_assert(test(std::ranges::find_end, a, a));
 //static_assert(test(std::ranges::find_first_of, a, a));
-//static_assert(test(std::ranges::find_if, a, odd));
-//static_assert(test(std::ranges::find_if_not, a, odd));
+static_assert(test(std::ranges::find_if, a, odd));
+static_assert(test(std::ranges::find_if_not, a, odd));
 //static_assert(test(std::ranges::for_each, a, odd));
 //static_assert(test(std::ranges::for_each_n, a, 10, odd));
 //static_assert(test(std::ranges::generate, a, 42));
 //static_assert(test(std::ranges::generate_n, a, 10, 42));
 //static_assert(test(std::ranges::includes, a, a));
 //static_assert(test(std::ranges::inplace_merge, a, a+5));
 //static_assert(test(std::ranges::is_heap, a));
 //static_assert(test(std::ranges::is_heap_until, a));

libcxx/test/support/almost_satisfies_types.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 ALMOST_SATISFIES_TYPES_H
+#define ALMOST_SATISFIES_TYPES_H
+
+#include <iterator>
+#include <ranges>
+
+#include "test_iterators.h"
+
+template <class T, class U = sentinel_wrapper<T>>
+class UncheckedRange {
+public:
+  T begin();
+  U end();
+};
+
+static_assert(std::ranges::contiguous_range<UncheckedRange<int*, int*>>);
+
+// almost an input_iterator
+class InputIteratorNotDerivedFrom {
+public:
+  using difference_type = long;
+  using value_type = int;
+  using iterator_category = void;
+
+  InputIteratorNotDerivedFrom& operator++();
+  void operator++(int);
+  const int& operator*() const;
+};
+
+using InputRangeNotDerivedFrom = UncheckedRange<InputIteratorNotDerivedFrom>;
+
+static_assert(std::input_or_output_iterator<InputIteratorNotDerivedFrom>);
+static_assert(std::indirectly_readable<InputIteratorNotDerivedFrom>);
+static_assert(!std::input_iterator<InputIteratorNotDerivedFrom>);
+static_assert(!std::ranges::input_range<InputRangeNotDerivedFrom>);
+
+class InputIteratorNotIndirectlyReadable {
+public:
+  using difference_type = long;
+  using iterator_category = std::input_iterator_tag;
+
+  InputIteratorNotIndirectlyReadable& operator++();
+  void operator++(int);
+  const int& operator*() const;
+};
+
+using InputRangeNotIndirectlyReadable = UncheckedRange<InputIteratorNotIndirectlyReadable>;
+
+static_assert(std::input_or_output_iterator<InputIteratorNotIndirectlyReadable>);
+static_assert(!std::indirectly_readable<InputIteratorNotIndirectlyReadable>);
+static_assert(!std::input_iterator<InputIteratorNotIndirectlyReadable>);
+static_assert(!std::ranges::input_range<InputIteratorNotIndirectlyReadable>);
+
+class InputIteratorNotInputOrOutputIterator {
+public:
+  using difference_type = long;
+  using value_type = int;
+  using iterator_category = std::input_iterator_tag;
+
+  int& operator++();
+  void operator++(int);
+  const int& operator*() const;
+};
+
+using InputRangeNotInputOrOutputIterator = UncheckedRange<InputIteratorNotInputOrOutputIterator>;
+
+static_assert(!std::input_or_output_iterator<InputIteratorNotInputOrOutputIterator>);
+static_assert(std::indirectly_readable<InputIteratorNotInputOrOutputIterator>);
+static_assert(!std::input_iterator<InputIteratorNotInputOrOutputIterator>);
+static_assert(!std::ranges::input_range<InputRangeNotInputOrOutputIterator>);
+
+// almost an indirect_unary_predicate
+class IndirectUnaryPredicateNotCopyConstructible {
+public:
+  IndirectUnaryPredicateNotCopyConstructible(const IndirectUnaryPredicateNotCopyConstructible&) = delete;
+  bool operator()(int) const;
+};
+
+static_assert(std::predicate<IndirectUnaryPredicateNotCopyConstructible, int&>);
+static_assert(!std::indirect_unary_predicate<IndirectUnaryPredicateNotCopyConstructible, int*>);
+
+class IndirectUnaryPredicateNotPredicate {
+public:
+  bool operator()(int&&) const;
+};
+
+static_assert(!std::predicate<IndirectUnaryPredicateNotPredicate, int&>);
+static_assert(!std::indirect_unary_predicate<IndirectUnaryPredicateNotPredicate, int*>);
+
+// almost a sentinel_for cpp20_input_iterator
+class SentinelForNotSemiregular {
+public:
+  SentinelForNotSemiregular() = delete;
+  using difference_type = long;
+  SentinelForNotSemiregular& operator++();
+  void operator++(int);
+  const int& operator*() const;
+  friend bool operator==(const SentinelForNotSemiregular&, const cpp20_input_iterator<int*>&);
+};
+
+using InputRangeNotSentinelSemiregular = UncheckedRange<cpp20_input_iterator<int*>, SentinelForNotSemiregular>;
+
+static_assert(std::input_or_output_iterator<SentinelForNotSemiregular>);
+static_assert(!std::semiregular<SentinelForNotSemiregular>);
+static_assert(!std::sentinel_for<SentinelForNotSemiregular, cpp20_input_iterator<int*>>);
+
+// almost a sentinel_for cpp20_input_iterator
+class SentinelForNotWeaklyEqualityComparableWith {
+public:
+  using difference_type = long;
+  SentinelForNotWeaklyEqualityComparableWith& operator++();
+  void operator++(int);
+  const int& operator*() const;
+};
+
+using InputRangeNotSentinelEqualityComparableWith =
+  UncheckedRange<cpp20_input_iterator<int*>, SentinelForNotWeaklyEqualityComparableWith>;
+
+static_assert(std::input_or_output_iterator<SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(std::semiregular<SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!std::sentinel_for<SentinelForNotWeaklyEqualityComparableWith, cpp20_input_iterator<int*>>);
+
+#endif // ALMOST_SATISFIES_TYPES_H