Remove more inappropriate paragraph breaks.

Author: Eelis

source/algorithms.tex

@@ -6596,7 +6596,6 @@
 If we define \tcode{equiv(a, b)} as \tcode{!comp(a, b) \&\& !comp(b, a)},
 then the requirements are that \tcode{comp} and \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item \tcode{comp(a, b) \&\& comp(b, c)} implies \tcode{comp(a, c)}
 \item \tcode{equiv(a, b) \&\& equiv(b, c)} implies \tcode{equiv(a, c)}
@@ -7507,7 +7506,6 @@
   For the overload with an \tcode{ExecutionPolicy},
   \bigoh{N \log N} swaps and \bigoh{N} applications of the predicate.
 \end{itemize}
-
 \end{itemdescr}
 
 \indexlibraryglobal{stable_partition}%
@@ -8349,7 +8347,6 @@
 {heap with respect to comp and proj@heap with respect to \tcode{comp} and \tcode{proj}}
 for a comparator and projection \tcode{comp} and \tcode{proj}
 if its elements are organized such that:
-
 \begin{itemize}
 \item
   With \tcode{$N$ = b - a}, for all $i$, $0 < i < N$,
@@ -10786,7 +10783,6 @@
 \pnum
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
-
 \begin{itemdecl}
 template<class I>
 concept @\defexposconcept{nothrow-input-iterator}@ = // \expos

source/basic.tex

@@ -253,7 +253,6 @@
 namespace N { int d; }          // defines \tcode{N} and \tcode{N::d}
 namespace N1 = N;               // defines \tcode{N1}
 X anX;                          // defines \tcode{anX}
-
 \end{codeblock}
 whereas these are just declarations:
 \begin{codeblock}
@@ -701,7 +700,6 @@
 
 \pnum
 For the purposes of the preceding requirements:
-
 \begin{itemize}
 \item If \tcode{D} is a class with an implicitly-declared
 constructor\iref{class.default.ctor,class.copy.ctor},
@@ -4226,7 +4224,6 @@
 
 \pnum
 Comparing alignments is meaningful and provides the obvious results:
-
 \begin{itemize}
 \item Two alignments are equal when their numeric values are equal.
 \item Two alignments are different when their numeric values are not equal.
@@ -5578,7 +5575,6 @@
 
 \pnum
 Every integer type has an \term{integer conversion rank} defined as follows:
-
 \begin{itemize}
 \item No two signed integer types other than \keyword{char} and \tcode{\keyword{signed}
 \keyword{char}} (if \keyword{char} is signed) have the same rank, even if they have
@@ -6140,7 +6136,6 @@
 \item
 for some evaluation $X$, $A$ is dependency-ordered before $X$ and
 $X$ carries a dependency to $B$.
-
 \end{itemize}
 \begin{note}
 The relation ``is dependency-ordered before'' is analogous to

source/classes.tex

@@ -1584,7 +1584,6 @@
 that is of class type (or array thereof),
 the constructor selected to copy/move that member is trivial;
 \end{itemize}
-
 \indextext{constructor!move!non-trivial}%
 otherwise the copy/move constructor is
 \defnx{non-trivial}{constructor!copy!nontrivial}.
@@ -3204,7 +3203,6 @@
 destructor and \tcode{N} has a non-trivial constructor (for instance, if they declare or inherit
 virtual functions), the active member of \tcode{u} can be safely switched from \tcode{m} to
 \tcode{n} using the destructor and placement \grammarterm{new-expression} as follows:
-
 \begin{codeblock}
 u.m.~M();
 new (&u.n) N;
@@ -3382,7 +3380,6 @@
 \indextext{multiple inheritance}%
 A list of base classes can be specified in a class definition using
 the notation:
-
 \begin{bnf}
 \nontermdef{base-clause}\br
     \terminal{:} base-specifier-list
@@ -4837,7 +4834,6 @@
 \pnum
 A friend declaration that does not declare a function
 shall have one of the following forms:
-
 \begin{ncsimplebnf}
 \keyword{friend} elaborated-type-specifier \terminal{;}\br
 \keyword{friend} simple-type-specifier \terminal{;}\br
@@ -5342,7 +5338,6 @@
 non-static data members can be specified by a
 \grammarterm{ctor-initializer},
 which has the form
-
 \begin{bnf}
 \nontermdef{ctor-initializer}\br
     \terminal{:} mem-initializer-list
@@ -5804,7 +5799,6 @@
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6412,7 +6406,6 @@
 A binary operator expression \tcode{a @ b} is
 \defnx{usable}{usable!binary operator expression}
 if either
-
 \begin{itemize}
 \item
 \tcode{a} or \tcode{b} is of class or enumeration type and
@@ -6533,7 +6526,6 @@
 of type \tcode{R}\iref{cmp.categories}
 of glvalues \tcode{a} and \tcode{b} of the same type
 is defined as follows:
-
 \begin{itemize}
 \item
 If \tcode{a <=> b} is usable\iref{class.compare.default} and
@@ -6632,7 +6624,6 @@
 of a possibly-empty list of $n$ comparison category types
 $\tcode{T}_0$, $\tcode{T}_1$, $\dotsc$, $\tcode{T}_{n-1}$
 is defined as follows:
-
 \begin{itemize}
 \item
 If at least one $\tcode{T}_i$ is \tcode{std::partial_ordering},

source/compatibility.tex

