[libc++] Implement ranges::ends_with

[ZijunZhao]

make some format changes

[ZijunZhao]

update all the robust_against_* tests but no need for robust_against_dangling one

[ZijunZhao]

make some changes on tests

[ZijunZhao]

replace ranges::drop_view with ranges::subrange

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

219

In line 252, forward_iterator_list is tested and include all input_iterators features. So input_iterators are tested?

[var-const]

libcxx/include/__algorithm/ranges_ends_with.h

60

Still seems not done?

63

Wrapping them in std::ref will probably solve the issue. equal has a bunch of optimizations based on the iterator type and it's likely we're skipping some logic by bypassing both equal and __equal and going straight to __equal_impl.

82

I would strongly advise to do so unless there's a compelling reason not to. It's better to avoid code duplication when possible in these cases.

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

66

I think these need to be reformatted (throughout the file).

77

Seems not done?

155

Looks like this test is duplicated (see line 139).

156

Seems not done?

170

How about:

The suffix occurs several time within the string, but not at the end.

?

216

Duplicated.

217

How about:

int a[] = {5, 1, 3, 2, 7};
int p[] = {-2, -7};
auto pred = [](int l, int r) { return l * -1 == r; };

I'm sorry for partially pushing my personal preference, but what I like about this is that a) it compares more than 1 element and b) the comparison is more specific (only one value would compare equal, whereas an infinite number of values would compare greater than). I also find that using the negative complement of a number is an easy transformation to read (no need to do any mental math).

219

It's kind of the opposite -- for an algorithm that supports input iterators, we need to make sure we don't accidentally end up relying on some features that are only available on forward iterators (or only on bidirectional iterators, etc.). In other words, we're checking that the algorithm only uses the very minimalistic interface provided by an input_iterator and nothing else. If we only test with forward_iterators, for example, we wouldn't be able to catch if the algorithm presumes that calling i++ on an iterator i returns a value (an input iterator can return anything, including void).

[var-const]

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

64

We need to also add one test to check the return type, something like:

{ // Check the return type
    int a[] = {1, 2, 3, 4, 5, 6};
    int p[] = {5, 6};
    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
   
   {
      [[maybe_unused]] std::same_as<bool> decltype(auto) ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
    }
    {
      [[maybe_unused]] std::same_as<bool> decltype(auto) ret = std::ranges::ends_with(whole, suffix);
    }
  }

[ZijunZhao]

Fix some nits:

1. delete duplication
2. call ranges::equal in the implementation
3. use decltype
4. add some tests

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

64

okay I think the simple test is duplicated so I will make the simple test to check and use std::same_as<bool>

[ZijunZhao]

delegate to the non-range overload of operator()

[ZijunZhao]

1. use ranges::advance() rather than std::advance()
2. add two test cases: range consists of just one element and suffix consists of just one element
3. remove the duplicated test case about predicate

libcxx/include/__algorithm/ranges_ends_with.h

82

okay! I add a new helper function like ranges_mismatch.h to simplify code!

[var-const]

libcxx/include/__algorithm/ranges_ends_with.h

44

