[libc++][ranges] Implement ranges::mismatch

[philnik]

Summary

Implement ranges::mismatch

[var-const]

Drive-by comment: can you also update Status/RangesPaper.csv and Status/RangesAlgorithms.csv?

libcxx/include/module.modulemap

291

Drive-by comment: s/rnages/ranges/

[philnik]

• Address comments and fix CI

[• Quuxplusone]

Thanks for working on this!

libcxx/include/__algorithm/ranges_mismatch.h

39–46

48

_VSTD::invoke throughout; and please add a regression test involving Holder<Incomplete>*.
https://quuxplusone.github.io/blog/2019/09/26/uglification-doesnt-stop-adl/

59–60

65–67

Here, either std::move(__foo) or, better, rejigger this so that we can use references (or our __comp_ref trick) with all of these callables. The Standard permits us to copy these callables as much as we like (AFAIK); but as a quality-of-implementation thing, we want to make zero copies and ideally (IMHO) zero moves as well.

I think it's easy to make this work; you just have to pull out the algorithm itself into a helper

template<class _I1, class _S1, class _I2, class _S2,
         class _Pred, class _Proj1, class _Proj2>
static _LIBCPP_HIDE_FROM_ABI constexpr
mismatch_result<_I1, _I2>
__go(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
     _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) const {
  while (~~~
  return {__first1, __first2};
}

and then call __go from both overloads of operator(), e.g.:

~~~
mismatch_result<_I1, _I2>
operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
           _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
  return __go(_VSTD::move(__first1), __last1, _VSTD::move(__first2), __last2,
               __pred, __proj1, __proj2);
}

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

2

Please uncomment the relevant line in std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp.
Consider adding explicit test coverage here for C arrays, e.g.

int a[] = {1, 2, 3, 4};
int b[] = {1, 2, 4, 8, 16};
auto [ai, bi] = std::ranges::mismatch(a, b);
assert(ai == a + 2);
assert(bi == b + 2);
auto [aj, bj] = std::ranges::mismatch(a, a+4, b, b+5);
assert(aj == a + 2);
assert(bj == b + 2);

This is on my mind tonight because of D117940; but I don't think there's anything specific to mismatch that would bite us here, and niebloid.compile.pass.cpp already (by a happy accident) tests the C-array case.

17–31

I think this layer of indirection is more confusing than helpful. Strongly recommend inlining these assertions directly into test_iters, test_different_lengths, and test_borrowed_range — I think that will probably even shorten the code!

76

mismatch's constraint says input_iterator, so you need to test with both cpp17_input_iterator and (especially) cpp20_input_iterator, as well as all these.
Please also throw in contiguous_iterator<int*>, since there's no good reason to leave it out.

[philnik]

• Rebased
• Address comments

libcxx/include/__algorithm/ranges_mismatch.h

48

Using Holder<Incomplete>* currently errors in input_range, so I won't put a regression test in since fixing input_range is out of scope for this PR.

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

17–31

Veto on doing this for test_ranges. For that I would either have to inline the return type check as well or explicitly name the template parameters. Both of which make the code definitely less readable.

[• Quuxplusone]

Just test nits at this point (probably all related to inlining test_ranges :))

libcxx/include/__algorithm/ranges_mismatch.h

37

Here and line 39, consider linebreaking after _S2,. These lines are just barely too long for Phabricator, so this is a pretty minor nit; but it's also super easy to fix.

39–46

Just a note to say this implementation LGTM now, and awesome, I see that testing with cpp20_input_iterator caught a bug :)

48

Yikes, I see this now: https://godbolt.org/z/WPzrhda1f Is that the problem you mean? If so, OK, no-regression-test is fine.

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

24–28

And change the signature on line 19 to take int *expected1, int *expected2.

89

You can replace this call to test_ranges with simply

using Expected = std::ranges::mismatch_result<Iter, Iter>;
std::same_as<Expected> auto ret = std::ranges::mismatch(b1, b2);
assert(base(ret.in1) == r1 + 3);
assert(base(ret.in2) == r2 + 3);

(leaving off the base() if you want, since here Iter is hardcoded to int* already).
However, this doesn't seem to match the name of the test case... it's supposed to be testing a borrowed range, right? The thing that's special about borrowed ranges is that they work as rvalues. So what you should be testing here is rvalues. I continue to recommend views::all(r1) because it's easy to type.

