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 规定两个类型共享一个公共类型，并且任一类型的 const 左值或非 const 右值(自 C++23 起)可转换到该公共类型。

1) std :: equality_comparable < T > 仅在满足以下条件时被建模：给定类型 T 的对象 a 和 b ， bool ( a == b ) 为 true 当且仅当 a 和 b 相等。结合 a == b 需满足 等值保持性 的要求，这意味着 == 具有对称性和传递性，并且进一步表明对于所有至少与另一个对象相等的对象 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 起)