fixup: use \placeholder for various local variables and fix overfull hbox

Author: dietmarkuehl

source/exec.tex

@@ -5732,23 +5732,23 @@
 \end{codeblock}
 
 \pnum
-Let \tcode{out_sndr} be a subexpression denoting a sender
+Let \tcode{\placeholder{out_sndr}} be a subexpression denoting a sender
 returned from \tcode{affine_on(sndr, sch)} or one equal to such,
-and let \tcode{OutSndr} be the type \tcode{decltype((out_sndr))}.
-Let \tcode{out_rcvr} be a subexpression denoting a receiver that
-has an environment of type \tcode{Env} such that \tcode{\libconcept{sender_in}<OutSndr, Env>}
+and let \tcode{\placeholder{OutSndr}} be the type \tcode{decltype((\placeholder{out_sndr}))}.
+Let \tcode{\placeholder{out_rcvr}} be a subexpression denoting a receiver that
+has an environment of type \tcode{Env} such that \tcode{\libconcept{sender_in}<\placeholder{OutSndr}, Env>}
 is \tcode{true}.
-Let \tcode{op} be an lvalue referring to the operation state that
-results from connecting \tcode{out_sndr} to \tcode{out_rcvr}.
-Calling \tcode{start(op)} will start \tcode{sndr} on the current
-execution agent and execute completion operations on \tcode{out_rcvr}
+Let \tcode{\placeholder{op}} be an lvalue referring to the operation state that
+results from connecting \tcode{\placeholder{out_sndr}} to \tcode{\placeholder{out_rcvr}}.
+Calling \tcode{start(\placeholder{op})} will start \tcode{sndr} on the current
+execution agent and execute completion operations on \tcode{\placeholder{out_rcvr}}
 on an execution agent of the execution resource associated with
 \tcode{sch}.
 If the current execution resource is the same as the execution
 resource associated with \tcode{sch}, the completion operation on
-\tcode{out_rcvr} may be called before \tcode{start(op)} completes.
+\tcode{\placeholder{out_rcvr}} may be called before \tcode{start(op)} completes.
 If scheduling onto \tcode{sch} fails, an error completion on
-\tcode{out_rcvr} shall be executed on an unspecified execution
+\tcode{\placeholder{out_rcvr}} shall be executed on an unspecified execution
 agent.
 
 \rSec2[exec.inline.scheduler]{\tcode{execution::inline_scheduler}}
@@ -5794,22 +5794,22 @@
 \tcode{((void)sndr, auto(rcvr))} is potentially-throwing, and
 \item the expression
 \tcode{get_completion_scheduler<set_value_t>(get_env(sndr))} has
-type\brk{}\tcode{inline_scheduler} and is potentially-throwing
+type\brk{} \tcode{inline_\-sched\-ul\-er} and is potentially-throwing
 if and only if \tcode{get_env(sndr)} is potentially-throwing.
 \end{itemize}
 
 \pnum
-Let \tcode{o} be a non-const lvalue of type
-\tcode{\exposid{inline-state}<Rcvr>}, and let \tcode{REC(o)} be
-a non-const lvalue reference to an object of type \tcode{Rcvr} that
+Let \placeholder{o} be a non-\tcode{const} lvalue of type
+\tcode{\exposid{inline-state}<Rcvr>}, and let \tcode{REC(@\placeholder{o}@)} be
+a non-\tcode{const} lvalue reference to an object of type \tcode{Rcvr} that
 was initialized with the expression \tcode{rcvr} passed to an
-invocation of \tcode{connect} that returned \tcode{o}, then:
+invocation of \tcode{connect} that returned \placeholder{o}, then:
 
 \begin{itemize}
-\item the object to which \tcode{REC(o)} refers remains valid for
-the lifetime of the object to which \tcode{o} refers, and
-\item the expression \tcode{start(o)} is equivalent to
-\tcode{set_value(std::move(REC(o)))}.
+\item the object to which \tcode{REC(@\placeholder{o}@)} refers remains valid for
+the lifetime of the object to which \tcode{@\placeholder{o}@} refers, and
+\item the expression \tcode{start(@\placeholder{o}@)} is equivalent to
+\tcode{set_value(std::move(REC(@\placeholder{o}@)))}.
 \end{itemize}
 
 \rSec2[exec.task.scheduler]{\tcode{execution::task_scheduler}}
@@ -5860,7 +5860,7 @@
 \pnum
 \effects
 Initialize \exposid{sch_} with
-\tcode{allocate_shared<remove_cvref_t<Sch>>(alloc,\brk{} std::forward<Sch>(sch))}.
+\tcode{allocate_shared<remove_cvref_t<Sch>>(alloc,\brk{} std::forward<Sch>\brk{}(sch))}.
 
 \pnum
 \recommended
@@ -5882,7 +5882,7 @@
 \pnum
 \effects
 Returns an object of type \exposid{ts-sender} containing a sender