constexpr void test_borrowed_range() {
  int r1[] = {1, 2, 3, 4, 5, 6};
  int r2[] = {1, 2, 3, 5, 4};
  {
    // non-borrowed lvalue vs. borrowed rvalue
    std::same_as<std::ranges::mismatch_result<int*, int*>> auto ret =
      std::ranges::mismatch(r1, std::views::all(r2));
    assert(ret.in1 == r1 + 3);
    assert(ret.in2 == r2 + 3);
  }
  {
    // borrowed rvalue vs. non-borrowed lvalue
    std::same_as<std::ranges::mismatch_result<int*, int*>> auto ret =
      std::ranges::mismatch(std::views::all(r1), r2);
    assert(ret.in1 == r1 + 3);
    assert(ret.in2 == r2 + 3);
  }
  {
    // borrowed rvalue vs. borrowed rvalue
    std::same_as<std::ranges::mismatch_result<int*, int*>> auto ret =
      std::ranges::mismatch(std::views::all(r1), std::views::all(r2));
    assert(ret.in1 == r1 + 3);
    assert(ret.in2 == r2 + 3);
  }
}

(the // comments are optional)

I'm hoping that seeing this example changes your mind about the utility of inlining test_ranges everywhere else. I haven't dug into those call-sites yet myself, and am hoping you will.

[philnik]

• Address comments

libcxx/include/__algorithm/ranges_mismatch.h

48

Yes.

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

89

std::views::all seems to not be a borrowed_range. At least it's not a borrowed range in libc++ and I couldn't find anything in the standard.

[• Quuxplusone]

libcxx/include/__algorithm/ranges_mismatch.h

48

This is now D118213, so hopefully by end-of-week you can add that regression test after all. :)

Holder<Incomplete> *a[3] = {};
Holder<Incomplete> *b[4] = {};
auto [ai, bi] = std::ranges::mismatch(a, b);
assert(ai == a+3);
assert(bi == b+3);

[philnik]

• Rebased
• IWYU

[• Quuxplusone]

libcxx/include/__algorithm/ranges_mismatch.h

48

D118213 is landed! So you should be able to add the above test now.

[• Quuxplusone]

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

89

D118164 fixed the borrowed-ness of views::all(r), so you can do this now too.

[philnik]

• Updates

libcxx/include/__algorithm/ranges_mismatch.h

48

Now it fails in iterator_traits.h:150. I don't really understand why and I also don't feel like fixing all the concepts before landing this.

[• Quuxplusone]

LGTM % nits.

libcxx/include/__algorithm/ranges_mismatch.h

31

This will need merge-conflict resolution. I suggest just this for now:

#if !defined(_LIBCPP_HAS_NO_CONCEPTS)

although if we wait long enough, D118736 might change it again.

48

Discussed offline, and discovered that Ranges algorithms are fundamentally not ADL-proof, so we actively cannot add the test I was asking for.

https://godbolt.org/z/P9fhhYWvW

I actually now have a suggested fix to ADL-firewall std::projected, but it will require a paper.

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

66

a.begin() + 3 is a funny way to spell a.end().
How about changing a and b to C arrays, and then you can just say test_iterators(a, a + 3, b, b + 2, a + 2, b + 2)?

Please also test when the first range is shorter, i.e. add test_iterators(b, b + 2, a, a + 3, b + 2, a + 2).

168

I claim that we traditionally put a blank line before the return 0;.

[philnik]

• Address comments

[ldionne]

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

13

Please document what you're testing by adding the synopsis here. That's what we do everywhere else.

22

You could easily inline that function into the only place where it's called (unless I missed a second usage?).

38

Please inline those test_foo() functions into the body below, and separate them with scopes like we've started doing:

// meaningful comment
{
  <...>
}

Using a comment allows for something more descriptive than just test_sentinel.

[philnik]

• Rebased
• Address comments

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

22

It's also used in test_different_lengths().

[philnik]

ping @ldionne

[philnik]

Rebased

[philnik]

• Rebased
• Fix spelling

ping @ldionne

[ldionne]

libcxx/include/__algorithm/ranges_mismatch.h

62

Any reason why we don't implement the algorithm here and then call *this in the range version immediately below?

libcxx/include/algorithm

47–58

This is strangely formatted. Also, we need to say // since C++20.

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

107

We should add test with non-default projections and predicate for the range overload.

Edit: And for the iterator overload too, since it appears we don't have such tests.

[philnik]

• Address comments

libcxx/include/__algorithm/ranges_mismatch.h

62

With the current implementation the predicates and projections are never moved. using *this() would mean we have to move them at least once.

