[libc++] Implement ranges::is_sorted{, _until}

[Mordante]

Thanks for working on this! It needs a bit more work.

libcxx/docs/Status/RangesAlgorithms.csv

31

Please update to the right URL.

libcxx/include/__algorithm/ranges_is_sorted.h

11

3 occurrences here and the same for the guards of the _until header.

47

This looks sensible, however it seems the Standard doesn't specify this overload. Is there an LWG issue?

libcxx/include/__algorithm/ranges_is_sorted_until.h

45

The move semantics in this function are inconsistent and wrong in some places.
while (++__i != __last) uses a moved from iterator.
one return moves, the other doesn't. Why move in the return, a forward_iterator is copyable.

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp

8

libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp and libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp need to be updated.

47

Then please make the fifth element sorted.

89

Can you also test a range with 1 element?

112

Originally I wanted to say I missed tests for the projection ;-)

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp

48

The comments for the sorted test apply here too, except this specific test.
You can update it, but since you test the location of the "failure" I deem the sorting of the last element not too important.

131

The interesting question is, does std::ranges::sorted work with a temporary?
I expect it should, but please add a test for sorted in the sorted test.

[philnik]

• Address comments

libcxx/include/__algorithm/ranges_is_sorted.h

47

I'm not sure what you mean. It's both in the current standard and in the one ranges proposal. Did you just miss it? It's right after http://eel.is/c++draft/alg.sort#is.sorted-4.

libcxx/include/__algorithm/ranges_is_sorted_until.h

45

Idk. I must have thought these are input_iterators for some reason.

[Mordante]

LGTM, except for the CI failure. I'll only approve it on my name to give others some time to have a look too.

libcxx/include/__algorithm/ranges_is_sorted.h

47

Nevermind, it seems I missed http://eel.is/c++draft/algorithms#requirements-15, which makes the wording clear. (Unless you want to be pedantic, then ranges::end(__range) seems not to be specified.)

[philnik]

• Fix CI

[var-const]

Looks really good, just a few extra test cases to add plus a couple nits.

libcxx/include/__algorithm/ranges_is_sorted.h

38

Nit: move?

47

Nit: store the result in a variable so we don't have to call end twice?

libcxx/include/__algorithm/ranges_is_sorted_until.h

55

Nit: move the iterator and the sentinel for consistency with other algorithms?

libcxx/include/algorithm

279

A couple nits:

• in the standard, is_sorted goes before is_sorted_until, can you reorder for consistency?
• there's an empty line between two overloads of is_sorted_until but not is_sorted, can you make this consistent?

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp

35

Optional: consider creating a helper function that takes care of both the (iterator, sentinel) and the (range) overloads:

test_one({1, 2, 3, 4, 3}, /*expected=*/true); // Might need to use `std::array` as input

36

Nit: decltype(auto).

118

Please also add SFINAE tests.

119

I think we also need to test the case when the sentinel is a different type from the iterator.

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp

31

Same comments as the other test file.

145

Nit: decltype(auto).

[philnik]

• Address comments

[philnik]

• Try to fix CI

[var-const]

LGTM when the CI is green.

libcxx/docs/Status/RangesAlgorithms.csv

 Search,max_element,Nikolas Klauser,`D117523 <https://llvm.org/D117523>`_,✅
 Search,minmax_element,Nikolas Klauser,`D120637 <https://llvm.org/D120637>`_,✅
 Search,count,Nikolas Klauser, `D121523 <https://llvm.org/D121523>`_,✅
 Search,count_if,Nikolas Klauser, `D121523 <https://llvm.org/D121523>`_,✅
 Search,search,Not assigned,n/a,Not started
 Search,search_n,Not assigned,n/a,Not started
 Search,find_end,Not assigned,n/a,Not started
 Read-only,is_partitioned,Nikolas Klauser,`D124440 <https://llvm.org/D124440>`_,✅