This helper function doesn't need default arguments (since it's never invoked outside this file) and can take the predicate and the projections by reference (so there's no need to wrap the arguments passed to it in std::ref -- std::ref is only needed when passing those arguments to ranges::equal).

60

Friendly ping on this -- this sounds like a good optimization to implement.

[ZijunZhao]

1. Test input_iterators
2. Update help function (will try to optimize later)
3. some nits fixed

libcxx/include/__algorithm/ranges_ends_with.h

44

Wrapped by std::ref only when passing args to ranges::equal will cause ranges_robust_against_copying_comparators.pass.cpp fail.
So I only wrap them when passing args to __ends_with_fn_impl works.

[ZijunZhao]

1. Optimize when input is bidirectional iterator.
2. Reformat test file

[var-const]

libcxx/include/__algorithm/ranges_ends_with.h

40

The helper function should take _Pred and _Proj1/_Proj2 by a reference, which would avoid the need for std::ref when delegating. Unlike the public functions which must have the same signature as in the standard, we can use references in the internal helper.

44

I mean that the helper function should take the arguments by reference, then wrap them in std::ref before passing to other algorithms. Basically, I'm suggesting to move the wrapping from the public function into the helper function.

48

Note: we only qualify the namespace on function calls (to avoid triggering ADL). There is no need to qualify class names, concept names, etc.

50

How about something like

if constexpr (bidirectional_iterator<_Iter1> && bidirectional_iterator<_Iter2>) {
  auto __rbegin1 = std::make_reverse_iterator(__first1);
  auto __rbegin2 = std::make_reverse_iterator(__first2);
  auto __rend1 = std::make_reverse_iterator(ranges::next(__first1, __last1));
  auto __rend2 = std::make_reverse_iterator(ranges::next(__first2, __last2));
  return ranges::starts_with(__rbegin1, __rend1, __rbegin2, __rend2, std::ref(__pred), std::ref(__proj1), std::ref(__proj2));
}

?

65

Why do we have to unwrap here? Can't we delegate that to equal?

72

std::ref should be here.

114

I think we're missing the case where the ranges are sized (meaning we can get the size in constant time) but the sentinels aren't, and the iterators aren't random-access. In other words, we miss the case when we have a way to get the sizes in constant time while we still have the range objects, but once we reduce them to iterators, getting the size becomes linear.

I took a stab at it and can suggest something like the following. There are many potential microoptimizations here (in particular if we consider all the cases where one of the ranges is sized and the other is not), but personally I think we need to strike the right balance between performance and code clarity. My current thinking is:

1. If we can get the sizes from the ranges in constant time, that takes priority over everything else -- otherwise, we end up losing this bit of information down the line (in step 3). This also allows us to immediately filter out corner cases of empty ranges, or range2 being bigger than range1, in constant time;
2. Otherwise, if we can iterate the ranges in reverse and have the end iterators, that's the next priority -- this avoids any unnecessary linear work for finding the sizes;
3. Otherwise, calculate the sizes of both ranges (at worst two linear operations), advance the iterator on the first range (at worst linear), do the comparisons (linear). If any of these operations can be done in constant time, we get that without any extra code.

Pseudocode (I omitted the predicate and projections, as well as function attributes, for simplicity):

template <class _Iter1, class _Iter2>
bool __impl_bidirectional(_Iter1 __first1, _Iter1 __last1, _Iter2 __first2, _Iter2 __last2) {
  auto __rbegin1 = std::make_reverse_iterator(__first1);
  auto __rend1 = std::make_reverse_iterator(__last1);
  auto __rbegin2 = std::make_reverse_iterator(__first2);
  auto __rend2 = std::make_reverse_iterator(__last2);
  return ranges::starts_with(__rbegin1, __rend1, __rbegin2, __rend2);
}

template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Diff>
bool __impl_with_offset(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Diff __offset) {
  ranges::advance(__first1, __offset);
  return ranges::equal(__first1, __last1, __first2, __last2);
}

template <class _Iter1, class _Sent1, class _Iter2, class _Sent2>
bool __impl_with_sentinels(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2) {
  if constexpr (bidirectional_iterator<_Sent1> && bidirectional_iterator<_Sent2>) {
    return __impl_bidirectional(__first1, __last1, __first2, __last2);

  } else {
    auto __n1 = ranges::distance(__first1, __last1);
    auto __n2 = ranges::distance(__first2, __last2);
    if (__n2 == 0) {
      return true;
    }
    if (__n2 > __n1) { // Also covers the case when `__n1` is `0`.
      return false;
    }

    return __impl_with_offset(__first1, __last1, __first2, __last2, __n1 - __n2);
}

// Public function that takes iterators
{
  return __impl_with_sentinels(__first1, __last1, __first2, __last2);
}

// Public function that takes ranges
{
  if constexpr (sized_range<_Range1> && sized_range<_Range2>) {
    auto __n1 = ranges::distance(__range1);
    auto __n2 = ranges::distance(__range2);
    if (__n2 == 0) {
      return true;
    }
    if (__n2 > __n1) { // Also covers the case when `__n1` is `0`.
      return false;
    }

    return __impl_with_offset(ranges::begin(__range1), ranges::end(__range1),
                              ranges::begin(__range2), ranges::end(__range2), __n1 - __n2);

  } else {
    return __impl_with_sentinels(ranges::begin(__range1), ranges::end(__range1),
                  ranges::begin(__range2), ranges::end(__range2));
  }
}

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

256

You might want to add a comment to this branch and the next one that this is to test the (forward_iterator<_Iter1> || sized_sentinel_for<_Sent1, _Iter1>) condition.

[ZijunZhao]

1. If we can get the size of input directly, get it, then compare the sizes and return the result in some cases. Otherwise, go to step2.
2. If the input is bidirectional, go to __bidirectional_impl() directly. If not, go to step 3
3. Call ranges::equal() to get the result

[ZijunZhao]

libcxx/include/__algorithm/ranges_ends_with.h

72

yes, I tried to pass std::ref in ranges::equal() and ranges::start() only and copy tests failed. And tries to remove std::ref when passing to __ends_with_fn_impl() and still failed the tests.

[ZijunZhao]

Pass by referrence

[ZijunZhao]

add a comment to make code more clear

libcxx/include/__algorithm/ranges_ends_with.h

48

Do I need to add a comment here?

[philnik]

Looks pretty good, but I'd like to get the ranges::equal optimization in again, since it's probably quite significant.

libcxx/include/__algorithm/ranges_ends_with.h

37

It looks like we've dropped the ranges::equal optimization again?

65–83

Just to make it a bit leaner to compile.

148–149

To make it obvious that it's constant time and avoid a few instantiations.

165–173

[AMP999]

libcxx/include/__algorithm/ranges_ends_with.h

159

I don't think these std::moves are needed since ranges::begin() already return prvalue.

[ZijunZhao]

Update else to make it a bit leaner to compile.

[ZijunZhao]

1. use ranges::size() instead of ranges::distance to get the size of an array at constant time
2. remove std::move for all input which call ranges algorithms.

[ZijunZhao]

Get ranges::equal optimization back when the iterator is random access iterator, and add a benchmark test to verify the optimization works.

[ldionne]

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

275

Instead, we should add a benchmark under <monorepo>/libcxx/benchmarks and post the results of that benchmark here in this review. I know this isn't an automated test, but the test as-is risks being flaky. Let's leave the benchmarks in libcxx/benchmarks and we can figure out a way to track performance through time (and potentially compare performance of different operations?) more generally.

[var-const]

Thanks a lot, this is getting very close to LGTM. The implementation looks good (just a few formatting nitpicks), just a few minor things in tests to address plus the benchmark needs to be reworked. My sincere apologies for the very slow review (mostly due to the upcoming LLVM 17 release).

libcxx/include/__algorithm/ranges_ends_with.h

40

How about naming this function __ends_with_fn_impl_bidirectional, just for consistency with the other helpers?

68

Nit: please add a blank line before this line.

74

Nit: please add a blank line after this line.

105

Nit: can you add spaces before and after the &&? Or just clang-format these lines. If it's clang-format that produces this formatting, then never mind (although I'd be surprised).

105

Nit: the parentheses around !std::random_access_iterator<_Sent1> are unnecessary (same for the _Sent2 check).

106

Nit: std::move the iterators here as well?

118

Nit: please add a blank line after this line (to separate different functions from each other).

168

Nit: please add a blank line before this line.

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

43

Nit: I think we need one successful test case for each number of template arguments, so here we need to add:

static_assert(!HasEndsWithIt<int*, int*>);

(this is to "test the test", so to speak)

52

Nit: Range1 and Range2 should be forwarding references, and in the body of the concept, range1 and range2 should be forwarded. That way, it would be more similar to how the function is actually invoked.

59

Here we also need to have a successful test case for two template arguments.

60

Optional: IMO it's not necessary to test out every single not-forward-range we have, just a couple is enough (e.g. I would leave just ForwardRangeNotDerivedFrom and ForwardRangeNotSentinelSemiregular).

235

Nit: formatting needs fixing.

256

I think this should be random_access_iterator list, otherwise none of the iterator types in the list are a forward iterator so the if constexpr (std::forward_iterator...) below will never be taken.

275

Nit: s/benmark/benchmark/ (here and below).

275

+1, benchmarks should be under the benchmarks folder and use the infrastructure we're currently using (that is, Google Benchmark).

Also, we shouldn't be benchmarking the implementation details like this, partially because it's easy for the benchmark and the actual implementation to get out of sync. Rather, you can use the same input vectors for different test cases but wrap their iterators into our helper iterators, then call ends_with using the wrappers:

std::vector<int> a = /*some initializer*/;
std::vector<int> p = /*some initializer*/;

{
  std::random_access_iterator<int*> begin1(a.begin());
  std::random_access_iterator<int*> end1(a.end());
  std::random_access_iterator<int*> begin2(p.begin());
  std::random_access_iterator<int*> end2(p.end());
  std::ranges::ends_with(begin1, end1, begin2, end2);
  // ...
}
{
  std::bidirectional_iterator<int*> begin1(a.begin());
  std::bidirectional_iterator <int*> end1(a.end());
  std::bidirectional_iterator <int*> begin2(p.begin());
  std::bidirectional_iterator <int*> end2(p.end());
  std::ranges::ends_with(begin1, end1, begin2, end2);
  // ...
}

You can even test the sized optimization using sized_sentinel. Like Louis mentioned above, we unfortunately don't have a way to test for performance regressions currently, and we shouldn't try to solve that problem in this patch. Rather, it would be great if you could run the new benchmarks locally, make sure the numbers are as expected (i.e., random access iterators are faster than bidirectional iterators, etc.), then post the results in this review.

276

This should be just std::vector.

278

Nit: formatting (should be a space after for, i.e., for ().

284

Names used in tests don't have to be uglified with leading __ underscores (in fact, they shouldn't be since these are technically reserved names for the library. Even though the test is testing the library, the test itself isn't a part of the library).

289

Since these are the default values, I think they should be omitted (the predicate and the projections, that is).

[ZijunZhao]

1. reformat
2. rename helper function
3. add std::move

[ZijunZhao]

reformat

[ZijunZhao]

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

256

I think cpp20_input_iterator_list already contains random_access_iterator?
Why I think so is because from libcxx/test/support/test_iterators.h

using random_access_iterator_list =
    type_list<Ptr,
#if TEST_STD_VER >= 20
              contiguous_iterator<Ptr>,
#endif
              random_access_iterator<Ptr> >;

template <class Ptr>
using bidirectional_iterator_list =
    concatenate_t<random_access_iterator_list<Ptr>, type_list<bidirectional_iterator<Ptr> > >;

template <class Ptr>
using forward_iterator_list = concatenate_t<bidirectional_iterator_list<Ptr>, type_list<forward_iterator<Ptr> > >;

template <class Ptr>
using cpp17_input_iterator_list = concatenate_t<forward_iterator_list<Ptr>, type_list<cpp17_input_iterator<Ptr> > >;

#if TEST_STD_VER >= 20
template <class Ptr>
using cpp20_input_iterator_list =
    concatenate_t<forward_iterator_list<Ptr>, type_list<cpp20_input_iterator<Ptr>, cpp17_input_iterator<Ptr>>>;
#endif

[ZijunZhao]

Update HasEndsWithR test

[var-const]

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

53

Nit: you would also need to call std::forward<Range1>(range1) here (same for the other argument).

275

Sorry, rereading this comment, I mean random_access_iterator and bidirectional_iterator from our test_iterators.h header. Please ignore the std:: qualification, I copy-pasted it accidentally. So basically

std::vector<int> a = /*some initializer*/;
std::vector<int> p = /*some initializer*/;

{
  random_access_iterator<int*> begin1(a.begin());
  random_access_iterator<int*> end1(a.end());
  random_access_iterator<int*> begin2(p.begin());
  random_access_iterator<int*> end2(p.end());
  std::ranges::ends_with(begin1, end1, begin2, end2);
  // ...
}
{
  bidirectional_iterator<int*> begin1(a.begin());
  bidirectional_iterator<int*> end1(a.end());
  bidirectional_iterator<int*> begin2(p.begin());
  bidirectional_iterator<int*> end2(p.end());
  std::ranges::ends_with(begin1, end1, begin2, end2);
  // ...
}

[ZijunZhao]

Update benchmarks test

[ZijunZhao]

Update test

[var-const]

libcxx/benchmarks/algorithms/ranges_ends_with.bench.cpp

15

I tried out the benchmarks locally. After applying the fixes outlined above, I noticed a couple of interesting things:

1. Random access iterators end up being a little slower than bidirectional iterators, at least in my environment. This is because std::__equal_impl ends up being a little slower than std::ranges::__mismatch::__fn::__go for the same arguments. It looks like the combination of calling advance on __first1 (even though in this case it's a no-op) with the fact that equal checks __first1 == __last1 in the end inhibits some optimization. I'm reluctant to try to fix this, though, at least in this patch -- the difference is small and isn't really specific to ends_with; it might also be dependent on the compiler.

2. equal contains a powerful memcmp optimization for contiguous iterators but it doesn't get triggered currently. That's because ends_with wraps the predicate and the projections in a reference_wrapper, and the optimization only kicks in if (simplified):

__is_trivial_equality_predicate<_Pred, _Tp, _Up>::value && __is_identity<_Proj1>::value && __is_identity<_Proj2>::value

__is_trivial_equality_predicate recognizes ranges::equal_to as trivial, but not reference_wrapper<ranges::equal_to>, similarly for __is_identity.

There are a few potential solutions:

1. Modify these traits to recognize reference_wrapper.
2. Call an internal version of ranges::equal that takes functors by reference (needs to be written) or call std::__equal directly. It would also be necessary to duplicate the __unwrap_iter and __unwrap_range logic that's currently in ranges::equal.
3. Stop providing the guarantee that we never copy functors in algorithms.

I'm currently leaning towards option 1. @philnik Nikolas, what do you think?

22

Sorry, I miswrote the suggestion above, this should be

#include "test_iterators.h"

// ...

auto begin1 = random_access_iterator(a.begin());
// ...

std::random_access_iterator is a concept and as such it evaluates to a boolean. In other words, begin1, end1, begin2 and end2 end up being boolean variables, then we create zero- or one-element containers from those booleans (because they implicitly convert to integers, unfortunately), which means we ignore the size of state.range() generated by benchmark and always measure the same (meaningless) thing.

26

What we want to do is to test how the implementation of the algorithm treats different iterator categories, but at the same time we want to use the same underlying container type so that it's not a factor in our measurement (otherwise, if we compare e.g. a vector against a list, it's impossible to say how much of the performance difference is due to random-access iterator optimizations in ends_with and how much is due to the fact that vector is much more cache-friendly). Since we can make the iterator category more limited (e.g. turn a bidirectional iterator into a forward iterator) but not vice versa, that means we need to use a container with the most powerful iterator category -- so it would have to be a vector, an array or a built-in array.

If we use a container, wrap its iterators but then create a new container from those iterators, it negates the idea because the new container would have the same iterator category as before. E.g. if we create a list, wrap its (bidirectional) iterators into forward iterators, then create a new list from those forward iterators, the new list once again would have bidirectional iterators, completely negating our wrapping. In other words, you should just do

benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));