[ldionne]

LGTM with my comments addressed. Thanks!

libcxx/include/__algorithm/ranges_mismatch.h

62

Oh, I see. Clever. Can you please add a libc++ specific test for that? I know it's nitpicky, but that seems like a useful guarantee to test if we're providing it. I suggest finding a simple way to test this because I'll be requesting the same kind of test for other algorithms as well (e.g. find_if).

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

128

[ldionne]

By the way, I know CI is flaky right now with failures around installing cxxabi_config.h -- I'm getting there but there's a couple pre-requisites to fix this. For now, please ignore.

[• Quuxplusone]

libcxx/include/__algorithm/ranges_mismatch.h

62

I'd be happy to tackle this in a different PR; it'd basically be a Ranges version of libcxx/test/libcxx/algorithms/robust_against_copying_comparators.pass.cpp.

[var-const]

libcxx/docs/Status/RangesAlgorithms.csv

10

Ultranit: can you use the checkmark emoji instead? It would be consistent with other completed entries (and I think stands out better visually).

libcxx/include/__algorithm/ranges_mismatch.h

31

Since D118736 has landed, does this need to change again?

81

This comment looks like it doesn't match the #if condition.

libcxx/include/algorithm

51

Do you need to also add mismatch_result to the synopsis?

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

35

Ultranit: include <utility>?

42

Nit: it's not obvious from names alone how test_iters is different from test_iterators. Feel free to ignore because the scope is small enough. (For a concrete suggestion, I'd use test_iters and test_iters_impl, though it's certainly not perfect)

107

Very optional: you could use CTAD here to avoid providing an element count.

123

Question: is wrapping in Iter necessary? It seems like array-to-pointer decay would work.

128

Nit: s/sized/size/?

171

Optional: this seems like a test of std::ranges::in_in_result?

289

I think this patch also needs to test the constraints to make sure that parameters that don't satisfy input_iterator, indirectly_comparable, etc. SFINAE away properly.

[var-const]

@philnik Sorry, looks like I'm a little late with my review. Can you please address some of the comments in a follow-up? You can definitely ignore the nits and optionals -- I'm mostly concerned about the potentially missing tests for SFINAE and missing mismatch_result from the synopsis. Thanks!

[var-const]

One more suggestion -- how about testing with empty range(s)?

libcxx/docs/Status/RangesAlgorithms.csv

 Category,Algorithm,Assignee,CL,Complete
 Search,any_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
 Search,all_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
 Search,none_of,Christopher Di Bella,`D105793 <https://llvm.org/D105793>`_
 Search,find,Christopher Di Bella,`D105456 <https://llvm.org/D105456>`_
 Search,find_if,Christopher Di Bella,`D105792 <https://llvm.org/D105792>`_
 Search,find_if_not,Christopher Di Bella,`D105792 <https://llvm.org/D105792>`_
 Search,find_first_of,Not assigned,n/a,Not started
 Search,adjacent_find,Not assigned,n/a,Not started
-Search,mismatch,Not assigned,n/a,Not started
+Search,mismatch,Nikolas Klauser,`D117817 <https://llvm.org/D117817>`,Complete
 Search,equal,Not assigned,n/a,Not started
 Search,lexicographical_compare,Not assigned,n/a,Not started
 Search,partition_point,Christopher Di Bella,`D105794 <https://llvm.org/D105794>`_,Under review
 Search,lower_bound,Christopher Di Bella,`D105795 <https://llvm.org/D105795>`_,Under review
 Search,upper_bound,Christopher Di Bella,`D105795 <https://llvm.org/D105795>`_,Under review
 Search,equal_range,Christopher Di Bella,n/a,Not started
 Search,binary_search,Christopher Di Bella,n/a,Not started
 Search,min,Not assigned,n/a,Not started

libcxx/include/CMakeLists.txt

