[libc++][ranges] Implement `ranges::is_heap{,_until}`.

[var-const]

Use the actual patch number.

[var-const]

Fix the CI and rebase.

[huixie90]

Almost LGTM thanks!

libcxx/include/__algorithm/is_heap.h

31

i think perhaps not to pass the comp_ref type explicitly since the __is_heap_until already takes it by reference?

libcxx/include/__algorithm/ranges_is_heap.h

58

nit:
for ranges that do model sized_range but their iter/sent pair do not model sized_sentinel_for, by doing this it lost its size information and possibly as a result the ranges::next call becomes linear whereas it could be constant. What do you think?

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/ranges_is_heap.pass.cpp

147–148

most other tests use a different type to test projection. perhaps it is a good idea to adopt the same approach, since having different types sound more realistic use case

[ldionne]

libcxx/include/__algorithm/ranges_is_heap.h

58

That is an interesting corner case, however that would also require the range's iterator to be a random_access_iterator but not a sized_sentinel_for<It, Sent>. That seems rather broken to me.

For example, imagine a null-terminated string where the iterators are random access (roughly char*), but comparing against the end sentinel checks whether *it == '\0'. If the range is a sized_range, it means that it also stores the size of the string. In a case like that, I can't imagine why one would implement the iterator and the sentinel as different types, because the size is known anyway so end() can be implemented as begin() + size() trivially.

If I'm not imaginative enough, please feel free to enlighten me, however if this is such a tiny corner case, perhaps it is not worth increasing the complexity of our implementation to handle it.

[huixie90]

libcxx/include/__algorithm/ranges_is_heap.h

58

@ldionne

auto v = std::ranges::iota_view(5, 7L);
using iter = std::ranges::iterator_t<decltype(v)>;
using sent = std::ranges::sentinel_t<decltype(v)>;

static_assert(std::ranges::sized_range<decltype(v)>);
static_assert(std::random_access_iterator<iter>);
static_assert(!std::sized_sentinel_for<sent, iter>);

https://godbolt.org/z/7bd91z5c4

Yes it is a corner case and yes iota_view is weird. so I am happy to NAD this

[var-const]

Address feedback and rebase.

libcxx/include/__algorithm/is_heap.h

31

Thanks!

libcxx/docs/Status/RangesAlgorithms.csv

 Search,count_if,Nikolas Klauser,`D121523 <https://llvm.org/D121523>`_,✅
 Search,search,Nikolas Klauser,`D124079 <https://llvm.org/D124079>`_,✅
 Search,search_n,Nikolas Klauser,`D124079 <https://llvm.org/D124079>`_,✅
 Search,find_end,Nikolas Klauser,`D124079 <https://llvm.org/D124079>`_,✅
 Read-only,is_partitioned,Nikolas Klauser,`D124440 <https://llvm.org/D124440>`_,✅
 Read-only,is_sorted,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
 Read-only,is_sorted_until,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
 Read-only,includes,Hui Xie,`D130116 <https://llvm.org/D130116>`,✅
-Read-only,is_heap,Nikolas Klauser,n/a,Not started
-Read-only,is_heap_until,Nikolas Klauser,n/a,Not started
+Read-only,is_heap,Konstantin Varlamov,`D130547 <https://llvm.org/D130547>`_,✅
+Read-only,is_heap_until,Konstantin Varlamov,`D130547 <https://llvm.org/D130547>`_,✅
 Read-only,clamp,Nikolas Klauser,`D126193 <https://llvm.org/D126193>`_,Under review
 Read-only,is_permutation,Nikolas Klauser,`D127194 <https://llvm.org/D127194>`_,Under review
 Read-only,for_each,Nikolas Klauser,`D124332 <https://llvm.org/D124332>`_,✅
 Read-only,for_each_n,Nikolas Klauser,`D124332 <https://llvm.org/D124332>`_,✅
 Write,copy,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,copy_if,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,copy_n,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅
 Write,copy_backward,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅

libcxx/include/__algorithm/is_heap.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
 //
 //===----------------------------------------------------------------------===//
 

 
 template <class _RandomAccessIterator, class _Compare>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
     typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
-    return _VSTD::__is_heap_until<_Comp_ref>(__first, __last, __comp) == __last;
+    return std::__is_heap_until<_Comp_ref>(__first, __last, static_cast<_Comp_ref>(__comp)) == __last;
 }
 
 template<class _RandomAccessIterator>
 _LIBCPP_NODISCARD_EXT inline
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
     return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IS_HEAP_H

