fixup: add up to 34.9.11.5

Author: jensmaurer

source/exec.tex

@@ -2834,6 +2834,178 @@
 
 \rSec3[exec.schedule.from]{\tcode{execution::schedule_from}}
 
+\pnum
+\tcode{schedule_from} schedules work dependent on the completion of a sender
+onto a scheduler's associated execution resource.
+\begin{note}
+\tcode{schedule_from} is not meant to be used in user code;
+it is used in the implementation of \tcode{continues_on}.
+\end{note}
+
+\pnum
+The name \tcode{schedule_from} denotes a customization point object.
+For some subexpressions \tcode{sch} and \tcode{sndr},
+let \tcode{Sch} be \tcode{decltype((sch))} and
+\tcode{Sndr} be \tcode{decltype((sndr))}.
+If \tcode{Sch} does not satisfy \libconcept{scheduler}, or
+\tcode{Sndr} does not satisfy \libconcept{sender},
+\tcode{schedule_from(sch, sndr)} is ill-formed.
+
+\pnum
+Otherwise,
+the expression \tcode{schedule_from(sch, sndr)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(
+  @\exposid{query-or-default}@(get_domain, sch, default_domain()),
+  @\exposid{make-sender}@(schedule_from, sch, sndr))
+\end{codeblock}
+except that \tcode{sch} is evaluated only once.
+
+\pnum
+The exposition-only class template \exposid{impls-for}\iref{exec.snd.general}
+is specialized for \tcode{schedule_from_t} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<>
+  struct @\exposid{impls-for}@<schedule_from_t> : @\exposid{default-impls}@ {
+    static constexpr auto @\exposid{get-attrs}@ = @\seebelow@;
+    static constexpr auto @\exposid{get-state}@ = @\seebelow@;
+    static constexpr auto @\exposid{complete}@ = @\seebelow@;
+  };
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<schedule_from_t>::\exposid{get-attrs}}
+is initialized with a callable object equivalent to the following lambda:
+\begin{codeblock}
+[](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
+The member \tcode{\exposid{impls-for}<schedule_from_t>::\exposid{get-state}}
+is initialized with a callable object equivalent to the following lambda:
+\begin{codeblock}
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept(see below)
+    requires @\libconcept{sender_in}@<@\exposid{child-type}@<Sndr>, env_of_t<Rcvr>> {
+
+  auto& [_, sch, child] = sndr;
+
+  using sched_t = decltype(auto(sch));
+  using variant_t = @\seebelow@;
+  using receiver_t = @\seebelow@;
+  using operation_t = connect_result_t<schedule_result_t<sched_t>, receiver_t>;
+  constexpr bool nothrow = noexcept(connect(schedule(sch), receiver_t{nullptr}));
+
+  struct @\exposid{state-type}@ {
+    Rcvr& @\exposid{rcvr}@;                 // \expos
+    variant_t @\exposid{async-result}@;     // \expos
+    operation_t @\exposid{op-state}@;       // \expos
+
+    explicit @\exposid{state-type}@(sched_t sch, Rcvr& rcvr) noexcept(nothrow)
+      : @\exposid{rcvr}@(rcvr), @\exposid{op-state}@(connect(schedule(sch), receiver_t{this})) {}
+  };
+
+  return @\exposid{state-type}@{sch, rcvr};
+}
+\end{codeblock}
+
+\pnum
+Objects of the local class \exposid{state-type} can be used
+to initialize a structured binding.
+
+\pnum
+Let \tcode{Sigs} be
+a pack of the arguments to the \tcode{completion_signatures} specialization
+named by \tcode{completion_signatures_of_t<child-type<Sndr>, env_of_t<Rcvr>>}.
+Let \exposid{as-tuple} be an alias template
+that transforms a completion signature \tcode{Tag(Args...)} into
+the tuple specialization \tcode{decayed-tuple<Tag, Args...>}.
+Then \tcode{variant_t} denotes
+the type \tcode{variant<monostate, \exposid{as-tuple}<Sigs>...>},
+except with duplicate types removed.
+
+\pnum
+\tcode{receiver_t} is an alias for the following exposition-only class:
+\begin{codeblock}
+namespace std::execution {
+  struct @\exposid{receiver-type}@ {
+    using receiver_concept = receiver_t;
+    @\exposid{state-type}@* @\exposid{state}@;          // exposition only
+
+    void set_value() && noexcept {
+      visit(
+        [this]<class Tuple>(Tuple& result) noexcept -> void {
+          if constexpr (!@\libconcept{same_as}@<monostate, Tuple>) {
+            auto& [tag, ...args] = result;
+            tag(std::move(@\exposid{state}@->@\exposid{rcvr}@), std::move(args)...);
+          }
+        },
+        @\exposid{state}@->@\exposid{async-result}@);
+    }
+
+    template<class Error>
+    void set_error(Error&& err) && noexcept {
+      execution::set_error(std::move(@\exposid{state}@->@\exposid{rcvr}@), std::forward<Error>(err));
+    }
+
+    void set_stopped() && noexcept {
+      execution::set_stopped(std::move(@\exposid{state}@->@\exposid{rcvr}@));
+    }
+
+    decltype(auto) get_env() const noexcept {
+      return @\exposid{FWD-ENV}@(execution::get_env(@\exposid{state}@->@\exposid{rcvr}@));
+    }
+  };
+}
+\end{codeblock}
+
+\pnum
+The expression in the \tcode{noexcept} clause of the lambda is \tcode{true}
+if the construction of the returned \exposid{state-type} object
+is not potentially throwing;
+otherwise, \tcode{false}.
+
+\pnum
+The member \tcode{\exposid{impls-for}<schedule_from_t>::\exposid{complete}}
+is initialized with a callable object equivalent to the following lambda:
+\begin{codeblock}
+[]<class Tag, class... Args>(auto, auto& state, auto& rcvr, Tag, Args&&... args) noexcept -> void {
+  using result_t = @\exposid{decayed-tuple}@<Tag, Args...>;
+  constexpr bool nothrow = is_nothrow_constructible_v<result_t, Tag, Args...>;
+
+  @\exposid{TRY-EVAL}@(rcvr, [&]() noexcept(nothrow) {
+    state.@\exposid{async-result}@.template emplace<result_t>(Tag(), std::forward<Args>(args)...);
+  }());
+
+  if (state.@\exposid{async-result}@.valueless_by_exception())
+    return;
+  if (state.@\exposid{async-result}@.index() == 0)
+    return;
+
+  start(state.@\exposid{op-state}@);
+};
+\end{codeblock}
+
+\pnum
+Let \tcode{out_sndr} be a subexpression denoting
+a sender returned from \tcode{schedule_from(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 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.
+
 \rSec1[exec.util]{Sender/receiver utilities}