Reduce spacing after INVOKE, DECAY_COPY, GENERALIZED_SUM,

GENERALIZED_NONCOMMUTATIVE_SUM, and node_handle throughout.

This fixes an issue where PDF viewers are unable to find "INVOKE<" (and
instead the user must search for "INVOKE <").

Also fixed a few places where we had hardcoded breaks inside \tcode to
instead use \brk, removing some spurious whitespace in code snippets
where lines have since reflowed.

Fixes #1510.

Author: zygoloid

source/containers.tex

@@ -1224,7 +1224,7 @@
 is empty, it contains no allocator.
 
 \pnum
-Class \tcode{\textit{node_handle}} is for exposition only. An implementation is
+Class \tcode{\placeholder{node_handle}} is for exposition only. An implementation is
 permitted to provide equivalent functionality without providing a class with
 this name.
 
@@ -1237,7 +1237,7 @@
 
 \begin{codeblock}
 template<@\unspecnc@>
-  class @\textit{node_handle}@ {
+  class @\placeholder{node_handle}@ {
   public:
     // These type declarations are described in Tables \ref{tab:containers.associative.requirements} and \ref{tab:HashRequirements}.
     using value_type     = @\seebelownc{}@;   // not present for map containers
@@ -1253,10 +1253,10 @@
     optional<allocator_type> alloc_;
 
   public:
-    constexpr @\textit{node_handle}@() noexcept : ptr_(), alloc_() {}
-    ~@\textit{node_handle}@();
-    @\textit{node_handle}@(@\textit{node_handle}@&&) noexcept;
-    @\textit{node_handle}@& operator=(@\textit{node_handle}@&&);
+    constexpr @\placeholdernc{node_handle}@() noexcept : ptr_(), alloc_() {}
+    ~@\placeholdernc{node_handle}@();
+    @\placeholdernc{node_handle}@(@\placeholdernc{node_handle}@&&) noexcept;
+    @\placeholdernc{node_handle}@& operator=(@\placeholdernc{node_handle}@&&);
 
     value_type& value() const;          // not present for map containers
     key_type& key() const;              // not present for set containers
@@ -1266,32 +1266,32 @@
     explicit operator bool() const noexcept;
     bool empty() const noexcept;
 
-    void swap(@\textit{node_handle}@&)
+    void swap(@\placeholdernc{node_handle}@&)
       noexcept(ator_traits::propagate_on_container_swap::value ||
                ator_traits::is_always_equal::value);
 
-    friend void swap(@\textit{node_handle}@& x, @\textit{node_handle}@& y) noexcept(noexcept(x.swap(y))) {
+    friend void swap(@\placeholdernc{node_handle}@& x, @\placeholdernc{node_handle}@& y) noexcept(noexcept(x.swap(y))) {
       x.swap(y);
     }
 };
 \end{codeblock}
 
-\rSec3[container.node.cons]{\tcode{\textit{node_handle}} constructors, copy, and assignment}
+\rSec3[container.node.cons]{\tcode{\placeholder{node_handle}} constructors, copy, and assignment}
 
 \begin{itemdecl}
-@\textit{node_handle}@(@\textit{node_handle}@&& nh) noexcept;
+@\placeholdernc{node_handle}@(@\placeholdernc{node_handle}@&& nh) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\effects Constructs a \tcode{\textit{node_handle}} object initializing
+\effects Constructs a \tcode{\placeholder{node_handle}} object initializing
 \tcode{ptr_} with \tcode{nh.ptr_}.  Move constructs \tcode{alloc_} with
 \tcode{nh.alloc_}.  Assigns \tcode{nullptr} to \tcode{nh.ptr_} and assigns
 \tcode{nullopt} to \tcode{nh.alloc_}.
 \end{itemdescr}
 
 \begin{itemdecl}
-@\textit{node_handle}@& operator=(@\textit{node_handle}@&& nh);
+@\placeholdernc{node_handle}@& operator=(@\placeholdernc{node_handle}@&& nh);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1324,10 +1324,10 @@
 \pnum \throws Nothing.
 \end{itemdescr}
 
-\rSec3[container.node.dtor]{\tcode{\textit{node_handle}} destructor}
+\rSec3[container.node.dtor]{\tcode{\placeholder{node_handle}} destructor}
 
 \begin{itemdecl}
-~@\textit{node_handle}@();
+~@\placeholdernc{node_handle}@();
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1338,7 +1338,7 @@
 \tcode{ator_traits::rebind_traits<container_node_type>::deallocate}.
 \end{itemdescr}
 
-\rSec3[container.node.observers]{\tcode{\textit{node_handle}} observers}
+\rSec3[container.node.observers]{\tcode{\placeholder{node_handle}} observers}
 
 \begin{itemdecl}
 value_type& value() const;
@@ -1427,10 +1427,10 @@
 \returns \tcode{ptr_ == nullptr}.
 \end{itemdescr}
 
-\rSec3[container.node.modifiers]{\tcode{\textit{node_handle}} modifiers}
+\rSec3[container.node.modifiers]{\tcode{\placeholder{node_handle}} modifiers}
 
 \begin{itemdecl}
-void swap(@\textit{node_handle}@& nh)
+void swap(@\placeholdernc{node_handle}@& nh)
   noexcept(ator_traits::propagate_on_container_swap::value ||
            ator_traits::is_always_equal::value);
 \end{itemdecl}
@@ -1456,7 +1456,7 @@
 
 \begin{codeblock}
 template <class Iterator, class NodeType>
-struct @\textit{INSERT_RETURN_TYPE}@
+struct @\placeholder{INSERT_RETURN_TYPE}@
 {
   Iterator position;
   bool     inserted;
@@ -1465,8 +1465,8 @@
 \end{codeblock}
 
 \pnum
-The name \textit{\tcode{INSERT_RETURN_TYPE}} is exposition only.
-\textit{\tcode{INSERT_RETURN_TYPE}} has the template parameters,
+The name \tcode{\placeholder{INSERT_RETURN_TYPE}} is exposition only.
+\tcode{\placeholder{INSERT_RETURN_TYPE}} has the template parameters,
 data members, and special members specified above.
 It has no base classes or members other than those specified.
 
@@ -1650,7 +1650,7 @@
  compile time                       \\ \rowsep
 
 \tcode{X::node_type} &
- a specialization of a \tcode{\textit{node_handle}}
+ a specialization of a \tcode{\placeholder{node_handle}}
  class template, such that the public nested types are
  the same types as the corresponding types in \tcode{X}. &
  see~\ref{container.node} &
@@ -2289,7 +2289,7 @@
 \\ \rowsep
 %
 \tcode{X::node_type} &
- a specialization of a \tcode{\textit{node_handle}}
+ a specialization of a \tcode{\placeholder{node_handle}}
  class template, such that the public nested types are
  the same types as the corresponding types in \tcode{X}. &
  see~\ref{container.node} &
@@ -6081,7 +6081,7 @@
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = @\unspec@;
-    using insert_return_type     = @\textit{INSERT_RETURN_TYPE}@<iterator, node_type>;
+    using insert_return_type     = @\placeholdernc{INSERT_RETURN_TYPE}@<iterator, node_type>;
 
     class value_compare {
       friend class map;
@@ -6959,7 +6959,7 @@
     using reverse_iterator       = std::reverse_iterator<iterator>;
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using node_type              = @\unspec@;
-    using insert_return_type     = @\textit{INSERT_RETURN_TYPE}@<iterator, node_type>;
+    using insert_return_type     = @\placeholdernc{INSERT_RETURN_TYPE}@<iterator, node_type>;
 
     // \ref{set.cons}, construct/copy/destroy
     set() : set(Compare()) { }
@@ -7662,7 +7662,7 @@
     using local_iterator       = @\impdefx{type of \tcode{unordered_map::local_iterator}}@; // see \ref{container.requirements}
     using const_local_iterator = @\impdefx{type of \tcode{unordered_map::const_local_iterator}}@; // see \ref{container.requirements}
     using node_type            = @\unspec@;
-    using insert_return_type   = @\textit{INSERT_RETURN_TYPE}@<iterator, node_type>;
+    using insert_return_type   = @\placeholdernc{INSERT_RETURN_TYPE}@<iterator, node_type>;
 
     // \ref{unord.map.cnstr}, construct/copy/destroy
     unordered_map();
@@ -8578,7 +8578,7 @@
     using local_iterator       = @\impdefx{type of \tcode{unordered_set::local_iterator}}@; // see \ref{container.requirements}
     using const_local_iterator = @\impdefx{type of \tcode{unordered_set::const_local_iterator}}@; // see \ref{container.requirements}
     using node_type            = @\unspec@;
-    using insert_return_type   = @\textit{INSERT_RETURN_TYPE}@<iterator, node_type>;
+    using insert_return_type   = @\placeholdernc{INSERT_RETURN_TYPE}@<iterator, node_type>;
 
     // \ref{unord.set.cnstr}, construct/copy/destroy
     unordered_set();

source/numerics.tex

@@ -30,23 +30,23 @@
 
 \rSec1[numerics.defns]{Definitions}
 
-\indexlibrary{generalized_noncommutative_sum@\tcode{\textit{GENERALIZED_NONCOMMUTATIVE_SUM}}}%
+\indexlibrary{generalized_noncommutative_sum@\tcode{\placeholder{GENERALIZED_NONCOMMUTATIVE_SUM}}}%
 \pnum
-Define \tcode{\textit{GENERALIZED_NONCOMMUTATIVE_SUM}(op, a1, ..., aN)} as follows:
+Define \tcode{\placeholdernc{GENERALIZED_NONCOMMUTATIVE_SUM}(op, a1, ..., aN)} as follows:
 \begin{itemize}
 \item
 \tcode{a1} when \tcode{N} is \tcode{1}, otherwise
 
 \item
-\tcode{op(\textit{GENERALIZED_NONCOMMUTATIVE_SUM}(op, a1, ..., aK),} \\
-\tcode{\phantom{op(}\textit{GENERALIZED_NONCOMMUTATIVE_SUM}(op, aM, ..., aN))}
+\tcode{op(\placeholdernc{GENERALIZED_NONCOMMUTATIVE_SUM}(op, a1, ..., aK),} \\
+\tcode{\phantom{op(}\placeholdernc{GENERALIZED_NONCOMMUTATIVE_SUM}(op, aM, ..., aN))}
 for any \tcode{K} where $1 < \mathtt{K}+1 = \mathtt{M} \leq \mathtt{N}$.
 \end{itemize}
 
-\indexlibrary{generalized_sum@\tcode{\textit{GENERALIZED_SUM}}}%
+\indexlibrary{generalized_sum@\tcode{\placeholder{GENERALIZED_SUM}}}%
 \pnum
-Define \tcode{\textit{GENERALIZED_SUM}(op, a1, ..., aN)} as
-\tcode{\textit{GENERALIZED_NONCOMMUTATIVE_SUM}(op, b1, ..., bN)}
+Define \tcode{\placeholdernc{GENERALIZED_SUM}(op, a1, ..., aN)} as
+\tcode{\placeholdernc{GENERALIZED_NONCOMMUTATIVE_SUM}(op, b1, ..., bN)},
 where
 \tcode{b1, ..., bN} may be any permutation of \tcode{a1, ..., aN}.
 
@@ -8946,7 +8946,7 @@
 
 \pnum
 \returns
-\tcode{\textit{GENERALIZED_SUM}(binary_op, init, *i, ...)} for every \tcode{i} in \range{first}{last}.
+\tcode{\placeholdernc{GENERALIZED_SUM}(binary_op, init, *i, ...)} for every \tcode{i} in \range{first}{last}.
 
 \pnum
 \complexity
@@ -9074,7 +9074,7 @@
 \pnum
 \returns
 \begin{codeblock}
-@\textit{GENERALIZED_SUM}@(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)
+@\placeholdernc{GENERALIZED_SUM}@(binary_op1, init, binary_op2(*i, *(first2 + (i - first1))), ...)
 \end{codeblock}
 for every iterator \tcode{i} in \range{first1}{last1}.
 
@@ -9117,7 +9117,7 @@
 \pnum
 \returns
 \begin{codeblock}
-@\textit{GENERALIZED_SUM}@(binary_op, init, unary_op(*i), ...)
+@\placeholdernc{GENERALIZED_SUM}@(binary_op, init, unary_op(*i), ...)
 \end{codeblock}
 for every iterator \tcode{i} in \range{first}{last}.
 

source/threads.tex

@@ -272,9 +272,9 @@
 
 \pnum
 In several places in this Clause the operation
-\indextext{DECAY_COPY@\tcode{\textit{DECAY_COPY}}}%
-\indexlibrary{DECAY_COPY@\tcode{\textit{DECAY_COPY}}}%
-{\tcode{\textit{DECAY_COPY}(x)}} is used. All
+\indextext{DECAY_COPY@\tcode{\placeholder{DECAY_COPY}}}%
+\indexlibrary{DECAY_COPY@\tcode{\placeholder{DECAY_COPY}}}%
+{\tcode{\placeholdernc{DECAY_COPY}(x)}} is used. All
 such uses mean call the function \tcode{decay_copy(x)} and use the
 result, where \tcode{decay_copy} is defined as follows:
 
@@ -520,8 +520,12 @@
 \pnum
 \requires\ \tcode{F} and each \tcode{Ti} in \tcode{Args} shall satisfy the
 \tcode{MoveConstructible} requirements.
-\tcode{\textit{INVOKE}(\textit{DECAY_COPY}(}
-\tcode{std::forward<F>(f)), \textit{DECAY_COPY}(std::forward<Args>(args))...)}~(\ref{func.require}) shall be
+\tcode{%
+\placeholdernc{INVOKE}(\brk{}%
+\placeholdernc{DECAY_COPY}(\brk{}%
+std::forward<F>(f)),
+\placeholdernc{DECAY_COPY}(\brk{}%
+std::forward<Args>(\brk{}args))...)}~(\ref{func.require}) shall be
 a valid expression.
 
 \pnum
@@ -531,14 +535,18 @@
 
 \pnum
 \effects\ Constructs an object of type \tcode{thread}. The new thread of execution executes
-\tcode{\textit{INVOKE}(\textit{DECAY_COPY}(}\
-\tcode{std::forward<F>(f)), \textit{DECAY_COPY}(std::forward<Args>(args))...)} with the calls to
-\brk{}\tcode{\textit{DECAY_COPY}} being evaluated in the constructing thread. Any return value from this invocation
+\tcode{%
+\placeholdernc{INVOKE}(\brk{}%
+\placeholdernc{DECAY_COPY}(\brk{}%
+std::forward<F>(f)),
+\placeholdernc{DECAY_COPY}(\brk{}%
+std::forward<Args>(\brk{}args))...)} with the calls to
+\tcode{\placeholder{DECAY_COPY}} being evaluated in the constructing thread. Any return value from this invocation
 is ignored. \begin{note} This implies that any exceptions not thrown from the invocation of the copy
 of \tcode{f} will be thrown in the constructing thread, not the new thread. \end{note} If the
 invocation of
-\tcode{\textit{INVOKE}(\textit{DECAY_COPY}(}
-\tcode{std::forward<F>(f)), \textit{DECAY_COPY}(std::forward<Args>(args))...)}
+\tcode{\placeholdernc{INVOKE}(\placeholdernc{DECAY_COPY}(}
+\tcode{std::forward<F>(f)), \placeholdernc{DECAY_COPY}(std::forward<Args>(args))...)}
 terminates with an uncaught exception, \tcode{terminate} shall be called.
 
 
@@ -2782,17 +2790,17 @@
 \begin{itemdescr}
 \pnum
 \requires
-\tcode{\textit{INVOKE}(\brk{}}
-\tcode{std::forward<Callable>(func),
-std::forward<Args>(args)...)} \brk{}(\ref{func.require}) shall be
+\tcode{\placeholdernc{INVOKE}(\brk{}%
+std::forward<Callable>(func),
+std::forward<Args>(args)...)}~(\ref{func.require}) shall be
 a valid expression.
 
 \pnum
 \effects An execution of \tcode{call_once} that does not call its \tcode{func} is a
 \term{passive} execution. An execution of \tcode{call_once} that calls its \tcode{func}
 is an \term{active} execution. An active execution shall call
-\tcode{\textit{INVOKE}(}
-\tcode{std::forward<Callable>(func),
+\tcode{\placeholdernc{INVOKE}(\brk{}%
+std::forward<Callable>(func),
 std::forward<Args>(args)...)}. If such a call to \tcode{func}
 throws an exception the execution is \term{exceptional}, otherwise it is \term{returning}.
 An exceptional execution shall propagate the exception to the caller of
@@ -4822,17 +4830,17 @@
 \begin{itemize}
 \item
 If \tcode{launch::async} is set in \tcode{policy}, calls
-\tcode{\textit{INVOKE}(\textit{DECAY_COPY}(std::forward<F>(f)),}
-\tcode{\textit{DECAY_COPY}(std::forward<Args>(args))...)}
+\tcode{\placeholdernc{INVOKE}(\placeholdernc{DECAY_COPY}(std::forward<F>(f)),}
+\tcode{\placeholdernc{DECAY_COPY}(std::forward<Args>(args))...)}
 (\ref{func.require}, \ref{thread.thread.constr})
 as if in a new thread of execution represented by a \tcode{thread} object
-with the calls to \tcode{\textit{DECAY_COPY}()} being evaluated in the thread that called \tcode{async}.
+with the calls to \tcode{\placeholdernc{DECAY_COPY}()} being evaluated in the thread that called \tcode{async}.
 Any return value
 is stored as the result in the
 shared state. Any exception propagated from
 the execution of
-\tcode{\textit{INVOKE}(\textit{DECAY_COPY}(std::forward<F>(f)),
-\textit{DECAY_COPY}(std::forward<Args>(args))...)}
+\tcode{\placeholdernc{INVOKE}(\placeholdernc{DECAY_COPY}(std::forward<F>(f)),
+\placeholdernc{DECAY_COPY}(std::forward<Args>(args))...)}
 is stored as the exceptional result in the shared state.
 The \tcode{thread} object is
 stored in the shared state
@@ -4841,13 +4849,13 @@
 
 \item
 If \tcode{launch::deferred} is set in \tcode{policy},
-stores \tcode{\textit{DECAY_COPY}(std::forward<F>(f))} and
-\tcode{\textit{DECAY_COPY}(std::forward<Args>(args))...}
+stores \tcode{\placeholdernc{DECAY_COPY}(std::forward<F>(f))} and
+\tcode{\placeholdernc{DECAY_COPY}(std::forward<Args>(args))...}
 in the shared state. These copies of \tcode{f} and \tcode{args} constitute
 a \defn{deferred function}. Invocation of the deferred function evaluates
-\tcode{\textit{INVOKE}(std::move(g), std::move(xyz))} where \tcode{g} is the stored value of
-\tcode{\textit{DECAY_COPY}(std::forward<F>(f))} and \tcode{xyz} is the stored copy of
-\tcode{\textit{DECAY_COPY}(std::forward<Args>(args))...}.
+\tcode{\placeholdernc{INVOKE}(std::move(g), std::move(xyz))} where \tcode{g} is the stored value of
+\tcode{\placeholdernc{DECAY_COPY}(std::forward<F>(f))} and \tcode{xyz} is the stored copy of
+\tcode{\placeholdernc{DECAY_COPY}(std::forward<Args>(args))...}.
 Any return value is stored
 as the result in the shared state.
 Any exception propagated
@@ -4861,7 +4869,7 @@
 on an asynchronous return object referring to
 this shared state shall invoke the
 deferred function in the thread that called the waiting function.
-Once evaluation of \tcode{\textit{INVOKE}(std::move(g), std::move(xyz))} begins, the function is no longer
+Once evaluation of \tcode{\placeholdernc{INVOKE}(std::move(g), std::move(xyz))} begins, the function is no longer
 considered deferred.
 \begin{note} If this policy is specified together with other policies, such as when using a
 \tcode{policy} value of \tcode{launch::async | launch::deferred}, implementations should defer
@@ -5026,7 +5034,7 @@
 \begin{itemdescr}
 \pnum
 \requires
-\tcode{\textit{INVOKE}<R>(f, t1, t2, ..., tN)}, where \tcode{t1, t2, ..., tN} are values
+\tcode{\placeholdernc{INVOKE}<R>(f, t1, t2, ..., tN)}, where \tcode{t1, t2, ..., tN} are values
 of the corresponding types in \tcode{ArgTypes...}, shall be a valid expression. Invoking
 a copy of \tcode{f} shall behave the same as invoking \tcode{f}.
 
@@ -5148,7 +5156,7 @@
 
 \begin{itemdescr}
 \pnum
-\effects As if by \tcode{\textit{INVOKE}<R>(f, t1, t2, ..., tN)},
+\effects As if by \tcode{\placeholdernc{INVOKE}<R>(f, t1, t2, ..., tN)},
 where \tcode{f} is the
 stored task of \tcode{*this} and
 \tcode{t1, t2, ..., tN} are the values in \tcode{args...}. If the task returns normally,
@@ -5178,7 +5186,7 @@
 
 \begin{itemdescr}
 \pnum
-\effects As if by \tcode{\textit{INVOKE}<R>(f, t1, t2, ..., tN)},
+\effects As if by \tcode{\placeholdernc{INVOKE}<R>(f, t1, t2, ..., tN)},
 where \tcode{f} is the stored task and
 \tcode{t1, t2, ..., tN} are the values in \tcode{args...}. If the task returns normally,
 the return value is stored as the asynchronous result in the shared state of