fixup: add 34.9.3

Author: jensmaurer

source/exec.tex

@@ -1358,7 +1358,7 @@
 \end{codeblock}
 \begin{note}
 The \tcode{continues_on} algorithm works
-in tandem with \tcode{schedule_from}\iref{[exec.schedule.from}
+in tandem with \tcode{schedule_from}\iref{exec.schedule.from}
 to give scheduler authors a way to customize both
 how to transition onto (\tcode{continues_on}) and off of (\tcode{schedule_from})
 a given execution context.
@@ -1961,6 +1961,116 @@
 
 \rSec2[exec.awaitable]{Awaitable helpers}
 
+\pnum
+The sender concepts recognize awaitables as senders.
+For \ref{exec}, an \defn{awaitable} is an expression
+that would be well-formed as the operand of a \tcode{co_await} expression
+within a given context.
+
+\pnum
+For a subexpression \tcode{c},
+let \tcode{\exposid{GET-AWAITER}(c, p)} be expression-equivalent to
+the series of transformations and conversions applied to \tcode{c}
+as the operand of an \grammarterm{await-expression} in a coroutine,
+resulting in lvalue \tcode{e} as described by \ref{expr.await},
+where \tcode{p} is an lvalue referring to the coroutine's promise,
+which has type \tcode{Promise}.
+\begin{note}
+This includes the invocation of
+the promise type's \tcode{await_transform} member if any,
+the invocation of the \tcode{operator co_await}
+picked by overload resolution if any, and
+any necessary implicit conversions and materializations.
+\end{note}
+
+\pnum
+Let \exposconcept{is-awaitable} be the following exposition-only concept:
+\begin{codeblock}
+namespace std {
+  template<class T>
+  concept @\exposconcept{await-suspend-result}@ = @\seebelow@;                     // \expos
+
+  template<class A, class Promise>
+  concept @\defexposconcept{is-awaiter}@ =                                          // \expos
+    requires (A& a, coroutine_handle<Promise> h) {
+      a.await_ready() ? 1 : 0;
+      { a.await_suspend(h) } -> @\exposconcept{await-suspend-result}@;
+      a.await_resume();
+    };
+
+  template<class C, class Promise>
+  concept @\defexposconcept{is-awaitable}@ =                                        // \expos
+    requires (C (*fc)() noexcept, Promise& p) {
+      { @\exposid{GET-AWAITER}@(fc(), p) } -> @\exposconcept{is-awaiter}@<Promise>;
+    };
+}
+\end{codeblock}
+
+\tcode{\defexposconcept{await-suspend-result}<T>} is \tcode{true}
+if and only if one of the following is \tcode{true}:
+\begin{itemize}
+\item \tcode{T} is \tcode{void}, or
+\item \tcode{T} is \tcode{bool}, or
+\item \tcode{T} is a specialization of \tcode{coroutine_handle}.
+\end{itemize}
+
+\pnum
+For a subexpression \tcode{c}
+such that \tcode{decltype((c))} is type \tcode{C}, and
+an lvalue \tcode{p} of type \tcode{Promise},
+\tcode{\exposid{await-result-type}<C, Promise>} denotes
+the type \tcode{decltype(\exposid{GET-AWAITER}(c, p).await_resume())}.
+
+\pnum
+Let \exposid{with-await-transform} be the exposition-only class template:
+\begin{codeblock}
+namespace std::execution {
+  template<class T, class Promise>
+    concept @\defexposconcept{has-as-awaitable}@ =                                  // \expos
+      requires (T&& t, Promise& p) {
+        { std::forward<T>(t).as_awaitable(p) } -> @\exposconcept{is-awaitable}@<Promise&>;
+      };
+
+  template<class Derived>
+    struct @\exposid{with-await-transform}@ {                               // \expos
+      template<class T>
+        T&& await_transform(T&& value) noexcept {
+          return std::forward<T>(value);
+        }
+
+      template<@\exposconcept{has-as-awaitable}@<Derived> T>
+        decltype(auto) await_transform(T&& value)
+          noexcept(noexcept(std::forward<T>(value).as_awaitable(declval<Derived&>()))) {
+          return std::forward<T>(value).as_awaitable(static_cast<Derived&>(*this));
+        }
+    };
+}
+\end{codeblock}
+
+\pnum
+Let \exposid{env-promise} be the exposition-only class template:
+\begin{codeblock}
+namespace std::execution {
+  template<class Env>
+  struct @\exposid{env-promise}@ : @\exposid{with-await-transform}@<@\exposid{env-promise}@<Env>> { // \expos
+    @\unspec@ get_return_object() noexcept;
+    @\unspec@ initial_suspend() noexcept;
+    @\unspec@ final_suspend() noexcept;
+    void unhandled_exception() noexcept;
+    void return_void() noexcept;
+    coroutine_handle<> unhandled_stopped() noexcept;
+
+    const Env& get_env() const noexcept;
+  };
+}
+\end{codeblock}
+\begin{note}
+of \exposid{env-promise} are used only for the purpose of type computation;
+its members need not be defined.
+\end{note}
+
+
+
 \rSec1[exec.util]{Sender/receiver utilities}
 
 \rSec1[exec.ctx]{Execution contexts}