fixup: add up to 34.9.10.4

Author: jensmaurer

source/exec.tex

@@ -2609,6 +2609,231 @@
 the implementation is allowed to omit
 the \tcode{exception_ptr} error completion signature from the set.
 
+\rSec3[exec.adapt.obj]{Closure objects}
+
+\pnum
+A \defnadj{pipeable}{sender adaptor closure object} is a function object
+that accepts one or more \tcode{sender} arguments and returns a \tcode{sender}.
+For a pipeable sender adaptor closure object \tcode{c} and
+an expression \tcode{sndr}
+such that \tcode{decltype((sndr))} models \tcode{sender},
+the following expressions are equivalent and yield a \tcode{sender}:
+\begin{codeblock}
+c(sndr)
+sndr | c
+\end{codeblock}
+Given an additional pipeable sender adaptor closure object \tcode{d},
+the expression \tcode{c | d} produces
+another pipeable sender adaptor closure object \tcode{e}:
+
+\tcode{e} is a perfect forwarding call wrapper\iref{func.require}
+with the following properties:
+\begin{itemize}
+\item
+Its target object is an object \tcode{d2} of type \tcode{decltype(auto(d))}
+direct-non-list-initialized with \tcode{d}.
+\item
+It has one bound argument entity,
+an object \tcode{c2} of type \tcode{decltype(auto(c))}
+direct-non-list-initialized with \tcode{c}.
+\item
+Its call pattern is \tcode{d2(c2(arg))},
+where arg is the argument used in a function call expression of \tcode{e}.
+\end{itemize}
+The expression \tcode{c | d} is well-formed if and only if
+the initializations of the state entities\iref{func.def} of \tcode{e}
+are all well-formed.
+
+\pnum
+An object \tcode{t} of type \tcode{T} is
+a pipeable sender adaptor closure object
+if \tcode{T} models \tcode{\libconcept{derived_from}<sender_adaptor_closure<T>>},
+\tcode{T} has no other base classes
+of type \tcode{sender_adaptor_closure<U>} for any other type \tcode{U}, and
+\tcode{T} does not satisfy \tcode{sender}.
+
+\pnum
+The template parameter \tcode{D} for sender_adaptor_closure can be
+an incomplete type.
+Before any expression of type \cv{} \tcode{D} appears as
+an operand to the \tcode{|} operator,
+\tcode{D} shall be complete and
+model \tcode{\libconcept{derived_from}<sender_adaptor_closure<D>>}.
+The behavior of an expression involving an object of type \cv{} \tcode{D}
+as an operand to the \tcode{|} operator is undefined
+if overload resolution selects a program-defined \tcode{operator|} function.
+
+\pnum
+A \defnadj{pipeable}{sender adaptor object} is a customization point object
+that accepts a \tcode{sender} as its first argument and
+returns a \tcode{sender}.
+If a pipeable sender adaptor object accepts only one argument,
+then it is a pipeable sender adaptor closure object.
+
+\pnum
+If a pipeable sender adaptor object adaptor accepts more than one argument,
+then let \tcode{sndr} be an expression
+such that \tcode{decltype((sndr))} models \libconcept{sender},
+let \tcode{args...} be arguments
+such that \tcode{adaptor(sndr, args...)} is a well-formed expression
+as specified below, and
+let \tcode{BoundArgs} be a pack that denotes \tcode{decltype(auto(args))...}.
+The expression \tcode{adaptor(args...)} produces
+a pipeable sender adaptor closure object \tcode{f}
+that is a perfect forwarding call wrapper with the following properties:
+\begin{itemize}
+\item
+Its target object is a copy of adaptor.
+\item
+Its bound argument entities \tcode{bound_args} consist of
+objects of types \tcode{BoundArgs...} direct-non-list-initialized with
+\tcode{std::forward<decltype((args))>(args)...}, respectively.
+\item
+Its call pattern is \tcode{adaptor(rcvr, bound_args...)},
+where \tcode{rcvr} is
+the argument used in a function call expression of \tcode{f}.
+\end{itemize}
+The expression \tcode{adaptor(args...)} is well-formed if and only if
+the initializations of the bound argument entities of the result,
+as specified above, are all well-formed.
+
+\rSec3[exec.starts.on]{\tcode{execution::starts_on}}
+
+\pnum
+\tcode{starts_on} adapts an input sender into a sender
+that will start on an execution agent belonging to
+a particular scheduler's associated execution resource.
+
+\pnum
+The name \tcode{starts_on} denotes a customization point object.
+For subexpressions \tcode{sch} and \tcode{sndr},
+if \tcode{decltype((sch))} does not satisfy \libconcept{scheduler}, or
+\tcode{decltype((sndr))} does not satisfy \libconcept{sender},
+\tcode{starts_on(sch, sndr)} is ill-formed.
+
+\pnum
+Otherwise,
+the expression \tcode{starts_on(sch, sndr)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(
+  @\exposid{query-or-default}@(get_domain, sch, default_domain()),
+  @\exposid{make-sender}@(starts_on, sch, sndr))
+\end{codeblock}
+except that \tcode{sch} is evaluated only once.
+
+\pnum
+Let \tcode{out_sndr} and \tcode{env} be subexpressions
+such that \tcode{OutSndr} is \tcode{decltype((out_sndr))}.
+If \tcode{\exposconcept{sender-for}<OutSndr, starts_on_t>} is \tcode{false},
+then the expressions \tcode{starts_on.transform_env(out_sndr, env)} and
+\tcode{starts_on.transform_sender(out_sndr, env)} are ill-formed; otherwise
+\begin{itemize}
+\item
+\tcode{starts_on.transform_env(out_sndr, env)} is equivalent to:
+\begin{codeblock}
+auto&& [_, sch, _] = out_sndr;
+return @\exposid{JOIN-ENV}@(@\exposid{SCHED-ENV}@(sch), @\exposid{FWD-ENV}@(env));
+\end{codeblock}
+\item
+\tcode{starts_on.transform_sender(out_sndr, env)} is equivalent to:
+\begin{codeblock}
+auto&& [_, sch, sndr] = out_sndr;
+return let_value(
+  schedule(sch),
+  [sndr = std::forward_like<OutSndr>(sndr)]() mutable
+    noexcept(is_nothrow_move_constructible_v) {
+    return std::move(sndr);
+  });
+\end{codeblock}
+\end{itemize}
+
+\pnum
+Let \tcode{out_sndr} be a subexpression denoting
+a sender returned from \tcode{starts_on(sch, sndr)} 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>} is \tcode{true}.
+Let \tcode{op} be an lvalue referring to the operation state
+that results from connecting \tcode{out_sndr} with \tcode{out_rcvr}.
+Calling \tcode{start(op)} shall start \tcode{sndr}
+on an execution agent of the associated execution resource of \tcode{sch}.
+If scheduling onto \tcode{sch} fails,
+an error completion on \tcode{out_rcvr} shall be executed
+on an unspecified execution agent.
+
+\rSec3[exec.continues.on]{\tcode{execution::continues_on}}
+
+\pnum
+\tcode{continues_on} adapts a sender into one
+that completes on the specified scheduler.
+
+\pnum
+The name \tcode{continues_on} denotes a pipeable sender adaptor object.
+For subexpressions \tcode{sch} and \tcode{sndr},
+if \tcode{decltype((sch))} does not satisfy \libconcept{scheduler}, or
+\tcode{decltype((sndr))} does not satisfy \libconcept{sender},
+\tcode{continues_on(sndr, sch)} is ill-formed.
+
+\pnum
+Otherwise,
+the expression \tcode{continues_on(sndr, sch)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(continues_on, sch, sndr))
+\end{codeblock}
+except that \tcode{sndr} is evaluated only once.
+
+\pnum
+The exposition-only class template \exposid{impls-for}
+is specialized for \tcode{continues_on_t} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<>
+  struct @\exposid{impls-for}@<continues_on_t> : @\exposid{default-impls}@ {
+    static constexpr auto get_attrs =
+      [](const auto& data, const auto& child) noexcept -> decltype(auto) {
+        return @\exposid{JOIN-ENV}@(@\exposid{SCHED-ATTRS}@(data), @\exposid{FWD-ENV}@(get_env(child)));
+      };
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \tcode{sndr} and \tcode{env} be subexpressions
+such that \tcode{Sndr} is \tcode{decltype((sndr))}.
+If \tcode{\exposconcept{sender-for}<Sndr, continues_on_t>} is \tcode{false},
+then
+the expression \tcode{continues_on.transform_sender(sndr, env)} is ill-formed;
+otherwise, it is equal to:
+\begin{codeblock}
+auto [_, data, child] = sndr;
+return schedule_from(std::move(data), std::move(child));
+\end{codeblock}
+\begin{note}
+This causes the \tcode{continues_on(sndr, sch)} sender to become
+\tcode{schedule_from(sch, sndr)} when it is connected with a receiver
+whose execution domain does not customize \tcode{continues_on}.
+\end{note}
+
+\pnum
+Let \tcode{out_sndr} be a subexpression denoting
+a sender returned from \tcode{continues_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>} is \tcode{true}.
+Let \tcode{op} be an lvalue referring to the operation state
+that results from connecting \tcode{out_sndr} with \tcode{out_rcvr}.
+Calling \tcode{start(op)} shall
+start \tcode{sndr} on the current execution agent and
+execute completion operations on \tcode{out_rcvr}
+on an execution agent of the execution resource associated with \tcode{sch}.
+If scheduling onto \tcode{sch} fails,
+an error completion on \tcode{out_rcvr} shall be executed
+on an unspecified execution agent.
+
+\rSec3[exec.schedule.from]{\tcode{execution::schedule_from}}
+
 \rSec1[exec.util]{Sender/receiver utilities}