fixup: all of 34.9

Author: jensmaurer

source/exec.tex

@@ -4382,6 +4382,258 @@
     });
 \end{codeblock}
 
+\rSec2[exec.consumers]{Sender consumers}
+
+\rSec3[exec.sync.wait]{\tcode{this_thread::sync_wait}}
+
+\pnum
+\tcode{this_thread::sync_wait} and \tcode{this_thread::sync_wait_with_variant}
+are used
+to block the current thread of execution
+until the specified sender completes and
+to return its async result.
+\tcode{sync_wait} mandates
+that the input sender has exactly one value completion signature.
+
+\pnum
+Let \exposid{sync-wait-env} be the following exposition-only class type:
+\begin{codeblock}
+namespace std::this_thread {
+  struct @\exposid{sync-wait-env}@ {
+    execution::run_loop* @\exposid{loop}@;                                  // \expos
+
+    auto query(execution::get_scheduler_t) const noexcept {
+      return @\exposid{loop}@->get_scheduler();
+    }
+
+    auto query(execution::get_delegation_scheduler_t) const noexcept {
+      return @\exposid{loop}@->get_scheduler();
+    }
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \exposid{sync-wait-result-type} and
+\exposid{sync-wait-with-variant-result-type}
+be exposition-only alias templates defined as follows:
+\begin{codeblock}
+namespace std::this_thread {
+  template<execution::@\libconcept{sender_in}@<@\exposid{sync-wait-env}@> Sndr>
+    using sync-wait-result-type =
+      optional<execution::value_types_of_t<Sndr, @\exposid{sync-wait-env}@, @\exposid{decayed-tuple}@,
+               type_identity_t>>;
+
+  template<execution::sender_in<sync-wait-env> Sndr>
+    using @\exposid{sync-wait-with-variant-result-type}@ =
+      optional<execution::value_types_of_t<Sndr, @\exposid{sync-wait-env}@>>;
+}
+\end{codeblock}
+
+\pnum
+The name \tcode{this_thread::sync_wait} denotes a customization point object.
+For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
+If \tcode{\libconcept{sender_in}<Sndr, \exposid{sync-wait-env}>}
+is \tcode{false},
+the expression \tcode{this_thread::sync_wait(sndr)} is ill-formed.
+Otherwise, it is expression-equivalent to the following,
+except that \tcode{sndr} is evaluated only once:
+\begin{codeblock}
+apply_sender(@\exposid{get-domain-early}@(sndr), sync_wait, sndr)
+\end{codeblock}
+\mandates
+\begin{itemize}
+\item
+The type \tcode{\exposid{sync-wait-result-type}<Sndr>} is well-formed.
+\item
+\tcode{\libconcept{same_as}<decltype($e$), \exposid{sync-wait-result-type}<Sndr>>}
+is \tcode{true}, where $e$ is the apply_sender expression above.
+\end{itemize}
+
+\pnum
+Let \exposid{sync-wait-state} and \exposid{sync-wait-receiver}
+be the following exposition-only class templates:
+\begin{codeblock}
+namespace std::this_thread {
+  template<class Sndr>
+  struct @\exposid{sync-wait-state}@ {                                      // \expos
+    execution::run_loop @\exposid{loop}@;                                   // \expos
+    exception_ptr @\exposid{error}@;                                        // \expos
+    @\exposid{sync-wait-result-type}@<Sndr> @\exposid{result}@;                         // \expos
+  };
+
+  template<class Sndr>
+  struct @\exposid{sync-wait-receiver}@ {                                   // \expos
+    using receiver_concept = execution::receiver_t;
+    @\exposid{sync-wait-state}@<Sndr>* @\exposid{state}@;                               // \expos
+
+    template<class... Args>
+    void set_value(Args&&... args) && noexcept;
+
+    template<class Error>
+    void set_error(Error&& err) && noexcept;
+
+    void set_stopped() && noexcept;
+
+    @\exposid{sync-wait-env}@ get_env() const noexcept { return {&@\exposid{state}@->@\exposid{loop}@}; }
+  };
+}
+\end{codeblock}
+
+\begin{itemdecl}
+template<class... Args>
+void set_value(Args&&... args) && noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to:
+\begin{codeblock}
+try {
+  @\exposid{state}@->@\exposid{result}@.emplace(std::forward<Args>(args)...);
+} catch (...) {
+  @\exposid{state}@->@\exposid{error}@ = current_exception();
+}
+@\exposid{state}@->@\exposid{loop}@.finish();
+\end{codeblock}
+\end{itemdescr}
+
+\begin{itemdecl}
+template<class Error>
+void set_error(Error&& err) && noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to:
+\begin{codeblock}
+@\exposid{state}@->@\exposid{error}@ = @\exposid{AS-EXCEPT-PTR}@(std::forward<Error>(err));    // see \ref{exec.general}
+@\exposid{state}@->@\exposid{loop}@.finish();
+\end{codeblock}
+\end{itemdescr}
+
+\begin{itemdecl}
+void set_stopped() && noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to \tcode{\exposid{state}->\exposid{loop}.finish()}.
+\end{itemdescr}
+
+\pnum
+For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
+If \tcode{\exposconcept{sender_to}<Sndr, \exposid{sync-wait-receiver}<\linebreak Sndr>>}
+is \tcode{false},
+the expression \tcode{sync_wait.apply_sender(sndr)} is ill-formed;
+otherwise, it is equivalent to:
+\begin{codeblock}
+@\exposid{sync-wait-state}@<Sndr> state;
+auto op = connect(sndr, @\exposid{sync-wait-receiver}@<Sndr>{&state});
+start(op);
+
+state.@\exposid{loop}@.run();
+if (state.@\exposid{error}@) {
+  rethrow_exception(std::move(state.error));
+}
+return std::move(state.@\exposid{result}@);
+\end{codeblock}
+
+\pnum
+The behavior of \tcode{this_thread::sync_wait(sndr)} is undefined unless:
+\begin{itemize}
+\item
+It blocks the current thread of execution\iref{defns.block}
+with forward progress guarantee delegation\iref{intro.progress}
+until the specified sender completes.
+\begin{note}
+The default implementation of \tcode{sync_wait} achieves
+forward progress guarantee delegation by providing a \tcode{run_loop} scheduler
+via the \tcode{get_delegation_scheduler} query
+on the \exposid{sync-wait-receiver}'s environment.
+The \tcode{run_loop} is driven by the current thread of execution.
+\end{note}
+\item
+It returns the specified sender's async results as follows:
+\begin{itemize}
+\item
+For a value completion,
+the result datums are returned in
+a \tcode{tuple} in an engaged \tcode{optional} object.
+\item
+For an error completion, an exception is thrown.
+\item
+For a stopped completion, a disengaged \tcode{optional} object is returned.
+\end{itemize}
+\end{itemize}
+
+\rSec3[exec.sync.wait.var]{\tcode{this_thread::sync_wait_with_variant}}
+
+\pnum
+The name \tcode{this_thread::sync_wait_with_variant} denotes
+a customization point object.
+For a subexpression \tcode{sndr},
+let \tcode{Sndr} be \tcode{decltype(into_variant(sndr))}.
+If \tcode{\libconcept{sender_in}<Sndr, \exposid{sync-wait-env}>}
+is \tcode{false},
+\tcode{this_thread::sync_wait_with_variant(sndr)} is ill-formed.
+Otherwise, it is expression-equivalent to the following,
+except \tcode{sndr} is evaluated only once:
+\begin{codeblock}
+apply_sender(@\exposid{get-domain-early}@(sndr), sync_wait_with_variant, sndr)
+\end{codeblock}
+\mandates
+\begin{itemize}
+\item
+The type \tcode{\exposid{sync-wait-with-variant-result-type}<Sndr>}
+is well-formed.
+\item
+\tcode{\libconcept{same_as}<decltype($e$), \exposid{sync-wait-with-variant-result-type}<Sndr>>}
+is \tcode{true}, where $e$ is the \tcode{ap\-ply_sender} expression above.
+\end{itemize}
+
+\pnum
+If \tcode{\exposconcept{callable}<sync_wait_t, Sndr>} is \tcode{false},
+the expression \tcode{sync_wait_with_variant.apply_sender(\linebreak sndr)} is ill-formed.
+Otherwise, it is equivalent to:
+\begin{codeblock}
+using result_type = @\exposid{sync-wait-with-variant-result-type}@<Sndr>;
+if (auto opt_value = sync_wait(into_variant(sndr))) {
+  return result_type(std::move(get<0>(*opt_value)));
+}
+return result_type(nullopt);
+\end{codeblock}
+
+\pnum
+The behavior of \tcode{this_thread::sync_wait_with_variant(sndr)}
+is undefined unless:
+\begin{itemize}
+\item
+It blocks the current thread of execution\iref{defns.block}
+with forward progress guarantee delegation\iref{intro.progress}
+until the specified sender completes.
+\begin{note}
+The default implementation of \tcode{sync_wait_with_variant} achieves
+forward progress guarantee delegation by relying on
+the forward progress guarantee delegation provided by \tcode{sync_wait}.
+\end{note}
+\item
+It returns the specified sender's async results as follows:
+\begin{itemize}
+\item
+For a value completion,
+the result datums are returned in an engaged \tcode{optional} object
+that contains a \tcode{variant} of \tcode{tuple}s.
+\item
+For an error completion, an exception is thrown.
+\item
+For a stopped completion, a disengaged \tcode{optional} object is returned.
+\end{itemize}
+\end{itemize}
+
 \rSec1[exec.util]{Sender/receiver utilities}
 
 \rSec1[exec.ctx]{Execution contexts}