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 lvalue или non-const rvalue(начиная с C++23) любого из этих типов преобразуем в этот общий тип.

1) std :: equality_comparable < T > моделируется только тогда, когда для объектов a и b типа T , bool ( a == b ) равно true тогда и только тогда, когда a и b равны. В сочетании с требованием, что a == b является сохраняющим равенство , это подразумевает, что == является симметричным и транзитивным, а также что == является рефлексивным для всех объектов a , которые равны хотя бы одному другому объекту.

2) std :: equality_comparable_with < T, U > моделируется только если, пусть

• t и t2 будут lvalue, обозначающими различные равные объекты типов const std:: remove_reference_t < T > и std:: remove_cvref_t < T > соответственно,
• u и u2 будут lvalue, обозначающими различные равные объекты типов 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 , lvalue типа const std:: remove_reference_t < T > и
• u , lvalue типа 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 будут сохраняющими равенство выражениями, которые являются lvalue типа std:: remove_cvref_t < T > , u1 и u2 будут сохраняющими равенство выражениями, которые являются lvalue типа 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)