[libcxx] adds concepts std::equality_comparable[_with]

[cjdb]

Summary

Implements parts of:

• P0898R3 Standard Library Concepts
• P1754 Rename concepts to standard_case for C++20, while we still can

Depends on D96660

[Mordante]

I like the extensive set of tests you added! I'd like to see the build pass before accepting.

libcxx/include/concepts

232

t -> __t and u -> __u

[cjdb]

fixes CI problem

[cjdb]

Uglifies names

[ldionne]

The patch LGTM, but we should fix the GCC CI before committing.

[cjdb]

rebases to activate CI

[cjdb]

fixes GCC build errors:

• guards against missing std::mutex/std::lock_guard
• completes S type since GCC doesn't handle that https://godbolt.org/z/5x5n5z.

[• Quuxplusone]

Just some nits on tests. The concept definition looks like a straightforward transliteration of
http://eel.is/c++draft/concept.booleantestable
http://eel.is/c++draft/concept.equalitycomparable
so LGTM.

libcxx/test/std/concepts/comparison/types.h

15

Would anything change if this operator were explicit? In production code I would expect their operator bool to be explicit, because all constructors and conversions should always be explicit (and for bool conversions in particular, the explicit doesn't normally get in the way, because contextual conversion to bool).

50

Utter nit: I don't think most production code would bother to mark operator== as noexcept, so unless some test is relying on this, it might be better to remove the noexcept (for realism and to save characters). Or put it on some and not others (but with a comment explaining that that's on purpose).

friend int operator==(explicit_operators, eq_neq_different_return_types);

is already missing the noexcept, but without the comment explaining that it was on purpose. ;)

85

I'd say deleted_ne. This case is (intentionally) non-parallel to the no_eq case above.

163

Should this == say !=? At a glance, I have no idea what the overload set ends up looking like here. Which if that's the point, it needs a comment. ;)

[cjdb]

libcxx/test/std/concepts/comparison/types.h

15

Yes. boolean-testable refines convertible_to<T, bool>[1], which requires T be both implicitly and explicitly convertible to bool. Would you like an explicit_bool test as well?

[1]: http://eel.is/c++draft/concept.booleantestable

85

I intended them to mirror one another, so I'm not sure I understand what you're getting at.

163

Hmm... good point. I had to stop and think about it for a moment myself, so I agree some documentation is necessary (probably a static_assert to prove my intentions and code match). The overload set should look like this:

bool operator==(one_way_ne const&) const&;
bool operator!=(one_way_ne const&) const&; // generated

bool operator==(one_way_ne, explicit_operators);
bool operator!=(one_way_ne, explicit_operators) = delete;
bool operator==(explicit_operators), one_way_ne); // generated

[• Quuxplusone]

libcxx/test/std/concepts/comparison/types.h

85

no_neq has both an operator== and an operator!=, so when you try to do x != x you get the user-provided operator!= — which happens to be deleted, so x != x is ill-formed.

no_eq has an operator!= and no operator==, so when you try to do x == x... well, okay, I had thought that you'd get a synthesized candidate (if I'm using that term right) formed by negating x != x. I see from Godbolt that that doesn't actually happen. So indeed, x == x also ends up ill-formed.

IOW I was assuming that this asymmetry would materially affect your test results... but it seems that it doesn't really affect them as much as I thought. So nvm.

[cjdb]

• fixes <mutex> problem (hopefully).
• applies @Quuxplusone's feedback.
• adds a few extra boolean-testable tests per @Mordante's request in D96477.

libcxx/test/std/concepts/comparison/types.h

50

Maybe I'm in some niche for putting noexcept everywhere possible (I am apparently for top-level const). I've added a comment on line 14.

85

Yeah, only operator== and operator<=> have magical powers 🤷

163

PTAL

[• Quuxplusone]

