fixup: add 34.9.2

Author: jensmaurer

source/exec.tex

@@ -1816,6 +1816,151 @@
 
 \rSec2[exec.snd.concepts]{Sender concepts}
 
+\pnum
+The \libconcept{sender} concept defines
+the requirements for a sender type\iref{exec.async.ops}.
+The \libconcept{sender_in} concept defines
+the requirements for a sender type
+that can create asynchronous operations given an associated environment type.
+The \libconcept{sender_to} concept defines
+the requirements for a sender type
+that can connect with a specific receiver type.
+The \tcode{get_env} customization point object is used to access
+a sender's associated attributes.
+The connect customization point object is used to connect\iref{exec.async.ops}
+a sender and a receiver to produce an operation state.
+
+\begin{codeblock}
+namespace std::execution {
+  template<class Sigs>
+    concept @\exposconcept{valid-completion-signatures}@ = @\seebelow@;            // \expos
+
+  template<class Sndr>
+    concept @\defexposconcept{is-sender}@ =                                         // \expos
+      derived_from<typename Sndr::sender_concept, sender_t>;
+
+  template<class Sndr>
+    concept @\defexposconcept{enable-sender}@ =                                     // \expos
+      @\exposconcept{is-sender}@<Sndr> ||
+      @\exposconcept{is-awaitable}@<Sndr, @\exposconcept{env-promise}@<empty_env>>;               // \ref{exec.awaitables}
+
+  template<class Sndr>
+    concept @\deflibconcept{sender}@ =
+      bool(@\exposconcept{enable-sender}@<remove_cvref_t<Sndr>>) &&
+      requires (const remove_cvref_t<Sndr>& sndr) {
+        { get_env(sndr) } -> @\exposconcept{queryable}@;
+      } &&
+      @\libconcept{move_constructible}@<remove_cvref_t<Sndr>> &&
+      @\libconcept{constructible_from}@<remove_cvref_t<Sndr>, Sndr>;
+
+  template<class Sndr, class Env = empty_env>
+    concept @\deflibconcept{sender_in}@ =
+      @\libconcept{sender}@<Sndr> &&
+      @\exposconcept{queryable}@<Env> &&
+      requires (Sndr&& sndr, Env&& env) {
+        { get_completion_signatures(std::forward<Sndr>(sndr), std::forward<Env>(env)) }
+          -> @\exposconcept{valid-completion-signatures}@;
+      };
+
+  template<class Sndr, class Rcvr>
+    concept @\deflibconcept{sender_to}@ =
+      @\libconcept{sender_in}@<Sndr, env_of_t<Rcvr>> &&
+      @\libconcept{receiver_of}@<Rcvr, completion_signatures_of_t<Sndr, env_of_t<Rcvr>>> &&
+      requires (Sndr&& sndr, Rcvr&& rcvr) {
+        connect(std::forward<Sndr>(sndr), std::forward<Rcvr>(rcvr));
+      };
+}
+\end{codeblock}
+
+\pnum
+Given a subexpression \tcode{sndr},
+let \tcode{Sndr} be \tcode{decltype((sndr))} and
+let \tcode{rcvr} be a receiver
+with an associated environment whose type is \tcode{Env}.
+A completion operation is a \defnadj{permissible}{completion}
+for \tcode{Sndr} and \tcode{Env}
+if its completion signature appears in the argument list of the specialization of \tcode{completion_signatures} denoted by
+\tcode{completion_signatures_of_t<Sndr, Env>}.
+\tcode{Sndr} and \tcode{Env} model \tcode{\libconcept{sender_in}<Sndr, Env>}
+if all the completion operations
+that are potentially evaluated by connecting \tcode{sndr} to \tcode{rcvr} and
+starting the resulting operation state
+are permissible completions for \tcode{Sndr} and \tcode{Env}.
+
+\pnum
+A type models
+the exposition-only concept \exposconcept{valid-completion-signatures}
+if it denotes a specialization of
+the \tcode{completion_signatures} class template.
+
+\pnum
+The exposition-only concepts
+\exposconcept{sender-of} and \exposconcept{sender-in-of}
+define the requirements for a sender type
+that completes with a given unique set of value result types.
+\begin{codeblock}
+namespace std::execution {
+  template<class... As>
+    using @\exposid{value-signature}@ = set_value_t(As...);             // \expos
+
+  template<class Sndr, class Env, class... Values>
+    concept @\defexposconcept{sender-in-of}@ =
+      @\libconcept{sender_in}@<Sndr, Env> &&
+      @\exposid{MATCHING-SIG}@(                     // see \ref{exec.general}
+        set_value_t(Values...),
+        value_types_of_t<Sndr, Env, @\exposid{value-signature}@, type_identity_t>);
+
+  template<class Sndr, class... Values>
+    concept @\defexposconcept{sender-of}@ = @\exposconcept{sender-in-of}@<Sndr, empty_env, Values...>;
+}
+\end{codeblock}
+
+\pnum
+Let \tcode{sndr} be an expression
+such that \tcode{decltype((sndr))} is \tcode{Sndr}.
+The type \tcode{tag_of_t<Sndr>} is as follows:
+\begin{itemize}
+\item
+If the declaration
+\begin{codeblock}
+auto&& [tag, data, ...children] = sndr;
+\end{codeblock}
+would be well-formed, \tcode{tag_of_t<Sndr>} is
+an alias for \tcode{decltype(auto(tag))}.
+\item
+Otherwise, \tcode{tag_of_t<Sndr>} is ill-formed.
+\end{itemize}
+
+\pnum
+Let \exposconcept{sender-for} be an exposition-only concept defined as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<class Sndr, class Tag>
+  concept @\exposconcept{sender-for}@ =
+    @\libconcept{sender}@<Sndr> &&
+    @\libconcept{same_as}@<tag_of_t<Sndr>, Tag>;
+}
+\end{codeblock}
+
+\pnum
+For a type \tcode{T},
+\tcode{\exposid{SET-VALUE-SIG}(T)} denotes the type \tcode{set_value_t()}
+if \tcode{T} is \cv{} \tcode{void};
+otherwise, it denotes the type \tcode{set_value_t(T)}.
+
+\pnum
+Library-provided sender types
+\begin{itemize}
+\item
+always expose an overload of a member \tcode{connect}
+that accepts an rvalue sender and
+\item
+only expose an overload of a member \tcode{connect}
+that accepts an lvalue sender if they model \tcode{copy_constructible}.
+\end{itemize}
+
+\rSec2[exec.awaitable]{Awaitable helpers}
+
 \rSec1[exec.util]{Sender/receiver utilities}
 
 \rSec1[exec.ctx]{Execution contexts}