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

Files changed (1) hide show

tmp/tmpl7njrojk/{from.md → to.md} +234 -15

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

@@ -12,16 +12,18 @@ by their associated constraints [[temp.constr.order]]. — *end note*]
 #### 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.
@@ -200,11 +202,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
@@ -231,10 +234,93 @@ void g() {
                                 // call is ill-formed even though #2 is a better match
 ```
 — *end example*]
 ### Constrained declarations <a id="temp.constr.decl">[[temp.constr.decl]]</a>
 A template declaration [[temp.pre]] or templated function declaration
 [[dcl.fct]] can be constrained by the use of a *requires-clause*. This
 allows the specification of constraints for that declaration as an
@@ -345,16 +431,24 @@ The *normal form* of an *expression* `E` is a constraint
 - The normal form of an expression `( E )` is the normal form of `E`.
 - The normal form of an expression `E1 || E2` is the disjunction
   [[temp.constr.op]] of the normal forms of `E1` and `E2`.
 - The normal form of an expression `E1 && E2` is the conjunction of the
   normal forms of `E1` and `E2`.
-- The normal form of a concept-id `C<A₁, A₂, ..., Aₙ>` is the normal
- form of the *constraint-expression* of `C`, after substituting
-  `A₁, A₂, ..., Aₙ` for `C`'s respective template parameters in the
- parameter mappings in each atomic constraint. If any such substitution
- results in an invalid type or expression, the program is ill-formed;
-  no diagnostic is required.
   \[*Example 1*:
   ``` cpp
   template<typename T> concept A = T::value || true;
   template<typename U> concept B = A<U*>;
   template<typename V> concept C = B<V&>;
@@ -365,10 +459,35 @@ The *normal form* of an *expression* `E` is a constraint
   mapping), despite the expression `T::value` being ill-formed for a
   pointer type `T`. Normalization of `C`'s *constraint-expression*
   results in the program being ill-formed, because it would form the
   invalid type `V&*` in the parameter mapping.
   — *end example*]
 - The normal form of any other expression `E` is the atomic constraint
   whose expression is `E` and whose parameter mapping is the identity
   mapping.
 The process of obtaining the normal form of a *constraint-expression* is
@@ -399,27 +518,95 @@ The associated constraints of \#2 are `requires { typename T::type; }`
 The associated constraints of \#3 are `requires (T x) { ++x; }` (with
 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}$,
-  and
 - an atomic constraint A subsumes another atomic constraint B if and
   only if A and B are identical using the rules described in
-  [[temp.constr.atomic]].
 [*Example 1*: Let A and B be atomic constraints [[temp.constr.atomic]].
 The constraint A ∧ B subsumes A, but A does not subsume A ∧ B. The
 constraint A subsumes A ∨ B, but A ∨ B does not subsume A. Also note
 that every constraint subsumes itself. — *end example*]
@@ -437,14 +624,17 @@ partial ordering is used to determine
   [[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
 - `D1` and `D2` are both constrained declarations and `D1`’s associated
-  constraints subsume those of `D2`; or
 - `D2` has no associated constraints.
 A declaration `D1` is *more constrained* than another declaration `D2`
 when `D1` is at least as constrained as `D2`, and `D2` is not at least
 as constrained as `D1`.
@@ -466,5 +656,34 @@ g(true);                        // selects #3 because C1<bool> is not satisfied
 g(0);                           // selects #4
 ```
 — *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]].
 ### Constrained declarations <a id="temp.constr.decl">[[temp.constr.decl]]</a>
 A template declaration [[temp.pre]] or templated function declaration
 [[dcl.fct]] can be constrained by the use of a *requires-clause*. This
 allows the specification of constraints for that declaration as an
 - The normal form of an expression `( E )` is the normal form of `E`.
 - The normal form of an expression `E1 || E2` is the disjunction
   [[temp.constr.op]] of the normal forms of `E1` and `E2`.
 - The normal form of an expression `E1 && E2` is the conjunction of the
   normal forms of `E1` and `E2`.
+- For a concept-id `C<A₁, A₂, …, Aₙ>` termed `CI`:
+ - If `C` names a dependent concept, the normal form of `CI` is a
+    concept-dependent constraint whose concept-id is `CI` and whose
+ parameter mapping is the identity mapping.
+ - Otherwise, to form `CE`, any non-dependent concept template argument
+    `Aᵢ` is substituted into the *constraint-expression* of `C`. If any
+    such substitution results in an invalid concept-id, the program is
+    ill-formed; no diagnostic is required. The normal form of `CI` is
+    the result of substituting, in the normal form `N` of `CE`,
+    appearances of `C`'s template parameters in the parameter mappings
+    of the atomic constraints in `N` with their respective arguments
+    from `C`. If any such substitution results in an invalid type or
+    expression, the program is ill-formed; no diagnostic is required.
   \[*Example 1*:
   ``` cpp
   template<typename T> concept A = T::value || true;
   template<typename U> concept B = A<U*>;
   template<typename V> concept C = B<V&>;
   mapping), despite the expression `T::value` being ill-formed for a
   pointer type `T`. Normalization of `C`'s *constraint-expression*
   results in the program being ill-formed, because it would form the
   invalid type `V&*` in the parameter mapping.
   — *end example*]