-initialized with \tcode{sched\-ule(\brk{}\exposid{SCHED}(*this))}.
+initialized with \tcode{sched\-ule(\brk{}\exposid{SCHED}\brk{}(*this))}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -5933,10 +5933,10 @@
 \end{codeblock}
 
 \pnum
-Let \tcode{sch} be an object of type \tcode{task_scheduler}
+Let \tcode{\placeholder{sch}} be an object of type \tcode{task_scheduler}
 and let \tcode{sndr} be an object of type \exposid{ts-sender} obtained
-from \tcode{schedule(sch)}.
-Then \tcode{get_completion_scheduler<set_value_t>(get_env(sndr)) == sch}
+from \tcode{schedule(\placeholder{sch})}.
+Then \tcode{get_completion_scheduler<set_value_t>(get_env(sndr)) == \placeholder{sch}}
 is \tcode{true}.
 The object \tcode{SENDER(sndr)} is the sender object contained by
 \tcode{sndr} or an object move constructed from it.
@@ -5948,12 +5948,12 @@
 
 \pnum
 \effects
-Let \tcode{r} be an object of a type that models \libconcept{receiver}
+Let \tcode{\placeholder{r}} be an object of a type that models \libconcept{receiver}
 and whose completion handlers result in invoking the corresponding
 completion handlers of \tcode{rcvr} or copy thereof.
 Returns an object of type \tcode{\exposid{state}<Rcvr>} containing
 an operation state object initialized with \tcode{connect(SENDER(*this),
-std::move(r))}.
+std::move(\placeholder{r}))}.
 
 \begin{codeblock}
 template<@\libconcept{receiver}@ R>
@@ -6151,7 +6151,7 @@
 \begin{itemdescr}
 \pnum
 The type \exposid{own-env-t} is \tcode{Environment::template
-env_type<decltype(get_env(\brk{}declval<Rcvr>()))>} if that
+env_type<decltype(get_env(\brk{}declval\brk{}<Rcvr>(\brk{})))\brk{}>} if that
 qualified-id is valid and denotes a type, \tcode{env<>} otherwise.
 \end{itemdescr}
 
@@ -6199,37 +6199,36 @@
 \begin{itemdescr}
 \pnum
 \effects
-Let \tcode{prom} be the object \tcode{\exposid{handle}.promise()}.
-Associates \tcode{STATE(prom)}, \tcode{RCVR(prom)}, and \tcode{SCHED(prom)}
+Let \tcode{\placeholder{prom}} be the object \tcode{\exposid{handle}.promise()}.
+Associates \tcode{STATE(\placeholder{prom})}, \tcode{RCVR(\placeholder{prom})}, and \tcode{SCHED(\placeholder{prom})}
 with \tcode{*this} as follows:
 
 \begin{itemize}
-\item \tcode{STATE(prom)} is \tcode{*this}.
-\item \tcode{RCVR(prom)} is \exposid{rcvr}.
-\item \tcode{SCHED(prom)} is the object initialized
+\item \tcode{STATE(\placeholder{prom})} is \tcode{*this}.
+\item \tcode{RCVR(\placeholder{prom})} is \exposid{rcvr}.
+\item \tcode{SCHED(\placeholder{prom})} is the object initialized
 with \tcode{scheduler_type(get_scheduler(get_env(\exposid{rcvr})))}
 if that expression is valid and \tcode{scheduler_type()} otherwise.
 If neither of these expressions is valid, the program is ill-formed.
 \end{itemize}
 
-Let \tcode{st} be \tcode{get_stop_token(get_env(\exposid{rcvr}))}.
-Initializes \tcode{prom.\exposid{token}} and
-\tcode{prom.\exposid{source}} such that
+Let \tcode{\placeholder{st}} be \tcode{get_stop_token(get_env(\exposid{rcvr}))}.
+Initializes \tcode{\placeholder{prom}.\exposid{token}} and
+\tcode{\placeholder{prom}.\exposid{source}} such that
 
 \begin{itemize}
 \item
-\tcode{prom.\exposid{token}.stop_requested()} returns
-\tcode{st.stop_requested()};
+\tcode{\placeholder{prom}.\exposid{token}.stop_requested()} returns
+\tcode{\placeholder{st}.stop_requested()};
 \item
-\tcode{prom.\exposid{token}.stop_possible()} returns
-\tcode{st.stop_possible()}; and
+\tcode{\placeholder{prom}.\exposid{token}.stop_possible()} returns
+\tcode{\placeholder{st}.stop_possible()}; and
 \item
 for types \tcode{Fn} and \tcode{Init} such that both
 \tcode{\libconcept{invocable}<Fn>} and
 \tcode{\libconcept{constructible_from}<Fn, Init>} are modeled,
 \tcode{stop_token_type::callback_type<Fn>} models
-\tcode{\exposconcept{stoppable-callback-for}<Fn,\brk{} stop_token_type, Init>}.
-Init>}.
+\tcode{\exposconcept{stoppable-callback-for}<Fn,\brk{} stop\-_token_type, Init>}.
 \end{itemize}
 
 After that invokes \tcode{\exposid{handle}.resume()}.
