[libc++][ranges] Implement `ranges::clamp`

[var-const]

libcxx/docs/Status/RangesAlgorithms.csv

29–30

Please don't forget to update the link before merging.

libcxx/test/std/algorithms/alg.sorting/alg.clamp/ranges.clamp.pass.cpp

24

Can you also check SFINAE with indirect_­strict_­weak_­order?

33

Ultranit: maybe use different values in different test cases? I know it sounds funny but I'm slightly concerned that return 20; would pass most if not all the tests. :) It might also make it a bit more obvious which value is being returned (high/low/original) when the same value of 20 doesn't have different meanings in different test cases.

39

Can you also check with a comparator that returns something convertible to bool?

41

Can you also add test cases like (10, 10, 20) and (10, 20, 20), i.e., when value is equal to one of the bounds but not the other?

[var-const]

Rebase on main.

[jloser]

libcxx/include/algorithm

290

Please don't forget to remove this merge conflict marker.

[var-const]

Remove conflict marker.

[var-const]

libcxx/include/algorithm

290

Thanks!

[var-const]

• Fix a bug where the result of applying a projection could lose its value category and add a test;
• fix incorrect assertion checking that low <= high and add an assertion test for it;
• add SFINAE tests;
• add ranges::clamp to the relevant robust test suites;
• address the existing feedback.

[var-const]

Fix the CI and rebase.

[var-const]

Fix the CI.

[var-const]

Remove accidental.

[var-const]

Fix the CI.

[ldionne]

LGTM with CI fixed and my comments applied.

libcxx/include/__algorithm/ranges_clamp.h

43

Can we add a test with a predicate that returns something explicitly convertible to bool? This should only be supported in the Ranges version.

46–52

Based on our discussion just now, your value category test is correct, however this optimization is wrong because it can lead to double-moves.

It would be possible to catch this with:

// large values to avoid SSO
int val = 100000000000000000000000000000000;
int low = 200000000000000000000000000000000;
int high = 300000000000000000000000000000000;
auto proj = [](int i) { return std::to_string(i); }; // important: returns a temporary
auto comp = [](std::string lhs, std::string rhs) { // important: moves out of rvalue arguments
    return std::atoi(lhs.c_str()) < std::atoi(rhs.c_str());
};
std::ranges::clamp(val, low, high, comp, proj);

Something like this should trigger a double-move. Probably easier to test with a Tracked value of some sort.

Also, after adding the test, can you make sure that your current implementation does fail?

libcxx/test/std/algorithms/alg.sorting/alg.clamp/ranges.clamp.pass.cpp

10

I would XFAIL this on apple-clang-13. That's the CI issue.

[var-const]

Address feedback

[var-const]

Rebase on main.

libcxx/include/__algorithm/ranges_clamp.h

43

Hmm, it looks like the algorithm constraints actually prevent a return type that's only explicitly (and not implicitly) convertible to bool:

• the algorithm requires indirect_strict_weak_order for _Comp;
• indirect_strict_weak_order requires strict_weak_order;
• strict_weak_order requires relation;
• relation requires boolean-testable;
• boolean-testable requires boolean-testable-impl;
• boolean-testable-impl requires std::convertible_to<T, bool>;
• std::convertible_to<T, bool> requires *both* an explicit and an implicit conversion.

If I'm reading this correctly, the indirect_strict_weak_order constraint prevents the comparator that returns a type explicitly convertible to bool. If so, the bool casts in the definition of clamp in the standard appear redundant (at least for the range algorithm -- since the same wording is used for the classic algorithm as well, perhaps it's there because of it?). What do you think -- perhaps I'm missing something?

46–52

Added a new test case and verified it fails for the original version (I used a simple struct that checks for double-moving).

libcxx/test/std/algorithms/alg.sorting/alg.clamp/ranges.clamp.pass.cpp

10