libcxx/include/__algorithm/is_heap_until.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_IS_HEAP_UNTIL_H
 #define _LIBCPP___ALGORITHM_IS_HEAP_UNTIL_H
 
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
-__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
+__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp)
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     difference_type __len = __last - __first;
     difference_type __p = 0;
     difference_type __c = 1;
     _RandomAccessIterator __pp = __first;
     while (__c < __len)
     {
__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp)
     return __last;
 }
 
 template <class _RandomAccessIterator, class _Compare>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
     typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
-    return _VSTD::__is_heap_until<_Comp_ref>(__first, __last, __comp);
+    return std::__is_heap_until(__first, __last, static_cast<_Comp_ref>(__comp));
 }
 
 template<class _RandomAccessIterator>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator
 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
     return _VSTD::__is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_IS_HEAP_UNTIL_H

libcxx/include/__algorithm/ranges_is_heap.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_IS_HEAP_H
 #define _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H
 
-#include <__algorithm/is_heap.h>
+#include <__algorithm/is_heap_until.h>
 #include <__algorithm/make_projected.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
-#include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __is_heap {
 
 struct __fn {
 
+  template <class _Iter, class _Sent, class _Proj, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  static bool __is_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+    auto __last_iter = ranges::next(__first, __last);
+    auto&& __projected_comp = ranges::__make_projected_comp(__comp, __proj);
+
+    auto __result = std::__is_heap_until(std::move(__first), std::move(__last_iter), __projected_comp);
+    return __result == __last;
+  }
+
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
   _LIBCPP_HIDE_FROM_ABI constexpr
   bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__comp; (void)__proj;
-    return {};
+    return __is_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Proj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
   _LIBCPP_HIDE_FROM_ABI constexpr
   bool operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__range; (void)__comp; (void)__proj;
-    return {};
+    return __is_heap_fn_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
   }
 };
 
 } // namespace __is_heap
 
 inline namespace __cpo {
   inline constexpr auto is_heap = __is_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H

libcxx/include/__algorithm/ranges_is_heap_until.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_IS_HEAP_UNTIL_H
 #define _LIBCPP___ALGORITHM_RANGES_IS_HEAP_UNTIL_H
 
 #include <__algorithm/is_heap_until.h>
 #include <__algorithm/make_projected.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
-#include <__utility/forward.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __is_heap_until {
 
 struct __fn {
 
+  template <class _Iter, class _Sent, class _Proj, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  static _Iter __is_heap_until_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+    auto __last_iter = ranges::next(__first, __last);
+    auto&& __projected_comp = ranges::__make_projected_comp(__comp, __proj);
+
+    return std::__is_heap_until(std::move(__first), std::move(__last_iter), __projected_comp);
+  }
+
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
   _LIBCPP_HIDE_FROM_ABI constexpr
   _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__first; (void)__last; (void)__comp; (void)__proj;
-    return {};
+    return __is_heap_until_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Proj = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
   _LIBCPP_HIDE_FROM_ABI constexpr
   borrowed_iterator_t<_Range> operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
-    // TODO: implement
-    (void)__range; (void)__comp; (void)__proj;
-    return {};
+    return __is_heap_until_fn_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
   }
 
 };
 
 } // namespace __is_heap_until
 
 inline namespace __cpo {
   inline constexpr auto is_heap_until = __is_heap_until::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_UNTIL_H

libcxx/include/algorithm

template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
     constexpr I
       ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // since C++20
 
   template<random_access_range R, class Comp = ranges::less, class Proj = identity>
     requires sortable<iterator_t<R>, Comp, Proj>
     constexpr borrowed_iterator_t<R>
       ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {});                             // since C++20
 
+  template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+            indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+    constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                // Since C++20
+
+  template<random_access_range R, class Proj = identity,
+            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                          // Since C++20
+
+  template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+    constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});             // Since C++20
+
+  template<random_access_range R, class Proj = identity,
+           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    constexpr borrowed_iterator_t<R>
+      is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                 // Since C++20
+
   template<bidirectional_iterator I, sentinel_for<I> S>
     requires permutable<I>
     constexpr I ranges::reverse(I first, S last);                                           // since C++20
 
   template<bidirectional_range R>
     requires permutable<iterator_t<R>>
     constexpr borrowed_iterator_t<R> ranges::reverse(R&& r);                                // since C++20
 

 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_end.h>
 #include <__algorithm/ranges_find_first_of.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_includes.h>
