std::three_way_comparable, std::three_way_comparable_with

template< class T, class Cat = std::partial_ordering >
concept three_way_comparable =
    __WeaklyEqualityComparableWith<T, T> &&
    __PartiallyOrderedWith<T, T> &&
    requires(const std::remove_reference_t<T>& a,
             const std::remove_reference_t<T>& b) {
        { a <=> b } -> __ComparesAs<Cat>;
    };

template< class T, class U, class Cat = std::partial_ordering >
concept three_way_comparable_with =
    std::three_way_comparable<T, Cat> &&
    std::three_way_comparable<U, Cat> &&
    __ComparisonCommonTypeWith<T, U> &&
    std::three_way_comparable<
        std::common_reference_t<
            const std::remove_reference_t<T>&,
            const std::remove_reference_t<U>&>, Cat> &&
    __WeaklyEqualityComparableWith<T, U> &&
    __PartiallyOrderedWith<T, U> &&
    requires(const std::remove_reference_t<T>& t,
             const std::remove_reference_t<U>& u) {
        { t <=> u } -> __ComparesAs<Cat>;
        { u <=> t } -> __ComparesAs<Cat>;
    };

template< class T, class Cat >
concept __ComparesAs =
    std::same_as<std::common_comparison_category_t<T, Cat>, Cat>;

1) Концепт std::three_way_comparable определяет, что оператор трёхстороннего сравнения <=> над T даёт результаты, согласующиеся с категорией сравнения, подразумеваемой Cat.

2) Концепт std::three_way_comparable_with определяет, что оператор трёхстороннего сравнения <=> над (возможно, смешанными) операндами T и U даёт результаты, согласующиеся с категорией сравнения, подразумеваемой Cat. Сравнение смешанных операндов даёт результаты, эквивалентные сравнению операндов, преобразованных к их общему типу.

1) T и Cat моделируют std :: three_way_comparable < T, Cat > только если, для l-значений a и b типа const std:: remove_reference_t < T > , верно следующее:

• ( a <=> b == 0 ) == bool ( a == b ) ,
• ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
• ( ( a <=> b ) <=> 0 ) и ( 0 <=> ( b <=> a ) ) равны,
• bool ( a > b ) == bool ( b < a ) ,
• bool ( a >= b ) == ! bool ( a < b ) ,
• bool ( a <= b ) == ! bool ( b < a ) ,
• ( a <=> b < 0 ) == bool ( a < b ) ,
• ( a <=> b > 0 ) == bool ( a > b ) ,
• ( a <=> b <= 0 ) == bool ( a <= b ) , и
• ( a <=> b >= 0 ) == bool ( a >= b ) , и
• если Cat преобразуем в std::strong_ordering , T моделирует totally_ordered .

2) T , U , and Cat model std :: three_way_comparable_with < T, U, Cat > only if given

• t и t2 , lvalue-выражения, обозначающие различные равные объекты типов const std:: remove_reference_t < T > и std:: remove_reference_t < T > соответственно, и
• u и u2 , lvalue-выражения, обозначающие различные равные объекты типов const std:: remove_reference_t < U > и std:: remove_reference_t < U > соответственно.

Пусть C будет std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > и для данного выражения E и типа C , пусть CONVERT_TO < C > ( E ) будет:

static_cast < C > ( std:: as_const ( E ) ) .	(до C++23)
static_cast < const C & > ( std:: as_const ( E ) ) если это допустимое выражение, static_cast < const C & > ( std :: move ( E ) ) в противном случае.	(начиная с C++23)

следующие утверждения верны:

• t <=> u и u <=> t имеют одинаковую область определения,
• ( ( t <=> u ) <=> 0 ) и ( 0 <=> ( u <=> t ) ) равны,
• ( t <=> u == 0 ) == bool ( t == u ) ,
• ( t <=> u ! = 0 ) == bool ( t ! = u ) ,
• Cat ( t <=> u ) == Cat ( CONVERT_TO < C > ( t2 ) <=> CONVERT_TO < C > ( u2 ) ) ,
• ( t <=> u < 0 ) == bool ( t < u ) ,
• ( t <=> u > 0 ) == bool ( t > u ) ,
• ( t <=> u <= 0 ) == bool ( t <= u ) ,
• ( t <=> u >= 0 ) == bool ( t >= u ) , и
• если Cat преобразуется в std::strong_ordering , T и U моделируют std:: totally_ordered_with < T, U > .