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) Le concept std::three_way_comparable spécifie que l'opérateur de comparaison à trois voies <=> sur T produit des résultats cohérents avec la catégorie de comparaison impliquée par Cat.

2) Le concept std::three_way_comparable_with spécifie que l'opérateur de comparaison à trois voies <=> sur les opérandes (éventuellement mixtes) T et U produit des résultats cohérents avec la catégorie de comparaison impliquée par Cat. La comparaison d'opérandes mixtes produit des résultats équivalents à la comparaison des opérandes convertis en leur type commun.

1) T et Cat modélisent std :: three_way_comparable < T, Cat > seulement si, étant donné des lvalues a et b de type const std:: remove_reference_t < T > , les conditions suivantes sont vraies :

• ( a <=> b == 0 ) == bool ( a == b ) ,
• ( a <=> b ! = 0 ) == bool ( a ! = b ) ,
• ( ( a <=> b ) <=> 0 ) et ( 0 <=> ( b <=> a ) ) sont égaux,
• 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 ) , et
• ( a <=> b >= 0 ) == bool ( a >= b ) , et
• si Cat est convertible en std::strong_ordering , T modélise totally_ordered .

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

• t et t2 , des lvalues désignant des objets distincts mais égaux de types const std:: remove_reference_t < T > et std:: remove_reference_t < T > respectivement, et
• u et u2 , des lvalues désignant des objets distincts mais égaux de types const std:: remove_reference_t < U > et std:: remove_reference_t < U > respectivement.

Soit C le type std:: common_reference_t < const std:: remove_reference_t < T > & , const std:: remove_reference_t < U > & > et étant donné une expression E et un type C , soit CONVERT_TO < C > ( E ) défini comme suit :

static_cast < C > ( std:: as_const ( E ) ) .	(jusqu'à C++23)
static_cast < const C & > ( std:: as_const ( E ) ) si cela est une expression valide, static_cast < const C & > ( std :: move ( E ) ) sinon.	(depuis C++23)

les affirmations suivantes sont vraies :

• t <=> u et u <=> t ont le même domaine,
• ( ( t <=> u ) <=> 0 ) et ( 0 <=> ( u <=> t ) ) sont égaux,
• ( 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 ) , et
• si Cat est convertible en std::strong_ordering , T et U modélisent std:: totally_ordered_with < T, U > .