40

We would also want to test with contiguous_iterators and forward_iterators.

[philnik]

libcxx/benchmarks/algorithms/ranges_ends_with.bench.cpp

15

I think both (1) and (3) make sense. (1) Seems like a nice generalizations, but I doubt it will make much of a difference 99% of the time, and (3) seems like it simplifies some things quite a bit. I also have the suspicion that all the references in the algorithms might inhibit optimizations, but I didn't test that yet. I also don't expect most predicates and projections to be non-trivial, making this an optimization that only applies very rarely, and potentially a pessimization in some cases (although that's just conjecture on my part).

[ZijunZhao]

Update benchmark tests

[var-const]

Thank you for working on this and addressing all the feedback! LGTM with a green CI (let me know if you need any help with CI failures).

I don't know if you have commit permissions -- if not, I can help merge the patch (please provide the name and the email address to use for the author field in that case).

libcxx/benchmarks/algorithms/ranges_ends_with.bench.cpp

15

@philnik Thanks!

@ZijunZhao As discussed offline, let's implement (1) in a follow-up.

15

Nit: I don't think this header is used.

43

Nit: please add a blank line after this line.

68

Nit: extraneous blank line (here and in some other functions in this file).

95

Nit: please add a blank line after this line for consistency with other functions in this file.

[ZijunZhao]

1. add some headers in ranges_ends_with.h
2. fix nits: add/remove some blank lines
3. remove useless headers in ranges.ends_with.pass.cpp

[ZijunZhao]

Reformat

[ZijunZhao]

remove redundant headers to avoid transitive includes

[ZijunZhao]

Remove unused header files

[ZijunZhao]

Modify algorithm.inc to pass the presubmit

[ZijunZhao]

Update tests

[ZijunZhao]

change #if TEST_STD_VER > 20 to #if TEST_STD_VER >= 23

[ZijunZhao]

Correct the #if condition for ranges::starts_with() and ranges::ends_with()

[ZijunZhao]

Update algorithm.inc to pass prechecks

libcxx/benchmarks/CMakeLists.txt

set(BENCHMARK_TESTS
     algorithms/lower_bound.bench.cpp
     algorithms/make_heap.bench.cpp
     algorithms/make_heap_then_sort_heap.bench.cpp
     algorithms/min.bench.cpp
     algorithms/min_max_element.bench.cpp
     algorithms/pop_heap.bench.cpp
     algorithms/pstl.stable_sort.bench.cpp
     algorithms/push_heap.bench.cpp
+    algorithms/ranges_ends_with.bench.cpp
     algorithms/ranges_make_heap.bench.cpp
     algorithms/ranges_make_heap_then_sort_heap.bench.cpp
     algorithms/ranges_pop_heap.bench.cpp
     algorithms/ranges_push_heap.bench.cpp
     algorithms/ranges_sort.bench.cpp
     algorithms/ranges_sort_heap.bench.cpp
     algorithms/ranges_stable_sort.bench.cpp
     algorithms/sort.bench.cpp

libcxx/benchmarks/algorithms/ranges_ends_with.bench.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <iterator>
+
+#include "test_iterators.h"
+#include <vector>
+
+static void bm_ends_with_contiguous_iter(benchmark::State& state) {
+  std::vector<int> a(state.range(), 1);
+  std::vector<int> p(state.range(), 1);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(a);
+    benchmark::DoNotOptimize(p);
+
+    auto begin1 = contiguous_iterator(a.data());
+    auto end1   = contiguous_iterator(a.data() + a.size());
+    auto begin2 = contiguous_iterator(p.data());
+    auto end2   = contiguous_iterator(p.data() + p.size());
+
+    benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));
+  }
+}
+BENCHMARK(bm_ends_with_contiguous_iter)->RangeMultiplier(16)->Range(16, 16 << 20);
+
+static void bm_ends_with_random_iter(benchmark::State& state) {
+  std::vector<int> a(state.range(), 1);
+  std::vector<int> p(state.range(), 1);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(a);
+    benchmark::DoNotOptimize(p);
+
+    auto begin1 = random_access_iterator(a.begin());
+    auto end1   = random_access_iterator(a.end());
+    auto begin2 = random_access_iterator(p.begin());
+    auto end2   = random_access_iterator(p.end());
+
+    benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));
+  }
+}
+BENCHMARK(bm_ends_with_random_iter)->RangeMultiplier(16)->Range(16, 16 << 20);
+
+static void bm_ends_with_bidirectional_iter(benchmark::State& state) {
+  std::vector<int> a(state.range(), 1);
+  std::vector<int> p(state.range(), 1);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(a);
+    benchmark::DoNotOptimize(p);
+
+    auto begin1 = bidirectional_iterator(a.begin());
+    auto end1   = bidirectional_iterator(a.end());
+    auto begin2 = bidirectional_iterator(p.begin());
+    auto end2   = bidirectional_iterator(p.end());
+
+    benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));
+  }
+}
+BENCHMARK(bm_ends_with_bidirectional_iter)->RangeMultiplier(16)->Range(16, 16 << 20);
+
+static void bm_ends_with_forward_iter(benchmark::State& state) {
+  std::vector<int> a(state.range(), 1);
+  std::vector<int> p(state.range(), 1);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(a);
+    benchmark::DoNotOptimize(p);
+
+    auto begin1 = forward_iterator(a.begin());
+    auto end1   = forward_iterator(a.end());
+    auto begin2 = forward_iterator(p.begin());
+    auto end2   = forward_iterator(p.end());
+
+    benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));
+  }
+}
+BENCHMARK(bm_ends_with_forward_iter)->RangeMultiplier(16)->Range(16, 16 << 20);
+
+static void bm_ends_with_forward_iter_with_size_optimization(benchmark::State& state) {
+  std::vector<int> a(state.range(), 1);
+  std::vector<int> p(state.range(), 1);
+  p.push_back(2);
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(a);
+    benchmark::DoNotOptimize(p);
+
+    auto begin1 = forward_iterator(a.begin());
+    auto end1   = forward_iterator(a.end());
+    auto begin2 = forward_iterator(p.begin());
+    auto end2   = forward_iterator(p.end());
+
+    benchmark::DoNotOptimize(std::ranges::ends_with(begin1, end1, begin2, end2));
+  }
+}
+BENCHMARK(bm_ends_with_forward_iter_with_size_optimization)->RangeMultiplier(16)->Range(16, 16 << 20);
+
+BENCHMARK_MAIN();

