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

Files changed (1) hide show

tmp/tmp1jztu_tv/{from.md → to.md} +90 -4

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

@@ -2,16 +2,18 @@
 #### 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:
 - conjunctions [[temp.constr.op]],
-- disjunctions [[temp.constr.op]], and
-- atomic constraints [[temp.constr.atomic]].
 In order for a constrained template to be instantiated [[temp.spec]],
 its associated constraints [[temp.constr.decl]] shall be satisfied as
 described in the following subclauses.
@@ -190,11 +192,12 @@ void h2() {
 — *end note*]
 To determine if an atomic constraint is *satisfied*, the parameter
 mapping and template arguments are first substituted into its
-expression. If substitution results in an invalid type or expression,
 the constraint is not satisfied. Otherwise, the lvalue-to-rvalue
 conversion [[conv.lval]] is performed if necessary, and `E` shall be a
 constant expression of type `bool`. The constraint is satisfied if and
 only if evaluation of `E` results in `true`. If, at different points in
 the program, the satisfaction result is different for identical atomic
@@ -221,5 +224,88 @@ void g() {
                                 // call is ill-formed even though #2 is a better match
 ```
 — *end example*]

 #### 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 five different kinds of
 constraints:
 - conjunctions [[temp.constr.op]],
+- disjunctions [[temp.constr.op]],
+- atomic constraints [[temp.constr.atomic]],
+- concept-dependent constraints [[temp.constr.concept]], and
+- fold expanded constraints [[temp.constr.fold]].
 In order for a constrained template to be instantiated [[temp.spec]],
 its associated constraints [[temp.constr.decl]] shall be satisfied as
 described in the following subclauses.
 — *end note*]
 To determine if an atomic constraint is *satisfied*, the parameter
 mapping and template arguments are first substituted into its
+expression. If substitution results in an invalid type or expression in
+the immediate context of the atomic constraint [[temp.deduct.general]],
 the constraint is not satisfied. Otherwise, the lvalue-to-rvalue
 conversion [[conv.lval]] is performed if necessary, and `E` shall be a
 constant expression of type `bool`. The constraint is satisfied if and
 only if evaluation of `E` results in `true`. If, at different points in
 the program, the satisfaction result is different for identical atomic
                                 // call is ill-formed even though #2 is a better match
 ```
 — *end example*]
+#### Concept-dependent constraints <a id="temp.constr.concept">[[temp.constr.concept]]</a>
+A *concept-dependent constraint* `CD` is an atomic constraint whose
+expression is a concept-id `CI` whose *concept-name* names a dependent
+concept named `C`.
+To determine if `CD` is *satisfied*, the parameter mapping and template
+arguments are first substituted into `C`. If substitution results in an
+invalid concept-id in the immediate context of the constraint
+[[temp.deduct.general]], the constraint is not satisfied. Otherwise, let
+`CI'` be the normal form [[temp.constr.normal]] of the concept-id after
+substitution of `C`.
+[*Note 1*: Normalization of `CI` might be ill-formed; no diagnostic is
+required. — *end note*]
+To form `CI''`, each appearance of `C`'s template parameters in the
+parameter mappings of the atomic constraints (including
+concept-dependent constraints) in `CI'` is substituted with their
+respective arguments from the parameter mapping of `CD` and the
+arguments of `CI`.
+`CD` is satisfied if `CI''` is satisfied.
+[*Note 2*: Checking whether `CI''` is satisfied can lead to further
+normalization of concept-dependent constraints. — *end note*]
+[*Example 1*:
+``` cpp
+template<typename>
+concept C = true;
+template<typename T, template<typename> concept CC>
+concept D = CC<T>;
+template<typename U,
+         template<typename> concept CT,
+         template<typename, template<typename> concept> concept CU>
+int f() requires CU<U, CT>;
+int i = f<int, C, D>();
+```
+In this example, the associated constraints of `f` consist of a
+concept-dependent constraint whose expression is the concept-id
+`CU<U, CT>` with the mapping `U` ↦ `U`, `CT` ↦ `CT`, `CU` ↦ `CU`. The
+result of substituting `D` into this expression is `D<U, CT>`. We
+consider the normal form of the resulting concept-id, which is `CC<T>`
+with the mapping `T` ↦ `U`, `CC` ↦ `CT`. By recursion, `C` is
+substituted into `CC<T>`, and the result is normalized to the atomic
+constraint `true`, which is satisfied.
+— *end example*]
+#### Fold expanded constraint <a id="temp.constr.fold">[[temp.constr.fold]]</a>
+A *fold expanded constraint* is formed from a constraint C and a
+*fold-operator* which can either be `&&` or `||`. A fold expanded
+constraint is a pack expansion [[temp.variadic]]. Let N be the number of
+elements in the pack expansion parameters [[temp.variadic]].
+A fold expanded constraint whose *fold-operator* is `&&` is satisfied if
+it is a valid pack expansion and if N = 0 or if for each i where
+0 ≤ i < N in increasing order, C is satisfied when replacing each pack
+expansion parameter with the corresponding iᵗʰ element. No substitution
+takes place for any i greater than the smallest i for which the
+constraint is not satisfied.
+A fold expanded constraint whose *fold-operator* is `||` is satisfied if
+it is a valid pack expansion, N > 0, and if for i where 0 ≤ i < N in
+increasing order, there is a smallest i for which C is satisfied when
+replacing each pack expansion parameter with the corresponding iᵗʰ
+element. No substitution takes place for any i greater than the smallest
+i for which the constraint is satisfied.
+[*Note 1*: If the pack expansion expands packs of different size, then
+it is invalid and the fold expanded constraint is not
+satisfied. — *end note*]
+Two fold expanded constraints are *compatible for subsumption* if their
+respective constraints both contain an equivalent unexpanded pack
+[[temp.over.link]].

Diff to HTML by rtfpessoa