@@ -6301,11 +6300,11 @@
 \end{codeblock}
 
 \pnum
-Let \tcode{prom} be an object of \tcode{promise_type} and let \tcode{tsk} be
-the \tcode{task} object created by \tcode{prom.get_return_object()}.
-The description below refers to objects \tcode{STATE(prom)},
-\tcode{RCVR(prom)}, and \tcode{SCHED(prom)} associated
-with \tcode{tsk} during evalutation of \tcode{task::\exposid{state}<Rcvr>::start}
+Let \tcode{\placeholder{prom}} be an object of \tcode{promise_type} and let \tcode{\placeholder{tsk}} be
+the \tcode{task} object created by \tcode{\placeholder{prom}.get_return_object()}.
+The description below refers to objects \tcode{STATE(\placeholder{prom})},
+\tcode{RCVR(\placeholder{prom})}, and \tcode{SCHED(\placeholder{prom})} associated
+with \tcode{\placeholder{tsk}} during evalutation of \tcode{task::\exposid{state}<Rcvr>::start}
 for some receiver \tcode{Rcvr}.
 
 \pnum
@@ -6342,7 +6341,7 @@
 \pnum
 \returns
 A \tcode{task} object whose member \exposid{handle} is
-\tcode{coroutine_handle<promise_type>::\brk{}from_promise(*this)}.
+\tcode{coroutine_handle<promise_type>::\brk{}from_promise\brk{}(*this)}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -6396,15 +6395,15 @@
 \mandates
 \tcode{std::move(err.error)} is convertible to exactly one of the
 \tcode{set_error_t} argument types of \tcode{error_types}.
-Let \tcode{Cerr} be that type.
+Let \tcode{\placeholder{Cerr}} be that type.
 
 \pnum
 \returns
 An awaitable object of unspecified type\iref{expr.await} whose
 member functions arrange for the calling coroutine to be suspended
 and then completes the asynchronous operation associated with
 \tcode{STATE(*this)} by invoking \tcode{set_error(std::move(RCVR(*this)),
-Cerr(std::move(err.error)))}.
+\placeholder{Cerr}(std::move(err.error)))}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -6415,10 +6414,10 @@
 \begin{itemdescr}
 \pnum
 \returns
-If \tcode{@\libconcept{same_as}@<inline_scheduler, scheduler_type>} is \tcode{true}
-returns \tcode{as_awaitable(\brk{}std::forward<Sender>(sndr), *this)};
+If \tcode{\libconcept{same_as}<inline_scheduler, scheduler_type>} is \tcode{true}
+returns \tcode{as_awaitable(\brk{}std::\brk{}for\-ward<Sender>(sndr), *this)};
 otherwise returns
-\tcode{as_awaitable(affine_on(\brk{}std::forward<Sender>(sndr), \exposid{SCHED}(*this)), *this)}.
+\tcode{as_awaitable(affine_on(\brk{}std::\brk{}for\-ward<Sen\-der>(sndr), \exposid{SCHED}(*this)), *this)}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -6493,10 +6492,10 @@
 \begin{itemdescr}
 \pnum
 If there is no parameter with type \tcode{allocator_arg_t} then let
-\tcode{alloc} be \tcode{Allocator()}.
-Let \tcode{arg_next} be the parameter following the first
-\tcode{allocator_arg_t} parameter (if any) and let \tcode{alloc}
-be \tcode{Allocator(arg_next)}.
+\tcode{\placeholder{alloc}} be \tcode{Allocator()}.
+Let \tcode{\placeholder{arg_next}} be the parameter following the first
+\tcode{allocator_arg_t} parameter (if any) and let \tcode{\placeholder{alloc}}
+be \tcode{Allocator(\placeholder{arg_next})}.
 Then \tcode{PAlloc} is \tcode{allocator_traits<Allocator>::template
 re\-bind_alloc\brk{}<U>} where \tcode{U} is an unspecified type
 whose size and alignment are both \tcode{__STDCPP_DEFAULT_NEW_ALIGNMENT__}.
@@ -6506,15 +6505,15 @@
 
 \begin{itemize}
 \item The first parameter of type \tcode{allocator_arg_t} (if any) is not the last parameter.
-\item \tcode{Allocator(arg_next)} is a valid expression if there is a parameter
+\item \tcode{Allocator(\placeholder{arg_next})} is a valid expression if there is a parameter
    of type \tcode{allocator_arg_t}.
 \item \tcode{allocator_traits<PAlloc>::pointer} is a pointer type.
 \end{itemize}
 
 \pnum
 \effects
 Initializes an allocator \tcode{palloc} of type \tcode{PAlloc} with
-\tcode{alloc}.
+\tcode{\placeholder{alloc}}.
 Uses \tcode{palloc} to allocate storage for the
 smallest array of \tcode{U} sufficient to provide storage for a
 coroutine state of size \tcode{size}, and unspecified additional