Remove more inappropriate paragraph breaks.

Author: Eelis

source/algorithms.tex

@@ -6594,7 +6594,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)}
@@ -7505,7 +7504,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}%
@@ -8347,7 +8345,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$,
@@ -10784,7 +10781,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}
@@ -4214,7 +4213,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.
@@ -5566,7 +5564,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
@@ -6128,7 +6125,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

@@ -1585,7 +1585,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}.
@@ -3214,7 +3213,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;
@@ -3391,7 +3389,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
@@ -4848,7 +4845,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
@@ -5353,7 +5349,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
@@ -5815,7 +5810,6 @@
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6423,7 +6417,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
@@ -6544,7 +6537,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
@@ -6643,7 +6635,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

@@ -2088,7 +2088,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}
@@ -2160,7 +2159,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};
@@ -3181,7 +3179,6 @@
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -3195,7 +3192,6 @@
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -3220,7 +3216,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)}

source/containers.tex

@@ -641,7 +641,6 @@
 \ref{vector.modifiers})
 all container types defined in this Clause meet
 the following additional requirements:
-
 \begin{itemize}
 \item
 If an exception is thrown by an
@@ -704,7 +703,6 @@
 Likewise, the extent to which an implementation determines that a type cannot be
 an allocator is unspecified, except that as a minimum a type \tcode{A} shall not qualify
 as an allocator unless it meets both of the following conditions:
-
 \begin{itemize}
 \item The \grammarterm{qualified-id} \tcode{A::value_type}
 is valid and denotes a type\iref{temp.deduct}.
@@ -905,7 +903,6 @@
 the terms below are defined as if \tcode{A} were
 \tcode{allocator<T>} --- no allocator object needs to be created
 and user specializations of \tcode{allocator<T>} are not instantiated:
-
 \begin{itemize}
 \item
 \tcode{T} is \defnx{\oldconcept{DefaultInsertable} into \tcode{X}}
@@ -3933,14 +3930,12 @@
 to
 \tcode{j}
 is positive, the following condition holds:
-
 \begin{codeblock}
 value_comp(*j, *i) == false
 \end{codeblock}
 
 \pnum
 For associative containers with unique keys the stronger condition holds:
-
 \begin{codeblock}
 value_comp(*i, *j) != false
 \end{codeblock}
@@ -5960,7 +5955,6 @@
 
 \pnum
 The following exposition-only alias template may appear in deduction guides for sequence containers:
-
 \begin{codeblock}
 template<class InputIterator>
   using @\placeholdernc{iter-value-type}@ = typename iterator_traits<InputIterator>::value_type;  // \expos
@@ -8152,7 +8146,6 @@
 appends \tcode{sz - size()} default-inserted elements to the
 sequence.
 If \tcode{sz <= size()}, equivalent to:
-
 \begin{codeblock}
 list<T>::iterator it = begin();
 advance(it, sz);
@@ -9366,13 +9359,11 @@
 \pnum
 \effects
 Exchanges the contents of \tcode{x} and \tcode{y} as if by:
-
 \begin{codeblock}
 bool b = x;
 x = y;
 y = b;
 \end{codeblock}
-
 \end{itemdescr}
 
 \begin{itemdecl}