[temp.constr] - C++20 → C++23

Files changed (1) hide show

tmp/tmp0numiwg5/{from.md → to.md} +18 -11

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

@@ -1,15 +1,19 @@
 ## Template constraints <a id="temp.constr">[[temp.constr]]</a>
-[*Note 1*: This subclause defines the meaning of constraints on
-template arguments. The abstract syntax and satisfaction rules are
 defined in [[temp.constr.constr]]. Constraints are associated with
 declarations in [[temp.constr.decl]]. Declarations are partially ordered
 by their associated constraints [[temp.constr.order]]. — *end note*]
 ### Constraints <a id="temp.constr.constr">[[temp.constr.constr]]</a>
 A *constraint* is a sequence of logical operations and operands that
 specifies requirements on template arguments. The operands of a logical
 operation are constraints. There are three different kinds of
 constraints:
@@ -60,11 +64,11 @@ template<typename T>
   requires (sizeof(T) > 1) && (get_value<T>())
     void f(T);      // has associated constraint sizeof(T) > 1 ∧ get_value<T>()
 void f(int);
-f('a'); // OK: calls f(int)
 ```
 In the satisfaction of the associated constraints [[temp.constr.decl]]
 of `f`, the constraint `sizeof(char) > 1` is not satisfied; the second
 operand is not checked for satisfaction.
@@ -171,14 +175,14 @@ void h() {
 }
 ```
 — *end example*]
-This similarity includes the situation where a program is ill-formed, no
-diagnostic required, when the meaning of the program depends on whether
-two constructs are equivalent, and they are functionally equivalent but
-not equivalent.
 [*Example 2*:
 ``` cpp
 template <unsigned N> void f2()
@@ -379,11 +383,11 @@ names a concept specialization [[expr.prim.id]]. — *end note*]
 ``` cpp
 template<typename T> concept C1 = sizeof(T) == 1;
 template<typename T> concept C2 = C1<T> && 1 == 2;
 template<typename T> concept C3 = requires { typename T::type; };
-template<typename T> concept C4 = requires (T x) { ++x; }
 template<C2 U> void f1(U);      // #1
 template<C3 U> void f2(U);      // #2
 template<C4 U> void f3(U);      // #3
 ```
@@ -398,12 +402,15 @@ mapping `T` ↦ `U`).
 — *end example*]
 ### Partial ordering by constraints <a id="temp.constr.order">[[temp.constr.order]]</a>
 A constraint P *subsumes* a constraint Q if and only if, for every
-disjunctive clause Pᵢ in the disjunctive normal form[^4] of P, Pᵢ
-subsumes every conjunctive clause Qⱼ in the conjunctive normal form[^5]
 of Q, where
 - a disjunctive clause Pᵢ subsumes a conjunctive clause Qⱼ if and only
   if there exists an atomic constraint Pᵢₐ in Pᵢ for which there exists
   an atomic constraint $Q_{jb}$ in Qⱼ such that Pᵢₐ subsumes $Q_{jb}$,
@@ -425,11 +432,11 @@ partial ordering is used to determine
 - the best viable candidate of non-template functions
   [[over.match.best]],
 - the address of a non-template function [[over.over]],
 - the matching of template template arguments [[temp.arg.template]],
 - the partial ordering of class template specializations
-  [[temp.class.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
 A declaration `D1` is *at least as constrained* as a declaration `D2` if

 ## Template constraints <a id="temp.constr">[[temp.constr]]</a>
+### General <a id="temp.constr.general">[[temp.constr.general]]</a>
+[*Note 1*: Subclause [[temp.constr]] defines the meaning of constraints
+on template arguments. The abstract syntax and satisfaction rules are
 defined in [[temp.constr.constr]]. Constraints are associated with
 declarations in [[temp.constr.decl]]. Declarations are partially ordered
 by their associated constraints [[temp.constr.order]]. — *end note*]
 ### Constraints <a id="temp.constr.constr">[[temp.constr.constr]]</a>
+#### General <a id="temp.constr.constr.general">[[temp.constr.constr.general]]</a>
 A *constraint* is a sequence of logical operations and operands that
 specifies requirements on template arguments. The operands of a logical
 operation are constraints. There are three different kinds of
 constraints:
   requires (sizeof(T) > 1) && (get_value<T>())
     void f(T);      // has associated constraint sizeof(T) > 1 ∧ get_value<T>()
 void f(int);
+f('a'); // OK, calls f(int)
 ```
 In the satisfaction of the associated constraints [[temp.constr.decl]]
 of `f`, the constraint `sizeof(char) > 1` is not satisfied; the second
 operand is not checked for satisfaction.
 }
 ```
 — *end example*]
+As specified in [[temp.over.link]], if the validity or meaning of the
+program depends on whether two constructs are equivalent, and they are
+functionally equivalent but not equivalent, the program is ill-formed,
+no diagnostic required.
 [*Example 2*:
 ``` cpp
 template <unsigned N> void f2()
 ``` cpp
 template<typename T> concept C1 = sizeof(T) == 1;
 template<typename T> concept C2 = C1<T> && 1 == 2;
 template<typename T> concept C3 = requires { typename T::type; };
+template<typename T> concept C4 = requires (T x) { ++x; };
 template<C2 U> void f1(U);      // #1
 template<C3 U> void f2(U);      // #2
 template<C4 U> void f3(U);      // #3
 ```
 — *end example*]
 ### Partial ordering by constraints <a id="temp.constr.order">[[temp.constr.order]]</a>
 A constraint P *subsumes* a constraint Q if and only if, for every
+disjunctive clause Pᵢ in the disjunctive normal form[^4]
+of P, Pᵢ subsumes every conjunctive clause Qⱼ in the conjunctive normal
+form[^5]
 of Q, where
 - a disjunctive clause Pᵢ subsumes a conjunctive clause Qⱼ if and only
   if there exists an atomic constraint Pᵢₐ in Pᵢ for which there exists
   an atomic constraint $Q_{jb}$ in Qⱼ such that Pᵢₐ subsumes $Q_{jb}$,
 - the best viable candidate of non-template functions
   [[over.match.best]],
 - the address of a non-template function [[over.over]],
 - the matching of template template arguments [[temp.arg.template]],
 - the partial ordering of class template specializations
+  [[temp.spec.partial.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
 A declaration `D1` is *at least as constrained* as a declaration `D2` if

Diff to HTML by rtfpessoa