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) El concepto std::equality_comparable especifica que los operadores de comparación == y != en T reflejan igualdad: == produce true si y solo si los operandos son iguales.

2) El concepto std::equality_comparable_with especifica que los operadores de comparación == y != en operandos (posiblemente mixtos) T y U producen resultados consistentes con la igualdad. Comparar operandos mixtos produce resultados equivalentes a comparar los operandos convertidos a su tipo común.

3) El concepto solo de exposición __WeaklyEqualityComparableWith especifica que un objeto de tipo T y un objeto de tipo U pueden compararse por igualdad entre sí (en cualquier orden) usando ambos == y !=, y los resultados de las comparaciones son consistentes.

4) El concepto solo de exposición __ComparisonCommonTypeWith especifica que dos tipos comparten un tipo común, y un const lvalue o un non-const rvalue(desde C++23) de cualquier tipo es convertible a ese tipo común.

1) std :: equality_comparable < T > se modela solo si, dados los objetos a y b de tipo T , bool ( a == b ) es true si y solo si a y b son iguales. Junto con el requisito de que a == b es que preserva la igualdad , esto implica que == es simétrico y transitivo, y además que == es reflexivo para todos los objetos a que son iguales al menos a otro objeto.

2) std :: equality_comparable_with < T, U > se modela solo si, sean

• t y t2 lvalues que denoten objetos distintos e iguales de tipos const std:: remove_reference_t < T > y std:: remove_cvref_t < T > respectivamente,
• u y u2 lvalues que denoten objetos distintos e iguales de tipos const std:: remove_reference_t < U > y std:: remove_cvref_t < U > respectivamente,
• C sea std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > ,

la siguiente expresión es verdadera:

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

3) __WeaklyEqualityComparableWith < T, U > se modela solo si, dados

• t , un lvalue de tipo const std:: remove_reference_t < T > y
• u , un lvalue de tipo const std:: remove_reference_t < U > ,

se cumplen las siguientes condiciones:

• t == u , u == t , t ! = u , u ! = t tienen el mismo dominio;
• bool ( u == t ) == bool ( t == u ) ;
• bool ( t ! = u ) == ! bool ( t == u ) ; y
• bool ( u ! = t ) == bool ( t ! = u ) .

4) __WeaklyEqualityComparableWith < T, U > se modela solo si:

El concepto correspondiente common_reference_with está modelado.

(hasta C++23)

Sea C el tipo std:: common_reference_t < const T & , const U & > , t1 y t2 expresiones que preservan la igualdad y son lvalues de tipo std:: remove_cvref_t < T > , u1 y u2 expresiones que preservan la igualdad y son lvalues de tipo std:: remove_cvref_t < U > , se cumplen las siguientes condiciones: CONVERT_TO < C > ( t1 ) es igual a CONVERT_TO < C > ( t2 ) si y solo si t1 es igual a t2 ; y CONVERT_TO < C > ( u1 ) es igual a CONVERT_TO < C > ( u2 ) si y solo si u1 es igual a u2 .

(desde C++23)