[everywhere] Address a collection of minor editorial issues related to the concepts wording.

Author: zygoloid

source/derived.tex

@@ -695,7 +695,7 @@
 \begin{example}
 \begin{codeblock}
 struct A {
-  virtual void f() requires true; // error: constrained virtual function
+  virtual void f() requires true; // error: virtual function cannot be constrained~(\ref{temp.constr.decl})
 };
 \end{codeblock}
 \end{example}

source/expressions.tex

@@ -486,10 +486,10 @@
 that denotes the specialization of a concept~(\ref{temp.concept})
 results in a prvalue of type \tcode{bool}.
 The expression is \tcode{true} if
-the concept's normalized~(\ref{temp.constr.decl})
-\grammarterm{constraint-expression}
-is satisfied
-according to the rules in \ref{temp.constr.constr}
+the concept's normalized
+\grammarterm{constraint-expression}~(\ref{temp.constr.decl})
+is satisfied~(\ref{temp.constr.constr})
+by the specified template arguments
 and \tcode{false} otherwise.
 \begin{example}
 \begin{codeblock}
@@ -509,7 +509,7 @@
 A program that refers
 explicitly or implicitly
 to a function with a \grammarterm{requires-clause}
-whose \grammarterm{constraint-expression} is not satisfied~(\ref{temp.constr.decl}),
+whose \grammarterm{constraint-expression} is not satisfied,
 other than to declare it,
 is ill-formed.
 \begin{example}

source/overloading.tex

@@ -1505,10 +1505,10 @@
 context~(\ref{over.match.funcs}), a set of viable functions is
 chosen, from which the best function will be selected by
 comparing argument conversion sequences
-and associated constraints
+and associated constraints~(\ref{temp.constr.decl})
 for the best fit~(\ref{over.match.best}).
 The selection of viable functions considers
-associated constraints, if any~(\ref{temp.constr.decl}), and
+associated constraints, if any, and
 relationships between arguments and function parameters other
 than the ranking of conversion sequences.
 
@@ -2880,8 +2880,9 @@
 described in~\ref{expr.unary.op}.
 
 \pnum
-All functions whose
-associated constraints are not satisfied~(\ref{temp.constr.decl})
+All functions with
+associated constraints
+that are not satisfied~(\ref{temp.constr.decl})
 are eliminated from the set of selected functions.
 If more than one function in the set remains,
 all function template specializations

source/templates.tex

@@ -964,9 +964,9 @@
 all \grammarterm{template-argument}{s}
 in the \grammarterm{simple-template-id}
 are non-dependent~(\ref{temp.dep.temp}),
-the associated constraints
+the associated constraints~(\ref{temp.constr.decl})
 of the constrained template
-shall be satisfied~(\ref{temp.constr.decl}).
+shall be satisfied~(\ref{temp.constr.constr}).
 \begin{example}
 \begin{codeblock}
 template<typename T> concept C1 = sizeof(T) != sizeof(int);
@@ -1534,7 +1534,8 @@
 
 \pnum
 In order for a constrained template to be instantiated~(\ref{temp.spec}),
-its associated constraints shall be \defn{satisfied}~(\ref{temp.constr.decl}).
+its associated constraints~(\ref{temp.constr.decl})
+shall be satisfied as described in the following subsections.
 \begin{note}
 Forming the name of a specialization of
 a class template,
@@ -1545,8 +1546,6 @@
 requires the satisfaction of constraints
 on functions and function templates.
 \end{note}
-The rules for determining the satisfaction of different kinds of
-constraints are defined in the following subsections.
 
 \rSec3[temp.constr.op]{Logical operations}
 
@@ -1566,7 +1565,9 @@
 \pnum
 A \defn{conjunction} is a constraint taking two
 operands.
-To determine if a conjunction is satisfied, the satisfaction of
+To determine if a conjunction is
+\defnx{satisfied}{constraint!satisfaction!conjunction},
+the satisfaction of
 the first operand is checked.
 If that is not satisfied, the conjunction is not satisfied.
 Otherwise, the conjunction is satisfied if and only if the second
@@ -1576,7 +1577,9 @@
 A \defn{disjunction} is a constraint taking two
 operands.
 %
-To determine if a disjunction is satisfied, the satisfaction of
+To determine if a disjunction is
+\defnx{satisfied}{constraint!satisfaction!disjunction},
+the satisfaction of
 the first operand is checked.
 If that is satisfied, the disjunction is satisfied.
 Otherwise, the disjunction is satisfied if and only if the second
@@ -1627,8 +1630,10 @@
 according to the rules for expressions described in \ref{temp.over.link}.
 
 \pnum
-Determining if a constraint is satisfied entails the substitution
-of the parameter mapping and template arguments into that constraint.
+To determine if an atomic constraint is
+\defnx{satisfied}{constraint!satisfaction!atomic},
+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~(\ref{conv.lval})
@@ -1638,25 +1643,22 @@
 results in \tcode{true}.
 \begin{example}
 \begin{codeblock}