Right -- it looks like this has already come up before in test/std/ranges/range.adaptors/range.filter/pred.pass.cpp which has the following comment:

// Older Clangs don't properly deduce decltype(auto) with a concept constraint

[var-const]

Fix the CI.

libcxx/docs/Status/RangesAlgorithms.csv

 Search,min_element,Nikolas Klauser,`D117025 <https://llvm.org/D117025>`_,✅
 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,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,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,clamp,Nikolas Klauser,`D126193 <https://llvm.org/D126193>`_,✅
 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>`_,✅
 Write,move,Nikolas Klauser,`D126616 <https://llvm.org/D126616>`_,✅

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
   __algorithm/ranges_adjacent_find.h
   __algorithm/ranges_all_of.h
   __algorithm/ranges_any_of.h
   __algorithm/ranges_binary_search.h
+  __algorithm/ranges_clamp.h
   __algorithm/ranges_copy.h
   __algorithm/ranges_copy_backward.h
   __algorithm/ranges_copy_if.h
   __algorithm/ranges_copy_n.h
   __algorithm/ranges_count.h
   __algorithm/ranges_count_if.h
   __algorithm/ranges_equal.h
   __algorithm/ranges_equal_range.h

libcxx/include/__algorithm/clamp.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 14
 template<class _Tp, class _Compare>
 _LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+_LIBCPP_INLINE_VISIBILITY constexpr
 const _Tp&
 clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
 {
     _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
     return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
 
 }
 
 template<class _Tp>
 _LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+_LIBCPP_INLINE_VISIBILITY constexpr
 const _Tp&
 clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
 {
     return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_CLAMP_H

libcxx/include/__algorithm/ranges_clamp.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_CLAMP_H
+#define _LIBCPP___ALGORITHM_RANGES_CLAMP_H
+
+#include <__assert>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__utility/forward.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 __clamp {
+struct __fn {
+
+  template <class _Type,
+            class _Proj = identity,
+            indirect_strict_weak_order<projected<const _Type*, _Proj>> _Comp = ranges::less>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  const _Type& operator()(const _Type& __value,
+                          const _Type& __low,
+                          const _Type& __high,
+                          _Comp __comp = {},
+                          _Proj __proj = {}) const {
+    _LIBCPP_ASSERT(!bool(std::invoke(__comp, std::invoke(__proj, __high), std::invoke(__proj, __low))),
+                   "Bad bounds passed to std::ranges::clamp");
+
+    if (std::invoke(__comp, std::invoke(__proj, __value), std::invoke(__proj, __low)))
+      return __low;
+    else if (std::invoke(__comp, std::invoke(__proj, __high), std::invoke(__proj, __value)))
+      return __high;
+    else
+      return __value;
+  }
+
+};
+} // namespace __clamp
+
+inline namespace __cpo {
+  inline constexpr auto clamp = __clamp::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_CLAMP_H

libcxx/include/algorithm

template<input_range R, class Proj = identity,
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     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<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
           class Proj = identity>
     requires sortable<I, Comp, Proj>
     constexpr I
       ranges::push_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>
template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
     constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
 
   template<input_range R, class T, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     requires indirectly_writable<iterator_t<R>, const T&>
     constexpr borrowed_iterator_t<R>
       ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});                     // since C++20
 
+  template<class T, class Proj = identity,
+           indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
+    constexpr const T&
+      ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});          // since C++20
+
   template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
            class Proj1 = identity, class Proj2 = identity,
            indirect_strict_weak_order<projected<I1, Proj1>,
                                       projected<I2, Proj2>> Comp = ranges::less>
     constexpr bool
       ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                                       Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {});    // since C++20
 