LGTM!
(Obnitpick: I see a mix of auto operator== and bool operator==. Is auto operator== good C++20 style? Anyway, I don't think it ever matters for this particular test.)

[cjdb]

In D97176#2604693, @Quuxplusone wrote:

LGTM!
(Obnitpick: I see a mix of auto operator== and bool operator==. Is auto operator== good C++20 style? Anyway, I don't think it ever matters for this particular test.)

auto operator==(...) = default is ill-formed (it must be bool), but auto operator<=>(...) = default is allowed (the compiler will do magic to work out which of the three blessed types it'll be).

[• Quuxplusone]

libcxx/test/std/concepts/comparison/types.h

130

@cjdb: Here's a remaining auto operator==. You said a defaulted operator== should always be bool — yep, paper standard says https://eel.is/c++draft/class.eq#1 — but I was originally asking about all instances of operator==/operator!= in this file, including non-defaulted and deleted ones.

Looks like all vendors currently accept =delete'd functions with auto return types, and they're probably correct to do so. But I still think stylistically it would be preferable to say bool here.

(An interesting question, whose answer I don't currently know, is whether the difference between putting auto and bool here is detectable by a well-formed program.)

libcxx/include/concepts

 concept default_initializable = constructible_from<_Tp> &&
     requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
 template<class _Tp>
 concept move_constructible =
   constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
+// [concept.booleantestable]
+template<class _Tp>
+concept __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+template<class _Tp>
+concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
+  { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
+};
+
+// [concept.equalitycomparable]
+template<class _Tp, class _Up>
+concept __weakly_equality_comparable_with =
+  requires(const remove_reference_t<_Tp>& __t, const remove_reference_t<_Up>& __u) {
+    { __t == __u } -> __boolean_testable;
+    { __t != __u } -> __boolean_testable;
+    { __u == __t } -> __boolean_testable;
+    { __u != __t } -> __boolean_testable;
+  };
+
+template<class _Tp>
+concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
+
+template<class _Tp, class _Up>
+concept equality_comparable_with =
+  equality_comparable<_Tp> && equality_comparable<_Up> &&
+  common_reference_with<const remove_reference_t<_Tp>&, const remove_reference_t<_Up>&> &&
+  equality_comparable<
+    common_reference_t<
+      const remove_reference_t<_Tp>&,
+      const remove_reference_t<_Up>&>> &&
+  __weakly_equality_comparable_with<_Tp, _Up>;
+
 // [concept.copyconstructible]
 template<class _Tp>
 concept copy_constructible =
   move_constructible<_Tp> &&
   constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
   constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
 

libcxx/test/std/concepts/comparison/concepts.equalitycomparable/equality_comparable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T>
+// concept equality_comparable = // see below
+
+#include <concepts>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../types.h"
+
+namespace fundamentals {
+static_assert(std::equality_comparable<int>);
+static_assert(std::equality_comparable<double>);
+static_assert(std::equality_comparable<void*>);
+static_assert(std::equality_comparable<char*>);
+static_assert(std::equality_comparable<char const*>);
+static_assert(std::equality_comparable<char volatile*>);
+static_assert(std::equality_comparable<char const volatile*>);
+static_assert(std::equality_comparable<wchar_t&>);
+static_assert(std::equality_comparable<char8_t const&>);
+static_assert(std::equality_comparable<char16_t volatile&>);
+static_assert(std::equality_comparable<char32_t const volatile&>);
+static_assert(std::equality_comparable<unsigned char&&>);
+static_assert(std::equality_comparable<unsigned short const&&>);
+static_assert(std::equality_comparable<unsigned int volatile&&>);
+static_assert(std::equality_comparable<unsigned long const volatile&&>);
+static_assert(std::equality_comparable<int[5]>);
+static_assert(std::equality_comparable<int (*)(int)>);
+static_assert(std::equality_comparable<int (&)(int)>);
+static_assert(std::equality_comparable<int (*)(int) noexcept>);
+static_assert(std::equality_comparable<int (&)(int) noexcept>);
+static_assert(std::equality_comparable<std::nullptr_t>);
+
+struct S {};
+static_assert(std::equality_comparable<int S::*>);
+static_assert(std::equality_comparable<int (S::*)()>);
+static_assert(std::equality_comparable<int (S::*)() noexcept>);
+static_assert(std::equality_comparable<int (S::*)() &>);
+static_assert(std::equality_comparable<int (S::*)() & noexcept>);
+static_assert(std::equality_comparable<int (S::*)() &&>);
+static_assert(std::equality_comparable<int (S::*)() && noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const>);
+static_assert(std::equality_comparable<int (S::*)() const noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const&>);
+static_assert(std::equality_comparable<int (S::*)() const & noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const&&>);
+static_assert(std::equality_comparable<int (S::*)() const && noexcept>);
+static_assert(std::equality_comparable<int (S::*)() volatile>);
+static_assert(std::equality_comparable<int (S::*)() volatile noexcept>);
+static_assert(std::equality_comparable<int (S::*)() volatile&>);
+static_assert(std::equality_comparable<int (S::*)() volatile & noexcept>);
+static_assert(std::equality_comparable<int (S::*)() volatile&&>);
+static_assert(std::equality_comparable<int (S::*)() volatile && noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const volatile>);
+static_assert(std::equality_comparable<int (S::*)() const volatile noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const volatile&>);
+static_assert(std::equality_comparable<int (S::*)() const volatile & noexcept>);
+static_assert(std::equality_comparable<int (S::*)() const volatile&&>);
+static_assert(
+    std::equality_comparable<int (S::*)() const volatile && noexcept>);
+
+static_assert(!std::equality_comparable<void>);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(std::equality_comparable<std::array<int, 10> >);
+static_assert(std::equality_comparable<std::deque<int> >);
+static_assert(std::equality_comparable<std::forward_list<int> >);
+static_assert(std::equality_comparable<std::list<int> >);
+static_assert(!std::equality_comparable<std::lock_guard<std::mutex> >);
+static_assert(std::equality_comparable<std::map<int, void*> >);
+static_assert(!std::equality_comparable<std::mutex>);
+static_assert(std::equality_comparable<std::optional<int> >);
+static_assert(
+    !std::equality_comparable<std::optional<std::lock_guard<std::mutex> > >);
+static_assert(!std::equality_comparable<std::optional<std::mutex> >);
+static_assert(std::equality_comparable<std::set<int> >);
+static_assert(std::equality_comparable<std::unordered_map<int, void*> >);
+static_assert(std::equality_comparable<std::unordered_set<int> >);
+static_assert(std::equality_comparable<std::vector<bool> >);
+static_assert(std::equality_comparable<std::vector<int> >);
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+static_assert(std::equality_comparable<cxx20_member_eq>);
+static_assert(std::equality_comparable<cxx20_friend_eq>);
+static_assert(std::equality_comparable<member_three_way_comparable>);
+static_assert(std::equality_comparable<friend_three_way_comparable>);
+static_assert(std::equality_comparable<explicit_operators>);
+static_assert(std::equality_comparable<eq_neq_different_return_types>);
+static_assert(std::equality_comparable<one_member_one_friend>);
+static_assert(std::equality_comparable<equality_comparable_with_ec1>);
+
+static_assert(!std::equality_comparable<no_eq>);
+static_assert(!std::equality_comparable<no_neq>);
+static_assert(!std::equality_comparable<wrong_return_type_eq>);
+static_assert(!std::equality_comparable<wrong_return_type_ne>);
+static_assert(!std::equality_comparable<wrong_return_type>);
+static_assert(
+    !std::equality_comparable<cxx20_member_eq_operator_with_deleted_ne>);
+static_assert(
+    !std::equality_comparable<cxx20_friend_eq_operator_with_deleted_ne>);
+static_assert(
+    !std::equality_comparable<member_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !std::equality_comparable<member_three_way_comparable_with_deleted_ne>);
+static_assert(
+    !std::equality_comparable<friend_three_way_comparable_with_deleted_eq>);
+static_assert(
+    !std::equality_comparable<friend_three_way_comparable_with_deleted_ne>);
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/comparison/concepts.equalitycomparable/equality_comparable_with.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// template<class T, class U>
+// concept equality_comparable_with = // see below
+
+#include <concepts>
+
+#include <array>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../types.h"
+
+template <class T, class U>
+constexpr bool check_equality_comparable_with() {
+  constexpr bool result = std::equality_comparable_with<T, U>;
+  static_assert(std::equality_comparable_with<U, T> == result);
+  static_assert(std::equality_comparable_with<T, U const> == result);
+  static_assert(std::equality_comparable_with<T const, U const> == result);
+  static_assert(std::equality_comparable_with<T, U const&> == result);
+  static_assert(std::equality_comparable_with<T const, U const&> == result);
+  static_assert(std::equality_comparable_with<T&, U const> == result);
+  static_assert(std::equality_comparable_with<T const&, U const> == result);
+  static_assert(std::equality_comparable_with<T&, U const&> == result);
+  static_assert(std::equality_comparable_with<T const&, U const&> == result);
+  static_assert(std::equality_comparable_with<T, U const&&> == result);
+  static_assert(std::equality_comparable_with<T const, U const&&> == result);
+  static_assert(std::equality_comparable_with<T&, U const&&> == result);
+  static_assert(std::equality_comparable_with<T const&, U const&&> == result);
+  static_assert(std::equality_comparable_with<T&&, U const> == result);
+  static_assert(std::equality_comparable_with<T const&&, U const> == result);
+  static_assert(std::equality_comparable_with<T&&, U const&> == result);
+  static_assert(std::equality_comparable_with<T const&&, U const&> == result);
+  static_assert(std::equality_comparable_with<T&&, U const&&> == result);
+  static_assert(std::equality_comparable_with<T const&&, U const&&> == result);
+  return result;
+}
+
+namespace fundamentals {
+static_assert(check_equality_comparable_with<int, int>());
+static_assert(check_equality_comparable_with<int, bool>());
+static_assert(check_equality_comparable_with<int, char>());
+static_assert(check_equality_comparable_with<int, wchar_t>());
+static_assert(check_equality_comparable_with<int, double>());
+static_assert(!check_equality_comparable_with<int, int*>());
+static_assert(!check_equality_comparable_with<int, int[5]>());
+static_assert(!check_equality_comparable_with<int, int (*)()>());
+static_assert(!check_equality_comparable_with<int, int (&)()>());
+
+struct S {};
+static_assert(!check_equality_comparable_with<int, int S::*>());
+static_assert(!check_equality_comparable_with<int, int (S::*)()>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int, int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const volatile &
+                                                       noexcept>());
+static_assert(!check_equality_comparable_with<int, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int, int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int*, int*>());
+static_assert(check_equality_comparable_with<int*, int[5]>());
+static_assert(!check_equality_comparable_with<int*, int (*)()>());
+static_assert(!check_equality_comparable_with<int*, int (&)()>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)()>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int*, int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int*, int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int*, int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int*,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int[5], int[5]>());
+static_assert(!check_equality_comparable_with<int[5], int (*)()>());
+static_assert(!check_equality_comparable_with<int[5], int (&)()>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)()>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int[5], int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile &
+                                                          noexcept>());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int[5], int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int[5], int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int[5],
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (*)(), int (*)()>());
+static_assert(check_equality_comparable_with<int (*)(), int (&)()>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)()>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (*)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() volatile &
+                                                             noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (*)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (*)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (*)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (&)(), int (&)()>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)()>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() const>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (&)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() volatile &
+                                                             noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (&)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (&)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (&)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (&)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)(), int (S::*)()>());
+static_assert(
+    check_equality_comparable_with<int (S::*)(), int (S::*)() noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)(), int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)(),
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)(),
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() noexcept,
+                                             int (S::*)() noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() noexcept, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const, int (S::*)() const>());
+static_assert(check_equality_comparable_with<int (S::*)() const,
+                                             int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const noexcept,
+                                             int (S::*)() const noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const noexcept, int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const noexcept,
+                                    int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile,
+                                             int (S::*)() volatile>());
+static_assert(check_equality_comparable_with<int (S::*)() volatile,
+                                             int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() const volatile noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() volatile, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                             int (S::*)() volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile,
+                                             int (S::*)() const volatile>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile,
+                                   int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() &>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                   int (S::*)() const volatile noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() &>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() const&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile noexcept, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile noexcept,
+                                    int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() &, int (S::*)() &>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() &, int (S::*)() & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() &, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() &, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() && noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() & noexcept,
+                                             int (S::*)() & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const&>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() & noexcept, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const&, int (S::*)() const&>());
+static_assert(check_equality_comparable_with<int (S::*)() const&,
+                                             int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const&, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const volatile&>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const&, int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const&, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const & noexcept,
+                                             int (S::*)() const & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const & noexcept,
+                                    int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile&,
+                                             int (S::*)() volatile&>());
+static_assert(check_equality_comparable_with<
+              int (S::*)() volatile&, int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile&,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile&, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                   int (S::*)() volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const volatile&>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                    int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile&,
+                                             int (S::*)() const volatile&>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile&,
+                                   int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                   int (S::*)() const volatile & noexcept>());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() &&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() && noexcept > ());
+static_assert(!check_equality_comparable_with<
+              int (S::*)() const volatile & noexcept, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                    int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
+                                    int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)()
+                                                    const volatile& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() &&, int (S::*)() &&>());
+static_assert(check_equality_comparable_with<int (S::*)() &&,
+                                             int (S::*)() && noexcept>());
+static_assert(
+    !check_equality_comparable_with<int (S::*)() &&, int (S::*)() const&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() &&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() &&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() && noexcept,
+                                             int (S::*)() && noexcept>());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const&&,
+                                             int (S::*)() const&&>());
+static_assert(check_equality_comparable_with<int (S::*)() const&&,
+                                             int (S::*)() const && noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() const&&,
+                                              int (S::*)() volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&&,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with<int (S::*)() const&&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const && noexcept,
+                                             int (S::*)() const && noexcept>());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() volatile&& noexcept > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() volatile&&,
+                                             int (S::*)() volatile&&>());
+static_assert(check_equality_comparable_with<
+              int (S::*)() volatile&&, int (S::*)() volatile && noexcept>());
+static_assert(!check_equality_comparable_with<int (S::*)() volatile&&,
+                                              int (S::*)() const volatile&&>());
+static_assert(!check_equality_comparable_with < int (S::*)() volatile&&,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(
+    check_equality_comparable_with<int (S::*)() volatile && noexcept,
+                                   int (S::*)() volatile && noexcept>());
+static_assert(!check_equality_comparable_with <
+                  int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& > ());
+static_assert(!check_equality_comparable_with <
+                  int (S::*)() volatile&& noexcept,
+              int (S::*)() const volatile&& noexcept > ());
+
+static_assert(check_equality_comparable_with<int (S::*)() const volatile&&,
+                                             int (S::*)() const volatile&&>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile&&,
+                                   int (S::*)() const volatile && noexcept>());
+static_assert(
+    check_equality_comparable_with<int (S::*)() const volatile && noexcept,
+                                   int (S::*)() const volatile && noexcept>());
+
+static_assert(!check_equality_comparable_with<std::nullptr_t, int>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int*>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int[5]>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int (*)()>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int (&)()>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)()>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() const>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() volatile noexcept>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const volatile>());
+static_assert(check_equality_comparable_with<
+              std::nullptr_t, int (S::*)() const volatile noexcept>());
+static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)() &>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() & noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() const&>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const & noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&>());
+static_assert(check_equality_comparable_with<
+              std::nullptr_t, int (S::*)() volatile & noexcept>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const volatile&>());
+static_assert(check_equality_comparable_with<
+              std::nullptr_t, int (S::*)() const volatile & noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() &&>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() && noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() const&&>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const && noexcept>());
+static_assert(
+    check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&&>());
+static_assert(check_equality_comparable_with<
+              std::nullptr_t, int (S::*)() volatile && noexcept>());
+static_assert(check_equality_comparable_with<std::nullptr_t,
+                                             int (S::*)() const volatile&&>());
+static_assert(check_equality_comparable_with<
+              std::nullptr_t, int (S::*)() const volatile && noexcept>());
+
+static_assert(!std::equality_comparable_with<void, int>);
+static_assert(!std::equality_comparable_with<void, int*>);
+static_assert(!std::equality_comparable_with<void, std::nullptr_t>);
+static_assert(!std::equality_comparable_with<void, int[5]>);
+static_assert(!std::equality_comparable_with<void, int (*)()>);
+static_assert(!std::equality_comparable_with<void, int (&)()>);
+static_assert(!std::equality_comparable_with<void, int S::*>);
+static_assert(!std::equality_comparable_with<void, int (S::*)()>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() const>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() volatile>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() volatile noexcept>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const volatile>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const volatile noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() &>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() & noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() const&>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const & noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() volatile & noexcept>);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const volatile&>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() const volatile &
+                                                       noexcept>);
+static_assert(!std::equality_comparable_with<void, int (S::*)() &&>);
+static_assert(!std::equality_comparable_with < void,
+              int (S::*)() && noexcept >);
+static_assert(!std::equality_comparable_with<void, int (S::*)() const&&>);
+static_assert(!std::equality_comparable_with < void,
+              int (S::*)() const&& noexcept >);
+static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&&>);
+static_assert(!std::equality_comparable_with < void,
+              int (S::*)() volatile&& noexcept >);
+static_assert(
+    !std::equality_comparable_with<void, int (S::*)() const volatile&&>);
+static_assert(!std::equality_comparable_with < void,
+              int (S::*)() const volatile&& noexcept >);
+} // namespace fundamentals
+
+namespace standard_types {
+static_assert(check_equality_comparable_with<std::array<int, 10>,
+                                             std::array<int, 10> >());
+static_assert(!check_equality_comparable_with<std::array<int, 10>,
+                                              std::array<double, 10> >());
+static_assert(
+    check_equality_comparable_with<std::deque<int>, std::deque<int> >());
+static_assert(
+    !check_equality_comparable_with<std::deque<int>, std::vector<int> >());
+static_assert(check_equality_comparable_with<std::forward_list<int>,
+                                             std::forward_list<int> >());
+static_assert(!check_equality_comparable_with<std::forward_list<int>,
+                                              std::vector<int> >());
+static_assert(
+    check_equality_comparable_with<std::list<int>, std::list<int> >());
+static_assert(
+    !check_equality_comparable_with<std::list<int>, std::vector<int> >());
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
+                                              std::lock_guard<std::mutex> >());
+static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
+                                              std::vector<int> >());
+#endif
+
+static_assert(check_equality_comparable_with<std::map<int, void*>,
+                                             std::map<int, void*> >());
+static_assert(
+    !check_equality_comparable_with<std::map<int, void*>, std::vector<int> >());
+static_assert(!check_equality_comparable_with<std::mutex, std::mutex>());
+static_assert(!check_equality_comparable_with<std::mutex, std::vector<int> >());
+static_assert(
+    check_equality_comparable_with<std::optional<std::vector<int> >,
+                                   std::optional<std::vector<int> > >());
+static_assert(check_equality_comparable_with<std::optional<std::vector<int> >,
+                                             std::vector<int> >());
+static_assert(
+    check_equality_comparable_with<std::vector<int>, std::vector<int> >());
+static_assert(!check_equality_comparable_with<std::vector<int>, int>());
+} // namespace standard_types
+
+namespace types_fit_for_purpose {
+static_assert(
+    check_equality_comparable_with<cxx20_member_eq, cxx20_member_eq>());
+static_assert(
+    check_equality_comparable_with<cxx20_friend_eq, cxx20_friend_eq>());
+static_assert(
+    !check_equality_comparable_with<cxx20_member_eq, cxx20_friend_eq>());
+
+static_assert(check_equality_comparable_with<member_three_way_comparable,
+                                             member_three_way_comparable>());
+static_assert(check_equality_comparable_with<friend_three_way_comparable,
+                                             friend_three_way_comparable>());
+static_assert(!check_equality_comparable_with<member_three_way_comparable,
+                                              friend_three_way_comparable>());
+
+static_assert(
+    check_equality_comparable_with<explicit_operators, explicit_operators>());
+static_assert(check_equality_comparable_with<equality_comparable_with_ec1,
+                                             equality_comparable_with_ec1>());
+static_assert(check_equality_comparable_with<eq_neq_different_return_types,
+                                             eq_neq_different_return_types>());
+static_assert(check_equality_comparable_with<explicit_operators,
+                                             equality_comparable_with_ec1>());
+static_assert(check_equality_comparable_with<explicit_operators,
+                                             eq_neq_different_return_types>());
+
+static_assert(check_equality_comparable_with<one_way_eq, one_way_eq>());
+static_assert(
+    std::common_reference_with<one_way_eq const&, explicit_operators const&>);
+static_assert(
+    !check_equality_comparable_with<one_way_eq, explicit_operators>());
+
+static_assert(check_equality_comparable_with<one_way_ne, one_way_ne>());
+static_assert(
+    std::common_reference_with<one_way_ne const&, explicit_operators const&>);
+static_assert(
+    !check_equality_comparable_with<one_way_ne, explicit_operators>());
+} // namespace types_fit_for_purpose
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/comparison/types.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 TEST_STD_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H
+#define TEST_STD_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H
+
+#include <compare>
+#include <concepts>
+
+struct boolean {
+  operator bool() const noexcept;
+};
+
+struct equality_comparable_with_ec1;
+struct no_neq;
+
+struct cxx20_member_eq {
+  bool operator==(cxx20_member_eq const&) const = default;
+};
+
+struct cxx20_friend_eq {
+  friend bool operator==(cxx20_friend_eq const&,
+                         cxx20_friend_eq const&) = default;
+};
+
+struct member_three_way_comparable {
+  auto operator<=>(member_three_way_comparable const&) const = default;
+};
+
+struct friend_three_way_comparable {
+  friend auto operator<=>(friend_three_way_comparable const&,
+                          friend_three_way_comparable const&) = default;
+};
+
+struct explicit_operators {
+  friend bool operator==(explicit_operators, explicit_operators) noexcept;
+  friend bool operator!=(explicit_operators, explicit_operators) noexcept;
+
+  friend bool operator==(explicit_operators const&,
+                         equality_comparable_with_ec1 const&) noexcept;
+  friend bool operator==(equality_comparable_with_ec1 const&,
+                         explicit_operators const&) noexcept;
+  friend bool operator!=(explicit_operators const&,
+                         equality_comparable_with_ec1 const&) noexcept;
+  friend bool operator!=(equality_comparable_with_ec1 const&,
+                         explicit_operators const&) noexcept;
+};
+
+struct eq_neq_different_return_types {
+  int operator==(eq_neq_different_return_types) const noexcept;
+  friend long operator!=(eq_neq_different_return_types,
+                         eq_neq_different_return_types) noexcept;
+
+  friend int operator==(explicit_operators, eq_neq_different_return_types);
+  friend int operator==(eq_neq_different_return_types, explicit_operators);
+  friend long operator!=(explicit_operators, eq_neq_different_return_types);
+  friend long operator!=(eq_neq_different_return_types, explicit_operators);
+
+  operator explicit_operators() const;
+};
+
+struct one_member_one_friend {
+  friend boolean operator==(one_member_one_friend,
+                            one_member_one_friend) noexcept;
+  boolean operator!=(one_member_one_friend) const noexcept;
+
+  operator explicit_operators() const noexcept;
+  operator eq_neq_different_return_types() const noexcept;
+};
+
+struct equality_comparable_with_ec1 {
+  bool operator==(equality_comparable_with_ec1) const noexcept;
+  bool operator!=(equality_comparable_with_ec1) const noexcept;
+  operator explicit_operators() const noexcept;
+};
+
+struct no_eq {
+  friend bool operator!=(no_eq, no_eq) noexcept;
+};
+
+struct no_neq {
+  friend bool operator==(no_neq, no_neq) noexcept;
+  friend bool operator!=(no_neq, no_neq) = delete;
+};
+
+struct wrong_return_type_eq {
+  void operator==(wrong_return_type_eq) const noexcept;
+  bool operator!=(wrong_return_type_eq) const noexcept;
+};
+
+struct wrong_return_type_ne {
+  bool operator==(wrong_return_type_ne) const noexcept;
+  void operator!=(wrong_return_type_ne) const noexcept;
+};
+
+struct wrong_return_type {
+  void operator==(wrong_return_type) const noexcept;
+  void operator!=(wrong_return_type) const noexcept;
+};
+
+struct cxx20_member_eq_operator_with_deleted_ne {
+  bool
+  operator==(cxx20_member_eq_operator_with_deleted_ne const&) const = default;
+  bool
+  operator!=(cxx20_member_eq_operator_with_deleted_ne const&) const = delete;
+};
+
+struct cxx20_friend_eq_operator_with_deleted_ne {
+  friend bool
+  operator==(cxx20_friend_eq_operator_with_deleted_ne const&,
+             cxx20_friend_eq_operator_with_deleted_ne const&) = default;
+  friend bool
+  operator!=(cxx20_friend_eq_operator_with_deleted_ne const&,
+             cxx20_friend_eq_operator_with_deleted_ne const&) = delete;
+};
+
+struct member_three_way_comparable_with_deleted_eq {
+  auto operator<=>(member_three_way_comparable_with_deleted_eq const&) const =
+      default;
+  auto
+  operator==(member_three_way_comparable_with_deleted_eq const&) const = delete;
+};
+
+struct member_three_way_comparable_with_deleted_ne {
+  auto operator<=>(member_three_way_comparable_with_deleted_ne const&) const =
+      default;
+  auto
+  operator!=(member_three_way_comparable_with_deleted_ne const&) const = delete;
+};
+
+struct friend_three_way_comparable_with_deleted_eq {
+  friend auto
+  operator<=>(friend_three_way_comparable_with_deleted_eq const&,
+              friend_three_way_comparable_with_deleted_eq const&) = default;
+  friend auto
+  operator==(friend_three_way_comparable_with_deleted_eq const&,
+             friend_three_way_comparable_with_deleted_eq const&) = delete;
+};
+
+struct friend_three_way_comparable_with_deleted_ne {
+  friend auto
+  operator<=>(friend_three_way_comparable_with_deleted_ne const&,
+              friend_three_way_comparable_with_deleted_ne const&) = default;
+  friend auto
+  operator!=(friend_three_way_comparable_with_deleted_ne const&,
+             friend_three_way_comparable_with_deleted_ne const&) = delete;
+};
+
+struct one_way_eq {
+  bool operator==(one_way_eq const&) const = default;
+  friend bool operator==(one_way_eq, explicit_operators);
+  friend bool operator==(explicit_operators, one_way_eq) = delete;
+
+  operator explicit_operators() const;
+};
+
+struct one_way_ne {
+  bool operator==(one_way_ne const&) const = default;
+  friend bool operator==(one_way_ne, explicit_operators);
+  friend bool operator!=(one_way_ne, explicit_operators) = delete;
+
+  operator explicit_operators() const;
+};
+
+#endif // TEST_STD_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H