libcxx/include/CMakeLists.txt

set(files
   __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_ends_with.h
   __algorithm/ranges_equal.h
   __algorithm/ranges_equal_range.h
   __algorithm/ranges_fill.h
   __algorithm/ranges_fill_n.h
   __algorithm/ranges_find.h
   __algorithm/ranges_find_end.h
   __algorithm/ranges_find_first_of.h
   __algorithm/ranges_find_if.h

libcxx/include/__algorithm/ranges_ends_with.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_ENDS_WITH_H
+#define _LIBCPP___ALGORITHM_RANGES_ENDS_WITH_H
+
+#include <__algorithm/ranges_equal.h>
+#include <__algorithm/ranges_starts_with.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/advance.h>
+#include <__iterator/concepts.h>
+#include <__iterator/distance.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/reverse_iterator.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 >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __ends_with {
+struct __fn {
+  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __ends_with_fn_impl_bidirectional(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
+    auto __rbegin1 = std::make_reverse_iterator(__last1);
+    auto __rend1   = std::make_reverse_iterator(__first1);
+    auto __rbegin2 = std::make_reverse_iterator(__last2);
+    auto __rend2   = std::make_reverse_iterator(__first2);
+    return ranges::starts_with(
+        __rbegin1, __rend1, __rbegin2, __rend2, std::ref(__pred), std::ref(__proj1), std::ref(__proj2));
+  }
+
+  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __ends_with_fn_impl(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
+    if constexpr (std::bidirectional_iterator<_Sent1> && std::bidirectional_iterator<_Sent2> &&
+                  (!std::random_access_iterator<_Sent1>)&&(!std::random_access_iterator<_Sent2>)) {
+      return __ends_with_fn_impl_bidirectional(__first1, __last1, __first2, __last2, __pred, __proj1, __proj2);
+
+    } else {
+      auto __n1 = ranges::distance(__first1, __last1);
+      auto __n2 = ranges::distance(__first2, __last2);
+      if (__n2 == 0)
+        return true;
+      if (__n2 > __n1)
+        return false;
+
+      return __ends_with_fn_impl_with_offset(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__last2),
+          __pred,
+          __proj1,
+          __proj2,
+          __n1 - __n2);
+    }
+  }
+
+  template <class _Iter1,
+            class _Sent1,
+            class _Iter2,
+            class _Sent2,
+            class _Pred,
+            class _Proj1,
+            class _Proj2,
+            class _Offset>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __ends_with_fn_impl_with_offset(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2,
+      _Offset __offset) {
+    if constexpr (std::bidirectional_iterator<_Sent1> && std::bidirectional_iterator<_Sent2> &&
+                  !std::random_access_iterator<_Sent1> && !std::random_access_iterator<_Sent2>) {
+      return __ends_with_fn_impl_bidirectional(
+          std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
+
+    } else {
+      ranges::advance(__first1, __offset);
+      return ranges::equal(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__last2),
+          std::ref(__pred),
+          std::ref(__proj1),
+          std::ref(__proj2));
+    }
+  }
+
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            input_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires(forward_iterator<_Iter1> || sized_sentinel_for<_Sent1, _Iter1>) &&
+            (forward_iterator<_Iter2> || sized_sentinel_for<_Sent2, _Iter2>) &&
+            indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
+    return __ends_with_fn_impl(
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
+  }
+
+  template <input_range _Range1,
+            input_range _Range2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires(forward_range<_Range1> || sized_range<_Range1>) && (forward_range<_Range2> || sized_range<_Range2>) &&
+            indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
+  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    if constexpr (sized_range<_Range1> && sized_range<_Range2>) {
+      auto __n1 = ranges::size(__range1);
+      auto __n2 = ranges::size(__range2);
+      if (__n2 == 0)
+        return true;
+      if (__n2 > __n1)
+        return false;
+      auto __offset = __n1 - __n2;
+
+      return __ends_with_fn_impl_with_offset(
+          ranges::begin(__range1),
+          ranges::end(__range1),
+          ranges::begin(__range2),
+          ranges::end(__range2),
+          __pred,
+          __proj1,
+          __proj2,
+          __offset);
+
+    } else {
+      return __ends_with_fn_impl(
+          ranges::begin(__range1),
+          ranges::end(__range1),
+          ranges::begin(__range2),
+          ranges::end(__range2),
+          __pred,
+          __proj1,
+          __proj2);
+    }
+  }
+};
+} // namespace __ends_with
+
+inline namespace __cpo {
+inline constexpr auto ends_with = __ends_with::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___ALGORITHM_RANGES_ENDS_WITH_H

libcxx/include/algorithm

template<input_range R1, input_range R2, class Pred = ranges::equal_to,
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {});              // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 
+  template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+    requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
+           (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
+           indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+    constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
+
+  template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
+          class Proj2 = identity>
+    requires (forward_range<R1> || sized_range<R1>) &&
+           (forward_range<R2> || sized_range<R2>) &&
+           indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+    constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
+
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});             // since C++20
 
   template<input_range R, class Proj = identity,
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {});                       // since C++20
 

 #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_ends_with.h>
 #include <__algorithm/ranges_equal.h>
 #include <__algorithm/ranges_equal_range.h>
 #include <__algorithm/ranges_fill.h>
 #include <__algorithm/ranges_fill_n.h>
 #include <__algorithm/ranges_find.h>
 #include <__algorithm/ranges_find_end.h>
 #include <__algorithm/ranges_find_first_of.h>
 #include <__algorithm/ranges_find_if.h>