-Read-only,is_sorted,Not assigned,n/a,Not started
-Read-only,is_sorted_unitl,Not assigned,n/a,Not started
+Read-only,is_sorted,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
+Read-only,is_sorted_unitl,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
 Read-only,includes,Not assigned,n/a,Not started
 Read-only,is_heap,Not assigned,n/a,Not started
 Read-only,is_heap_until,Not assigned,n/a,Not started
 Read-only,clamp,Not assigned,n/a,Not started
 Read-only,is_permutation,Not assigned,n/a,Not started
 Read-only,for_each,Nikolas Klauser,n/a,✅
 Read-only,for_each_n,Nikolas Klauser,n/a,✅
 Write,copy,Nikolas Klauser,`D122982 <https://llvm.org/D122982>`_,✅

libcxx/include/CMakeLists.txt

set(files
   __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_is_sorted.h
+  __algorithm/ranges_is_sorted_until.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_reverse.h

libcxx/include/__algorithm/ranges_is_sorted.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_SORTED_H
+#define _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H
+
+#include <__algorithm/ranges_is_sorted_until.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__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_sorted {
+struct __fn {
+  template <forward_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 {
+    return ranges::__is_sorted_until_impl(std::move(__first), __last, __comp, __proj) == __last;
+  }
+
+  template <forward_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 {
+    auto __last = ranges::end(__range);
+    return ranges::__is_sorted_until_impl(ranges::begin(__range), __last, __comp, __proj) == __last;
+  }
+};
+} // namespace __is_sorted
+
+inline namespace __cpo {
+  inline constexpr auto is_sorted = __is_sorted::__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_SORTED_H

libcxx/include/__algorithm/ranges_is_sorted_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_SORTED_UNTIL_H
+#define _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Iter, class _Sent, class _Proj, class _Comp>
+_LIBCPP_HIDE_FROM_ABI constexpr
+_Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  if (__first == __last)
+    return __first;
+  auto __i = __first;
+  while (++__i != __last) {
+    if (std::invoke(__comp, std::invoke(__proj, *__i), std::invoke(__proj, *__first)))
+      return __i;
+    __first = __i;
+  }
+  return __i;
+}
+
+namespace __is_sorted_until {
+struct __fn {
+  template <forward_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 {
+    return ranges::__is_sorted_until_impl(std::move(__first), std::move(__last), __comp, __proj);
+  }
+
+  template <forward_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 {
+    return ranges::__is_sorted_until_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
+  }
+};
+} // namespace __is_sorted_until
+
+inline namespace __cpo {
+  inline constexpr auto is_sorted_until = __is_sorted_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_SORTED_UNTIL_H

libcxx/include/algorithm

template<input_iterator I, sentinel_for<I> S, class Proj = identity,
     constexpr bool ranges::is_partitioned(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::is_partitioned(R&& r, Pred pred, 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
 
   template<class T, output_iterator<const T&> O, sentinel_for<O> S>
     constexpr O ranges::fill(O first, S last, const T& value);                              // since C++20
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<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+    constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});      // since C++20
+
+  template<forward_range R, class Proj = identity,
+           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});                // since C++20
+
+  template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+    constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});   // since C++20
+
+  template<forward_range R, class Proj = identity,
+           indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+    constexpr borrowed_iterator_t<R>
+      ranges::is_sorted_until(R&& r, Comp comp = {}, 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/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_is_sorted.h>
+#include <__algorithm/ranges_is_sorted_until.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_reverse.h>

libcxx/include/module.modulemap

module __algorithm {
       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_is_sorted         { private header "__algorithm/ranges_is_sorted.h" }
+      module ranges_is_sorted_until   { private header "__algorithm/ranges_is_sorted_until.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_reverse           { private header "__algorithm/ranges_reverse.h" }

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

#endif
     //(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);
+    (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);
     //if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(first, mid, last, Less(&copies)); assert(copies == 0); }
     //if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(a, mid, Less(&copies)); assert(copies == 0); }
     //(void)std::ranges::lexicographical_compare(first, last, first2, last2, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::lexicographical_compare(a, b, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::lower_bound(first, last, value, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::lower_bound(a, value, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::make_heap(first, last, Less(&copies)); assert(copies == 0);
     //(void)std::ranges::make_heap(a, Less(&copies)); assert(copies == 0);

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

#endif
     //(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);
+    (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);
     //if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(first, mid, last, Less(), Proj(&copies)); assert(copies == 0); }
     //if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(a, mid, Less(), Proj(&copies)); assert(copies == 0); }
     //(void)std::ranges::lexicographical_compare(first, last, first2, last2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::lexicographical_compare(a, b, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::lower_bound(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::lower_bound(a, value, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::make_heap(first, last, Less(), Proj(&copies)); assert(copies == 0);
     //(void)std::ranges::make_heap(a, Less(), Proj(&copies)); assert(copies == 0);

libcxx/test/libcxx/private_headers.verify.cpp

 #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_is_sorted.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted.h'}}
+#include <__algorithm/ranges_is_sorted_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted_until.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_reverse.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_reverse.h'}}

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.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<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+//   constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+//          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+//   constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = Iter>
+concept HasIsSortedIt = requires(Iter iter, Sent sent) { std::ranges::is_sorted(iter, sent); };
+
+struct HasNoComparator {};
+
+static_assert(HasIsSortedIt<int*>);
+static_assert(!HasIsSortedIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasIsSortedIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasIsSortedIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsSortedIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasIsSortedIt<HasNoComparator*>);
+
+template <class Range>
+concept HasIsSortedR = requires(Range range) { std::ranges::is_sorted(range); };
+
+static_assert(HasIsSortedR<UncheckedRange<int*>>);
+static_assert(!HasIsSortedR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasIsSortedR<ForwardRangeNotIncrementable>);
+static_assert(!HasIsSortedR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasIsSortedR<ForwardRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasIsSortedR<UncheckedRange<HasNoComparator*>>);
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      int a[] = {1, 2, 3, 4, 3};
+      std::same_as<bool> decltype(auto) ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+      assert(!ret);
+    }
+    {
+      int a[] = {1, 2, 3, 4, 3};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::is_sorted(range);
+      assert(!ret);
+    }
+  }
+
+  { // second element isn't sorted
+    {
+      int a[] = {1, 0, 3, 4, 5};
+      auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+      assert(!ret);
+    }
+    {
+      int a[] = {1, 0, 3, 4, 5};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      auto ret = std::ranges::is_sorted(range);
+      assert(!ret);
+    }
+  }
+
+  { // all elements are sorted
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+      assert(ret);
+    }
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      auto ret = std::ranges::is_sorted(range);
+      assert(ret);
+    }
+  }
+
+  { // check that the comparator is used
+    {
+      int a[] = {5, 4, 3, 2};
+      auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 4)), std::ranges::greater{});
+      assert(ret);
+    }
+    {
+      int a[] = {5, 4, 3, 2};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 4)));
+      auto ret = std::ranges::is_sorted(range, std::ranges::greater{});
+      assert(ret);
+    }
+  }
+
+  { // check that an empty range works
+    {
+      int a[] = {};
+      auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a)));
+      assert(ret);
+    }
+    {
+      int a[] = {};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a)));
+      auto ret = std::ranges::is_sorted(range);
+      assert(ret);
+    }
+  }
+
+  { // check that a range with a single element works
+    {
+      int a[] = {32};
+      auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 1)));
+      assert(ret);
+    }
+    {
+      int a[] = {32};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 1)));
+      auto ret = std::ranges::is_sorted(range);
+      assert(ret);
+    }
+  }
+}
+
+constexpr bool test() {
+  test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_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*>();
+  test_iterators<const int*>();
+
+  { // check that the projection is used
+    struct S {
+      int i;
+      constexpr S(int i_) : i(i_) {}
+    };
+    {
+      S a[] = {1, 2, 3};
+      auto ret = std::ranges::is_sorted(a, a + 3, {}, &S::i);
+      assert(ret);
+    }
+    {
+      S a[] = {1, 2, 3};
+      auto ret = std::ranges::is_sorted(a, {}, &S::i);
+      assert(ret);
+    }
+  }
+
+  { // check that a dangling range works
+    assert(std::ranges::is_sorted(std::array{1, 2, 3, 4}));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_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<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+//          indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+//   constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+//          indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+//   constexpr borrowed_iterator_t<R>
+//     ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = Iter>
+concept HasIsSortedUntilIt = requires(Iter iter, Sent sent) { std::ranges::is_sorted_until(iter, sent); };
+
+struct HasNoComparator {};
+
+static_assert(HasIsSortedUntilIt<int*>);
+static_assert(!HasIsSortedUntilIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasIsSortedUntilIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasIsSortedUntilIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsSortedUntilIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasIsSortedUntilIt<HasNoComparator*>);
+
+template <class Range>
+concept HasIsSortedUntilR = requires(Range range) { std::ranges::is_sorted_until(range); };
+
+static_assert(HasIsSortedUntilR<UncheckedRange<int*>>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotIncrementable>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasIsSortedUntilR<UncheckedRange<HasNoComparator*>>);
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+  { // simple test
+    {
+      int a[] = {1, 2, 3, 4, 3};
+      std::same_as<Iter> auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+      assert(base(ret) == a + 4);
+    }
+    {
+      int a[] = {1, 2, 3, 4, 3};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      std::same_as<Iter> auto ret = std::ranges::is_sorted_until(range);
+      assert(base(ret) == a + 4);
+    }
+  }
+
+  { // second element isn't sorted
+    {
+      int a[] = {1, 0, 3, 4, 5};
+      auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+      assert(base(ret) == a + 1);
+    }
+    {
+      int a[] = {1, 0, 3, 4, 5};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      auto ret = std::ranges::is_sorted_until(range);
+      assert(base(ret) == a + 1);
+    }
+  }
+
+  { // all elements are sorted
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+      assert(base(ret) == a + 5);
+    }
+    {
+      int a[] = {1, 2, 3, 4, 5};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+      auto ret = std::ranges::is_sorted_until(range);
+      assert(base(ret) == a + 5);
+    }
+  }
+
+  { // check that the comparator is used
+    {
+      int a[] = {5, 4, 3, 2};
+      auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 4)), std::ranges::greater{});
+      assert(base(ret) == a + 4);
+    }
+    {
+      int a[] = {5, 4, 3, 2};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 4)));
+      auto ret = std::ranges::is_sorted_until(range, std::ranges::greater{});
+      assert(base(ret) == a + 4);
+    }
+  }
+
+  { // check that an empty range works
+    {
+      int a[] = {};
+      auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a)));
+      assert(base(ret) == a);
+    }
+    {
+      int a[] = {};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a)));
+      auto ret = std::ranges::is_sorted_until(range);
+      assert(base(ret) == a);
+    }
+  }
+
+  { // check that a range with a single element works
+    {
+      int a[] = {32};
+      auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 1)));
+      assert(base(ret) == a + 1);
+    }
+    {
+      int a[] = {32};
+      auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 1)));
+      auto ret = std::ranges::is_sorted_until(range);
+      assert(base(ret) == a + 1);
+    }
+  }
+}
+
+constexpr bool test() {
+  test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_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*>();
+  test_iterators<const int*>();
+
+  { // check that the projection is used
+    struct S {
+      int i;
+      constexpr S(int i_) : i(i_) {}
+    };
+    {
+      S a[] = {1, 2, 3};
+      auto ret = std::ranges::is_sorted_until(a, a + 3, {}, &S::i);
+      assert(base(ret) == a + 3);
+    }
+    {
+      S a[] = {1, 2, 3};
+      auto ret = std::ranges::is_sorted_until(a, {}, &S::i);
+      assert(base(ret) == a + 3);
+    }
+  }
+
+  { // check that std::ranges::dangling is returned
+    [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
+        std::ranges::is_sorted_until(std::array{1, 2, 3});
+  }
+
+  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

 //static_assert(test(std::ranges::generate, a, 42));
 //static_assert(test(std::ranges::generate_n, a, 10, 42));
 //static_assert(test(std::ranges::includes, a, a));
 //static_assert(test(std::ranges::inplace_merge, a, a+5));
 //static_assert(test(std::ranges::is_heap, a));
 //static_assert(test(std::ranges::is_heap_until, a));
 //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::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));
 static_assert(test(std::ranges::max_element, a));
 //static_assert(test(std::ranges::merge, a, a, a));
 static_assert(test(std::ranges::min, a));
 static_assert(test(std::ranges::min_element, a));

libcxx/test/support/almost_satisfies_types.h

public:
   WeaklyIncrementableNotMovable& operator++();
   void operator++(int);
   WeaklyIncrementableNotMovable(const WeaklyIncrementableNotMovable&) = delete;
 };
 
 static_assert(!std::movable<WeaklyIncrementableNotMovable>);
 static_assert(!std::weakly_incrementable<WeaklyIncrementableNotMovable>);
 
+// almost a forward_iterator
+class ForwardIteratorNotDerivedFrom {
+public:
+  using difference_type = long;
+  using value_type = int;
+  using iterator_category = std::input_iterator_tag;
+
+  ForwardIteratorNotDerivedFrom& operator++();
+  ForwardIteratorNotDerivedFrom operator++(int);
+  const int& operator*() const;
+  bool operator==(const ForwardIteratorNotDerivedFrom&) const = default;
+};
+
+using ForwardRangeNotDerivedFrom = UncheckedRange<ForwardIteratorNotDerivedFrom>;
+
+static_assert(std::input_iterator<ForwardIteratorNotDerivedFrom>);
+static_assert(std::incrementable<ForwardIteratorNotDerivedFrom>);
+static_assert(std::sentinel_for<ForwardIteratorNotDerivedFrom, ForwardIteratorNotDerivedFrom>);
+static_assert(!std::forward_iterator<ForwardIteratorNotDerivedFrom>);
+
+class ForwardIteratorNotIncrementable {
+public:
+  using difference_type = long;
+  using value_type = int;
+  using iterator_category = std::forward_iterator_tag;
+
+  ForwardIteratorNotIncrementable& operator++();
+  int operator++(int);
+  const int& operator*() const;
+  bool operator==(const ForwardIteratorNotIncrementable&) const = default;
+};
+
+using ForwardRangeNotIncrementable = UncheckedRange<ForwardIteratorNotIncrementable>;
+
+static_assert(std::input_iterator<ForwardIteratorNotIncrementable>);
+static_assert(!std::incrementable<ForwardIteratorNotIncrementable>);
+static_assert(std::sentinel_for<ForwardIteratorNotIncrementable, ForwardIteratorNotIncrementable>);
+static_assert(!std::forward_iterator<ForwardIteratorNotIncrementable>);
+
+using ForwardRangeNotSentinelSemiregular = UncheckedRange<forward_iterator<int*>, SentinelForNotSemiregular>;
+using ForwardRangeNotSentinelEqualityComparableWith =
+    UncheckedRange<forward_iterator<int*>, SentinelForNotWeaklyEqualityComparableWith>;
+
 class BidirectionalIteratorNotDerivedFrom {
 public:
   using difference_type = long;
   using value_type = int;
   using iterator_category = std::forward_iterator_tag;
 
   BidirectionalIteratorNotDerivedFrom& operator++();
   BidirectionalIteratorNotDerivedFrom operator++(int);