-template<typename T>
-  concept C = sizeof(T) == 4 && !true; // requires atomic constraints
-                                       // \tcode{sizeof(T) == 4} and \tcode{!true}
+template<typename T> concept C =
+  sizeof(T) == 4 && !true;      // requires atomic constraints
+                                // \tcode{sizeof(T) == 4} and \tcode{!true}
 
-template<typename T>
-  struct S {
-    constexpr operator bool() const { return true; }
-  };
+template<typename T> struct S {
+  constexpr operator bool() const { return true; }
+};
 
-template<typename T>
-  requires (S<T>{})
-    void f(T); // \#1
-void f(int);   // \#2
+template<typename T> requires (S<T>{})
+void f(T);          // \#1
+void f(int);        // \#2
 
 void g() {
-  f(0); // error: expression \tcode{S<int>\{\}} does not have type \tcode{bool}
-        // while checking satisfaction of deduced arguments of \#1,
-        // even though \#2 is a better match
-}
+  f(0);             // error: expression \tcode{S<int>\{\}} does not have type \tcode{bool}
+}                   // while checking satisfaction of deduced arguments of \#1;
+                    // call is ill-formed even though \#2 is a better match
 \end{codeblock}
 \end{example}
 
@@ -1799,7 +1801,7 @@
 Normalization of \tcode{B}{'s} \grammarterm{constraint-expression}
 is valid and results in
 \tcode{T::value} (with the mapping \tcode{T}$\mapsto$\tcode{U*})
-$\land$
+$\lor$
 \tcode{true} (with an empty mapping),
 despite the expression \tcode{T::value} being ill-formed
 for a pointer type \tcode{T}.
@@ -1828,10 +1830,10 @@
 template<C4 U> void f3(U);      // \#3
 \end{codeblock}
 The associated constraints of \#1 are
-$\tcode{sizeof(T) == 1}$ (with mapping \tcode{T}$\mapsto$\tcode{U}) $\land \tcode{1 == 2}$,
-those of \#2 are
-$\tcode{requires \{ typename T::type; \}}$ (with mapping \tcode{T}$\mapsto$\tcode{U}),
-those of \#3 are
+$\tcode{sizeof(T) == 1}$ (with mapping \tcode{T}$\mapsto$\tcode{U}) $\land \tcode{1 == 2}$.\\
+The associated constraints of \#2 are
+$\tcode{requires \{ typename T::type; \}}$ (with mapping \tcode{T}$\mapsto$\tcode{U}).\\
+The associated constraints of \#3 are
 $\tcode{requires (T x) \{ ++x; \}}$ (with mapping \tcode{T}$\mapsto$\tcode{U}).
 \end{example}
 \indextext{constraint!normalization|)}
@@ -2354,7 +2356,7 @@
 a \grammarterm{template-head} equivalent to that
 of the class template followed by
 a \grammarterm{template-head} equivalent to that
-of the member template.
+of the member template~(\ref{temp.over.link}).
 \begin{example}
 \begin{codeblock}
 template<class T> struct string {
@@ -3561,8 +3563,8 @@
 involving template parameters.
 Two \grammarterm{template-head}{s} are
 \defnx{functionally equivalent}{functionally equivalent!\idxgram{template-head}{s}}
-if they accept and are satisfied by the same set of template argument
-lists.
+if they accept and are satisfied by~(\ref{temp.constr.constr})
+the same set of template argument lists.
 
 \pnum
 \indextext{template!function!equivalent|see{equivalent, function template}}%
@@ -3867,9 +3869,10 @@
 
 \pnum
 A \grammarterm{concept-definition}
-declares its \grammarterm{identifier}
-to be a concept.
-The name of the concept is a \grammarterm{concept-name}.
+declares a concept.
+Its \grammarterm{identifier} becomes a \grammarterm{concept-name}
+referring to that concept
+within its scope.
 \begin{example}
 \begin{codeblock}
 template<typename T>
@@ -6057,7 +6060,7 @@
 the translation unit containing the explicit instantiation,
 provided that the associated constraints, if any,
 of that member are satisfied by the template arguments of the explicit
-instantiation~(\ref{temp.constr.decl}),
+instantiation~(\ref{temp.constr.decl}, \ref{temp.constr.constr}),
 except as described below.
 \begin{note} In addition, it will typically be an explicit instantiation of certain
 implementation-dependent data about the class. \end{note}
@@ -6962,7 +6965,7 @@
 or default argument values. If the substitution results in an
 invalid type, as described above, type deduction fails.
 If the function template has associated constraints~(\ref{temp.constr.decl}),
-those constraints are checked for satisfaction~(\ref{temp.constr}).
+those constraints are checked for satisfaction~(\ref{temp.constr.constr}).
 If the constraints are not satisfied, type deduction fails.
 
 \pnum