+#include <__algorithm/ranges_is_heap.h>
+#include <__algorithm/ranges_is_heap_until.h>
 #include <__algorithm/ranges_is_partitioned.h>
 #include <__algorithm/ranges_is_sorted.h>
 #include <__algorithm/ranges_is_sorted_until.h>
 #include <__algorithm/ranges_lexicographical_compare.h>
 #include <__algorithm/ranges_lower_bound.h>
 #include <__algorithm/ranges_make_heap.h>
 #include <__algorithm/ranges_max.h>
 #include <__algorithm/ranges_max_element.h>

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.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
 //
 //===----------------------------------------------------------------------===//
 
#endif
     (void)std::ranges::for_each(first, last, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
     (void)std::ranges::for_each(a, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
     (void)std::ranges::for_each_n(first, count, UnaryVoid(&copies)); assert(copies == 1); copies = 0;
     //(void)std::ranges::generate(first, last, NullaryValue(&copies)); assert(copies == 0);
     //(void)std::ranges::generate(a, NullaryValue(&copies)); assert(copies == 0);
     //(void)std::ranges::generate_n(first, count, NullaryValue(&copies)); assert(copies == 0);
     (void)std::ranges::includes(first, last, first2, last2, Less(&copies)); assert(copies == 0);
     (void)std::ranges::includes(a, b, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap(first, last, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap(a, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap_until(first, last, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap_until(a, Less(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap(first, last, Less(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap(a, Less(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap_until(first, last, Less(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap_until(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(a, UnaryTrue(&copies)); assert(copies == 0);
     //(void)std::ranges::is_permutation(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
     //(void)std::ranges::is_permutation(a, b, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted(a, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(first, last, Less(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(a, Less(&copies)); assert(copies == 0);

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.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
 //
 //===----------------------------------------------------------------------===//
 
#endif
     (void)std::ranges::find_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_if_not(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::for_each(first, last, UnaryVoid(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::for_each(a, UnaryVoid(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::for_each_n(first, count, UnaryVoid(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::includes(first, last, first2, last2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::includes(a, b, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap(first, last, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap(a, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::is_heap_until(a, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap(first, last, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap(a, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::is_heap_until(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_partitioned(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::is_permutation(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::is_permutation(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted(a, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::is_sorted_until(a, Less(), Proj(&copies)); assert(copies == 0);

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/ranges_is_heap.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-has-no-incomplete-ranges
 
 // <algorithm>
 
 // template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
-//              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-//       constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // Since C++20
+//          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+//   constexpr bool is_heap(I first, S last, Comp comp = {}, Proj proj = {});                   // Since C++20
 //
-//     template<random_access_range R, class Proj = identity,
-//              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-//       constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                             // Since C++20
+// template<random_access_range R, class Proj = identity,
+//          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+//   constexpr bool is_heap(R&& r, Comp comp = {}, Proj proj = {});                             // Since C++20
 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
+#include <utility>
 
 #include "almost_satisfies_types.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+// Test constraints of the (iterator, sentinel) overload.
+// ======================================================
+
+template <class Iter = int*, class Sent = int*, class Comp = std::ranges::less>
+concept HasIsHeapIter =
+    requires(Iter&& iter, Sent&& sent, Comp&& comp) {
+      std::ranges::is_heap(std::forward<Iter>(iter), std::forward<Sent>(sent), std::forward<Comp>(comp));
+    };
+
+static_assert(HasIsHeapIter<int*, int*, std::ranges::less>);
+
+// !random_access_iterator<I>
+static_assert(!HasIsHeapIter<RandomAccessIteratorNotDerivedFrom>);
+static_assert(!HasIsHeapIter<RandomAccessIteratorBadIndex>);
+
+// !sentinel_for<S, I>
+static_assert(!HasIsHeapIter<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsHeapIter<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+struct NoComparator {};
+// !indirect_strict_weak_order<Comp, projected<I, Proj>>
+static_assert(!HasIsHeapIter<NoComparator*, NoComparator*>);
+
+// Test constraints of the (range) overload.
+// =========================================
+
+template <class Range, class Comp = std::ranges::less>
+concept HasIsHeapRange =
+    requires(Range&& range, Comp&& comp) {
+      std::ranges::is_heap(std::forward<Range>(range), std::forward<Comp>(comp));
+    };
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasIsHeapRange<R<int*>>);
+
+// !random_access_range<R>
+static_assert(!HasIsHeapRange<RandomAccessRangeNotDerivedFrom>);
+static_assert(!HasIsHeapRange<RandomAccessRangeBadIndex>);
+
+// !indirect_strict_weak_order<Comp, projected<iterator_t<R>, Proj>>
+static_assert(!HasIsHeapRange<R<NoComparator*>>);
+
+template <class Iter, class Sent, size_t N>
+constexpr void test_one(std::array<int, N> input, bool expected) {
+  auto begin = Iter(input.data());
+  auto end = Sent(Iter(input.data() + input.size()));
+
+  { // (iterator, sentinel) overload.
+    std::same_as<bool> decltype(auto) result = std::ranges::is_heap(begin, end);
+    assert(result == expected);
+  }
+
+  { // (range) overload.
+    auto range = std::ranges::subrange(begin, end);
+    std::same_as<bool> decltype(auto) result = std::ranges::is_heap(range);
+    assert(result == expected);
+  }
+}
+
+template <class Iter, class Sent>
+constexpr void test_iter_sent() {
+  // Empty sequence.
+  test_one<Iter, Sent, 0>({}, true);
+  // 1-element sequence.
+  test_one<Iter, Sent>(std::array{1}, true);
+  // 2-element sequence, a heap.
+  test_one<Iter, Sent>(std::array{2, 1}, true);
+  // 2-element sequence, not a heap.
+  test_one<Iter, Sent>(std::array{1, 2}, false);
+  // Longer sequence, a heap.
+  test_one<Iter, Sent>(std::array{8, 6, 7, 3, 4, 1, 5, 2}, true);
+  // Longer sequence, not a heap.
+  test_one<Iter, Sent>(std::array{8, 6, 7, 3, 4, 1, 2, 5}, false);
+  // Longer sequence with duplicates, a heap.
+  test_one<Iter, Sent>(std::array{8, 7, 5, 5, 6, 4, 1, 2, 3, 2}, true);
+  // Longer sequence with duplicates, not a heap.
+  test_one<Iter, Sent>(std::array{7, 5, 5, 6, 4, 1, 2, 3, 2, 8}, false);
+  // All elements are the same.
+  test_one<Iter, Sent>(std::array{1, 1, 1}, true);
+}
+
+template <class Iter>
+constexpr void test_iter() {
+  test_iter_sent<Iter, Iter>();
+  test_iter_sent<Iter, sentinel_wrapper<Iter>>();
+}
+
+constexpr void test_iterators() {
+  test_iter<random_access_iterator<int*>>();
+  test_iter<contiguous_iterator<int*>>();
+  test_iter<int*>();
+  test_iter<const int*>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_iterators();
+
+  { // A custom comparator works.
+    std::ranges::less ls;
+    std::ranges::greater gt;
+    std::array in = {1, 3, 2, 5, 4, 7, 8, 6};
+
+    { // (iterator, sentinel) overload.
+      assert(!std::ranges::is_heap(in.begin(), in.end(), ls));
+      assert(std::ranges::is_heap(in.begin(), in.end(), gt));
+    }
+
+    { // (range) overload.
+      assert(!std::ranges::is_heap(in, ls));
+      assert(std::ranges::is_heap(in, gt));
+    }
+  }
+
+  { // A custom projection works.
+    std::array in = {-8, -6, -7, -3, -4, -1, -5, -2};
+    auto negate = [](int x) { return x * -1; };
+
+    { // (iterator, sentinel) overload.
+      assert(!std::ranges::is_heap(in.begin(), in.end(), {}));
+      assert(std::ranges::is_heap(in.begin(), in.end(), {}, negate));
+    }
+
+    { // (range) overload.
+      assert(!std::ranges::is_heap(in, {}));
+      assert(std::ranges::is_heap(in, {}, negate));
+    }
+  }
+
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/ranges_is_heap_until.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-has-no-incomplete-ranges
 
 // <algorithm>
 
 // template<random_access_iterator I, sentinel_for<I> S, class Proj = identity,
-//              indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
-//       constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});                // Since C++20
+//          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+//   constexpr I is_heap_until(I first, S last, Comp comp = {}, Proj proj = {});                // Since C++20
 //
-//     template<random_access_range R, class Proj = identity,
-//              indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
-//       constexpr borrowed_iterator_t<R>
-//         is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                    // Since C++20
+// template<random_access_range R, class Proj = identity,
+//          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+//   constexpr borrowed_iterator_t<R>
+//     is_heap_until(R&& r, Comp comp = {}, Proj proj = {});                                    // Since C++20
 
 #include <algorithm>
 #include <array>
 #include <concepts>
 #include <functional>
 #include <ranges>
 
 #include "almost_satisfies_types.h"
 #include "test_iterators.h"
 
-// TODO: SFINAE tests.
+// Test constraints of the (iterator, sentinel) overload.
+// ======================================================
+
+template <class Iter = int*, class Sent = int*, class Comp = std::ranges::less>
+concept HasIsHeapUntilIter =
+    requires(Iter&& iter, Sent&& sent, Comp&& comp) {
+      std::ranges::is_heap_until(std::forward<Iter>(iter), std::forward<Sent>(sent), std::forward<Comp>(comp));
+    };
+
+static_assert(HasIsHeapUntilIter<int*, int*, std::ranges::less>);
+
+// !random_access_iterator<I>
+static_assert(!HasIsHeapUntilIter<RandomAccessIteratorNotDerivedFrom>);
+static_assert(!HasIsHeapUntilIter<RandomAccessIteratorBadIndex>);
+
+// !sentinel_for<S, I>
+static_assert(!HasIsHeapUntilIter<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsHeapUntilIter<int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+struct NoComparator {};
+// !indirect_strict_weak_order<Comp, projected<I, Proj>>
+static_assert(!HasIsHeapUntilIter<NoComparator*, NoComparator*>);
+
+// Test constraints of the (range) overload.
+// =========================================
+
+template <class Range, class Comp = std::ranges::less>
+concept HasIsHeapUntilRange =
+    requires(Range&& range, Comp&& comp) {
+      std::ranges::is_heap_until(std::forward<Range>(range), std::forward<Comp>(comp));
+    };
+
+template <class T>
+using R = UncheckedRange<T>;
+
+static_assert(HasIsHeapUntilRange<R<int*>>);
+
+// !random_access_range<R>
+static_assert(!HasIsHeapUntilRange<RandomAccessRangeNotDerivedFrom>);
+static_assert(!HasIsHeapUntilRange<RandomAccessRangeBadIndex>);
+
+// !indirect_strict_weak_order<Comp, projected<iterator_t<R>, Proj>>
+static_assert(!HasIsHeapUntilRange<R<NoComparator*>>);
+
+template <class Iter, class Sent, size_t N>
+constexpr void test_one(std::array<int, N> input, size_t until_index) {
+  auto begin = Iter(input.data());
+  auto end = Sent(Iter(input.data() + input.size()));
+
+  { // (iterator, sentinel) overload.
+    std::same_as<Iter> decltype(auto) result = std::ranges::is_heap_until(begin, end);
+    assert(base(result) == input.data() + until_index);
+  }
+
+  { // (range) overload.
+    auto range = std::ranges::subrange(begin, end);
+    std::same_as<Iter> decltype(auto) result = std::ranges::is_heap_until(range);
+    assert(base(result) == input.data() + until_index);
+  }
+}
+
+template <class Iter, class Sent>
+constexpr void test_iter_sent() {
+  // Empty sequence.
+  test_one<Iter, Sent, 0>({}, 0);
+  // 1-element sequence.
+  test_one<Iter, Sent>(std::array{1}, 1);
+  // 2-element sequence, a heap.
+  test_one<Iter, Sent>(std::array{2, 1}, 2);
+  // 2-element sequence, not a heap.
+  test_one<Iter, Sent>(std::array{1, 2}, 1);
+  // Longer sequence, a heap.
+  test_one<Iter, Sent>(std::array{8, 6, 7, 3, 4, 1, 5, 2}, 8);
+  // Longer sequence, not a heap.
+  test_one<Iter, Sent>(std::array{8, 6, 7, 3, 4, 1, 2, 5}, 7);
+  // Longer sequence with duplicates, a heap.
+  test_one<Iter, Sent>(std::array{8, 7, 5, 5, 6, 4, 1, 2, 3, 2}, 10);
+  // Longer sequence with duplicates, not a heap.
+  test_one<Iter, Sent>(std::array{7, 5, 5, 6, 4, 1, 2, 3, 2, 8}, 3);
+  // All elements are the same.
+  test_one<Iter, Sent>(std::array{1, 1, 1}, 3);
+}
+
+template <class Iter>
+constexpr void test_iter() {
+  test_iter_sent<Iter, Iter>();
+  test_iter_sent<Iter, sentinel_wrapper<Iter>>();
+}
+
+constexpr void test_iterators() {
+  test_iter<random_access_iterator<int*>>();
+  test_iter<contiguous_iterator<int*>>();
+  test_iter<int*>();
+  test_iter<const int*>();
+}
 
 constexpr bool test() {
-  // TODO: main tests.
-  // TODO: A custom comparator works.
-  // TODO: A custom projection works.
+  test_iterators();
+
+  { // A custom comparator works.
+    std::ranges::less ls;
+    std::ranges::greater gt;
+    std::array in = {1, 3, 2, 5, 4, 7, 8, 6};
+
+    { // (iterator, sentinel) overload.
+      auto result_default_comp = std::ranges::is_heap_until(in.begin(), in.end(), ls);
+      assert(result_default_comp == in.begin() + 1);
+      auto result_custom_comp = std::ranges::is_heap_until(in.begin(), in.end(), gt);
+      assert(result_custom_comp == in.end());
+    }
+
+    { // (range) overload.
+      auto result_default_comp = std::ranges::is_heap_until(in, ls);
+      assert(result_default_comp == in.begin() + 1);
+      auto result_custom_comp = std::ranges::is_heap_until(in, gt);
+      assert(result_custom_comp == in.end());
+    }
+  }
+
+  { // A custom projection works.
+    std::array in = {-8, -6, -7, -3, -4, -1, -5, -2};
+    auto negate = [](int x) { return x * -1; };
+
+    { // (iterator, sentinel) overload.
+      auto result_default_comp = std::ranges::is_heap_until(in.begin(), in.end(), {});
+      assert(result_default_comp == in.begin() + 1);
+      auto result_custom_comp = std::ranges::is_heap_until(in.begin(), in.end(), {}, negate);
+      assert(result_custom_comp == in.end());
+    }
+
+    { // (range) overload.
+      auto result_default_comp = std::ranges::is_heap_until(in, {});
+      assert(result_default_comp == in.begin() + 1);
+      auto result_custom_comp = std::ranges::is_heap_until(in, {}, negate);
+      assert(result_custom_comp == in.end());
+    }
+  }
+
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/algorithms/ranges_robust_against_dangling.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr bool test_all() {
   //dangling_1st(std::ranges::equal_range, in, x);
   dangling_1st(std::ranges::min_element, in);
   dangling_1st(std::ranges::max_element, in);
   dangling_1st<minmax_result<dangling>>(std::ranges::minmax_element, in);
   dangling_1st(std::ranges::search, in, in2);
   dangling_1st(std::ranges::search_n, in, count, x);
   dangling_1st(std::ranges::find_end, in, in2);
   dangling_1st(std::ranges::is_sorted_until, in);
-  //dangling_1st(std::ranges::is_heap_until, in);
+  dangling_1st(std::ranges::is_heap_until, in);
   dangling_1st<for_each_result<dangling, decltype(unary_pred)>>(std::ranges::for_each, in, unary_pred);
   dangling_1st<copy_result<dangling, int*>>(std::ranges::copy, in, out);
   // TODO: uncomment `copy_backward` once https://reviews.llvm.org/D128864 lands.
   //dangling_1st<copy_backward_result<dangling, int*>>(std::ranges::copy_backward, in, out);
   dangling_1st<copy_if_result<dangling, int*>>(std::ranges::copy_if, in, out, unary_pred);
   dangling_1st<move_result<dangling, int*>>(std::ranges::move, in, out);
   // TODO: uncomment `move_backward` once https://reviews.llvm.org/D128864 lands.
   //dangling_1st<move_backward_result<dangling, int*>>(std::ranges::move_backward, in, out);

libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr bool test_all() {
   test(std::ranges::count_if, in, unary_pred);
   test(std::ranges::search, in, in2, binary_pred);
   test(std::ranges::search_n, in, count, x, binary_pred);
   test(std::ranges::find_end, in, in2, binary_pred);
   test(std::ranges::is_partitioned, in, unary_pred);
   test(std::ranges::is_sorted, in, binary_pred);
   test(std::ranges::is_sorted_until, in, binary_pred);
   test(std::ranges::includes, in, in2, binary_pred);
-  //test(std::ranges::is_heap, in, binary_pred);
-  //test(std::ranges::is_heap_until, in, binary_pred);
+  test(std::ranges::is_heap, in, binary_pred);
+  test(std::ranges::is_heap_until, in, binary_pred);
   //std::ranges::clamp(2, 1, 3, binary_pred);
   //test(std::ranges::is_permutation, in, in2, binary_pred);
   test(std::ranges::copy_if, in, out, unary_pred);
   //test(std::ranges::remove_copy_if, in, out, unary_pred);
   test(std::ranges::replace_if, in, unary_pred, x);
   //test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   //test(std::ranges::unique_copy, in, out, binary_pred);
   test(std::ranges::partition_copy, in, out, out2, unary_pred);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr bool test_all() {
   test(std::ranges::count_if, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::search, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::search_n, in, count, x, &Foo::binary_pred, &Bar::val);
   test(std::ranges::find_end, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::is_partitioned, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::is_sorted, in, &Foo::binary_pred, &Bar::val);
   test(std::ranges::is_sorted_until, in, &Foo::binary_pred, &Bar::val);
   test(std::ranges::includes, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
-  //test(std::ranges::is_heap, in, &Foo::binary_pred, &Bar::val);
-  //test(std::ranges::is_heap_until, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::is_heap, in, &Foo::binary_pred, &Bar::val);
+  test(std::ranges::is_heap_until, in, &Foo::binary_pred, &Bar::val);
   //std::ranges::clamp(b, a, c, &Foo::binary_pred);
   //test(std::ranges::is_permutation, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::for_each, in, &Foo::unary_pred, &Bar::val);
   std::ranges::for_each_n(in.begin(), count, &Foo::unary_pred, &Bar::val);
   // `copy`, `copy_n` and `copy_backward` have neither a projection nor a predicate.
   test(std::ranges::copy_if, in, out, &Foo::unary_pred, &Bar::val);
   // `move` and `move_backward` have neither a projection nor a predicate.
   // `fill` and `fill_n` have neither a projection nor a predicate.

libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr void run_tests() {
   test(std::ranges::count_if, in, unary_pred);
   test(std::ranges::search, in, in2);
   test(std::ranges::search_n, in, count, x);
   test(std::ranges::find_end, in, in2);
   test(std::ranges::is_partitioned, in, unary_pred);
   test(std::ranges::is_sorted, in);
   test(std::ranges::is_sorted_until, in);
   test(std::ranges::includes, in, in2);
-  //test(std::ranges::is_heap, in);
-  //test(std::ranges::is_heap_until, in);
+  test(std::ranges::is_heap, in);
+  test(std::ranges::is_heap_until, in);
   //test(std::ranges::is_permutation, in, in2);
   test(std::ranges::for_each, in, std::identity{});
   std::ranges::for_each_n(in.begin(), count, std::identity{});
   if constexpr (std::copyable<T>) {
     test(std::ranges::copy, in, out);
     std::ranges::copy_n(in.begin(), count, out);
     test(std::ranges::copy_if, in, out, unary_pred);
     // TODO: uncomment `copy_backward` once https://reviews.llvm.org/D128864 lands.

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.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
 //
 //===----------------------------------------------------------------------===//
 

 static_assert(test(std::ranges::find_if, a, odd));
 static_assert(test(std::ranges::find_if_not, a, odd));
 static_assert(test(std::ranges::for_each, a, odd));
 static_assert(test(std::ranges::for_each_n, a, 10, odd));
 //static_assert(test(std::ranges::generate, a, gen));
 //static_assert(test(std::ranges::generate_n, a, 10, gen));
 static_assert(test(std::ranges::includes, a, a));
 //static_assert(test(std::ranges::inplace_merge, a, a+5));
-//static_assert(test(std::ranges::is_heap, a));
-//static_assert(test(std::ranges::is_heap_until, a));
+static_assert(test(std::ranges::is_heap, a));
+static_assert(test(std::ranges::is_heap_until, a));
 static_assert(test(std::ranges::is_partitioned, a, odd));
 //static_assert(test(std::ranges::is_permutation, a, a));
 static_assert(test(std::ranges::is_sorted, a));
 static_assert(test(std::ranges::is_sorted_until, a));
 static_assert(test(std::ranges::lexicographical_compare, a, a));
 static_assert(test(std::ranges::lower_bound, a, 42));
 static_assert(test(std::ranges::make_heap, a));
 static_assert(test(std::ranges::max, a));