+- For a *fold-operator* `Op` [[expr.prim.fold]] that is either `&&` or
+  `||`:
+  - The normal form of an expression `( ... Op E )` is the normal form
+    of `( E Op ... )`.
+  - The normal form of an expression `( E1 Op ... Op E2 )` is the normal
+    form of
+    - `( E1 Op ... ) Op E2` if `E1` contains an unexpanded pack, or
+    - `E1 Op ( E2 Op ... )` otherwise.
+  - The normal form of an expression `F` of the form `( E Op ... )` is
+    as follows:
+    If `E` contains an unexpanded concept template parameter pack, it
+    shall not contain an unexpanded template parameter pack of another
+    kind. Let `E'` be the normal form of `E`.
+    - If `E` contains an unexpanded concept template parameter pack `Pₖ`
+      that has corresponding template arguments in the parameter mapping
+      of any atomic constraint (including concept-dependent constraints)
+      of `E'`, the number of arguments specified for all such `Pₖ` shall
+      be the same number N. The normal form of `F` is the normal form of
+      `E₀ Op … Op E_{N-1}` after substituting in `Eᵢ` the respective iᵗʰ
+      concept argument of each `Pₖ`. If any such substitution results in
+      an invalid type or expression, the program is ill-formed; no
+      diagnostic is required.
+    - Otherwise, the normal form of `F` is a fold expanded constraint
+      [[temp.constr.fold]] whose constraint is `E'` and whose
+      *fold-operator* is `Op`.
 - The normal form of any other expression `E` is the atomic constraint
   whose expression is `E` and whose parameter mapping is the identity
   mapping.
 The process of obtaining the normal form of a *constraint-expression* is
 The associated constraints of \#3 are `requires (T x) { ++x; }` (with
 mapping `T` ↦ `U`).
 — *end example*]
+[*Example 3*:
+``` cpp
+template<typename T>
+concept C = true;
+template<typename T, template<typename> concept CT>
+concept CC = CT<T>;
+template<typename U,
+         template<typename, template<typename> concept> concept CT>
+  void f() requires CT<U*, C>;
+template<typename U>
+  void g() requires CC<U*, C>;
+```
+The normal form of the associated constraints of `f` is the
+concept-dependent constraint `CT<T, C>`.
+The normal form of the associated constraints of `g` is the atomic
+constraint `true`.
+— *end example*]
+[*Example 4*:
+``` cpp
+template<typename T>
+concept A = true;
+template<typename T>
+concept B = A<T> && true;                               // B subsumes A
+template<typename T>
+concept C = true;
+template<typename T>
+concept D = C<T> && true;                               // D subsumes C
+template<typename T, template<typename> concept... CTs>
+concept all_of = (CTs<T> && ...);
+template<typename T> requires all_of<T, A, C>
+  constexpr int f(T) { return 1; }                      // #1
+template<typename T> requires all_of<T, B, D>
+  constexpr int f(T) { return 2; }                      // #2
+static_assert(f(1) == 2);                               // ok
+```
+The normal form of `all_of<T, A, C>` is the conjunction of the normal
+forms of `A<T>` and `C<T>`.
+Similarly, the normal form of `all_of<T, B, D>` is the conjunction of
+the normal forms of `B<T>` and `D<T>`.
+\#2 therefore is more constrained than \#1.
+— *end example*]
+[*Example 5*:
+``` cpp
+template<typename T, template<typename> concept>
+struct wrapper {};
+template<typename... T, template<typename> concept... CTs>
+  int f(wrapper<T, CTs>...) requires (CTs<T> && ...);   // error: fold expression contains
+                                                        // different kinds of template parameters
+```
+— *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[^3]
 of P, Pᵢ subsumes every conjunctive clause Qⱼ in the conjunctive normal
+form[^4]
 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}$,
 - an atomic constraint A subsumes another atomic constraint B if and
   only if A and B are identical using the rules described in
+  [[temp.constr.atomic]], and
+- a fold expanded constraint A subsumes another fold expanded constraint
+  B if they are compatible for subsumption, have the same
+  *fold-operator*, and the constraint of A subsumes that of B.
 [*Example 1*: Let A and B be atomic constraints [[temp.constr.atomic]].
 The constraint A ∧ B subsumes A, but A does not subsume A ∧ B. The
 constraint A subsumes A ∨ B, but A ∨ B does not subsume A. Also note
 that every constraint subsumes itself. — *end example*]
   [[temp.spec.partial.order]], and
 - the partial ordering of function templates [[temp.func.order]].
 — *end note*]
+The associated constraints `C` of a declaration `D` are *eligible for
+subsumption* unless `C` contains a concept-dependent constraint.
 A declaration `D1` is *at least as constrained* as a declaration `D2` if
 - `D1` and `D2` are both constrained declarations and `D1`’s associated
+  constraints are eligible for subsumption and subsume those of `D2`; or
 - `D2` has no associated constraints.
 A declaration `D1` is *more constrained* than another declaration `D2`
 when `D1` is at least as constrained as `D2`, and `D2` is not at least
 as constrained as `D1`.
 g(0);                           // selects #4
 ```
 — *end example*]
+[*Example 3*:
+``` cpp
+template<template<typename T> concept CT, typename T>
+struct S {};
+template<typename T>
+concept A = true;
+template<template<typename T> concept X, typename T>
+int f(S<X, T>) requires A<T> { return 42; }             // #1
+template<template<typename T> concept X, typename T>
+int f(S<X, T>) requires X<T> { return 43; }             // #2
+f(S<A, int>{});                 // ok, select #1 because #2 is not eligible for subsumption
+```
+— *end example*]
+A non-template function `F1` is *more partial-ordering-constrained* than
+a non-template function `F2` if
+- they have the same non-object-parameter-type-lists [[dcl.fct]], and
+- if they are member functions, both are direct members of the same
+  class, and
+- if both are non-static member functions, they have the same types for
+  their object parameters, and
+- the declaration of `F1` is more constrained than the declaration of
+  `F2`.

Diff to HTML by rtfpessoa