set(files
   __algorithm/partial_sort_copy.h
   __algorithm/partition.h
   __algorithm/partition_copy.h
   __algorithm/partition_point.h
   __algorithm/pop_heap.h
   __algorithm/prev_permutation.h
   __algorithm/push_heap.h
   __algorithm/ranges_min_element.h
+  __algorithm/ranges_mismatch.h
   __algorithm/ranges_swap_ranges.h
   __algorithm/remove.h
   __algorithm/remove_copy.h
   __algorithm/remove_copy_if.h
   __algorithm/remove_if.h
   __algorithm/replace.h
   __algorithm/replace_copy.h
   __algorithm/replace_copy_if.h

libcxx/include/__algorithm/ranges_mismatch.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_MISMATCH_H
+#define _LIBCPP___ALGORITHM_RANGES_MISMATCH_H
+
+#include <__algorithm/in_in_result.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+namespace ranges {
+
+template <class _I1, class _I2>
+using mismatch_result = in_in_result<_I1, _I2>;
+
+namespace __mismatch {
+struct __fn {
+  template <class _I1, class _S1, class _I2, class _S2,
+            class _Pred, class _Proj1, class _Proj2>
+  static _LIBCPP_HIDE_FROM_ABI constexpr
+  mismatch_result<_I1, _I2>
+  __go(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
+       _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+    while (__first1 != __last1 && __first2 != __last2) {
+      if (!std::invoke(__pred, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__first2)))
+        break;
+      ++__first1;
+      ++__first2;
+    }
+    return {std::move(__first1), std::move(__first2)};
+  }
+
+  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>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  mismatch_result<_I1, _I2> operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
+                                       _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    return __go(std::move(__first1), __last1, std::move(__first2), __last2, __pred, __proj1, __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>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  mismatch_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
+  operator()(_R1&& __r1, _R2&& __r2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    return __go(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2),
+                __pred, __proj1, __proj2);
+  }
+};
+} // namespace __mismatch
+
+inline namespace __cpo {
+  constexpr inline auto mismatch = __mismatch::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H

libcxx/include/algorithm

namespace ranges {
 
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>             // since C++20
   constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
 
   template<forward_range R, class Proj = identity,
     indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
   constexpr borrowed_iterator_t<R> min_element(R&& r, Comp comp = {}, Proj proj = {});
+
+  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 mismatch_result<_I1, _I2>
+  mismatch()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) // since C++20
+
+  template <input_range R1, input_range R2,
+          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+    requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+  constexpr mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+  mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})                           // since C++20
 }
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20

 #include <__algorithm/partial_sort_copy.h>
 #include <__algorithm/partition.h>
 #include <__algorithm/partition_copy.h>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
 #include <__algorithm/push_heap.h>
 #include <__algorithm/ranges_min_element.h>
+#include <__algorithm/ranges_mismatch.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
 #include <__algorithm/replace_copy_if.h>

libcxx/include/module.modulemap

