fixup: add up to 34.9.9

Author: jensmaurer

source/exec.tex

@@ -2202,6 +2202,264 @@
 \tcode{noexcept(\exposid{final-sndr})}.
 \end{itemdescr}
 
+\rSec2[exec.snd.transform.env]{\tcode{execution::transform_env}}
+
+\begin{itemdecl}
+namespace std::execution {
+  template<class Domain, @\libconcept{sender}@ Sndr, @\exposconcept{queryable}@ Env>
+    constexpr @\exposconcept{queryable}@ decltype(auto) transform_env(Domain dom, Sndr&& sndr, Env&& env) noexcept;
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+Let \tcode{e} be the expression
+\begin{codeblock}
+dom.transform_env(std::forward<Sndr>(sndr), std::forward<Env>(env))
+\end{codeblock}
+if that expression is well-formed; otherwise,
+\begin{codeblock}
+default_domain().transform_env(std::forward<Sndr>(sndr), std::forward<Env>(env))
+\end{codeblock}
+
+\pnum
+\mandates
+\tcode{noexcept(e)} is \tcode{true}.
+
+\pnum
+\returns
+\tcode{e}
+\end{itemdescr}
+
+\rSec2[exec.snd.apply]{\tcode{execution::apply_sender}}
+
+\begin{itemdecl}
+namespace std::execution {
+  template<class Domain, class Tag, @\libconcept{sender}@ Sndr, class... Args>
+    constexpr decltype(auto) apply_sender(Domain dom, Tag, Sndr&& sndr, Args&&... args)
+      noexcept(see below);
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+Let $e$ be the expression
+\begin{codeblock}
+dom.apply_sender(Tag(), std::forward<Sndr>(sndr), std::forward<Args>(args)...)
+\end{codeblock}
+if that expression is well-formed; otherwise,
+\begin{codeblock}
+default_domain().apply_sender(Tag(), std::forward<Sndr>(sndr), std::forward<Args>(args)...)
+\end{codeblock}
+
+\pnum
+\constraints
+The expression $e$ is well-formed.
+
+\pnum
+\returns
+$e$
+
+\pnum
+\remarks
+The exception specification is equivalent to \tcode{noexcept($e$)}.
+\end{itemdescr}
+
+\rSec2[exec.getcomplsigs]{\tcode{execution::get_completion_signatures}}
+
+\pnum
+\tcode{get_completion_signatures} is a customization point object.
+Let \tcode{sndr} be an expression
+such that \tcode{decltype((sndr))} is \tcode{Sndr}, and
+let \tcode{env} be an expression
+such that \tcode{decltype((env))} is \tcode{Env}.
+Let \tcode{new_sndr} be the expression
+\tcode{transform_sender(decltype(\exposid{get-domain-late}(sndr, env)){}, sndr, env)}, and
+let \tcode{NewSndr} be \tcode{decltype((new_sndr))}.
+Then \tcode{get_completion_signatures(sndr, env)} is expression-equivalent to
+\tcode{(void(sndr), void(env), CS())}
+except that \tcode{void(sndr)} and \tcode{void(env)} are
+indeterminately sequenced,
+where \tcode{CS} is:
+\begin{itemize}
+\item
+\tcode{decltype(new_sndr.get_completion_signatures(env))}
+if that type is well-formed,
+
+\item
+Otherwise, \tcode{remove_cvref_t<NewSndr>::completion_signatures}
+if that type is well-formed,
+
+\item
+Otherwise,
+if \tcode{\exposid{is-awaitable}<NewSndr, env-promise<Env>>} is \tcode{true},
+then:
+\begin{codeblock}
+completion_signatures<
+  @\exposid{SET-VALUE-SIG}@(@\exposid{await-result-type}@<NewSndr, @\exposid{env-promise}@<Env>>),        // \iref{exec.snd.concepts}
+  set_error_t(exception_ptr),
+  set_stopped_t()>
+\end{codeblock}
+
+\item
+Otherwise, \tcode{CS} is ill-formed.
+\end{itemize}
+
+\pnum
+Let \tcode{rcvr} be an rvalue
+whose type \tcode{Rcvr} models \libconcept{receiver}, and
+let \tcode{Sndr} be the type of a sender
+such that \tcode{\libconcept{sender_in}<Sndr, env_of_t<Rcvr>>} is \tcode{true}.
+Let \tcode{Sigs...} be the template arguments of
+the \tcode{completion_signatures} specialization
+named by \tcode{completion_signatures_of_t<Sndr, env_of_t<Rcvr>>}.
+Let \tcode{CSO} be a completion function.
+If sender \tcode{Sndr} or its operation state cause
+the expression \tcode{CSO(rcvr, args...)}
+to be potentially evaluated\iref{basic.def.odr}
+then there shall be a signature \tcode{Sig} in \tcode{Sigs...}
+such that
+\begin{codeblock}
+@\exposid{MATCHING-SIG}@(@\exposid{decayed-typeof}@<CSO>(decltype(args)...), Sig)
+\end{codeblock}
+is \tcode{true}\iref{exec.general}.
+
+\rSec2[exec.connect]{\tcode{execution::connect}}
+
+\pnum
+\tcode{connect} connects\iref{exec.async.ops} a sender with a receiver.
+
+\pnum
+The name \tcode{connect} denotes a customization point object.
+For subexpressions \tcode{sndr} and \tcode{rcvr},
+let \tcode{Sndr} be \tcode{decltype((sndr))} and
+\tcode{Rcvr} be \tcode{decltype((rcvr))},
+let \tcode{new_sndr} be the expression
+\begin{codeblock}
+transform_sender(decltype(@\exposid{get-domain-late}@(sndr, get_env(rcvr))){}, sndr, get_env(rcvr))
+\end{codeblock}
+and let \tcode{DS} and \tcode{DR} be
+\tcode{decay_t<decltype((new_sndr))>} and \tcode{decay_t<Rcvr>}, respectively.
+
+\pnum
+Let \exposid{connect-awaitable-promise} be the following exposition-only class:
+
+\begin{codeblock}
+namespace std::execution {
+  struct @\exposid{connect-awaitable-promise}@ : @\exposid{with-await-transform}@<@\exposid{connect-awaitable-promise}@> {
+
+    @\exposid{connect-awaitable-promise}@(DS&, DR& rcvr) noexcept : @\exposid{rcvr}@(rcvr) {}
+
+    suspend_always initial_suspend() noexcept { return {}; }
+    [[noreturn]] suspend_always final_suspend() noexcept { terminate(); }
+    [[noreturn]] void unhandled_exception() noexcept { terminate(); }
+    [[noreturn]] void return_void() noexcept { terminate(); }
+
+    coroutine_handle<> unhandled_stopped() noexcept {
+      set_stopped(std::move(@\exposid{rcvr}@));
+      return noop_coroutine();
+    }
+
+    @\exposid{operation-state-task}@ get_return_object() noexcept {
+      return @\exposid{operation-state-task}@{
+        coroutine_handle<@\exposid{connect-awaitable-promise}@>::from_promise(*this)};
+    }
+
+    env_of_t<DR> get_env() const noexcept {
+      return execution::get_env(@\exposid{rcvr}@);
+    }
+
+  private:
+    DR& @\exposid{rcvr}@;                           // \expos
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \exposid{operation-state-task} be the following exposition-only class:
+\begin{codeblock}
+namespace std::execution {
+  struct @\exposid{operation-state-task}@ {
+    using operation_state_concept = operation_state_t;
+    using promise_type = @\exposid{connect-awaitable-promise}@;
+
+    explicit @\exposid{operation-state-task}@(coroutine_handle<> h) noexcept : coro(h) {}
+    @\exposid{operation-state-task}@(@\exposid{operation-state-task}@&& o) noexcept
+      : @\exposid{coro}@(exchange(o.@\exposid{coro}@, {})) {}
+    ~@\exposid{operation-state-task}@() { if (@\exposid{coro}@) @\exposid{coro}@.destroy(); }
+
+    void start() & noexcept {
+      @\exposid{coro}@.resume();
+    }
+
+  private:
+    coroutine_handle<> @\exposid{coro}@;                                    // \expos
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \tcode{V} name the type
+\tcode{\exposid{await-result-type}<DS, \exposid{connect-awaitable-promise}>},
+let \tcode{Sigs} name the type
+\begin{codeblock}
+completion_signatures<
+  @\exposid{SET-VALUE-SIG}@(V),         // see \iref{exec.snd.concepts}
+  set_error_t(exception_ptr),
+  set_stopped_t()>
+\end{codeblock}
+and let \exposid{connect-awaitable} be an exposition-only coroutine
+defined as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<class Fun, class... Ts>
+  auto @\exposid{suspend-complete}@(Fun fun, Ts&&... as) noexcept {    // \expos
+    auto fn = [&, fun]() noexcept { fun(std::forward<Ts>(as)...); };
+
+    struct awaiter {
+      decltype(@\exposid{fn}@) @\exposid{fn}@;                                     // \expos
+
+      static constexpr bool await_ready() noexcept { return false; }
+      void await_suspend(coroutine_handle<>) noexcept { @\exposid{fn}@(); }
+      [[noreturn]] void await_resume() noexcept { unreachable(); }
+    };
+    return awaiter{@\exposid{fn}@};
+  }
+
+  @\exposid{operation-state-task}@ @\exposid{connect-awaitable}@(DS sndr, DR rcvr) requires @\libconcept{receiver_of}@<DR, Sigs> {
+    exception_ptr ep;
+    try {
+      if constexpr (@\libconcept{same_as}@<V, void>) {
+        co_await std::move(sndr);
+        co_await @\exposid{suspend-complete}@(set_value, std::move(rcvr));
+      } else {
+        co_await @\exposid{suspend-complete}@(set_value, std::move(rcvr), co_await std::move(sndr));
+      }
+    } catch(...) {
+      ep = current_exception();
+    }
+    co_await @\exposid{suspend-complete}@(set_error, std::move(rcvr), std::move(ep));
+  }
+}
+\end{codeblock}
+
+\pnum
+The expression \tcode{connect(sndr, rcvr)} is expression-equivalent to:
+\begin{itemize}
+\item
+\tcode{new_sndr.connect(rcvr)} if that expression is well-formed.
+
+\mandates
+The type of the expression above satisfies \libconcept{operation_state}.
+
+\item
+Otherwise, \tcode{\exposid{connect-awaitable}(new_sndr, rcvr)}.
+\end{itemize}
+
+\mandates
+\tcode{\libconcept{sender}<Sndr> \&\& \libconcept{receiver}<Rcvr>} is \tcode{true}.
+       
+  
 \rSec1[exec.util]{Sender/receiver utilities}
 
 \rSec1[exec.ctx]{Execution contexts}