fixuip: add 34.7

Author: jensmaurer

source/exec.tex

@@ -922,7 +922,7 @@
 
 \pnum
 The \libconcept{scheduler} concept defines
-the requirements of a scheduler type\iref{async.ops}.
+the requirements of a scheduler type\iref{exec.async.ops}.
 \tcode{schedule} is a customization point object
 that accepts a scheduler.
 A valid invocation of \tcode{schedule} is a schedule-expression.
@@ -998,7 +998,99 @@
 
 \pnum
 A receiver represents the continuation of an asynchronous operation.
-The \libconcept{receiver} concept defines the requirements for a receiver type ([async.ops]). The receiver_of concept defines the requirements for a receiver type that is usable as the first argument of a set of completion operations corresponding to a set of completion signatures. The get_env customization point object is used to access a receiver’s associated environment.
+The \libconcept{receiver} concept defines
+the requirements for a receiver type\iref{exec.async.ops}.
+The \libconcept{receiver_of} concept defines
+the requirements for a receiver type that is usable as
+the first argument of a set of completion operations
+corresponding to a set of completion signatures.
+The \tcode{get_env} customization point object is used to access
+a receiver's associated environment.
+\begin{codeblock}
+namespace std::execution {
+  template<class Rcvr>
+    concept @\deflibconcept{receiver}@ =
+      @\libconcept{derived_from}@<typename remove_cvref_t<Rcvr>::receiver_concept, receiver_t> &&
+      requires(const remove_cvref_t<Rcvr>& rcvr) {
+        { get_env(rcvr) } -> queryable;
+      } &&
+      @\libconcept{move_constructible}@<remove_cvref_t<Rcvr>> &&       // rvalues are movable, and
+      @\libconcept{constructible_from}@<remove_cvref_t<Rcvr>, Rcvr>;   // lvalues are copyable
+
+  template<class Signature, class Rcvr>
+    concept @\defexposconcept{valid-completion-for}@ =
+      requires (Signature* sig) {
+        []<class Tag, class... Args>(Tag(*)(Args...))
+            requires @\libconcept{callable}@<Tag, remove_cvref_t<Rcvr>, Args...>
+        {}(sig);
+      };
+
+  template<class Rcvr, class Completions>
+    concept @\defexposconcept{has-completions}@ =
+      requires (Completions* completions) {
+        []<@\exposconcept{valid-completion-for}@<Rcvr>...Sigs>(completion_signatures<Sigs...>*)
+        {}(completions);
+      };
+
+  template<class Rcvr, class Completions>
+    concept @\deflibconcept{receiver_of}@ =
+      @\libconcept{receiver}@<Rcvr> && @\exposconcept{has-completions}@<Rcvr, Completions>;
+}
+\end{codeblock}
+
+\pnum
+Class types that are marked \tcode{final} do not model the receiver concept.
+
+\pnum
+Let \tcode{rcvr} be a receiver and
+let \tcode{op_state} be an operation state associated with
+an asynchronous operation created by connecting \tcode{rcvr} with a sender.
+Let \tcode{token} be a stop token equal to
+\tcode{get_stop_token(get_env(rcvr))}.
+\tcode{token} shall remain valid
+for the duration of the asynchronous operation's lifetime\iref{exec.async.ops}.
+\begin{note}
+This means that, unless it knows about further guarantees
+provided by the type of \tcode{rcvr},
+the implementation of \tcode{op_state} cannot use \tcode{token}
+after it executes a completion operation.
+This also implies that any stop callbacks registered on token
+must be destroyed before the invocation of the completion operation.
+\end{note}
+
+\rSec2[exec.set.value]{\tcode{execution::set_value}}
+
+\pnum
+\tcode{set_value} is a value completion function\iref{exec.async.ops}.
+Its associated completion tag is \tcode{set_value_t}.
+The expression \tcode{set_value(rcvr, vs...)}
+for a subexpression \tcode{rcvr} and
+pack of subexpressions \tcode{vs} is ill-formed
+if \tcode{rcvr} is an lvalue or an rvalue of const type.
+Otherwise, it is expression-equivalent to
+\tcode{\exposid{MANDATE-NOTHROW}(rcvr.set_value(vs...))}.
+
+\rSec2[exec.set.error]{\tcode{execution::set_error}}
+
+\pnum
+\tcode{set_error} is an error completion function\iref{exec.async.ops}.
+Its associated completion tag is \tcode{set_error_t}.
+The expression \tcode{set_error(rcvr, err)}
+for some \tcode{subexpressions} \tcode{rcvr} and \tcode{err} is ill-formed
+if \tcode{rcvr} is an lvalue or an rvalue of const type.
+Otherwise, it is expression-equivalent to
+\tcode{\exposid{MANDATE-NOTHROW}(rcvr.set_error(err))}.
+
+\rSec2[exec.set.stopped]{\tcode{execution::set_stopped}}
+
+\pnum
+\tcode{set_stopped} is a stopped completion function\iref{exec.async.ops}.
+Its associated completion tag is \tcode{set_stopped_t}.
+The expression \tcode{set_stopped(rcvr)}
+for a subexpression \tcode{rcvr} is ill-formed
+if \tcode{rcvr} is an lvalue or an rvalue of const type.
+Otherwise, it is expression-equivalent to
+\tcode{\exposid{MANDATE-NOTHROW}(rcvr.set_stopped())}.
 
 \rSec1[exec.opstate]{Operation states}