[cmp] - C++20 → C++23

Files changed (1) hide show

tmp/tmp7l6llzaq/{from.md → to.md} +76 -54

tmp/tmp7l6llzaq/{from.md → to.md} RENAMED Viewed

@@ -5,10 +5,11 @@
 The header `<compare>` specifies types, objects, and functions for use
 primarily in connection with the three-way comparison operator
 [[expr.spaceship]].
 ``` cpp
 namespace std {
   // [cmp.categories], comparison category types
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
@@ -65,13 +66,11 @@ collectively termed the *comparison category types*. Each is specified
 in terms of an exposition-only data member named `value` whose value
 typically corresponds to that of an enumerator from one of the following
 exposition-only enumerations:
 ``` cpp
-enum class eq { equal = 0, equivalent = equal,
-                nonequal = 1, nonequivalent = nonequal };   // exposition only
-enum class ord { less = -1, greater = 1 };                  // exposition only
 enum class ncmp { unordered = -127 };                                     // exposition only
 ```
 [*Note 1*: The type `strong_ordering` corresponds to the term total
 ordering in mathematics. — *end note*]
@@ -98,24 +97,22 @@ where `f` denotes a function that reads only comparison-salient state
 that is accessible via the argument’s public const members.
 #### Class `partial_ordering` <a id="cmp.partialord">[[cmp.partialord]]</a>
 The `partial_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), (b)
-does not imply substitutability, and (c) permits two values to be
-incomparable. [^34]
 ``` cpp
 namespace std {
   class partial_ordering {
     int value;          // exposition only
     bool is_ordered;    // exposition only
     // exposition-only constructors
-    constexpr explicit
-      partial_ordering(eq v) noexcept : value(int(v)), is_ordered(true) {}      // exposition only
     constexpr explicit
       partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {}     // exposition only
     constexpr explicit
       partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {}   // exposition only
@@ -141,11 +138,11 @@ namespace std {
     friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr partial_ordering partial_ordering::less(ord::less);
-  inline constexpr partial_ordering partial_ordering::equivalent(eq::equivalent);
   inline constexpr partial_ordering partial_ordering::greater(ord::greater);
   inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
 }
 ```
