[libcxx][algorithms] adds ranges::all_of, ranges::any_of, and ranges::none_of

[cjdb]

Summary

Implements part of http://wg21.link/p0896.
Implements [alg.all.of], [alg.any.of], [alg.none.of].

Depends on D105792.

[cjdb]

rebases to activate CI

[cjdb]

rebases to activate CI

[cjdb]

adds missing includes

[cjdb]

rebases to activate CI

libcxx/include/__algorithm/all_of.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_ALL_OF_H
 #define _LIBCPP___ALGORITHM_ALL_OF_H
 
 #include <__config>
+#include <__function_like.h>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (!__pred(*__first))
       return false;
   return true;
 }
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  struct __all_of_fn final : __function_like {
+    constexpr explicit __all_of_fn(__tag __x) noexcept : __function_like(__x) {}
+
+    template<input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Ip __first, const _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+      for (; __first != __last; ++__first) {
+        if (!_VSTD::invoke(__pred, _VSTD::invoke(__proj, *__first))) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    template<input_range _Rp, class _Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+      return (*this)(ranges::begin(__r), ranges::end(__r), _VSTD::ref(__pred), _VSTD::ref(__proj));
+    }
+  };
+
+  inline constexpr auto all_of = __all_of_fn(__function_like::__tag());
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ALGORITHM_ALL_OF_H

libcxx/include/__algorithm/any_of.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_ANY_OF_H
 #define _LIBCPP___ALGORITHM_ANY_OF_H
 
+#include <__algorithm/find_if.h>
 #include <__config>
+#include <__function_like.h>
+#include <__functional/identity.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (__pred(*__first))
       return true;
   return false;
 }
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  struct __any_of_fn final : __function_like {
+    constexpr explicit __any_of_fn(__tag __x) noexcept : __function_like(__x) {}
+
+    template<input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Ip __first, const _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+      return ranges::find_if(_VSTD::move(__first), __last, _VSTD::ref(__pred), _VSTD::ref(__proj)) != __last;
+    }
+
+    template<input_range _Rp, class _Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+      return (*this)(ranges::begin(__r), ranges::end(__r), _VSTD::ref(__pred), _VSTD::ref(__proj));
+    }
+  };
+
+  inline constexpr auto any_of = __any_of_fn(__function_like::__tag());
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ALGORITHM_ANY_OF_H

libcxx/include/__algorithm/none_of.h

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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_NONE_OF_H
 #define _LIBCPP___ALGORITHM_NONE_OF_H
 
+#include <__algorithm/find_if.h>
 #include <__config>
+#include <__function_like.h>
+#include <__functional/identity.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 bool
 none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (__pred(*__first))
       return false;
   return true;
 }
 
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+namespace ranges {
+  struct __none_of_fn final : __function_like {
+    constexpr explicit __none_of_fn(__tag __x) noexcept : __function_like(__x) {}
+
+    template<input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Ip __first, const _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+      return ranges::find_if(_VSTD::move(__first), __last, _VSTD::ref(__pred), _VSTD::ref(__proj)) == __last;
+    }
+
+    template<input_range _Rp, class _Proj = identity,
+             indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+    _LIBCPP_NODISCARD_EXT constexpr
+    bool operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+      return (*this)(ranges::begin(__r), ranges::end(__r), _VSTD::ref(__pred), _VSTD::ref(__proj));
+    }
+  };
+
+  inline constexpr auto none_of = __none_of_fn(__function_like::__tag());
+} // namespace ranges
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___ALGORITHM_NONE_OF_H