module __algorithm {
       module partial_sort             { private header "__algorithm/partial_sort.h" }
       module partial_sort_copy        { private header "__algorithm/partial_sort_copy.h" }
       module partition                { private header "__algorithm/partition.h" }
       module partition_copy           { private header "__algorithm/partition_copy.h" }
       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_min_element       { private header "__algorithm/ranges_min_element.h" }
+      module ranges_mismatch          { private header "__algorithm/ranges_mismatch.h" }
       module ranges_swap_ranges       { private header "__algorithm/ranges_swap_ranges.h" }
       module remove                   { private header "__algorithm/remove.h" }
       module remove_copy              { private header "__algorithm/remove_copy.h" }
       module remove_copy_if           { private header "__algorithm/remove_copy_if.h" }
       module remove_if                { private header "__algorithm/remove_if.h" }
       module replace                  { private header "__algorithm/replace.h" }
       module replace_copy             { private header "__algorithm/replace_copy.h" }
       module replace_copy_if          { private header "__algorithm/replace_copy_if.h" }

libcxx/test/libcxx/diagnostics/detail.headers/algorithm/ranges_mismatch.module.verify.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: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}
+#include <__algorithm/ranges_mismatch.h>

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/ranges_mismatch.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// 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 mismatch_result<_I1, _I2>
+// ranges::mismatch()(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 mismatch_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>
+// ranges::mismatch(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {})
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "test_iterators.h"
+
+template <class Iter1, class Iter2>
+constexpr void test_iterators(Iter1 begin1, Iter1 end1, Iter2 begin2, Iter2 end2, int* expected1, int* expected2) {
+  using Expected = std::ranges::mismatch_result<Iter1, Iter2>;
+  std::same_as<Expected> auto ret = std::ranges::mismatch(std::move(begin1), sentinel_wrapper<Iter1>(std::move(end1)),
+                                                          std::move(begin2), sentinel_wrapper<Iter2>(std::move(end2)));
+  assert(base(ret.in1) == expected1);
+  assert(base(ret.in2) == expected2);
+}
+
+template <class Iter1, class Iter2>
+constexpr void test_iters() {
+  int a[] = {1, 2, 3, 4, 5};
+  int b[] = {1, 2, 3, 5, 4};
+
+  test_iterators(Iter1(a), Iter1(a + 5), Iter2(b), Iter2(b + 5), a + 3, b + 3);
+}
+
+constexpr bool test() {
+  test_iters<cpp17_input_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, forward_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<cpp17_input_iterator<int*>, int*>();
+
+  test_iters<cpp20_input_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, forward_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<cpp20_input_iterator<int*>, int*>();
+
+  test_iters<forward_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<forward_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<forward_iterator<int*>, forward_iterator<int*>>();
+  test_iters<forward_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<forward_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<forward_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<forward_iterator<int*>, int*>();
+
+  test_iters<bidirectional_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, forward_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<bidirectional_iterator<int*>, int*>();
+
+  test_iters<random_access_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, forward_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<random_access_iterator<int*>, int*>();
+
+  test_iters<contiguous_iterator<int*>, cpp17_input_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, cpp20_input_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, forward_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, bidirectional_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, random_access_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, contiguous_iterator<int*>>();
+  test_iters<contiguous_iterator<int*>, int*>();
+
+  test_iters<int*, cpp17_input_iterator<int*>>();
+  test_iters<int*, cpp20_input_iterator<int*>>();
+  test_iters<int*, forward_iterator<int*>>();
+  test_iters<int*, bidirectional_iterator<int*>>();
+  test_iters<int*, random_access_iterator<int*>>();
+  test_iters<int*, contiguous_iterator<int*>>();
+  test_iters<int*, int*>();
+
+  { // test with a range
+    std::array<int, 5> a = {1, 2, 3, 4, 5};
+    std::array<int, 5> b = {1, 2, 3, 5, 4};
+    using Expected = std::ranges::mismatch_result<int*, int*>;
+    std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
+    assert(ret.in1 == a.begin() + 3);
+    assert(ret.in2 == b.begin() + 3);
+  }
+
+  { // test with non-iterator sentinel
+    int a[] = {1, 2, 3, 4, 5};
+    int b[] = {1, 2, 3, 5, 4};
+
+    using Iter = int*;
+    using Sentinel = sentinel_wrapper<Iter>;
+    using Expected = std::ranges::mismatch_result<Iter, Iter>;
+
+    std::same_as<Expected> auto r = std::ranges::mismatch(Iter(a), Sentinel(a + 5), Iter(b), Sentinel(b + 5));
+    assert(r.in1 == a + 3);
+    assert(r.in2 == b + 3);
+  }
+
+  { // test with different array sized
+    {
+      int a[] = {1, 2, 3};
+      int b[] = {1, 2};
+      test_iterators(a, a + 3, b, b + 2, a + 2, b + 2);
+      using Expected = std::ranges::mismatch_result<int*, int*>;
+      std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
+      assert(ret.in1 == a + 2);
+      assert(ret.in2 == b + 2);
+    }
+    {
+      int a[] = {1, 2};
+      int b[] = {1, 2, 3};
+      test_iterators(a, a + 2, b, b + 3, a + 2, b + 2);
+      using Expected = std::ranges::mismatch_result<int*, int*>;
+      std::same_as<Expected> auto ret = std::ranges::mismatch(a, b);
+      assert(ret.in1 == a + 2);
+      assert(ret.in2 == b + 2);
+    }
+  }
+
+  { // test with borrowed ranges
+    int r1[] = {1, 2, 3, 4, 5};
+    int r2[] = {1, 2, 3, 5, 4};
+
+    using Expected = std::ranges::mismatch_result<int*, int*>;
+    {
+      std::same_as<Expected> auto ret = std::ranges::mismatch(r1, std::views::all(r2));
+      assert(ret.in1 == r1 + 3);
+      assert(ret.in2 == r2 + 3);
+    }
+    {
+      std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), r2);
+      assert(ret.in1 == r1 + 3);
+      assert(ret.in2 == r2 + 3);
+    }
+    {
+      std::same_as<Expected> auto ret = std::ranges::mismatch(std::views::all(r1), std::views::all(r2));
+      assert(ret.in1 == r1 + 3);
+      assert(ret.in2 == r2 + 3);
+    }
+  }
+
+  { // test structured bindings
+    int a[] = {1, 2, 3, 4};
+    int b[] = {1, 2, 4, 8, 16};
+    auto [ai, bi] = std::ranges::mismatch(a, b);
+    assert(ai == a + 2);
+    assert(bi == b + 2);
+    auto [aj, bj] = std::ranges::mismatch(a, a+4, b, b+5);
+    assert(aj == a + 2);
+    assert(bj == b + 2);
+  }
+
+  { // test predicate
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a + 8, b, b + 8, std::ranges::greater{});
+      assert(ret.in1 == a + 4);
+      assert(ret.in2 == b + 4);
+      assert(*ret.in1 == 5);
+      assert(*ret.in2 == 5);
+    }
+
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, b, std::ranges::greater{});
+      assert(ret.in1 == a + 4);
+      assert(ret.in2 == b + 4);
+      assert(*ret.in1 == 5);
+      assert(*ret.in2 == 5);
+    }
+  }
+
+  { // test projection
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, b,
+                                       std::ranges::greater{},
+                                       [](int i) { return i == 5 ? +100 : i; },
+                                       [](int i) { return i == 5 ? -100 : i; });
+      assert(ret.in1 == a + 5);
+      assert(ret.in2 == b + 5);
+      assert(*ret.in1 == 1);
+      assert(*ret.in2 == 1);
+    }
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a,
+                                       std::less<double>{},
+                                       [](int i) { return i * 1.01; },
+                                       [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; });
+      assert(ret.in1 == a + 5);
+      assert(ret.in2 == a + 5);
+      assert(*ret.in1 == 1);
+      assert(*ret.in2 == 1);
+    }
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      int b[] = {6, 5, 8, 2, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a + 8, b, b + 8,
+                                       std::ranges::greater{},
+                                       [](int i) { return i == 5 ? +100 : i; },
+                                       [](int i) { return i == 5 ? -100 : i; });
+      assert(ret.in1 == a + 5);
+      assert(ret.in2 == b + 5);
+      assert(*ret.in1 == 1);
+      assert(*ret.in2 == 1);
+    }
+    {
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a + 8, a, a + 8,
+                                       std::less<double>{},
+                                       [](int i) { return i * 1.01; },
+                                       [c = 0](int i) mutable { return c++ < 5 ? i * 1.02 : i; });
+      assert(ret.in1 == a + 5);
+      assert(ret.in2 == a + 5);
+      assert(*ret.in1 == 1);
+      assert(*ret.in2 == 1);
+    }
+  }
+
+  { // test predicate and projection call count
+    {
+      int pred_count = 0;
+      int proj1_count = 0;
+      int proj2_count = 0;
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a,
+                                       [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; },
+                                       [&](int i) { ++proj1_count; return i; },
+                                       [&](int i) { ++proj2_count; return i; });
+      assert(ret.in1 == a + 8);
+      assert(ret.in2 == a + 8);
+      assert(pred_count == 8);
+      assert(proj1_count == 8);
+      assert(proj2_count == 8);
+    }
+    {
+      int pred_count = 0;
+      int proj1_count = 0;
+      int proj2_count = 0;
+      int a[] = {7, 6, 9, 3, 5, 1, 2, 4};
+      auto ret = std::ranges::mismatch(a, a + 8, a, a + 8,
+                                       [&](int lhs, int rhs) { ++pred_count; return lhs == rhs; },
+                                       [&](int i) { ++proj1_count; return i; },
+                                       [&](int i) { ++proj2_count; return i; });
+      assert(ret.in1 == a + 8);
+      assert(ret.in2 == a + 8);
+      assert(pred_count == 8);
+      assert(proj1_count == 8);
+      assert(proj2_count == 8);
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

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

 //static_assert(test(std::ranges::make_heap, a));
 //static_assert(test(std::ranges::max, a));
 //static_assert(test(std::ranges::max_element, a));
 //static_assert(test(std::ranges::merge, a, a, a));
 //static_assert(test(std::ranges::min, a));
 static_assert(test(std::ranges::min_element, a));
 //static_assert(test(std::ranges::minmax, a));
 //static_assert(test(std::ranges::minmax_element, a));
-//static_assert(test(std::ranges::mismatch, a, a));
+static_assert(test(std::ranges::mismatch, a, a));
 //static_assert(test(std::ranges::move, a, a));
 //static_assert(test(std::ranges::move_backward, a, a));
 //static_assert(test(std::ranges::next_permutation, a));
 //static_assert(test(std::ranges::none_of, a, odd));
 //static_assert(test(std::ranges::nth_element, a, a+5));
 //static_assert(test(std::ranges::partial_sort, a, a+5));
 //static_assert(test(std::ranges::partial_sort_copy, a, a));
 //static_assert(test(std::ranges::partition, a, odd));