template<input_range R1, input_range R2, class Pred = ranges::equal_to,
   template<input_range R, weakly_incrementable O, class Proj = identity,
            indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
     requires indirectly_copyable<iterator_t<R>, O> &&
              (forward_iterator<iterator_t<R>> ||
               (input_iterator<O> && same_as<range_value_t<R>, iter_value_t<O>>) ||
               indirectly_copyable_storable<iterator_t<R>, O>)
     constexpr unique_copy_result<borrowed_iterator_t<R>, O>
       unique_copy(R&& r, O result, C comp = {}, Proj proj = {});                                   // Since C++20
+<<<<<<< HEAD
 
   template<class I, class O>
       using remove_copy_result = in_out_result<I, O>;                                              // Since C++20
 
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O, class T,
            class Proj = identity>
              indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
     constexpr remove_copy_result<I, O>

 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
 #include <__algorithm/ranges_adjacent_find.h>
 #include <__algorithm/ranges_all_of.h>
 #include <__algorithm/ranges_any_of.h>
 #include <__algorithm/ranges_binary_search.h>
+#include <__algorithm/ranges_clamp.h>
 #include <__algorithm/ranges_copy.h>
 #include <__algorithm/ranges_copy_backward.h>
 #include <__algorithm/ranges_copy_if.h>
 #include <__algorithm/ranges_copy_n.h>
 #include <__algorithm/ranges_count.h>
 #include <__algorithm/ranges_count_if.h>
 #include <__algorithm/ranges_equal.h>
 #include <__algorithm/ranges_equal_range.h>

libcxx/include/module.modulemap.in

