[libc++] Implement ranges::{all, any, none}_of

[ldionne]

libcxx/include/__algorithm/ranges_all_of.h

36

I suggested naming these helpers __all_of_impl in a previous review (I think we had agreed on the naming scheme). I assume this slipped because you already had this patch locally when I made the comment, but please make sure to rebase all your local patches with my comments to make sure nothing slips through the cracks.

You can then ping me when you think this is ready for review.

[var-const]

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

31

Why is std::identity passed explicitly here, instead of relying on the default argument?

66

If I'm reading this correctly, the current tests would pass even if the implementation unconditionally returned true. Can you please add a few tests with a predicate that depends on the element (e.g. returns whether the number is even)?

• no element satisfies the condition;
• all elements satisfy the condition;
• only some elements satisfy the condition.

69

Nit: I still feel we should use decltype(auto) uniformly with same_as. Yes, it's exceedingly unlikely that this algorithm could return a reference, but it would be a simple rule to follow, always correct and requiring no decision-making.

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

31

Nit: s/AllOf/AnyOf/ (throughout the file).

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

31

Same nit re. the copy-paste error.

[philnik]

libcxx/include/__algorithm/ranges_all_of.h

36

I thought the new naming scheme was only for the ones that are used in multiple CPOs. I'll update my current patches!

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

31

There is no default argument. This is the predicate.

66

I knew I missed a few cases. These tests felt way to short.

[var-const]

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

31

