std::equality_comparable, std::equality_comparable_with

template< class T >
concept equality_comparable = __WeaklyEqualityComparableWith<T, T>;

template< class T, class U >
concept equality_comparable_with =
    std::equality_comparable<T> &&
    std::equality_comparable<U> &&
    __ComparisonCommonTypeWith<T, U> &&
    std::equality_comparable<
        std::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>> &&
    __WeaklyEqualityComparableWith<T, U>;

template< class T, class U >
concept __WeaklyEqualityComparableWith =
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
        { t == u } -> boolean-testable;
        { t != u } -> boolean-testable;
        { u == t } -> boolean-testable;
        { u != t } -> boolean-testable;
    };

template< class T, class U >
concept __ComparisonCommonTypeWith =
    std::common_reference_with<
        const std::remove_reference_t<T>&,
        const std::remove_reference_t<U>&>;

template< class T, class U, class C = std::common_reference_t<const T&, const U&> >
concept _ComparisonCommonTypeWithImpl =
    std::same_as<std::common_reference_t<const T&, const U&>,
                 std::common_reference_t<const U&, const T&>> &&
    requires {
        requires std::convertible_to<const T&, const C&> ||
            std::convertible_to<T, const C&>;
        requires std::convertible_to<const U&, const C&> ||
            std::convertible_to<U, const C&>;
    };
template< class T, class U >
concept __ComparisonCommonTypeWith =
    _ComparisonCommonTypeWithImpl<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;

1) コンセプト std::equality_comparable は、比較演算子 == と != に対する T が等価性を反映することを指定します: == は true を返し、被演算子が等しい場合に限ります。

2) コンセプト std::equality_comparable_with は、比較演算子 == と != を (混合される可能性のある) T と U の被演算子が等価性と一致する結果を生成します。混合された被演算子の比較は、それらを共通の型に変換した被演算子を比較するのと同等の結果を生成します。

3) 説明専用コンセプト __WeaklyEqualityComparableWith は、型 T のオブジェクトと型 U のオブジェクトは、互いに等価性を (任意の順序で) 比較でき、その際に == と != を使用し、比較の結果が一貫していることを指定します。

4) 説明専用コンセプト __ComparisonCommonTypeWith は、2つの型が共通の型を共有し、const 左辺値 または非 const 右辺値(since C++23) のいずれかの型がその共通の型に変換可能であることを指定します。

1) std :: equality_comparable < T > は、型Tのオブジェクトaおよびbが与えられたとき、aとbが等価である場合にのみ bool ( a == b ) が true となる場合にのみモデル化される。 equality-preserving （等価性保存）の要件と合わせて、これは==が対称的かつ推移的であることを意味し、さらに少なくとも1つの他のオブジェクトと等価なすべてのオブジェクトaに対して==が反射的であることを示す。

2) std :: equality_comparable_with < T, U > は、以下の条件が満たされる場合にのみモデル化される：

• t と t2 を、それぞれ型 const std:: remove_reference_t < T > および std:: remove_cvref_t < T > の、互いに等しいが異なるオブジェクトを表す左辺値とし、
• u と u2 を、それぞれ型 const std:: remove_reference_t < U > および std:: remove_cvref_t < U > の、互いに等しいが異なるオブジェクトを表す左辺値とし、
• C を std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > とするとき、

以下の式が真となる：

• bool ( t == u ) == bool ( CONVERT_TO < C > ( t2 ) == CONVERT_TO < C > ( u2 ) ) 。

3) __WeaklyEqualityComparableWith < T, U > がモデル化されるのは、以下の条件が与えられた場合のみです：

• t 、型 const std:: remove_reference_t < T > の左辺値、および
• u 、型 const std:: remove_reference_t < U > の左辺値が与えられたとき、

以下が真である場合です：

• t == u 、 u == t 、 t ! = u 、 u ! = t が同じ定義域を持つこと；
• bool ( u == t ) == bool ( t == u ) ；
• bool ( t ! = u ) == ! bool ( t == u ) ；および
• bool ( u ! = t ) == bool ( t ! = u ) 。

4) __WeaklyEqualityComparableWith < T, U > は以下の場合にのみモデル化される：

対応する common_reference_with コンセプトがモデル化されている場合。	(C++23まで)
以下を定義する： C を std:: common_reference_t < const T & , const U & > とする、 t1 と t2 を型 std:: remove_cvref_t < T > の左辺値であり 等価性を保存する 式とする、 u1 と u2 を型 std:: remove_cvref_t < U > の左辺値であり 等価性を保存する 式とする、 以下の条件が満たされること： CONVERT_TO < C > ( t1 ) が CONVERT_TO < C > ( t2 ) と等しいのは t1 が t2 と等しい場合に限る；かつ CONVERT_TO < C > ( u1 ) が CONVERT_TO < C > ( u2 ) と等しいのは u1 が u2 と等しい場合に限る。	(C++23以降)