module __algorithm {
       module partition_point                 { private header "__algorithm/partition_point.h" }
       module pop_heap                        { private header "__algorithm/pop_heap.h" }
       module prev_permutation                { private header "__algorithm/prev_permutation.h" }
       module push_heap                       { private header "__algorithm/push_heap.h" }
       module ranges_adjacent_find            { private header "__algorithm/ranges_adjacent_find.h" }
       module ranges_all_of                   { private header "__algorithm/ranges_all_of.h" }
       module ranges_any_of                   { private header "__algorithm/ranges_any_of.h" }
       module ranges_binary_search            { private header "__algorithm/ranges_binary_search.h" }
+      module ranges_clamp                    { private header "__algorithm/ranges_clamp.h" }
       module ranges_copy                     { private header "__algorithm/ranges_copy.h" }
       module ranges_copy_backward            { private header "__algorithm/ranges_copy_backward.h" }
       module ranges_copy_if                  { private header "__algorithm/ranges_copy_if.h" }
       module ranges_copy_n                   { private header "__algorithm/ranges_copy_n.h" }
       module ranges_count                    { private header "__algorithm/ranges_count.h" }
       module ranges_count_if                 { private header "__algorithm/ranges_count_if.h" }
       module ranges_equal                    { private header "__algorithm/ranges_equal.h" }
       module ranges_equal_range              { private header "__algorithm/ranges_equal_range.h" }

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

constexpr bool all_the_algorithms()
     (void)std::ranges::adjacent_find(first, last, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::adjacent_find(a, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(first, last, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(a, value, Less(&copies)); assert(copies == 0);
-    //(void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0);
+    (void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(first, last, first2, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(a, first2, UnaryTrue(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 20
     //(void)std::ranges::ends_with(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::equal(first, last, first2, last2, Equal(&copies)); assert(copies == 0);

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

constexpr bool all_the_algorithms()
     (void)std::ranges::adjacent_find(first, last, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::adjacent_find(a, Equal(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::all_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::any_of(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
-    //(void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(first, last, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(a, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
 #if TEST_STD_VER > 20
     //(void)std::ranges::ends_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__algorithm/partition_point.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/partition_point.h'}}
 #include <__algorithm/pop_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/pop_heap.h'}}
 #include <__algorithm/prev_permutation.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/prev_permutation.h'}}
 #include <__algorithm/push_heap.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/push_heap.h'}}
 #include <__algorithm/ranges_adjacent_find.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_adjacent_find.h'}}
 #include <__algorithm/ranges_all_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_all_of.h'}}
 #include <__algorithm/ranges_any_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_any_of.h'}}
 #include <__algorithm/ranges_binary_search.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_binary_search.h'}}
+#include <__algorithm/ranges_clamp.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_clamp.h'}}
 #include <__algorithm/ranges_copy.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy.h'}}
 #include <__algorithm/ranges_copy_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_backward.h'}}
 #include <__algorithm/ranges_copy_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_if.h'}}
 #include <__algorithm/ranges_copy_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_copy_n.h'}}
 #include <__algorithm/ranges_count.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count.h'}}
 #include <__algorithm/ranges_count_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_count_if.h'}}
 #include <__algorithm/ranges_equal.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal.h'}}
 #include <__algorithm/ranges_equal_range.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_equal_range.h'}}

libcxx/test/std/algorithms/alg.sorting/alg.clamp/assert.ranges_clamp.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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: has-unix-headers
+// UNSUPPORTED: c++03, c++11, c++14, c++17, libcpp-has-no-incomplete-ranges
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
+
+// <algorithm>
+
+// In a call to `ranges::clamp(val, low, high)`, `low` must be `<= high`.
+
+#include <algorithm>
+#include <functional>
+
+#include "check_assertion.h"
+
+int main(int, char**) {
+  std::ranges::clamp(1, 2, 0, std::ranges::greater{});
+  TEST_LIBCPP_ASSERT_FAILURE(std::ranges::clamp(1, 2, 0), "Bad bounds passed to std::ranges::clamp");
+
+  std::ranges::clamp(1, 0, 2);
+  TEST_LIBCPP_ASSERT_FAILURE(std::ranges::clamp(1, 0, 2, std::ranges::greater{}),
+      "Bad bounds passed to std::ranges::clamp");
+
+  std::ranges::clamp(1, 1, 1); // Equal bounds should be fine.
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.sorting/alg.clamp/ranges.clamp.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// Older Clangs don't properly deduce decltype(auto) with a concept constraint
+// XFAIL: apple-clang-13.0
+
+// template<class T, class Proj = identity,
+//          indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
+//   constexpr const T&
+//     ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
+
+#include <algorithm>
+#include <cassert>
+#include <functional>
+#include <utility>
+
+template <class T, class Comp = std::ranges::less, class Proj = std::identity>
+concept HasClamp =
+    requires(T&& val, T&& low, T&& high, Comp&& comp, Proj&& proj) {
+      std::ranges::clamp(std::forward<T>(val), std::forward<T>(low), std::forward<T>(high),
+          std::forward<Comp>(comp), std::forward<Proj>(proj));
+    };
+
+struct NoComp {};
+struct CreateNoComp {
+  auto operator()(int) const { return NoComp(); }
+};
+
+static_assert(HasClamp<int, std::ranges::less, std::identity>);
+static_assert(!HasClamp<NoComp>);
+static_assert(!HasClamp<int, NoComp>);
+static_assert(!HasClamp<int, std::ranges::less, CreateNoComp>);
+
+constexpr bool test() {
+  { // low < val < high
+    int val = 2;
+    int low = 1;
+    int high = 3;
+    std::same_as<const int&> decltype(auto) ret = std::ranges::clamp(val, low, high);
+    assert(ret == 2);
+    assert(&ret == &val);
+  }
+
+  { // low > val < high
+    assert(std::ranges::clamp(10, 20, 30) == 20);
+  }
+
+  { // low < val > high
+    assert(std::ranges::clamp(15, 5, 10) == 10);
+  }
+
+  { // low == val == high
+    int val = 10;
+    assert(&std::ranges::clamp(val, 10, 10) == &val);
+  }
+
+  { // Check that a custom comparator works.
+    assert(std::ranges::clamp(10, 30, 20, std::ranges::greater{}) == 20);
+  }
+
+  { // Check that a custom projection works.
+    struct S {
+      int i;
+
+      constexpr const int& lvalue_proj() const { return i; }
+      constexpr int prvalue_proj() const { return i; }
+    };
+
+    struct Comp {
+      constexpr bool operator()(const int& lhs, const int& rhs) const { return lhs < rhs; }
+      constexpr bool operator()(int&& lhs, int&& rhs) const { return lhs > rhs; }
+    };
+
+    auto val = S{10};
+    auto low = S{20};
+    auto high = S{30};
+    // Check that the value category of the projection return type is preserved.
+    assert(&std::ranges::clamp(val, low, high, Comp{}, &S::lvalue_proj) == &low);
+    assert(&std::ranges::clamp(val, high, low, Comp{}, &S::prvalue_proj) == &low);
+  }
+
+  { // Check that the implementation doesn't cause double moves (which could result from calling the projection on
+    // `value` once and then forwarding the result into the comparator).
+    struct CheckDoubleMove {
+      int i;
+      bool moved = false;
+
+      constexpr explicit CheckDoubleMove(int set_i) : i(set_i) {}
+      constexpr CheckDoubleMove(const CheckDoubleMove&) = default;
+      constexpr CheckDoubleMove(CheckDoubleMove&& rhs) noexcept : i(rhs.i) {
+        assert(!rhs.moved);
+        rhs.moved = true;
+      }
+    };
+
+    auto val = CheckDoubleMove{20};
+    auto low = CheckDoubleMove{10};
+    auto high = CheckDoubleMove{30};
+
+    auto moving_comp = [](CheckDoubleMove lhs, CheckDoubleMove rhs) { return lhs.i < rhs.i; };
+    auto prvalue_proj = [](const CheckDoubleMove& x) -> CheckDoubleMove { return x; };
+    assert(&std::ranges::clamp(val, low, high, moving_comp, prvalue_proj) == &val);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/ranges_robust_against_nonbool_predicates.pass.cpp

constexpr bool test_all() {
   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);
-  //std::ranges::clamp(2, 1, 3, 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);
   test(std::ranges::partial_sort_copy, in, in2, binary_pred);

libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp

constexpr bool test_all() {
   auto mid       = in.begin() + 1;
 
   std::array output = {Bar{Foo{7}}, Bar{Foo{8}}, Bar{Foo{9}}, Bar{Foo{10}}, Bar{Foo{11}}, Bar{Foo{12}}};
   auto out          = output.begin();
   auto out2         = output.begin() + 1;
 
   Bar a{Foo{1}};
   Bar b{Foo{2}};
-  //Bar c{Foo{3}};
+  Bar c{Foo{3}};
 
   Foo x{2};
   size_t count = 1;
 
   test(std::ranges::any_of, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::all_of, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::none_of, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::find, in, x, &Bar::val);
constexpr bool test_all() {
   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);
-  //std::ranges::clamp(b, a, c, &Foo::binary_pred);
+  std::ranges::clamp(b, a, c, &Foo::binary_pred, &Bar::val);
   //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/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 std::mt19937 g;
 
 // [algorithm.syn]
 
 static_assert(test(std::ranges::adjacent_find, a));
 static_assert(test(std::ranges::all_of, a, odd));
 static_assert(test(std::ranges::any_of, a, odd));
 static_assert(test(std::ranges::binary_search, a, 42));
-//static_assert(test(std::ranges::clamp, 42, 42, 42));
+static_assert(test(std::ranges::clamp, 42, 42, 42));
 static_assert(test(std::ranges::copy, a, a));
 static_assert(test(std::ranges::copy_backward, a, a));
 static_assert(test(std::ranges::copy_if, a, a, odd));
 static_assert(test(std::ranges::copy_n, a, 10, a));
 static_assert(test(std::ranges::count, a, 42));
 static_assert(test(std::ranges::count_if, a, odd));
 //static_assert(test(std::ranges::ends_with, a, a));
 static_assert(test(std::ranges::equal, a, a));