@@ -182,21 +179,20 @@ constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept
 `v < 0 ? partial_ordering::greater : v > 0 ? partial_ordering::less : v`.
 #### Class `weak_ordering` <a id="cmp.weakord">[[cmp.weakord]]</a>
 The `weak_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), and
-(b) does not imply substitutability.
 ``` cpp
 namespace std {
   class weak_ordering {
     int value;  // exposition only
     // exposition-only constructors
-    constexpr explicit weak_ordering(eq v) noexcept : value(int(v)) {}  // exposition only
     constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only
   public:
     // valid values
     static const weak_ordering less;
@@ -221,11 +217,11 @@ namespace std {
     friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr weak_ordering weak_ordering::less(ord::less);
-  inline constexpr weak_ordering weak_ordering::equivalent(eq::equivalent);
   inline constexpr weak_ordering weak_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
@@ -273,21 +269,20 @@ constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
 `v < 0 ? weak_ordering::greater : v > 0 ? weak_ordering::less : v`.
 #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
 The `strong_ordering` type is typically used as the result type of a
-three-way comparison operator [[expr.spaceship]] that (a) admits all of
-the six two-way comparison operators ([[expr.rel]], [[expr.eq]]), and
-(b) does imply substitutability.
 ``` cpp
 namespace std {
   class strong_ordering {
     int value;  // exposition only
     // exposition-only constructors
-    constexpr explicit strong_ordering(eq v) noexcept : value(int(v)) {}    // exposition only
     constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {}   // exposition only
   public:
     // valid values
     static const strong_ordering less;
@@ -314,12 +309,12 @@ namespace std {
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr strong_ordering strong_ordering::less(ord::less);
-  inline constexpr strong_ordering strong_ordering::equal(eq::equal);
-  inline constexpr strong_ordering strong_ordering::equivalent(eq::equivalent);
   inline constexpr strong_ordering strong_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
@@ -401,11 +396,11 @@ pack, or `void` if any element of `Ts` is not a comparison category
 type.
 [*Note 1*: This is `std::strong_ordering` if the expansion is
 empty. — *end note*]
-### Concept `three_way_comparable` <a id="cmp.concept">[[cmp.concept]]</a>
 ``` cpp
 template<class T, class Cat>
   concept compares-as =                 // exposition only
     same_as<common_comparison_category_t<T, Cat>, Cat>;
@@ -461,32 +456,37 @@ and `Cat` model `three_way_comparable<T, Cat>` only if:
 ``` cpp
 template<class T, class U, class Cat = partial_ordering>
   concept three_way_comparable_with =
     three_way_comparable<T, Cat> &&
     three_way_comparable<U, Cat> &&
- common_reference_with<const remove_reference_t<T>&, const remove_reference_t<U>&> &&
     three_way_comparable<
       common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
     weakly-equality-comparable-with<T, U> &&
     partially-ordered-with<T, U> &&
     requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
       { t <=> u } -> compares-as<Cat>;
       { u <=> t } -> compares-as<Cat>;
     };
 ```
-Let `t` and `u` be lvalues of types `const remove_reference_t<T>` and
-`const remove_reference_t<U>`, respectively. Let `C` be
 `common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>`.
-`T`, `U`, and `Cat` model `three_way_comparable_with<T, U, Cat>` only
-if:
 - `t <=> u` and `u <=> t` have the same domain,
 - `((t <=> u) <=> 0)` and `(0 <=> (u <=> t))` are equal,
 - `(t <=> u == 0) == bool(t == u)` is `true`,
 - `(t <=> u != 0) == bool(t != u)` is `true`,
-- `Cat(t <=> u) == Cat(C(t) <=> C(u))` is `true`,
 - `(t <=> u < 0) == bool(t < u)` is `true`,
 - `(t <=> u > 0) == bool(t > u)` is `true`,
 - `(t <=> u <= 0) == bool(t <= u)` is `true`,
 - `(t <=> u >= 0) == bool(t >= u)` is `true`, and
 - if `Cat` is convertible to `strong_ordering`, `T` and `U` model
@@ -509,38 +509,41 @@ member `type`.
 ### Comparison algorithms <a id="cmp.alg">[[cmp.alg]]</a>
 The name `strong_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `strong_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `strong_order(E, F)` is
   ill-formed.
 - Otherwise, `strong_ordering(strong_order(E, F))` if it is a
-  well-formed expression with overload resolution performed in a context
- that does not include a declaration of `std::strong_order`.
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `strong_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators, and if
   `numeric_limits<T>::is_iec559` is `true`, is additionally consistent
   with the `totalOrder` operation as specified in ISO/IEC/IEEE 60559.
 - Otherwise, `strong_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
-- Otherwise, `strong_order(E, F)` is ill-formed. \[*Note 1*: This case
-  can result in substitution failure when `strong_order(E, F)` appears
-  in the immediate context of a template instantiation. — *end note*]
 The name `weak_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `weak_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `weak_order(E, F)` is
   ill-formed.
 - Otherwise, `weak_ordering(weak_order(E, F))` if it is a well-formed
-  expression with overload resolution performed in a context that does
- not include a declaration of `std::weak_order`.
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `weak_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators and `strong_order`,
   and if `numeric_limits<T>::is_iec559` is `true`, is additionally
   consistent with the following equivalence classes, ordered from lesser
@@ -556,86 +559,105 @@ expression `weak_order(E, F)` is expression-equivalent
   - together, all positive NaN values.
 - Otherwise, `weak_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `weak_ordering(strong_order(E, F))` if it is a well-formed
   expression.
-- Otherwise, `weak_order(E, F)` is ill-formed. \[*Note 2*: This case can
-  result in substitution failure when `std::weak_order(E, F)` appears in
-  the immediate context of a template instantiation. — *end note*]
 The name `partial_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `partial_order(E, F)` is expression-equivalent
-[[defns.expression-equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `partial_order(E, F)` is
   ill-formed.
 - Otherwise, `partial_ordering(partial_order(E, F))` if it is a
-  well-formed expression with overload resolution performed in a context
- that does not include a declaration of `std::partial_order`.
 - Otherwise, `partial_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `partial_ordering(weak_order(E, F))` if it is a well-formed
   expression.
-- Otherwise, `partial_order(E, F)` is ill-formed. \[*Note 3*: This case
-  can result in substitution failure when `std::partial_order(E, F)`
-  appears in the immediate context of a template
 instantiation. — *end note*]
 The name `compare_strong_order_fallback` denotes a customization point
-object [[customization.point.object]]. Given subexpressions `E` and F,
 the expression `compare_strong_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_strong_order_fallback(E, F)` is ill-formed.
 - Otherwise, `strong_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? strong_ordering::equal :
   E < F  ? strong_ordering::less :
            strong_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_strong_order_fallback(E, F)` is ill-formed.
 The name `compare_weak_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_weak_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_weak_order_fallback(E, F)` is ill-formed.
 - Otherwise, `weak_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? weak_ordering::equivalent :
   E < F  ? weak_ordering::less :
            weak_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_weak_order_fallback(E, F)` is ill-formed.
 The name `compare_partial_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_partial_order_fallback(E, F)` is
-expression-equivalent [[defns.expression-equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_partial_order_fallback(E, F)` is ill-formed.
 - Otherwise, `partial_order(E, F)` if it is a well-formed expression.
-- Otherwise, if the expressions `E == F` and `E < F` are both
-  well-formed and convertible to `bool`,
   ``` cpp
   E == F ? partial_ordering::equivalent :
   E < F  ? partial_ordering::less :
   F < E  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_partial_order_fallback(E, F)` is ill-formed.

 The header `<compare>` specifies types, objects, and functions for use
 primarily in connection with the three-way comparison operator
 [[expr.spaceship]].
 ``` cpp
+// all freestanding
 namespace std {
   // [cmp.categories], comparison category types
   class partial_ordering;
   class weak_ordering;
   class strong_ordering;
 in terms of an exposition-only data member named `value` whose value
 typically corresponds to that of an enumerator from one of the following
 exposition-only enumerations:
 ``` cpp
+enum class ord { equal = 0, equivalent = equal, less = -1, greater = 1 }; // exposition only
 enum class ncmp { unordered = -127 };                                     // exposition only
 ```
 [*Note 1*: The type `strong_ordering` corresponds to the term total
 ordering in mathematics. — *end note*]
 that is accessible via the argument’s public const members.
 #### Class `partial_ordering` <a id="cmp.partialord">[[cmp.partialord]]</a>
 The `partial_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]],
+for which equality need not imply substitutability, and that permits two
+values to be incomparable.[^32]
 ``` cpp
 namespace std {
   class partial_ordering {
     int value;          // exposition only
     bool is_ordered;    // exposition only
     // exposition-only constructors
     constexpr explicit
       partial_ordering(ord v) noexcept : value(int(v)), is_ordered(true) {}     // exposition only
     constexpr explicit
       partial_ordering(ncmp v) noexcept : value(int(v)), is_ordered(false) {}   // exposition only
     friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr partial_ordering partial_ordering::less(ord::less);
+  inline constexpr partial_ordering partial_ordering::equivalent(ord::equivalent);
   inline constexpr partial_ordering partial_ordering::greater(ord::greater);
   inline constexpr partial_ordering partial_ordering::unordered(ncmp::unordered);
 }
 ```
 `v < 0 ? partial_ordering::greater : v > 0 ? partial_ordering::less : v`.
 #### Class `weak_ordering` <a id="cmp.weakord">[[cmp.weakord]]</a>
 The `weak_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]]
+and for which equality need not imply substitutability.
 ``` cpp
 namespace std {
   class weak_ordering {
     int value;  // exposition only
     // exposition-only constructors
     constexpr explicit weak_ordering(ord v) noexcept : value(int(v)) {} // exposition only
   public:
     // valid values
     static const weak_ordering less;
     friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr weak_ordering weak_ordering::less(ord::less);
+  inline constexpr weak_ordering weak_ordering::equivalent(ord::equivalent);
   inline constexpr weak_ordering weak_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
 `v < 0 ? weak_ordering::greater : v > 0 ? weak_ordering::less : v`.
 #### Class `strong_ordering` <a id="cmp.strongord">[[cmp.strongord]]</a>
 The `strong_ordering` type is typically used as the result type of a
+three-way comparison operator [[expr.spaceship]] for a type that admits
+all of the six two-way comparison operators [[expr.rel]], [[expr.eq]]
+and for which equality does imply substitutability.
 ``` cpp
 namespace std {
   class strong_ordering {
     int value;  // exposition only
     // exposition-only constructors
     constexpr explicit strong_ordering(ord v) noexcept : value(int(v)) {}   // exposition only
   public:
     // valid values
     static const strong_ordering less;
     friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
   };
   // valid values' definitions
   inline constexpr strong_ordering strong_ordering::less(ord::less);
+  inline constexpr strong_ordering strong_ordering::equal(ord::equal);
+  inline constexpr strong_ordering strong_ordering::equivalent(ord::equivalent);
   inline constexpr strong_ordering strong_ordering::greater(ord::greater);
 }
 ```
 ``` cpp
 type.
 [*Note 1*: This is `std::strong_ordering` if the expansion is
 empty. — *end note*]
+### Concept <a id="cmp.concept">[[cmp.concept]]</a>
 ``` cpp
 template<class T, class Cat>
   concept compares-as =                 // exposition only
     same_as<common_comparison_category_t<T, Cat>, Cat>;
 ``` cpp
 template<class T, class U, class Cat = partial_ordering>
   concept three_way_comparable_with =
     three_way_comparable<T, Cat> &&
     three_way_comparable<U, Cat> &&
+ comparison-common-type-with<T, U> &&
     three_way_comparable<
       common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>, Cat> &&
     weakly-equality-comparable-with<T, U> &&
     partially-ordered-with<T, U> &&
     requires(const remove_reference_t<T>& t, const remove_reference_t<U>& u) {
       { t <=> u } -> compares-as<Cat>;
       { u <=> t } -> compares-as<Cat>;
     };
 ```
+Let `t` and `t2` be lvalues denoting distinct equal objects of types
+`const remove_reference_t<T>` and `remove_cvref_t<T>`, respectively, and
+let `u` and `u2` be lvalues denoting distinct equal objects of types
+`const remove_reference_t<U>` and `remove_cvref_t<U>`, respectively. Let
+`C` be
 `common_reference_t<const remove_reference_t<T>&, const remove_reference_t<U>&>`.
+Let `CONVERT_TO_LVALUE<C>(E)` be defined as in
+[[concepts.compare.general]]. `T`, `U`, and `Cat` model
+`three_way_comparable_with<T, U, Cat>` only if:
 - `t <=> u` and `u <=> t` have the same domain,
 - `((t <=> u) <=> 0)` and `(0 <=> (u <=> t))` are equal,
 - `(t <=> u == 0) == bool(t == u)` is `true`,
 - `(t <=> u != 0) == bool(t != u)` is `true`,
+- `Cat(t <=> u) == Cat(CONVERT_TO_LVALUE<C>(t2) <=>
+  CONVERT_TO_LVALUE<C>(u2))` is `true`,
 - `(t <=> u < 0) == bool(t < u)` is `true`,
 - `(t <=> u > 0) == bool(t > u)` is `true`,
 - `(t <=> u <= 0) == bool(t <= u)` is `true`,
 - `(t <=> u >= 0) == bool(t >= u)` is `true`, and
 - if `Cat` is convertible to `strong_ordering`, `T` and `U` model
 ### Comparison algorithms <a id="cmp.alg">[[cmp.alg]]</a>
 The name `strong_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `strong_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `strong_order(E, F)` is
   ill-formed.
 - Otherwise, `strong_ordering(strong_order(E, F))` if it is a
+  well-formed expression where the meaning of `strong_order` is
+ established as-if by performing argument-dependent lookup only
+  [[basic.lookup.argdep]].
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `strong_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators, and if
   `numeric_limits<T>::is_iec559` is `true`, is additionally consistent
   with the `totalOrder` operation as specified in ISO/IEC/IEEE 60559.
 - Otherwise, `strong_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
+- Otherwise, `strong_order(E, F)` is ill-formed.
+[*Note 1*: Ill-formed cases above result in substitution failure when
+`strong_order(E, F)` appears in the immediate context of a template
+instantiation. — *end note*]
 The name `weak_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `weak_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `weak_order(E, F)` is
   ill-formed.
 - Otherwise, `weak_ordering(weak_order(E, F))` if it is a well-formed
+  expression where the meaning of `weak_order` is established as-if by
+ performing argument-dependent lookup only [[basic.lookup.argdep]].
 - Otherwise, if the decayed type `T` of `E` is a floating-point type,
   yields a value of type `weak_ordering` that is consistent with the
   ordering observed by `T`’s comparison operators and `strong_order`,
   and if `numeric_limits<T>::is_iec559` is `true`, is additionally
   consistent with the following equivalence classes, ordered from lesser
   - together, all positive NaN values.
 - Otherwise, `weak_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `weak_ordering(strong_order(E, F))` if it is a well-formed
   expression.
+- Otherwise, `weak_order(E, F)` is ill-formed.
+[*Note 2*: Ill-formed cases above result in substitution failure when
+`weak_order(E, F)` appears in the immediate context of a template
+instantiation. — *end note*]
 The name `partial_order` denotes a customization point object
 [[customization.point.object]]. Given subexpressions `E` and `F`, the
 expression `partial_order(E, F)` is expression-equivalent
+[[defns.expression.equivalent]] to the following:
 - If the decayed types of `E` and `F` differ, `partial_order(E, F)` is
   ill-formed.
 - Otherwise, `partial_ordering(partial_order(E, F))` if it is a
+  well-formed expression where the meaning of `partial_order` is
+ established as-if by performing argument-dependent lookup only
+  [[basic.lookup.argdep]].
 - Otherwise, `partial_ordering(compare_three_way()(E, F))` if it is a
   well-formed expression.
 - Otherwise, `partial_ordering(weak_order(E, F))` if it is a well-formed
   expression.
+- Otherwise, `partial_order(E, F)` is ill-formed.
+[*Note 3*: Ill-formed cases above result in substitution failure when
+`partial_order(E, F)` appears in the immediate context of a template
 instantiation. — *end note*]
 The name `compare_strong_order_fallback` denotes a customization point
+object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_strong_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_strong_order_fallback(E, F)` is ill-formed.
 - Otherwise, `strong_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? strong_ordering::equal :
   E < F  ? strong_ordering::less :
            strong_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_strong_order_fallback(E, F)` is ill-formed.
+[*Note 4*: Ill-formed cases above result in substitution failure when
+`compare_strong_order_fallback(E, F)` appears in the immediate context
+of a template instantiation. — *end note*]
 The name `compare_weak_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_weak_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_weak_order_fallback(E, F)` is ill-formed.
 - Otherwise, `weak_order(E, F)` if it is a well-formed expression.
 - Otherwise, if the expressions `E == F` and `E < F` are both
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? weak_ordering::equivalent :
   E < F  ? weak_ordering::less :
            weak_ordering::greater
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_weak_order_fallback(E, F)` is ill-formed.
+[*Note 5*: Ill-formed cases above result in substitution failure when
+`compare_weak_order_fallback(E, F)` appears in the immediate context of
+a template instantiation. — *end note*]
 The name `compare_partial_order_fallback` denotes a customization point
 object [[customization.point.object]]. Given subexpressions `E` and `F`,
 the expression `compare_partial_order_fallback(E, F)` is
+expression-equivalent [[defns.expression.equivalent]] to:
 - If the decayed types of `E` and `F` differ,
   `compare_partial_order_fallback(E, F)` is ill-formed.
 - Otherwise, `partial_order(E, F)` if it is a well-formed expression.
+- Otherwise, if the expressions `E == F`, `E < F`, and `F < E` are all
+  well-formed and each of `decltype(E == F)` and `decltype(E < F)`
+  models `boolean-testable`,
   ``` cpp
   E == F ? partial_ordering::equivalent :
   E < F  ? partial_ordering::less :
   F < E  ? partial_ordering::greater :
            partial_ordering::unordered
   ```
   except that `E` and `F` are evaluated only once.
 - Otherwise, `compare_partial_order_fallback(E, F)` is ill-formed.
+[*Note 6*: Ill-formed cases above result in substitution failure when
+`compare_partial_order_fallback(E, F)` appears in the immediate context
+of a template instantiation. — *end note*]

Diff to HTML by rtfpessoa