@@ -2105,7 +2105,6 @@
 \effect
 The signatures of the following member functions changed from taking an
 \tcode{iterator} to taking a \tcode{const_iterator}:
-
 \begin{itemize}
 \item \tcode{insert(iter, val)} for \tcode{vector}, \tcode{deque}, \tcode{list},
 \tcode{set}, \tcode{multiset}, \tcode{map}, \tcode{multimap}
@@ -2177,7 +2176,6 @@
 Valid \CppIII{} code that relies on implicit boolean conversions will fail to
 compile with this revision of \Cpp{}. Such conversions occur in the
 following conditions:
-
 \begin{itemize}
 \item passing a value to a function that takes an argument of type \tcode{bool};
 \item using \tcode{operator==} to compare to \tcode{false} or \tcode{true};
@@ -3198,7 +3196,6 @@
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -3212,7 +3209,6 @@
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -3237,7 +3233,6 @@
 \pnum
 Header \libheaderref{cstdlib}:
 The following functions have different behavior:
-
 \begin{itemize}
 \item \tcode{atexit}
 \item \tcode{exit}

source/concepts.tex

@@ -150,7 +150,6 @@
 The following type \tcode{T} meets the explicitly stated syntactic requirements
 of concept \tcode{C} above but does not meet the additional implicit
 requirements:
-
 \begin{codeblock}
 struct T {
   bool operator==(const T&) const { return true; }
@@ -365,15 +364,13 @@
 such that \tcode{f()} is equality-preserving.
 Types \tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}
 only if:
-
 \begin{itemize}
 \item
 \tcode{To} is not an object or reference-to-object type, or
 \tcode{static_cast<To>(f())} is equal to \tcode{test(f)}.
 
 \item
 \tcode{FromR} is not a reference-to-object type, or
-
 \begin{itemize}
 \item
 If \tcode{FromR} is an rvalue reference to a non const-qualified type, the
@@ -486,7 +483,6 @@
 Users can customize the behavior of \libconcept{common_with} by specializing the
 \tcode{common_type} class template\iref{meta.trans.other}.
 \end{note}
-
 \end{itemdescr}
 
 \rSec2[concepts.arithmetic]{Arithmetic concepts}
@@ -540,12 +536,10 @@
 \end{itemize}
 \tcode{LHS} and \tcode{RHS} model
 \tcode{\libconcept{assignable_from}<LHS, RHS>} only if
-
 \begin{itemize}
 \item \tcode{addressof(lhs = rhs) == addressof(lcopy)}.
 
 \item After evaluating \tcode{lhs = rhs}:
-
 \begin{itemize}
 \item \tcode{lhs} is equal to \tcode{rcopy}, unless \tcode{rhs} is a non-const
 xvalue that refers to \tcode{lcopy}.
@@ -600,7 +594,6 @@
 \tcode{ranges::swap(E1, E2)} for subexpressions \tcode{E1}
 and \tcode{E2} is expression-equivalent to an expression
 \tcode{S} determined as follows:
-
 \begin{itemize}
 \item
   \tcode{S} is \tcode{(void)swap(E1, E2)}
@@ -808,7 +801,6 @@
 If \tcode{T} is an object type, then let \tcode{rv} be an rvalue of type
 \tcode{T} and \tcode{u2} a distinct object of type \tcode{T} equal to
 \tcode{rv}. \tcode{T} models \libconcept{move_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = rv;}, \tcode{u} is equal to \tcode{u2}.
 
@@ -835,15 +827,13 @@
 If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 \tcode{T} or \tcode{\keyword{const} T} or an rvalue of type \tcode{\keyword{const} T}.
 \tcode{T} models \libconcept{copy_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = v;},
 \tcode{u} is equal to \tcode{v}\iref{concepts.equality} and
 \tcode{v} is not modified.
 
 \item \tcode{T(v)} is equal to \tcode{v} and does not modify \tcode{v}.
 \end{itemize}
-
 \end{itemdescr}
 
 \rSec1[concepts.compare]{Comparison concepts}
@@ -882,7 +872,6 @@
 Let \tcode{e} be an expression such that
 \tcode{decltype((e))} is \tcode{T}.
 \tcode{T} models \exposconcept{boolean-testable-impl} only if:
-
 \begin{itemize}
 \item
 either \tcode{remove_cvref_t<T>} is not a class type, or
@@ -900,7 +889,6 @@
 \pnum
 A \defnadj{disqualifying}{parameter}
 is a function parameter whose declared type \tcode{P}
-
 \begin{itemize}
 \item
 is not dependent on a template parameter, and
@@ -948,7 +936,6 @@
 
 \pnum
 A \defnadj{disqualifying}{declaration} is
-
 \begin{itemize}
 \item
 a (non-template) function declaration that
@@ -1131,7 +1118,6 @@
 Given a type \tcode{T}, let \tcode{a}, \tcode{b}, and \tcode{c} be
 lvalues of type \tcode{const remove_reference_t<T>}.
 \tcode{T} models \libconcept{totally_ordered} only if
-
 \begin{itemize}
 \item Exactly one of \tcode{bool(a < b)}, \tcode{bool(a > b)}, or
       \tcode{bool(a == b)} is \tcode{true}.
@@ -1140,7 +1126,6 @@
 \item \tcode{bool(a <= b) == !bool(b < a)}.
 \item \tcode{bool(a >= b) == !bool(a < b)}.
 \end{itemize}
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -1339,7 +1324,6 @@
 and
 \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item
 \tcode{comp(a, b) \&\& comp(b, c)}