fixup: add upto 34.9.11.8

Author: jensmaurer

source/exec.tex

@@ -3286,6 +3286,207 @@
 forwards all other completion operations unchanged.
 \end{itemize}
 
+\rSec3[exec.let]{\tcode{execution::let_value}, \tcode{execution::let_error}, \tcode{execution::let_stopped}}
+
+\pnum
+\tcode{let_value}, \tcode{let_error}, and \tcode{let_stopped} transform
+a sender's value, error, and stopped completions, respectively,
+into a new child asynchronous operation
+by passing the sender's result datums to a user-specified callable,
+which returns a new sender that is connected and started.
+
+\pnum
+For \tcode{let_value}, \tcode{let_error}, and \tcode{let_stopped},
+let \exposid{set-cpo} be
+\tcode{set_value}, \tcode{set_error}, and \tcode{set_stopped}, respectively.
+Let the expression \exposid{let-cpo} be one of
+\tcode{let_value}, \tcode{let_error}, or \tcode{let_stopped}.
+For a subexpression \tcode{sndr},
+let \tcode{\exposid{let-env}(sndr)} be expression-equivalent to
+the first well-formed expression below:
+\begin{itemize}
+\item
+\tcode{SCHED-ENV(get_completion_scheduler<\exposid{decayed-typeof}<\exposid{set-cpo}>>(get_env(sndr)))}
+\item
+\tcode{\exposid{MAKE-ENV}(get_domain, get_domain(get_env(sndr)))}
+\item
+\tcode{(void(sndr), empty_env\{\})}
+\end{itemize}
+
+\pnum
+The names \tcode{let_value}, \tcode{let_error}, and \tcode{let_stopped} denote
+pipeable sender adaptor objects.
+For subexpressions \tcode{sndr} and \tcode{f},
+let \tcode{F} be the decayed type of \tcode{f}.
+If \tcode{decltype((sndr))} does not satisfy \libconcept{sender} or
+if \tcode{decltype((f))} does not satisfy \exposconcept{movable-value},
+the expression \tcode{\exposid{let-cpo}(sndr, f)} is ill-formed.
+If \tcode{F} does not satisfy \libconcept{invocable},
+the expression \tcode{let_stopped(sndr, f)} is ill-formed.
+
+\pnum
+Otherwise,
+the expression \tcode{\exposid{let-cpo}(sndr, f)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(@\exposid{let-cpo}@, f, sndr))
+\end{codeblock}
+except that \tcode{sndr} is evaluated only once.
+
+\pnum
+The exposition-only class template \exposid{impls-for}\iref{exec.snd.general}
+is specialized for \exposid{let-cpo} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<class State, class Rcvr, class... Args>
+  void @\exposid{let-bind}@(State& state, Rcvr& rcvr, Args&&... args);      // \expos
+
+  template<>
+  struct @\exposid{impls-for}@<@\exposid{decayed-typeof}@<@\exposid{let-cpo}@>> : @\exposid{default-impls}@ {
+    static constexpr auto @\exposid{get-state}@ = @\seebelow@;
+    static constexpr auto @\exposid{complete}@ = @\seebelow@;
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \exposid{receiver2} denote the following exposition-only class template:
+\begin{codeblock}
+namespace std::execution {
+  template<class Rcvr, class Env>
+  struct @\exposid{receiver2}@ {
+    using receiver_concept = receiver_t;
+
+    template<class... Args>
+    void set_value(Args&&... args) && noexcept {
+      execution::set_value(std::move(@\exposid{rcvr}@), std::forward<Args>(args)...);
+    }
+
+    template<class Error>
+    void set_error(Error&& err) && noexcept {
+      execution::set_error(std::move(@\exposid{rcvr}@), std::forward<Error>(err));
+    }
+
+    void set_stopped() && noexcept {
+      execution::set_stopped(std::move(@\exposid{rcvr}@));
+    }
+
+    decltype(auto) get_env() const noexcept {
+      return @\exposid{JOIN-ENV}@(@\exposid{env}@, @\exposid{FWD-ENV}@(execution::get_env(@\exposid{rcvr}@)));
+    }
+
+    Rcvr& @\exposid{rcvr}@;                 // exposition only
+    Env @\exposid{env}@;                    // exposition only
+  };
+}
+\end{codeblock}
+
+\pnum
+\tcode{\exposid{impls-for}<\exposid{decayed-typeof}<\exposid{let-cpo}>>::\exposid{get-state}}
+is initialized with a callable object equivalent to the following:
+\begin{codeblock}
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) requires @\seebelow@ {
+  auto& [_, fn, child] = sndr;
+  using fn_t = decay_t<decltype(fn)>;
+  using env_t = decltype(@\exposid{let-env}@(child));
+  using args_variant_t = @\seebelow@;
+  using ops2_variant_t = @\seebelow@;
+
+  struct @\exposid{state-type}@ {
+    fn_t @\exposid{fn}@;                    // exposition only
+    env_t @\exposid{env}@;                  // exposition only
+    args_variant_t @\exposid{args}@;        // exposition only
+    ops2_variant_t @\exposid{ops2}@;        // exposition only
+  };
+  return @\exposid{state-type}@{std::forward_like<Sndr>(fn), @\exposid{let-env}@(child), {}, {}};
+}
+\end{codeblock}
+
+\pnum
+Let \tcode{Sigs} be a pack of the arguments
+to the \tcode{completion_signatures} specialization named by
+\tcode{completion_signatures_of_t<\exposid{child-type}<Sndr>, env_of_t<Rcvr>>}.
+Let \tcode{LetSigs} be a pack of those types in \tcode{Sigs}
+with a return type of \tcode{\exposid{decayed-typeof}<\exposid{set-cpo}>}.
+Let \exposid{as-tuple} be an alias template
+such that \tcode{\exposid{as-tuple}<Tag(Args...)>} denotes
+the type \tcode{\exposid{decayed-tuple}<Args...>}.
+Then \tcode{args_variant_t} denotes
+the type \tcode{variant<monostate, \exposid{as-tuple}<LetSigs>...>}
+except with duplicate types removed.
+
+\pnum
+Given a type \tcode{Tag} and a pack \tcode{Args},
+let \exposid{as-sndr2} be an alias template
+such that \tcode{\exposid{as-sndr2}<Tag(Args...)>} denotes
+the type \tcode{\exposid{call-result-t}<Fn, decay_t<Args>\&...>}.
+Then \tcode{ops2_variant_t} denotes
+the type \tcode{variant<monostate, connect_result_t<\exposid{as-sndr2}<LetSigs>, \exposid{receiver2}<Rcvr, Env>>...>}
+except with duplicate types removed.
+
+\pnum
+The \grammarterm{requires-clause} constraining the above lambda is satisfied
+if and only if
+the types \tcode{args_variant_t} and \tcode{ops2_variant_t} are well-formed.
+
+\pnum
+The exposition-only function template \exposid{let-bind}
+has effects equivalent to:
+\begin{codeblock}
+using args_t = @\exposid{decayed-tuple}@<Args...>;
+auto mkop2 = [&] {
+  return connect(
+    apply(std::move(state.fn),
+          state.args.template emplace<args_t>(std::forward<Args>(args)...)),
+    @\exposid{receiver2}@{rcvr, std::move(state.env)});
+};
+start(state.ops2.template emplace<decltype(mkop2())>(@\exposid{emplace-from}@{mkop2}));
+\end{codeblock}
+
+\pnum
+\tcode{\exposid{impls-for}<\exposid{decayed-typeof}<let-cpo>>::\exposid{complete}}
+is initialized with a callable object equivalent to the following:
+\begin{codeblock}
+[]<class Tag, class... Args>
+  (auto, auto& state, auto& rcvr, Tag, Args&&... args) noexcept -> void {
+    if constexpr (@\libconcept{same_as}@<Tag, @\exposid{decayed-typeof}@<@\exposid{set-cpo}@>>) {
+      @\exposid{TRY-EVAL}@(rcvr, @\exposid{let-bind}@(state, rcvr, std::forward<Args>(args)...));
+    } else {
+      Tag()(std::move(rcvr), std::forward<Args>(args)...);
+    }
+  }
+\end{codeblock}
+
+\pnum
+Let \tcode{sndr} and \tcode{env} be subexpressions, and
+let \tcode{Sndr} be \tcode{decltype((sndr))}.
+If
+\tcode{\exposconcept{sender-for<}Sndr, \exposid{decayed-typeof}<\exposid{let-cpo}>>}
+is \tcode{false},
+then the expression \tcode{\exposid{let-cpo}.transform_env(sndr, env)}
+is ill-formed.
+Otherwise, it is equal to
+\tcode{\exposid{JOIN-ENV}(\exposid{let-env}(sndr), \exposid{FWD-ENV}(env))}.
+
+\pnum
+Let the subexpression \tcode{out_sndr} denote
+the result of the invocation \tcode{\exposid{let-cpo}(sndr, f)} or
+an object equal to such, and
+let the subexpression \tcode{rcvr} denote a receiver
+such that the expression \tcode{connect(out_sndr, rcvr)} is well-formed.
+The expression \tcode{connect(out_sndr, rcvr)} has undefined behavior
+unless it creates an asynchronous operation\iref{exec.async.ops} that,
+when started:
+\begin{itemize}
+\item
+invokes \tcode{f} when \exposid{set-cpo} is called
+with \tcode{sndr}'s result datums,
+\item
+makes its completion dependent on
+the completion of a sender returned by \tcode{f}, and
+\item
+propagates the other completion operations sent by \tcode{sndr}.
+\end{itemize}
+
 \rSec1[exec.util]{Sender/receiver utilities}