Ah, right -- seeing std::identity, I mistook it for the projection. Perhaps change it to something else that looks more like a predicate (you could create a simple global functor like AlwaysTrue or similar and reuse it across the tests if you'd like)?

[philnik]

• Address comments

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

31

I'd much rather just use a simple lambda. I can add a TODO so we change it once AppleClang supports them in this context if you want.

[var-const]

LGTM once the CI is green, but I'd wait for one other review before merging.

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

31

FWIW, I still feel that using std::identity as a predicate is unnecessarily confusing, but this is non-blocking.

[philnik]

• Try to fix CI

[philnik]

Rebased

[philnik]

• Rebased
• Fix CI

[ldionne]

I don't think we have any tests that these algorithms are actually function objects that can be e.g. passed as a function argument. Didn't we have a test file that checked all algorithms and views for being niebloids? If so, let's update it. If not, let's create one.

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,any_of,Nikolas Klauser,`D123016 <https://llvm.org/D123016>`_,✅
+Search,all_of,Nikolas Klauser,`D123016 <https://llvm.org/D123016>`_,✅
+Search,none_of,Nikolas Klauser,`D123016 <https://llvm.org/D123016>`_,✅
 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>`_,✅
 Search,equal,Nikolas Klauser,n/a,✅
 Search,lexicographical_compare,Not assigned,n/a,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort.h
   __algorithm/partial_sort_copy.h
   __algorithm/partition.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
+  __algorithm/ranges_all_of.h
+  __algorithm/ranges_any_of.h
   __algorithm/ranges_copy.h
   __algorithm/ranges_copy_backward.h
   __algorithm/ranges_copy_if.h
   __algorithm/ranges_copy_n.h
   __algorithm/ranges_count.h
   __algorithm/ranges_count_if.h
   __algorithm/ranges_equal.h
   __algorithm/ranges_fill.h
   __algorithm/ranges_fill_n.h
   __algorithm/ranges_find.h
   __algorithm/ranges_find_if.h
   __algorithm/ranges_find_if_not.h
   __algorithm/ranges_for_each.h
   __algorithm/ranges_for_each_n.h
   __algorithm/ranges_is_partitioned.h
   __algorithm/ranges_max.h
   __algorithm/ranges_max_element.h
   __algorithm/ranges_min.h
   __algorithm/ranges_min_element.h
   __algorithm/ranges_minmax.h
   __algorithm/ranges_minmax_element.h
   __algorithm/ranges_mismatch.h
+  __algorithm/ranges_none_of.h
   __algorithm/ranges_reverse.h
   __algorithm/ranges_swap_ranges.h
   __algorithm/ranges_transform.h
   __algorithm/remove.h
   __algorithm/remove_copy.h
   __algorithm/remove_copy_if.h
   __algorithm/remove_if.h
   __algorithm/replace.h

libcxx/include/__algorithm/ranges_all_of.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_ALL_OF_H
+#define _LIBCPP___ALGORITHM_RANGES_ALL_OF_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 <__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 __all_of {
+struct __fn {
+
+  template <class _Iter, class _Sent, class _Proj, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  bool __all_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+    for (; __first != __last; ++__first) {
+      if (!std::invoke(__pred, std::invoke(__proj, *__first)))
+        return false;
+    }
+    return true;
+  }
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+    return __all_of_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <input_range _Range, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    return __all_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
+  }
+};
+} // namespace __all_of
+
+inline namespace __cpo {
+  inline constexpr auto all_of = __all_of::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_ALL_OF_H

libcxx/include/__algorithm/ranges_any_of.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_ANY_OF_H
+#define _LIBCPP___ALGORITHM_RANGES_ANY_OF_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 <__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 __any_of {
+struct __fn {
+
+  template <class _Iter, class _Sent, class _Proj, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  bool __any_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+    for (; __first != __last; ++__first) {
+      if (std::invoke(__pred, std::invoke(__proj, *__first)))
+        return true;
+    }
+    return false;
+  }
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
+    return __any_of_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <input_range _Range, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    return __any_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
+  }
+};
+} // namespace __any_of
+
+inline namespace __cpo {
+  inline constexpr auto any_of = __any_of::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_ANY_OF_H

libcxx/include/__algorithm/ranges_none_of.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_NONE_OF_H
+#define _LIBCPP___ALGORITHM_RANGES_NONE_OF_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 <__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 __none_of {
+struct __fn {
+
+  template <class _Iter, class _Sent, class _Proj, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  bool __none_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+    for (; __first != __last; ++__first) {
+      if (std::invoke(__pred, std::invoke(__proj, *__first)))
+        return false;
+    }
+    return true;
+  }
+
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
+    return __none_of_impl(std::move(__first), std::move(__last), __pred, __proj);
+  }
+
+  template <input_range _Range, class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    return __none_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
+  }
+};
+} // namespace __none_of
+
+inline namespace __cpo {
+  inline constexpr auto none_of = __none_of::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_NONE_OF_H

libcxx/include/algorithm

constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
                                 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 bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
                                 Proj1 proj1 = {}, Proj2 proj2 = {});                        // since C++20
 
+  template<input_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr bool ranges::all_of(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 bool ranges::all_of(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 bool ranges::any_of(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 bool ranges::any_of(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 bool ranges::none_of(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 bool ranges::none_of(R&& r, Pred pred, Proj proj = {});               // since C++20
+
 }
 
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     any_of(InputIterator first, InputIterator last, Predicate pred);

 #include <__algorithm/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_all_of.h>
+#include <__algorithm/ranges_any_of.h>
 #include <__algorithm/ranges_copy.h>
 #include <__algorithm/ranges_copy_backward.h>
 #include <__algorithm/ranges_copy_if.h>
 #include <__algorithm/ranges_copy_n.h>
 #include <__algorithm/ranges_count.h>
 #include <__algorithm/ranges_count_if.h>
 #include <__algorithm/ranges_equal.h>
 #include <__algorithm/ranges_fill.h>
 #include <__algorithm/ranges_fill_n.h>
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_if.h>
 #include <__algorithm/ranges_find_if_not.h>
 #include <__algorithm/ranges_for_each.h>
 #include <__algorithm/ranges_for_each_n.h>
 #include <__algorithm/ranges_is_partitioned.h>
 #include <__algorithm/ranges_max.h>
 #include <__algorithm/ranges_max_element.h>
 #include <__algorithm/ranges_min.h>
 #include <__algorithm/ranges_min_element.h>
 #include <__algorithm/ranges_minmax.h>
 #include <__algorithm/ranges_minmax_element.h>
 #include <__algorithm/ranges_mismatch.h>
+#include <__algorithm/ranges_none_of.h>
 #include <__algorithm/ranges_reverse.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/ranges_transform.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/replace.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_all_of            { private header "__algorithm/ranges_all_of.h" }
+      module ranges_any_of            { private header "__algorithm/ranges_any_of.h" }
       module ranges_copy              { private header "__algorithm/ranges_copy.h" }
       module ranges_copy_backward     { private header "__algorithm/ranges_copy_backward.h" }
       module ranges_copy_if           { private header "__algorithm/ranges_copy_if.h" }
       module ranges_copy_n            { private header "__algorithm/ranges_copy_n.h" }
       module ranges_count             { private header "__algorithm/ranges_count.h" }
       module ranges_count_if          { private header "__algorithm/ranges_count_if.h" }
       module ranges_equal             { private header "__algorithm/ranges_equal.h" }
       module ranges_fill              { private header "__algorithm/ranges_fill.h" }
       module ranges_fill_n            { private header "__algorithm/ranges_fill_n.h" }
       module ranges_find              { private header "__algorithm/ranges_find.h" }
       module ranges_find_if           { private header "__algorithm/ranges_find_if.h" }
       module ranges_find_if_not       { private header "__algorithm/ranges_find_if_not.h" }
       module ranges_for_each          { private header "__algorithm/ranges_for_each.h" }
       module ranges_for_each_n        { private header "__algorithm/ranges_for_each_n.h" }
       module ranges_is_partitioned    { private header "__algorithm/ranges_is_partitioned.h" }
       module ranges_max               { private header "__algorithm/ranges_max.h" }
       module ranges_max_element       { private header "__algorithm/ranges_max_element.h" }
       module ranges_min               { private header "__algorithm/ranges_min.h" }
       module ranges_min_element       { private header "__algorithm/ranges_min_element.h" }
       module ranges_minmax            { private header "__algorithm/ranges_minmax.h" }
       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_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" }
       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" }
       module replace                  { private header "__algorithm/replace.h" }

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

constexpr bool all_the_algorithms()
     //void **mid2 = b+5;
     void **last2 = b+10;
     void *value = nullptr;
     //int count = 1;
 
     int copies = 0;
     //(void)std::ranges::adjacent_find(first, last, Equal(&copies)); assert(copies == 0);
     //(void)std::ranges::adjacent_find(a, Equal(&copies)); assert(copies == 0);
-    //(void)std::ranges::all_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
-    //(void)std::ranges::all_of(a, UnaryTrue(&copies)); assert(copies == 0);
-    //(void)std::ranges::any_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
-    //(void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::all_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::all_of(a, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::any_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::binary_search(first, last, value, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::binary_search(a, value, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::copy_if(first, last, first2, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::copy_if(a, first2, UnaryTrue(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 20
#endif
     (void)std::ranges::minmax({ value, value }, Less(&copies)); assert(copies == 0);
     (void)std::ranges::minmax(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::minmax_element(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::minmax_element(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::mismatch(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::mismatch(a, b, Equal(&copies)); assert(copies == 0);
     //(void)std::ranges::next_permutation(first, last, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::next_permutation(a, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::none_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
-    //(void)std::ranges::none_of(a, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::none_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
+    (void)std::ranges::none_of(a, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::nth_element(first, mid, last, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::nth_element(a, mid, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort(first, mid, last, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort(a, mid, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort_copy(first, last, first2, mid2, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort_copy(a, b, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::partition(first, last, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::partition(a, UnaryTrue(&copies)); assert(copies == 0);

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

constexpr bool all_the_algorithms()
     //T *mid2 = b+5;
     T *last2 = b+10;
     void *value = nullptr;
     //int count = 1;
 
     int copies = 0;
     //(void)std::ranges::adjacent_find(first, last, Equal(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::adjacent_find(a, Equal(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::copy_if(first, last, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
#endif
     (void)std::ranges::minmax({ T(), T() }, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::minmax(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::minmax_element(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::minmax_element(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::mismatch(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::mismatch(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::next_permutation(first, last, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::next_permutation(a, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::none_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::none_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::none_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::none_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::nth_element(first, mid, last, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::nth_element(a, mid, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort(first, mid, last, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort(a, mid, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort_copy(first, last, first2, mid2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partial_sort_copy(a, b, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partition(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::partition(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__algorithm/partial_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort.h'}}
 #include <__algorithm/partial_sort_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partial_sort_copy.h'}}
 #include <__algorithm/partition.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition.h'}}
 #include <__algorithm/partition_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_copy.h'}}
 #include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}}
 #include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}}
 #include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}}
 #include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}}
+#include <__algorithm/ranges_all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_all_of.h'}}
+#include <__algorithm/ranges_any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_any_of.h'}}
 #include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}}
 #include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}}
 #include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}}
 #include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
 #include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}}
 #include <__algorithm/ranges_count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count_if.h'}}
 #include <__algorithm/ranges_equal.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal.h'}}
 #include <__algorithm/ranges_fill.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill.h'}}
 #include <__algorithm/ranges_fill_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_fill_n.h'}}
 #include <__algorithm/ranges_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find.h'}}
 #include <__algorithm/ranges_find_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if.h'}}
 #include <__algorithm/ranges_find_if_not.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_find_if_not.h'}}
 #include <__algorithm/ranges_for_each.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each.h'}}
 #include <__algorithm/ranges_for_each_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each_n.h'}}
 #include <__algorithm/ranges_is_partitioned.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_partitioned.h'}}
 #include <__algorithm/ranges_max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max.h'}}
 #include <__algorithm/ranges_max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max_element.h'}}
 #include <__algorithm/ranges_min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min.h'}}
 #include <__algorithm/ranges_min_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min_element.h'}}
 #include <__algorithm/ranges_minmax.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax.h'}}
 #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_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'}}
 #include <__algorithm/remove.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove.h'}}
 #include <__algorithm/remove_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_copy.h'}}
 #include <__algorithm/remove_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_copy_if.h'}}
 #include <__algorithm/remove_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/remove_if.h'}}
 #include <__algorithm/replace.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/replace.h'}}

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/ranges.all_of.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 bool ranges::all_of(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 bool ranges::all_of(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct UnaryFunctor {
+  bool operator()(auto&&);
+};
+
+template <class It, class Sent = sentinel_wrapper<It>>
+concept HasAllOfIt = requires(It first, Sent last) { std::ranges::all_of(first, last, UnaryFunctor{}); };
+
+static_assert(HasAllOfIt<int*>);
+static_assert(!HasAllOfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasAllOfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasAllOfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasAllOfIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasAllOfIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Func>
+concept HasAllOfItFunc = requires(int* ptr) { std::ranges::all_of(ptr, ptr, Func{}); };
+
+static_assert(HasAllOfItFunc<UnaryFunctor>);
+static_assert(!HasAllOfItFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasAllOfItFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class Range>
+concept HasAllOfR = requires(Range range) { std::ranges::all_of(range, UnaryFunctor{}); };
+
+static_assert(HasAllOfR<std::array<int, 10>>);
+static_assert(!HasAllOfR<InputRangeNotDerivedFrom>);
+static_assert(!HasAllOfR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasAllOfR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasAllOfR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasAllOfR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class Func>
+concept HasAllOfRFunc = requires(std::array<int, 10> range) { std::ranges::all_of(range, Func{}); };
+
+static_assert(HasAllOfRFunc<UnaryFunctor>);
+static_assert(!HasAllOfRFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasAllOfRFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      int a[] = {1, 2, 3, 4};
+      std::same_as<bool> decltype(auto) ret = std::ranges::all_of(It(a), Sent(It(a + 4)), [](int) { return true; });
+      assert(ret);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::all_of(range, [](int) { return true; });
+      assert(ret);
+    }
+  }
+
+  { // check that an empty range works
+    std::array<int, 0> a;
+    assert(std::ranges::all_of(It(a.data()), Sent(It(a.data())), [](int) { return false; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data())));
+    assert(std::ranges::all_of(range, [](int) { return false; }));
+  }
+
+  { // check that the complexity requirements are met
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return true; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      assert(std::ranges::all_of(It(a.begin()), Sent(It(a.end())), pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return true; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      assert(std::ranges::all_of(range, pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+  }
+
+  { // check that false is returned if no element satisfies the condition
+    std::array a = {1, 2, 3, 4};
+    assert(!std::ranges::all_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(!std::ranges::all_of(range, [](int i) { return i > 5; }));
+  }
+
+  { // check that true is returned if all elements satisfy the condition
+    std::array a = {1, 2, 3, 4};
+    assert(std::ranges::all_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i < 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(std::ranges::all_of(range, [](int i) { return i < 5; }));
+  }
+
+  { // check that false is returned if ony one elements satisfies the condition
+    std::array a = {1, 2, 3, 4, 6};
+    assert(!std::ranges::all_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(!std::ranges::all_of(range, [](int i) { return i > 5; }));
+  }
+}
+
+constexpr bool test() {
+  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 std::invoke is used
+    struct S { int check; int other; };
+    S a[] = {{1, 2}, {1, 7}, {1, 3}};
+    assert(std::ranges::all_of(a, a + 3, [](int i) { return i == 1; }, &S::check));
+    assert(std::ranges::all_of(a, [](int i) { return i == 1; }, &S::check));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/ranges.any_of.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 bool ranges::any_of(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 bool ranges::any_of(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct UnaryFunctor {
+  bool operator()(auto&&);
+};
+
+template <class It, class Sent = sentinel_wrapper<It>>
+concept HasAnyOfIt = requires(It first, Sent last) { std::ranges::any_of(first, last, UnaryFunctor{}); };
+
+static_assert(HasAnyOfIt<int*>);
+static_assert(!HasAnyOfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasAnyOfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasAnyOfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasAnyOfIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasAnyOfIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Func>
+concept HasAnyOfItFunc = requires(int* ptr) { std::ranges::any_of(ptr, ptr, Func{}); };
+
+static_assert(HasAnyOfItFunc<UnaryFunctor>);
+static_assert(!HasAnyOfItFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasAnyOfItFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class Range>
+concept HasAnyOfR = requires(Range range) { std::ranges::any_of(range, UnaryFunctor{}); };
+
+static_assert(HasAnyOfR<std::array<int, 10>>);
+static_assert(!HasAnyOfR<InputRangeNotDerivedFrom>);
+static_assert(!HasAnyOfR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasAnyOfR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasAnyOfR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasAnyOfR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class Func>
+concept HasAnyOfRFunc = requires(std::array<int, 10> range) { std::ranges::any_of(range, Func{}); };
+
+static_assert(HasAnyOfRFunc<UnaryFunctor>);
+static_assert(!HasAnyOfRFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasAnyOfRFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      int a[] = {1, 2, 3, 4};
+      std::same_as<bool> decltype(auto) ret = std::ranges::any_of(It(a), Sent(It(a + 4)), [](int) { return true; });
+      assert(ret);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::any_of(range, [](int) { return true; });
+      assert(ret);
+    }
+  }
+
+  { // check that an empty range works
+    std::array<int, 0> a;
+    assert(!std::ranges::any_of(It(a.data()), Sent(It(a.data())), [](int) { return false; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data())));
+    assert(!std::ranges::any_of(range, [](int) { return false; }));
+  }
+
+  { // check that the complexity requirements are met
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      assert(!std::ranges::any_of(It(a.begin()), Sent(It(a.end())), pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      assert(!std::ranges::any_of(range, pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+  }
+
+  { // check that false is returned if no element satisfies the condition
+    std::array a = {1, 2, 3, 4};
+    assert(!std::ranges::any_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(!std::ranges::any_of(range, [](int i) { return i > 5; }));
+  }
+
+  { // check that true is returned if all elements satisfy the condition
+    std::array a = {1, 2, 3, 4};
+    assert(std::ranges::any_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i < 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(std::ranges::any_of(range, [](int i) { return i < 5; }));
+  }
+
+  { // check that true is returned if ony one elements satisfies the condition
+    std::array a = {1, 2, 3, 4, 6};
+    assert(std::ranges::any_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(std::ranges::any_of(range, [](int i) { return i > 5; }));
+  }
+}
+
+constexpr bool test() {
+  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 std::invoke is used
+    struct S { int check; int other; };
+    S a[] = {{1, 2}, {1, 7}, {1, 3}};
+    assert(std::ranges::any_of(a, a + 3, [](int i) { return i == 1; }, &S::check));
+    assert(std::ranges::any_of(a, [](int i) { return i == 1; }, &S::check));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/ranges.none_of.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 bool ranges::none_of(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 bool ranges::none_of(R&& r, Pred pred, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+struct UnaryFunctor {
+  bool operator()(auto&&);
+};
+
+template <class It, class Sent = sentinel_wrapper<It>>
+concept HasNoneOfIt = requires(It first, Sent last) { std::ranges::none_of(first, last, UnaryFunctor{}); };
+
+static_assert(HasNoneOfIt<int*>);
+static_assert(!HasNoneOfIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasNoneOfIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasNoneOfIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasNoneOfIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasNoneOfIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Func>
+concept HasNoneOfItFunc = requires(int* ptr) { std::ranges::none_of(ptr, ptr, Func{}); };
+
+static_assert(HasNoneOfItFunc<UnaryFunctor>);
+static_assert(!HasNoneOfItFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasNoneOfItFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class Range>
+concept HasNoneOfR = requires(Range range) { std::ranges::none_of(range, UnaryFunctor{}); };
+
+static_assert(HasNoneOfR<std::array<int, 10>>);
+static_assert(!HasNoneOfR<InputRangeNotDerivedFrom>);
+static_assert(!HasNoneOfR<InputRangeNotIndirectlyReadable>);
+static_assert(!HasNoneOfR<InputRangeNotInputOrOutputIterator>);
+static_assert(!HasNoneOfR<InputRangeNotSentinelSemiregular>);
+static_assert(!HasNoneOfR<InputRangeNotSentinelEqualityComparableWith>);
+
+template <class Func>
+concept HasNoneOfRFunc = requires(std::array<int, 10> range) { std::ranges::none_of(range, Func{}); };
+
+static_assert(HasNoneOfRFunc<UnaryFunctor>);
+static_assert(!HasNoneOfRFunc<IndirectUnaryPredicateNotCopyConstructible>);
+static_assert(!HasNoneOfRFunc<IndirectUnaryPredicateNotPredicate>);
+
+template <class It, class Sent = It>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      int a[] = {1, 2, 3, 4};
+      std::same_as<bool> decltype(auto) ret = std::ranges::none_of(It(a), Sent(It(a + 4)), [](int) { return true; });
+      assert(!ret);
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::none_of(range, [](int) { return true; });
+      assert(!ret);
+    }
+  }
+
+  { // check that an empty range works
+    std::array<int, 0> a;
+    assert(std::ranges::none_of(It(a.data()), Sent(It(a.data())), [](int) { return false; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data())));
+    assert(std::ranges::none_of(range, [](int) { return false; }));
+  }
+
+  { // check that the complexity requirements are met
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      assert(std::ranges::none_of(It(a.begin()), Sent(It(a.end())), pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+    {
+      int predicateCount = 0;
+      int projectionCount = 0;
+      auto pred = [&](int) { ++predicateCount; return false; };
+      auto proj = [&](int i) { ++projectionCount; return i; };
+      std::array a = {9, 7, 5, 3};
+      auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+      assert(std::ranges::none_of(range, pred, proj));
+      assert(predicateCount == 4);
+      assert(projectionCount == 4);
+    }
+  }
+
+  { // check that true is returned if no element satisfies the condition
+    std::array a = {1, 2, 3, 4};
+    assert(std::ranges::none_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(std::ranges::none_of(range, [](int i) { return i > 5; }));
+  }
+
+  { // check that false is returned if all elements satisfy the condition
+    std::array a = {1, 2, 3, 4};
+    assert(!std::ranges::none_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i < 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(!std::ranges::none_of(range, [](int i) { return i < 5; }));
+  }
+
+  { // check that false is returned if ony one elements satisfies the condition
+    std::array a = {1, 2, 3, 4, 6};
+    assert(!std::ranges::none_of(It(a.data()), Sent(It(a.data() + a.size())), [](int i) { return i > 5; }));
+    auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
+    assert(!std::ranges::none_of(range, [](int i) { return i > 5; }));
+  }
+}
+
+constexpr bool test() {
+  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 std::invoke is used
+    struct S { int check; int other; };
+    S a[] = {{1, 2}, {1, 7}, {1, 3}};
+    assert(std::ranges::none_of(a, a + 3, [](int i) { return i != 1; }, &S::check));
+    assert(std::ranges::none_of(a, [](int i) { return i != 1; }, &S::check));
+  }
+
+  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

 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::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::min, a));
 static_assert(test(std::ranges::min_element, a));
 static_assert(test(std::ranges::minmax, a));
 static_assert(test(std::ranges::minmax_element, a));
 static_assert(test(std::ranges::mismatch, a, a));
 //static_assert(test(std::ranges::move, a, a));
 //static_assert(test(std::ranges::move_backward, a, a));
 //static_assert(test(std::ranges::next_permutation, a));
-//static_assert(test(std::ranges::none_of, a, odd));
+static_assert(test(std::ranges::none_of, a, odd));
 //static_assert(test(std::ranges::nth_element, a, a+5));
 //static_assert(test(std::ranges::partial_sort, a, a+5));
 //static_assert(test(std::ranges::partial_sort_copy, a, a));
 //static_assert(test(std::ranges::partition, a, odd));
 //static_assert(test(std::ranges::partition_copy, a, a, a, odd));
 //static_assert(test(std::ranges::partition_point, a, odd));
 //static_assert(test(std::ranges::pop_heap, a));
 //static_assert(test(std::ranges::prev_permutation, a));