Fix overfull hboxes.

Author: zygoloid

source/algorithms.tex

@@ -1436,8 +1436,8 @@
     template<class I, class O>
     using replace_copy_result = copy_result<I, O>;
 
-    template<input_iterator I, sentinel_for<I> S, class T1, class T2, output_iterator<const T2&> O,
-             class Proj = identity>
+    template<input_iterator I, sentinel_for<I> S, class T1, class T2,
+             output_iterator<const T2&> O, class Proj = identity>
       requires indirectly_copyable<I, O> &&
                indirect_relation<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr replace_copy_result<I, O>
@@ -1909,7 +1909,8 @@
   namespace ranges {
     template<class I, class O> using partial_sort_copy_result = copy_result<I, O>;
 
-    template<input_iterator I1, sentinel_for<I1> S1, random_access_iterator I2, sentinel_for<I2> S2,
+    template<input_iterator I1, sentinel_for<I1> S1,
+             random_access_iterator I2, sentinel_for<I2> S2,
              class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
       requires indirectly_copyable<I1, I2> && sortable<I2, Comp, Proj2> &&
                indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
@@ -2183,7 +2184,8 @@
         }
     };
 
-    template<input_iterator I, sentinel_for<I> S, weakly_incrementable O1, weakly_incrementable O2,
+    template<input_iterator I, sentinel_for<I> S,
+             weakly_incrementable O1, weakly_incrementable O2,
              class Proj = identity, indirect_unary_predicate<projected<I, Proj>> Pred>
       requires indirectly_copyable<I, O1> && indirectly_copyable<I, O2>
       constexpr partition_copy_result<I, O1, O2>

source/concepts.tex

@@ -1044,7 +1044,8 @@
 \indexlibrary{\idxcode{regular}}%
 \begin{itemdecl}
 template<class T>
-  concept movable = is_object_v<T> && move_constructible<T> && assignable_from<T&, T> && swappable<T>;
+  concept movable = is_object_v<T> && move_constructible<T> &&
+                    assignable_from<T&, T> && swappable<T>;
 template<class T>
   concept copyable = copy_constructible<T> && movable<T> && assignable_from<T&, const T&>;
 template<class T>

source/iterators.tex

@@ -513,13 +513,15 @@
 
 \pnum
 The six categories of iterators correspond to the iterator concepts
-\libconcept{input_iterator}\iref{iterator.concept.input},
-\libconcept{output_iterator}\iref{iterator.concept.output},
-\libconcept{forward_iterator}\iref{iterator.concept.forward},
-\libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}
-\libconcept{random_access_iterator}\iref{iterator.concept.random.access},
+\begin{itemize}
+\item \libconcept{input_iterator}\iref{iterator.concept.input},
+\item \libconcept{output_iterator}\iref{iterator.concept.output},
+\item \libconcept{forward_iterator}\iref{iterator.concept.forward},
+\item \libconcept{bidirectional_iterator}\iref{iterator.concept.bidir}
+\item \libconcept{random_access_iterator}\iref{iterator.concept.random.access},
 and
-\libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
+\item \libconcept{contiguous_iterator}\iref{iterator.concept.contiguous},
+\end{itemize}
 respectively.
 The generic term \defn{iterator} refers to any type that models the
 \libconcept{input_or_output_iterator} concept\iref{iterator.concept.iterator}.
@@ -1536,7 +1538,8 @@
 
 \pnum
 The \libconcept{sized_sentinel_for} concept specifies
-requirements on an \libconcept{input_or_output_iterator} and a \libconcept{sentinel_for}
+requirements on an \libconcept{input_or_output_iterator} and
+a corresponding \libconcept{sentinel_for}
 that allow the use of the \tcode{-} operator to compute the distance
 between them in constant time.
 

source/ranges.tex

@@ -360,12 +360,17 @@
   Otherwise, if \tcode{E} is an lvalue,
   \tcode{\placeholdernc{decay-copy}(E.end())}
   if it is a valid expression and its type \tcode{S} models
-  \tcode{sentinel_for<decltype(\brk{}ranges::\brk{}begin(E))>}.
+  \begin{codeblock}
+  sentinel_for<decltype(ranges::begin(E))>
+  \end{codeblock}
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(end(E))} if it is a valid
   expression and its type \tcode{S} models
-  \tcode{sentinel_for<decltype(\brk{}ranges::\brk{}begin(E))>} with overload
+  \begin{codeblock}
+  sentinel_for<decltype(ranges::begin(E))>
+  \end{codeblock}
+  with overload
   resolution performed in a context that includes the declarations:
   \begin{codeblock}
   template<class T> void end(T&&) = delete;
@@ -480,12 +485,17 @@
 \item
   If \tcode{E} is an lvalue, \tcode{\placeholdernc{decay-copy}(E.rend())}
   if it is a valid expression and its type \tcode{S} models
-  \tcode{sentinel_for<\brk{}decltype(ranges::rbegin(E))>}.
+  \begin{codeblock}
+  sentinel_for<decltype(ranges::rbegin(E))>
+  \end{codeblock}
 
 \item
   Otherwise, \tcode{\placeholdernc{decay-copy}(rend(E))} if it is a valid
   expression and its type \tcode{S} models
-  \tcode{sentinel_for<decltype(\brk{}ranges::rbegin(E))>} with overload
+  \begin{codeblock}
+  sentinel_for<decltype(ranges::rbegin(E))>
+  \end{codeblock}
+  with overload
   resolution performed in a context that includes the declaration:
   \begin{codeblock}
   template<class T> void rend(T&&) = delete;
@@ -4874,8 +4884,8 @@
 \begin{itemdescr}
 \pnum
 \effects
-Initializes \tcode{base_} with \tcode{views::all(std::forward<R>(r))} and
-\tcode{pattern_} with \tcode{views::all(std\brk{}::forward<P>(p))}.
+Initializes \tcode{base_} with \tcode{views::all(std::forward<R>(r))}, and
+\tcode{pattern_} with \tcode{views::all(\brk{}std::forward<P>(p))}.
 \end{itemdescr}
 
 \indexlibrary{\idxcode{split_view}!\idxcode{split_view}}%
@@ -4889,7 +4899,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Initializes \tcode{base_} with \tcode{views::all(std::forward<R>(r))} and
+Initializes \tcode{base_} with \tcode{views::all(std::forward<R>(r))}, and
 \tcode{pattern_} with \tcode{single_view\{\brk{}std::move(e)\}}.
 \end{itemdescr}
 
@@ -5252,10 +5262,10 @@
 
 \begin{itemize}
 \item If \tcode{T} models \libconcept{input_or_output_iterator} and
-  \tcode{decltype((F))} models \tcode{\libconcept{convertible_to}<iter_difference_t<T>>},
+  \tcode{decltype((F))} models \tcode{\libconcept{convertible_to}<iter_differ\-ence_t<T>>},
   \begin{itemize}
   \item \tcode{subrange\{E, E + static_cast<iter_difference_t<T>>(F)\}}
-    if \tcode{T} models \libconcept{random_access_iterator}.
+    if \tcode{T} models \libconcept{random_access_\-it\-er\-ator}.
   \item Otherwise,
     \tcode{subrange\{counted_iterator\{E, F\}, default_sentinel\}}.
 \end{itemize}