[temp.deduct] Split long paragraph 8

Author: tkoeppe

source/templates.tex

@@ -6853,16 +6853,13 @@
 or obtained from default
 \grammarterm{template-argument}{s}.
 \begin{example}
-
 \begin{codeblock}
 void f(Array<dcomplex>& cv, Array<int>& ci) {
   sort(cv);                     // calls \tcode{sort(Array<dcomplex>\&)}
   sort(ci);                     // calls \tcode{sort(Array<int>\&)}
 }
 \end{codeblock}
-
 and
-
 \begin{codeblock}
 void g(double d) {
   int i = convert<int>(d);      // calls \tcode{convert<int,double>(double)}
@@ -6878,7 +6875,6 @@
 deduction fails.  Specifically, the following steps are performed when
 evaluating an explicitly specified template argument list with respect
 to a given function template:
-
 \begin{itemize}
 \item The specified template arguments must match the template parameters in
 kind (i.e., type, non-type, template). There
@@ -6908,7 +6904,6 @@
 variable within the function.
 \end{note}
 \begin{example}
-
 \begin{codeblock}
 template <class T> void f(T t);
 template <class X> void g(const X x);
@@ -6962,7 +6957,6 @@
 }
 \end{codeblock}
 \end{example}
-
 When all template arguments have been deduced or obtained from
 default template arguments, all uses of template parameters in
 the template parameter list of the template and the function type
@@ -6989,10 +6983,13 @@
 template arguments but also general expressions (i.e., non-constant expressions)
 inside \tcode{sizeof}, \tcode{decltype}, and other contexts that allow non-constant
 expressions. The substitution proceeds in lexical order and stops when
-a condition that causes deduction to fail is encountered. \begin{note} The equivalent substitution in exception specifications is
-done only when the \grammarterm{noexcept-specifier} is instantiated, at which point a program is ill-formed
-if the substitution results in an invalid type or
-expression. \end{note}
+a condition that causes deduction to fail is encountered.
+\begin{note}
+The equivalent substitution in exception specifications is
+done only when the \grammarterm{noexcept-specifier} is instantiated,
+at which point a program is ill-formed
+if the substitution results in an invalid type or expression.
+\end{note}
 \begin{example}
 \begin{codeblock}
 template <class T> struct A { using X = typename T::X; };
@@ -7011,17 +7008,25 @@
 \pnum
 If a substitution results in an invalid type or expression, type deduction fails. An
 invalid type or expression is one that would be ill-formed, with a diagnostic
-required, if written using the substituted arguments. \begin{note} If no
+required, if written using the substituted arguments.
+\begin{note}
+If no
 diagnostic is required, the program is still ill-formed. Access checking is done
 as part of the substitution
-process. \end{note} Only invalid types and expressions in the immediate
+process.
+\end{note}
+Only invalid types and expressions in the immediate
 context of the function type and its template parameter types can result in a deduction
-failure. \begin{note} The substitution into types and expressions can result
+failure.
+\begin{note}
+The substitution into types and expressions can result
 in effects such as the instantiation of class template specializations and/or
 function template specializations, the generation of implicitly-defined functions,
 etc. Such effects are not in the ``immediate context'' and can result in the
-program being ill-formed.\end{note}
+program being ill-formed.
+\end{note}
 
+\pnum
 \begin{example}
 \begin{codeblock}
 struct X { };
@@ -7036,17 +7041,16 @@
 X x3 = f(x1, x2);   // deduction fails on \#1 (cannot add \tcode{X+X}), calls \#2\end{codeblock}
 \end{example}
 
-\begin{note} Type deduction may fail for
-the following reasons:
-
+\pnum
+\begin{note}
+Type deduction may fail for the following reasons:
 \begin{itemize}
 \item Attempting to instantiate a pack expansion containing multiple parameter packs of differing lengths.
 \item
 Attempting to create an array with an element type that is \tcode{void}, a
 function type, a reference type, or an abstract class type, or attempting
 to create an array with a size that is zero or negative.
 \begin{example}
-
 \begin{codeblock}
 template <class T> int f(T[5]);
 int I = f<int>(0);
@@ -7056,7 +7060,6 @@
 \item
 Attempting to use a type that is not a class or enumeration type in a qualified name.
 \begin{example}
-
 \begin{codeblock}
 template <class T> int f(typename T::B*);
 int i = f<int>(0);
@@ -7075,7 +7078,6 @@
 the specified member is not a non-type where a non-type is required.
 \end{itemize}
 \begin{example}
-
 \begin{codeblock}
 template <int I> struct X { };
 template <template <class T> class> struct Z { };
@@ -7108,7 +7110,6 @@
 Attempting to create ``pointer to member of \tcode{T}'' when \tcode{T} is not a
 class type.
 \begin{example}
-
 \begin{codeblock}
 template <class T> int f(int T::*);
 int i = f<int>(0);