libcxx/include/algorithm

 
 namespace std
 {
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
+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 <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     any_of(InputIterator first, InputIterator last, Predicate pred);
 
+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 <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     none_of(InputIterator first, InputIterator last, Predicate pred);
 
+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
+
 template <class InputIterator, class Function>
     constexpr Function          // constexpr in C++20
     for_each(InputIterator first, InputIterator last, Function f);
 
 template<class InputIterator, class Size, class Function>
     constexpr InputIterator     // constexpr in C++20
     for_each_n(InputIterator first, Size n, Function f); // C++17
 

libcxx/include/module.modulemap

module std [system] {
 
   module algorithm {
     header "algorithm"
     export initializer_list
     export *
 
     module __algorithm {
       module adjacent_find            { header "__algorithm/adjacent_find.h" }
-      module all_of                   { header "__algorithm/all_of.h" }
-      module any_of                   { header "__algorithm/any_of.h" }
+      module all_of {
+        header "__algorithm/all_of.h"
+        export __function_like
+      }
+      module any_of {
+        header "__algorithm/any_of.h"
+        export __function_like
+      }
       module binary_search            { header "__algorithm/binary_search.h" }
       module clamp                    { header "__algorithm/clamp.h" }
       module comp                     { header "__algorithm/comp.h" }
       module comp_ref_type            { header "__algorithm/comp_ref_type.h" }
       module copy                     { header "__algorithm/copy.h" }
       module copy_backward            { header "__algorithm/copy_backward.h" }
       module copy_if                  { header "__algorithm/copy_if.h" }
       module copy_n                   { header "__algorithm/copy_n.h" }
module __algorithm {
       module min                      { header "__algorithm/min.h" }
       module min_element              { header "__algorithm/min_element.h" }
       module minmax                   { header "__algorithm/minmax.h" }
       module minmax_element           { header "__algorithm/minmax_element.h" }
       module mismatch                 { header "__algorithm/mismatch.h" }
       module move                     { header "__algorithm/move.h" }
       module move_backward            { header "__algorithm/move_backward.h" }
       module next_permutation         { header "__algorithm/next_permutation.h" }
-      module none_of                  { header "__algorithm/none_of.h" }
+      module none_of {
+        header "__algorithm/none_of.h"
+        export __function_like
+      }
       module nth_element              { header "__algorithm/nth_element.h" }
       module partial_sort             { header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { header "__algorithm/partial_sort_copy.h" }
       module partition                { header "__algorithm/partition.h" }
       module partition_copy           { header "__algorithm/partition_copy.h" }
       module partition_point          { header "__algorithm/partition_point.h" }
       module pop_heap                 { header "__algorithm/pop_heap.h" }
       module prev_permutation         { header "__algorithm/prev_permutation.h" }

libcxx/test/libcxx/diagnostics/nodiscard_ranges_extensions.pass.cpp

 
 #include "test_macros.h"
 
 
 int main(int, char**) {
   auto arr = std::array{0, 1, 2, 3, 4, 5};
   namespace ranges = std::ranges;
 
+  ranges::all_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+  ranges::all_of(arr, [](auto) { return true; });
+
+  ranges::any_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+  ranges::any_of(arr, [](auto) { return true; });
+
+  ranges::none_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+  ranges::none_of(arr, [](auto) { return true; });
+
   ranges::find(ranges::begin(arr), ranges::end(arr), 1);
   ranges::find(arr, 1);
 
   ranges::find_if(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
   ranges::find_if(arr, [](auto) { return true; });
 
   ranges::find_if_not(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
   ranges::find_if_not(arr, [](auto) { return true; });
 
   return 0;
 }

libcxx/test/libcxx/diagnostics/nodiscard_ranges_extensions.verify.cpp

 #include <array>
 
 int main()
 {
   auto arr = std::array{0, 1, 2, 3, 4, 5};
   namespace ranges = std::ranges;
 
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::all_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::all_of(arr, [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::any_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::any_of(arr, [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::none_of(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
+  ranges::none_of(arr, [](auto) { return true; });
+
+  // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   ranges::find(ranges::begin(arr), ranges::end(arr), 1);
 
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   ranges::find(arr, 1);
 
   // expected-warning-re@+1 {{ignoring return value of function declared with {{'nodiscard'|warn_unused_result}} attribute}}
   ranges::find_if(ranges::begin(arr), ranges::end(arr), [](auto) { return true; });
 

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/ranges_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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// <algorithm>
+
+// ranges::all_of
+
+#include <algorithm>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "test_algorithm.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+template<template<class...> class I, class T>
+constexpr bool check_all_of()
+{
+  namespace ranges = std::ranges;
+
+  auto range = std::array{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  auto successor = [](auto const x) { return x + 1; };
+  auto is_zero = [](T const x) { return x == 0; };
+  auto is_ten = [](T const x) { return x == 10; };
+
+  {
+    auto pred = complexity_invocable(is_zero);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::all_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::all_of(subrange, std::ref(pred)));
+    }
+
+    assert(pred.count() == 2 * ranges::ssize(range));
+  }
+  {
+    auto pred = complexity_invocable(is_ten);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::all_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::all_of(subrange, std::ref(pred)));
+    }
+    assert(pred.count() == 2);
+  }
+  {
+    auto pred = complexity_invocable([](auto const x){ return x % 2 == 1; });
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::all_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::all_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2 * ranges::ssize(range));
+    assert(proj.count() == 2 * ranges::ssize(range));
+  }
+  {
+    auto pred = complexity_invocable(is_ten);
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::all_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::all_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2);
+    assert(proj.count() == 2);
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  static_assert(check_all_of<cpp17_input_iterator, int>());
+  static_assert(check_all_of<cpp17_input_iterator, double>());
+  check_all_of<cpp17_input_iterator, int>();
+  check_all_of<cpp17_input_iterator, double>();
+
+  static_assert(check_all_of<cpp20_input_iterator, int>());
+  static_assert(check_all_of<cpp20_input_iterator, double>());
+  check_all_of<cpp20_input_iterator, int>();
+  check_all_of<cpp20_input_iterator, double>();
+
+  static_assert(check_all_of<forward_iterator, int>());
+  static_assert(check_all_of<forward_iterator, double>());
+  check_all_of<forward_iterator, int>();
+  check_all_of<forward_iterator, double>();
+
+  static_assert(check_all_of<bidirectional_iterator, int>());
+  static_assert(check_all_of<bidirectional_iterator, double>());
+  check_all_of<bidirectional_iterator, int>();
+  check_all_of<bidirectional_iterator, double>();
+
+  static_assert(check_all_of<random_access_iterator, int>());
+  static_assert(check_all_of<random_access_iterator, double>());
+  check_all_of<random_access_iterator, int>();
+  check_all_of<random_access_iterator, double>();
+
+  static_assert(check_all_of<contiguous_iterator, int>());
+  static_assert(check_all_of<contiguous_iterator, double>());
+  check_all_of<contiguous_iterator, int>();
+  check_all_of<contiguous_iterator, double>();
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/ranges_all_of/special_function.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::all_of
+
+#include <algorithm>
+
+#include <array>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+#include "test_standard_function.h"
+
+static_assert(is_function_like<decltype(std::ranges::all_of)>());
+
+namespace ranges = std::ranges;
+
+namespace std::ranges {
+  template<class T>
+  class basic_istream_view {
+    struct iterator;
+  public:
+    iterator begin();
+    default_sentinel_t end() const;
+  };
+} // namespace std::ranges
+
+auto f = [](auto) { return true; };
+
+// The entities defined in the std::ranges namespace in this Clause are not found by argument-dependent
+// name lookup ([basic.lookup.argdep]). When found by unqualified ([basic.lookup.unqual]) name lookup for
+// the postfix-expression in a function call ([expr.call]), they inhibit argument-dependent name lookup.
+template <class T>
+constexpr bool no_unqualified_lookup() {
+  auto identity = ranges::basic_istream_view<T>();
+  static_assert(!requires(T value) { all_of(ranges::begin(identity), ranges::end(identity), f); });
+  static_assert(!requires(T value) { all_of(ranges::begin(identity), ranges::end(identity), f, &T::first); });
+  static_assert(!requires(T value) { all_of(identity, f); });
+  static_assert(!requires(T value) { all_of(identity, f, &T::first); });
+  return true;
+};
+
+static_assert(no_unqualified_lookup<std::pair<int, int>>());
+
+namespace test {
+template <class>
+struct iterator {
+  using value_type = std::pair<int, int>;
+  using difference_type = std::ptrdiff_t;
+  using iterator_category = std::forward_iterator_tag;
+
+  iterator() = default;
+
+  value_type operator*() const;
+  iterator& operator++();
+  iterator operator++(int);
+
+  bool operator==(iterator const&) const = default;
+};
+
+template<class>
+struct range {
+  std::pair<int, int> const* begin() const;
+  std::pair<int, int> const* end() const;
+};
+
+template <class I>
+void all_of(iterator<I>, iterator<I>, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class I>
+void all_of(iterator<I>, iterator<I>, auto, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class R>
+void all_of(R&&, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+
+template <class R>
+void all_of(R&&, auto, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+} // namespace test
+
+// When found by unqualified ([basic.lookup.unqual]) name lookup for the postfix-expression in a
+// function call ([expr.call]), they inhibit argument-dependent name lookup.
+void adl_inhibition() {
+  using std::ranges::all_of;
+
+  test::iterator<std::pair<int, int>*> x;
+  (void)all_of(x, x, f);
+  (void)all_of(x, x, f, &std::pair<int, int>::first);
+
+  test::range<int*> r;
+  (void)all_of(r, f);
+  (void)all_of(r, f, &std::pair<int, int>::first);
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/ranges_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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// <algorithm>
+
+// ranges::any_of
+
+#include <algorithm>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "test_algorithm.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+template<template<class...> class I, class T>
+constexpr bool check_any_of()
+{
+  namespace ranges = std::ranges;
+
+  auto range = std::array{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  auto successor = [](auto const x) { return x + 1; };
+  auto is_zero = [](T const x) { return x == 0; };
+  auto is_ten = [](T const x) { return x == 10; };
+
+  {
+    auto pred = complexity_invocable(is_zero);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::any_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::any_of(subrange, std::ref(pred)));
+    }
+    assert(pred.count() == 2);
+  }
+  {
+    auto pred = complexity_invocable(is_ten);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::any_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::any_of(subrange, std::ref(pred)));
+    }
+    assert(pred.count() == 2 * ranges::ssize(range));
+  }
+  {
+    auto pred = complexity_invocable([](auto const x){ return x % 2 == 1; });
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::any_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::any_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2);
+    assert(proj.count() == 2);
+  }
+  {
+    auto pred = complexity_invocable(is_ten);
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::any_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::any_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2 * ranges::ssize(range));
+    assert(proj.count() == 2 * ranges::ssize(range));
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  // static_assert(check_any_of<cpp17_input_iterator, int>());
+  // static_assert(check_any_of<cpp17_input_iterator, double>());
+  check_any_of<cpp17_input_iterator, int>();
+  check_any_of<cpp17_input_iterator, double>();
+
+  // static_assert(check_any_of<cpp20_input_iterator, int>());
+  // static_assert(check_any_of<cpp20_input_iterator, double>());
+  check_any_of<cpp20_input_iterator, int>();
+  check_any_of<cpp20_input_iterator, double>();
+
+  // static_assert(check_any_of<forward_iterator, int>());
+  // static_assert(check_any_of<forward_iterator, double>());
+  check_any_of<forward_iterator, int>();
+  check_any_of<forward_iterator, double>();
+
+  // static_assert(check_any_of<bidirectional_iterator, int>());
+  // static_assert(check_any_of<bidirectional_iterator, double>());
+  check_any_of<bidirectional_iterator, int>();
+  check_any_of<bidirectional_iterator, double>();
+
+  // static_assert(check_any_of<random_access_iterator, int>());
+  // static_assert(check_any_of<random_access_iterator, double>());
+  check_any_of<random_access_iterator, int>();
+  check_any_of<random_access_iterator, double>();
+
+  // static_assert(check_any_of<contiguous_iterator, int>());
+  // static_assert(check_any_of<contiguous_iterator, double>());
+  check_any_of<contiguous_iterator, int>();
+  check_any_of<contiguous_iterator, double>();
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/ranges_any_of/special_function.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::any_of
+
+#include <algorithm>
+
+#include <array>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+#include "test_standard_function.h"
+
+static_assert(is_function_like<decltype(std::ranges::any_of)>());
+
+namespace ranges = std::ranges;
+
+namespace std::ranges {
+  template<class T>
+  class basic_istream_view {
+    struct iterator;
+  public:
+    iterator begin();
+    default_sentinel_t end() const;
+  };
+} // namespace std::ranges
+
+auto f = [](auto) { return true; };
+
+// The entities defined in the std::ranges namespace in this Clause are not found by argument-dependent
+// name lookup ([basic.lookup.argdep]). When found by unqualified ([basic.lookup.unqual]) name lookup for
+// the postfix-expression in a function cany ([expr.cany]), they inhibit argument-dependent name lookup.
+template <class T>
+constexpr bool no_unqualified_lookup() {
+  auto identity = ranges::basic_istream_view<T>();
+  static_assert(!requires(T value) { any_of(ranges::begin(identity), ranges::end(identity), f); });
+  static_assert(!requires(T value) { any_of(ranges::begin(identity), ranges::end(identity), f, &T::first); });
+  static_assert(!requires(T value) { any_of(identity, f); });
+  static_assert(!requires(T value) { any_of(identity, f, &T::first); });
+  return true;
+};
+
+static_assert(no_unqualified_lookup<std::pair<int, int>>());
+
+namespace test {
+template <class>
+struct iterator {
+  using value_type = std::pair<int, int>;
+  using difference_type = std::ptrdiff_t;
+  using iterator_category = std::forward_iterator_tag;
+
+  iterator() = default;
+
+  value_type operator*() const;
+  iterator& operator++();
+  iterator operator++(int);
+
+  bool operator==(iterator const&) const = default;
+};
+
+template<class>
+struct range {
+  std::pair<int, int> const* begin() const;
+  std::pair<int, int> const* end() const;
+};
+
+template <class I>
+void any_of(iterator<I>, iterator<I>, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class I>
+void any_of(iterator<I>, iterator<I>, auto, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class R>
+void any_of(R&&, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+
+template <class R>
+void any_of(R&&, auto, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+} // namespace test
+
+// When found by unqualified ([basic.lookup.unqual]) name lookup for the postfix-expression in a
+// function cany ([expr.cany]), they inhibit argument-dependent name lookup.
+void adl_inhibition() {
+  using std::ranges::any_of;
+
+  test::iterator<std::pair<int, int>*> x;
+  (void)any_of(x, x, f);
+  (void)any_of(x, x, f, &std::pair<int, int>::first);
+
+  test::range<int*> r;
+  (void)any_of(r, f);
+  (void)any_of(r, f, &std::pair<int, int>::first);
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/ranges_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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// <algorithm>
+
+// ranges::none_of
+
+#include <algorithm>
+
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "test_algorithm.h"
+#include "test_macros.h"
+#include "test_iterators.h"
+#include "test_range.h"
+
+template<template<class...> class I, class T>
+constexpr bool check_none_of()
+{
+  namespace ranges = std::ranges;
+
+  auto range = std::array{10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+  auto successor = [](auto const x) { return x + 1; };
+  auto is_zero = [](T const x) { return x == 0; };
+  auto is_ten = [](T const x) { return x == 10; };
+
+  {
+    auto pred = complexity_invocable(is_zero);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::none_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::none_of(subrange, std::ref(pred)));
+    }
+
+    assert(pred.count() == 2 * ranges::ssize(range));
+  }
+  {
+    auto pred = complexity_invocable(is_ten);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::none_of(subrange.begin(), subrange.end(), std::ref(pred)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::none_of(subrange, std::ref(pred)));
+    }
+    assert(pred.count() == 2);
+  }
+  {
+    auto pred = complexity_invocable(is_zero);
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::none_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(ranges::none_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2 * ranges::ssize(range));
+    assert(proj.count() == 2 * ranges::ssize(range));
+  }
+  {
+    auto pred = complexity_invocable([](auto const x){ return x % 2 != 0; });
+    auto proj = complexity_invocable(successor);
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::none_of(subrange.begin(), subrange.end(), std::ref(pred), std::ref(proj)));
+    }
+    {
+      auto subrange = ranges::subrange(I(range.begin()), sentinel_wrapper(range.end()));
+      assert(!ranges::none_of(subrange, std::ref(pred), std::ref(proj)));
+    }
+    assert(pred.count() == 2);
+    assert(proj.count() == 2);
+  }
+
+  return true;
+}
+
+int main(int, char**)
+{
+  // static_assert(check_none_of<cpp17_input_iterator, int>());
+  // static_assert(check_none_of<cpp17_input_iterator, double>());
+  check_none_of<cpp17_input_iterator, int>();
+  check_none_of<cpp17_input_iterator, double>();
+
+  // static_assert(check_none_of<cpp20_input_iterator, int>());
+  // static_assert(check_none_of<cpp20_input_iterator, double>());
+  // check_none_of<cpp20_input_iterator, int>();
+  // check_none_of<cpp20_input_iterator, double>();
+
+  // static_assert(check_none_of<forward_iterator, int>());
+  // static_assert(check_none_of<forward_iterator, double>());
+  // check_none_of<forward_iterator, int>();
+  // check_none_of<forward_iterator, double>();
+
+  // static_assert(check_none_of<bidirectional_iterator, int>());
+  // static_assert(check_none_of<bidirectional_iterator, double>());
+  // check_none_of<bidirectional_iterator, int>();
+  // check_none_of<bidirectional_iterator, double>();
+
+  // static_assert(check_none_of<random_access_iterator, int>());
+  // static_assert(check_none_of<random_access_iterator, double>());
+  // check_none_of<random_access_iterator, int>();
+  // check_none_of<random_access_iterator, double>();
+
+  // static_assert(check_none_of<contiguous_iterator, int>());
+  // static_assert(check_none_of<contiguous_iterator, double>());
+  // check_none_of<contiguous_iterator, int>();
+  // check_none_of<contiguous_iterator, double>();
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/ranges_none_of/special_function.compile.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// ranges::none_of
+
+#include <algorithm>
+
+#include <array>
+#include <iterator>
+#include <ranges>
+#include <utility>
+
+#include "test_standard_function.h"
+
+static_assert(is_function_like<decltype(std::ranges::none_of)>());
+
+namespace ranges = std::ranges;
+
+namespace std::ranges {
+  template<class T>
+  class basic_istream_view {
+    struct iterator;
+  public:
+    iterator begin();
+    default_sentinel_t end() const;
+  };
+} // namespace std::ranges
+
+auto f = [](auto) { return true; };
+
+// The entities defined in the std::ranges namespace in this Clause are not found by argument-dependent
+// name lookup ([basic.lookup.argdep]). When found by unqualified ([basic.lookup.unqual]) name lookup for
+// the postfix-expression in a function cany ([expr.cany]), they inhibit argument-dependent name lookup.
+template <class T>
+constexpr bool no_unqualified_lookup() {
+  auto identity = ranges::basic_istream_view<T>();
+  static_assert(!requires(T value) { none_of(ranges::begin(identity), ranges::end(identity), f); });
+  static_assert(!requires(T value) { none_of(ranges::begin(identity), ranges::end(identity), f, &T::first); });
+  static_assert(!requires(T value) { none_of(identity, f); });
+  static_assert(!requires(T value) { none_of(identity, f, &T::first); });
+  return true;
+};
+
+static_assert(no_unqualified_lookup<std::pair<int, int>>());
+
+namespace test {
+template <class>
+struct iterator {
+  using value_type = std::pair<int, int>;
+  using difference_type = std::ptrdiff_t;
+  using iterator_category = std::forward_iterator_tag;
+
+  iterator() = default;
+
+  value_type operator*() const;
+  iterator& operator++();
+  iterator operator++(int);
+
+  bool operator==(iterator const&) const = default;
+};
+
+template<class>
+struct range {
+  std::pair<int, int> const* begin() const;
+  std::pair<int, int> const* end() const;
+};
+
+template <class I>
+void none_of(iterator<I>, iterator<I>, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class I>
+void none_of(iterator<I>, iterator<I>, auto, auto) {
+  static_assert(std::same_as<I, I*>);
+}
+
+template <class R>
+void none_of(R&&, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+
+template <class R>
+void none_of(R&&, auto, auto) {
+  static_assert(std::same_as<R, R*>);
+}
+} // namespace test
+
+// When found by unqualified ([basic.lookup.unqual]) name lookup for the postfix-expression in a
+// function cany ([expr.cany]), they inhibit argument-dependent name lookup.
+void adl_inhibition() {
+  using std::ranges::none_of;
+
+  test::iterator<std::pair<int, int>*> x;
+  (void)none_of(x, x, f);
+  (void)none_of(x, x, f, &std::pair<int, int>::first);
+
+  test::range<int*> r;
+  (void)none_of(r, f);
+  (void)none_of(r, f, &std::pair<int, int>::first);
+}