libcxx/modules/std/algorithm.inc

namespace ranges {
     using std::ranges::search_n;
   }
 
   namespace ranges {
 #if _LIBCPP_STD_VER >= 23
     // [alg.starts.with], starts with
     using std::ranges::starts_with;
 
-#  if 0
     // [alg.ends.with], ends with
     using std::ranges::ends_with;
 
+#  if 0
     // [alg.fold], fold
     using std::ranges::fold_left;
     using std::ranges::fold_left_first;
     using std::ranges::fold_right;
     using std::ranges::fold_right_last;
     using std::ranges::fold_left_with_iter;
     using std::ranges::fold_left_with_iter_result;
     using std::ranges::fold_left_with_iter;

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

constexpr bool all_the_algorithms()
     (void)std::ranges::any_of(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(first, last, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::binary_search(a, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::clamp(value, value, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(first, last, first2, UnaryTrue(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(a, first2, UnaryTrue(&copies)); assert(copies == 0);
-#if TEST_STD_VER > 20
-    //(void)std::ranges::ends_with(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
+#if TEST_STD_VER >= 23
+    (void)std::ranges::ends_with(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
+    (void)std::ranges::ends_with(a, b, Equal(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::equal(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::equal(a, b, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::equal_range(first, last, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::equal_range(a, value, Less(&copies)); assert(copies == 0);
     (void)std::ranges::find_end(first, last, first2, mid2, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::find_end(a, b, Equal(&copies)); assert(copies == 0);
     (void)std::ranges::find_first_of(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::binary_search(a, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::clamp(T(), T(), T(), Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(first, last, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::count_if(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::copy_if(first, last, first2, UnaryTrue(), Proj(&copies)); assert(copies == 0);
     (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);
+#if TEST_STD_VER >= 23
+    (void)std::ranges::ends_with(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
+    (void)std::ranges::ends_with(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
 #endif
     (void)std::ranges::equal(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::equal(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::equal_range(first, last, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::equal_range(a, value, Less(), Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find(first, last, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find(a, value, Proj(&copies)); assert(copies == 0);
     (void)std::ranges::find_end(first, last, first2, mid2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);

libcxx/test/std/algorithms/alg.nonmodifying/alg.ends_with/ranges.ends_with.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, c++20
+
+// template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+//          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+//   requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+//   constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+//                                      Proj1 proj1 = {}, Proj2 proj2 = {});
+// 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::ends_with(R1&& r1, R2&& r2, Pred pred = {},
+//                                      Proj1 proj1 = {}, Proj2 proj2 = {});
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <ranges>
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+using namespace std::chrono;
+
+template <class Iter1, class Sent1 = Iter1, class Iter2 = int*, class Sent2 = Iter2>
+concept HasEndsWithIt = requires(Iter1 first1, Sent1 last1, Iter2 first2, Sent2 last2) {
+  std::ranges::ends_with(first1, last1, first2, last2);
+};
+
+static_assert(HasEndsWithIt<int*>);
+static_assert(!HasEndsWithIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasEndsWithIt<ForwardIteratorNotIncrementable>);
+static_assert(HasEndsWithIt<int*, int*>);
+static_assert(!HasEndsWithIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasEndsWithIt<int*, int*, int**>); // not indirectly comparable
+static_assert(!HasEndsWithIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasEndsWithIt<int*, int*, ForwardIteratorNotDerivedFrom>);
+static_assert(!HasEndsWithIt<int*, int*, ForwardIteratorNotIncrementable>);
+static_assert(!HasEndsWithIt<int*, int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasEndsWithIt<int*, int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range1, class Range2 = UncheckedRange<int*>>
+concept HasEndsWithR = requires(Range1&& range1, Range2&& range2) {
+    std::ranges::ends_with(std::forward<Range1>(range1), std::forward<Range2>(range2)); };
+
+static_assert(HasEndsWithR<UncheckedRange<int*>>);
+static_assert(!HasEndsWithR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasEndsWithR<ForwardIteratorNotIncrementable>);
+static_assert(!HasEndsWithR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasEndsWithR<ForwardRangeNotSentinelEqualityComparableWith>);
+static_assert(HasEndsWithR<UncheckedRange<int*>, UncheckedRange<int*>>);
+static_assert(!HasEndsWithR<UncheckedRange<int*>, UncheckedRange<int**>>); // not indirectly comparable
+static_assert(!HasEndsWithR<UncheckedRange<int*>, ForwardRangeNotDerivedFrom>);
+static_assert(!HasEndsWithR<UncheckedRange<int*>, ForwardRangeNotSentinelSemiregular>);
+
+// clang-format off
+template <class Iter1, class Sent1 = Iter1, class Iter2, class Sent2 = Iter2>
+constexpr void test_iterators() {
+  { // simple tests
+    int a[]          = {1, 2, 3, 4, 5, 6};
+    int p[]          = {4, 5, 6};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
+    {
+      [[maybe_unused]] std::same_as<bool> decltype(auto) ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(ret);
+    }
+    {
+      [[maybe_unused]] std::same_as<bool> decltype(auto) ret = std::ranges::ends_with(whole, suffix);
+      assert(ret);
+    }
+  }
+
+  { // suffix doesn't match
+    int a[] = {1, 2, 3, 4, 5, 6};
+    int p[] = {1, 2, 3};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
+    {
+      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(!ret);
+    }
+    {
+      bool ret = std::ranges::ends_with(whole, suffix);
+      assert(!ret);
+    }
+  }
+
+  { // range consists of just one element
+    int a[] = {1};
+    int p[] = {1};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 1)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 1)));
+    {
+      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(ret);
+    }
+    {
+      bool ret = std::ranges::ends_with(whole, suffix);
+      assert(ret);
+    }
+  }
+
+  { // suffix consists of just one element
+    int a[] = {5, 1, 2, 4, 3};
+    int p[] = {3};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 5)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 1)));
+    {
+      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(ret);
+    }
+    {
+      bool ret = std::ranges::ends_with(whole, suffix);
+      assert(ret);
+    }
+  }
+
+  { // range and suffix are identical
+    int a[] = {1, 2, 3, 4, 5, 6};
+    int p[] = {1, 2, 3, 4, 5, 6};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 6)));
+    {
+      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(ret);
+    }
+    {
+      bool ret = std::ranges::ends_with(whole, suffix);
+      assert(ret);
+    }
+  }
+
+  { // suffix is longer than range
+    int a[] = {3, 4, 5, 6, 7, 8};
+    int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
+    auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+    auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
+    {
+      bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+      assert(!ret);
+    }
+    {
+      bool ret = std::ranges::ends_with(whole, suffix);
+      assert(!ret);
+    }
+ }
+
+ { // suffix has zero length
+   int a[] = {1, 2, 3, 4, 5, 6};
+   int p[] = {};
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+     assert(ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix);
+     assert(ret);
+   }
+ }
+
+ { // range has zero length
+   int a[] = {};
+   int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+     assert(!ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix);
+     assert(!ret);
+   }
+ }
+
+ { // subarray
+   int a[] = {0, 3, 5, 10, 7, 3, 5, 89, 3, 5, 2, 1, 8, 6};
+   int p[] = {3, 5};
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 13)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+     assert(!ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix);
+     assert(!ret);
+   }
+ }
+
+ { // repeated suffix
+   int a[] = {8, 6, 3, 5, 1, 2};
+   int p[] = {1, 2, 1, 2};
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 4)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end());
+     assert(!ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix);
+     assert(!ret);
+   }
+ }
+
+ { // check that the predicate is used
+   int a[] = {5, 1, 3, 2, 7};
+   int p[] = {-2, -7};
+   auto pred = [](int l, int r) { return l * -1 == r; };
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 5)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end(), pred);
+     assert(ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix, pred);
+     assert(ret);
+   }
+ }
+
+ { // check that the projections are used
+   int a[] = {1, 3, 15, 1, 2, 1};
+   int p[] = {2, 1, 2};
+   auto whole = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+   auto suffix  = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
+   {
+     bool ret = std::ranges::ends_with(whole.begin(), whole.end(), suffix.begin(), suffix.end(), {},
+         [](int i) { return i - 3; },
+         [](int i) { return i * -1; });
+     assert(ret);
+   }
+   {
+     bool ret = std::ranges::ends_with(whole, suffix, {},
+         [](int i) { return i - 3; },
+         [](int i) { return i * -1; });
+     assert(ret);
+   }
+  }
+}
+
+constexpr bool test() {
+  // This is to test (forward_iterator<_Iter1> || sized_sentinel_for<_Sent1, _Iter1>) condition.
+  types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iter2>() {
+    types::for_each(types::cpp20_input_iterator_list<int*>{}, []<class Iter1>() {
+      if constexpr (std::forward_iterator<Iter1> && std::forward_iterator<Iter2>)
+        test_iterators<Iter1, Iter1, Iter2, Iter2>();
+      if constexpr (std::forward_iterator<Iter2>)
+        test_iterators<Iter1, sized_sentinel<Iter1>, Iter2, Iter2>();
+      if constexpr (std::forward_iterator<Iter1>)
+        test_iterators<Iter1, Iter1, Iter2, sized_sentinel<Iter2>>();
+      test_iterators<Iter1, sized_sentinel<Iter1>, Iter2, sized_sentinel<Iter2>>();
+    });
+  });
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

constexpr bool test_all() {
   auto out2 = output2.begin();
 
   std::ranges::equal_to eq;
   std::ranges::less less;
   auto sum = [](int lhs, A rhs) { return lhs + rhs.x; };
   auto proj1 = [](int x) { return x * -1; };
   auto proj2 = [](A a) { return a.x * -1; };
 
+#if TEST_STD_VER >= 23
+  test(std::ranges::ends_with, in, in2, eq, proj1, proj2);
+#endif
   test(std::ranges::equal, in, in2, eq, proj1, proj2);
   test(std::ranges::lexicographical_compare, in, in2, eq, proj1, proj2);
   test(std::ranges::is_permutation, in, in2, eq, proj1, proj2);
   test(std::ranges::includes, in, in2, less, proj1, proj2);
   test(std::ranges::find_first_of, in, in2, eq, proj1, proj2);
   test(std::ranges::mismatch, in, in2, eq, proj1, proj2);
   test(std::ranges::search, in, in2, eq, proj1, proj2);
   test(std::ranges::find_end, in, in2, eq, proj1, proj2);
   test(std::ranges::transform, in, in2, out, sum, proj1, proj2);
   test(std::ranges::transform, in, in2, out2, sum, proj1, proj2);
   test(std::ranges::partial_sort_copy, in, in2, less, proj1, proj2);
   test(std::ranges::merge, in, in2, out, less, proj1, proj2);
   test(std::ranges::merge, in, in2, out2, less, proj1, proj2);
   test(std::ranges::set_intersection, in, in2, out, less, proj1, proj2);
   test(std::ranges::set_intersection, in, in2, out2, less, proj1, proj2);
   test(std::ranges::set_difference, in, in2, out, less, proj1, proj2);
   test(std::ranges::set_difference, in, in2, out2, less, proj1, proj2);
   test(std::ranges::set_symmetric_difference, in, in2, out, less, proj1, proj2);
   test(std::ranges::set_symmetric_difference, in, in2, out2, less, proj1, proj2);
   test(std::ranges::set_union, in, in2, out, less, proj1, proj2);
   test(std::ranges::set_union, in, in2, out2, less, proj1, proj2);
 #if TEST_STD_VER > 20
   test(std::ranges::starts_with, in, in2, eq, proj1, proj2);
-  // test(std::ranges::ends_with, in, in2, eq, proj1, proj2);
 #endif
 
   return true;
 }
 
 int main(int, char**) {
   test_all();
   static_assert(test_all());
 
   return 0;
 }

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

 
 #include <array>
 #include <concepts>
 #include <initializer_list>
 #include <iterator>
 #include <ranges>
 
 #include "boolean_testable.h"
+#include "test_macros.h"
 
 constexpr auto unary_pred = [](int i) { return BooleanTestable(i > 0); };
 static_assert(!std::same_as<decltype(unary_pred(1)), bool>);
 static_assert(std::convertible_to<decltype(unary_pred(1)), bool>);
 
 constexpr auto binary_pred = [](int i, int j) { return BooleanTestable(i < j); };
 static_assert(!std::same_as<decltype(binary_pred(1, 2)), bool>);
 static_assert(std::convertible_to<decltype(binary_pred(1, 2)), bool>);
constexpr bool test_all() {
   auto out          = output.begin();
   auto out2         = output.begin() + 1;
 
   int x     = 2;
   int count = 1;
 
   test(std::ranges::any_of, in, unary_pred);
   test(std::ranges::all_of, in, unary_pred);
+#if TEST_STD_VER >= 23
+  test(std::ranges::ends_with, in, in2, binary_pred);
+#endif
   test(std::ranges::none_of, in, unary_pred);
   test(std::ranges::find_if, in, unary_pred);
   test(std::ranges::find_if_not, in, unary_pred);
   test(std::ranges::find_first_of, in, in2, binary_pred);
   test(std::ranges::adjacent_find, in, binary_pred);
   test(std::ranges::mismatch, in, in2, binary_pred);
   test(std::ranges::equal, in, in2, binary_pred);
   test(std::ranges::lexicographical_compare, in, in2, binary_pred);
#endif
   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);
   test(std::ranges::merge, in, in2, out, binary_pred);
+#if TEST_STD_VER > 20
+  test(std::ranges::starts_with, in, in2, binary_pred);
+#endif
   test(std::ranges::set_difference, in, in2, out, binary_pred);
   test(std::ranges::set_intersection, in, in2, out, binary_pred);
   test(std::ranges::set_symmetric_difference, in, in2, out, binary_pred);
   test(std::ranges::set_union, in, in2, out, binary_pred);
   test(std::ranges::remove_if, in, unary_pred);
   test(std::ranges::unique, in, binary_pred);
   test(std::ranges::partition, in, unary_pred);
   if (!std::is_constant_evaluated())

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

 
 #include <algorithm>
 
 #include <array>
 #include <concepts>
 #include <initializer_list>
 #include <iterator>
 #include <ranges>
+#include "test_macros.h"
 
 struct Foo {
   int val;
   constexpr bool unary_pred() const { return val > 0; }
   constexpr bool binary_pred(const Foo& rhs) const { return val < rhs.val; }
   constexpr auto operator<=>(const Foo&) const = default;
 };
 
constexpr bool test_all() {
   Bar b{Foo{2}};
   Bar c{Foo{3}};
 
   Foo x{2};
   std::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);
+#if TEST_STD_VER >= 23
+  test(std::ranges::ends_with, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+#endif
   test(std::ranges::none_of, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::find, in, x, &Bar::val);
   test(std::ranges::find_if, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::find_if_not, in, &Foo::unary_pred, &Bar::val);
   test(std::ranges::find_first_of, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::adjacent_find, in, &Foo::binary_pred, &Bar::val);
   test(std::ranges::mismatch, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::equal, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
#endif
   // `swap_ranges` has neither a projection nor a predicate.
   // `reverse_copy` has neither a projection nor a predicate.
   // `rotate_copy` has neither a projection nor a predicate.
   // For `sample`, whether the given generator is invoked via `std::invoke` is not observable.
   test(std::ranges::unique_copy, in, out, &Foo::binary_pred, &Bar::val);
   test(std::ranges::partition_copy, in, out, out2, &Foo::unary_pred, &Bar::val);
   test(std::ranges::partial_sort_copy, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::merge, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
+#if TEST_STD_VER > 20
+  test(std::ranges::starts_with, in, in2, &Foo::binary_pred, &Bar::val, &Bar::val);
+#endif
   test(std::ranges::set_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_intersection, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_symmetric_difference, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::set_union, in, in2, out, &Foo::binary_pred, &Bar::val, &Bar::val);
   test(std::ranges::remove, in, x, &Bar::val);
   test(std::ranges::remove_if, in, &Foo::unary_pred, &Bar::val);
   // `reverse` has neither a projection nor a predicate.
   // `rotate` has neither a projection nor a predicate.

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

 #include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <random>
 #include <ranges>
 
 #include "MoveOnly.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 
 // (in, ...)
 template <class Func, std::ranges::range Input, class ...Args>
 constexpr void test(Func&& func, Input& in, Args&& ...args) {
   (void)func(in.begin(), in.end(), std::forward<Args>(args)...);
   (void)func(in, std::forward<Args>(args)...);
 }
 
constexpr void run_tests() {
   int count = 1;
 
   auto unary_pred = [](const Proxy<T&>&) { return true; };
   auto binary_func = [](const Proxy<T>&, const Proxy<T>&) -> Proxy<T> { return Proxy<T>(T()); };
   auto gen = [] { return Proxy<T>(T{42}); };
 
   test(std::ranges::any_of, in, unary_pred);
   test(std::ranges::all_of, in, unary_pred);
+#if TEST_STD_VER >= 23
+  test(std::ranges::ends_with, in, in2);
+#endif
   test(std::ranges::none_of, in, unary_pred);
   test(std::ranges::find, in, x);
   test(std::ranges::find_if, in, unary_pred);
   test(std::ranges::find_if_not, in, unary_pred);
   test(std::ranges::find_first_of, in, in2);
   test(std::ranges::adjacent_find, in);
   test(std::ranges::mismatch, in, in2);
   test(std::ranges::equal, in, in2);
#endif
   if constexpr (std::copyable<T>) {
     test(std::ranges::remove_copy, in, out, x);
     test(std::ranges::remove_copy_if, in, out, unary_pred);
     test(std::ranges::replace, in, x, x);
     test(std::ranges::replace_if, in, unary_pred, x);
     test(std::ranges::replace_copy, in, out, x, x);
     test(std::ranges::replace_copy_if, in, out, unary_pred, x);
   }
+#if TEST_STD_VER > 20
+  test(std::ranges::starts_with, in, in2);
+#endif
   test(std::ranges::swap_ranges, in, in2);
   if constexpr (std::copyable<T>) {
     test(std::ranges::reverse_copy, in, out);
     test_mid(std::ranges::rotate_copy, in, mid, out);
     test(std::ranges::unique_copy, in, out);
     test(std::ranges::partition_copy, in, out, out2, unary_pred);
     test(std::ranges::partial_sort_copy, in, in2);
     test(std::ranges::merge, in, in2, out);

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 static_assert(test(std::ranges::binary_search, a, 42));
 static_assert(test(std::ranges::clamp, 42, 42, 42));
 static_assert(test(std::ranges::copy, a, a));
 static_assert(test(std::ranges::copy_backward, a, a));
 static_assert(test(std::ranges::copy_if, a, a, odd));
 static_assert(test(std::ranges::copy_n, a, 10, a));
 static_assert(test(std::ranges::count, a, 42));
 static_assert(test(std::ranges::count_if, a, odd));
-//static_assert(test(std::ranges::ends_with, a, a));
+#if TEST_STD_VER >= 23
+static_assert(test(std::ranges::ends_with, a, a));
+#endif
 static_assert(test(std::ranges::equal, a, a));
 static_assert(test(std::ranges::equal_range, a, 42));
 static_assert(test(std::ranges::fill, a, 42));
 static_assert(test(std::ranges::fill_n, a, 10, 42));
 static_assert(test(std::ranges::find, a, 42));
 static_assert(test(std::ranges::find_end, a, a));
 static_assert(test(std::ranges::find_first_of, a, a));
 static_assert(test(std::ranges::find_if, a, odd));