fixup: all of 34.10

Author: jensmaurer

source/exec.tex

@@ -4636,6 +4636,237 @@
 
 \rSec1[exec.util]{Sender/receiver utilities}
 
+\rSec2[exec.util.cmplsig]{\tcode{execution::completion_signatures}}
+
+\pnum
+\tcode{completion_signatures} is a type
+that encodes a set of completion signatures\iref{exec.async.ops}.
+
+\pnum
+\begin{example}
+\begin{codeblock}
+struct my_sender {
+  using sender_concept = sender_t;
+  using completion_signatures =
+    execution::completion_signatures<
+      set_value_t(),
+      set_value_t(int, float),
+      set_error_t(exception_ptr),
+      set_error_t(error_code),
+      set_stopped_t()>;
+};
+\end{codeblock}
+Declares \tcode{my_sender} to be a sender
+that can complete by calling one of the following
+for a receiver expression \tcode{rcvr}:
+\begin{itemize}
+\item \tcode{set_value(rcvr)}
+\item \tcode{set_value(rcvr, int\{...\}, float\{...\})}
+\item \tcode{set_error(rcvr, exception_ptr\{...\})}
+\item \tcode{set_error(rcvr, error_code\{...\})}
+\item \tcode{set_stopped(rcvr)}
+\end{itemize}
+\end{example}
+
+\pnum
+This subclause makes use of the following exposition-only entities:
+\begin{codeblock}
+template<class Fn>
+  concept @\defexposconcept{completion-signature}@ = @\seebelow@;
+\end{codeblock}
+
+\pnum
+A type \tcode{Fn} satisfies \exposconcept{completion-signature}
+if and only if it is a function type with one of the following forms:
+\begin{itemize}
+\item
+\tcode{set_value_t(Vs...)},
+where \tcode{Vs} is a pack of object or reference types.
+\item
+\tcode{set_error_t(Err)},
+where \tcode{Err} is an object or reference type.
+\item
+\tcode{set_stopped_t()}
+\end{itemize}
+
+\pnum
+\begin{codeblock}
+template<bool>
+  struct @\exposid{indirect-meta-apply}@ {
+    template<template<class...> class T, class... As>
+      using @\exposid{meta-apply}@ = T<As...>;                              // \expos
+  };
+
+template<class...>
+  concept @\defexposconcept{always-true}@ = true;                                   // \expos
+
+template<class Tag,
+         @\exposconcept{valid-completion-signatures}@ Completions,
+         template<class...> class Tuple,
+         template<class...> class Variant>
+  using @\exposid{gather-signatures}@ = @\seebelow@;
+\end{codeblock}
+
+\pnum
+Let \tcode{Fns} be a pack of the arguments of
+the \tcode{completion_signatures} specialization named by \tcode{Completions},
+let \tcode{TagFns} be a pack of the function types in \tcode{Fns}
+whose return types are \tcode{Tag}, and
+let $\tcode{Ts}_n$ be a pack of the function argument types
+in the $n$-th type in \tcode{TagFns}.
+Then, given two variadic templates \tcode{Tuple} and \tcode{Variant},
+the type \tcode{\exposid{gather-signatures}<Tag, Completions, Tuple, Variant>}
+names the type
+\begin{codeblock}
+@\exposid{META-APPLY}@(Variant, @\exposid{META-APPLY}@(Tuple, Ts@$_0$@...),
+                    @\exposid{META-APPLY}@(Tuple, Ts@$_1$@...),
+                    @\ldots@,
+                    @\exposid{META-APPLY}@(Tuple, Ts@$_{m-1}$@...))
+\end{codeblock}
+where $m$ is the size of the pack \tcode{TagFns} and
+\tcode{META-APPLY(T, As...)} is equivalent to:
+\begin{codeblock}
+typename @\exposid{indirect-meta-apply}@<@\exposid{always-true}@<As...>>::template @\exposid{meta-apply}@<T, As...>
+\end{codeblock}
+
+\pnum
+\begin{note}
+The purpose of \exposid{META-APPLY} is to make it valid
+to use non-variadic templates as \tcode{Variant} and \tcode{Tuple} arguments
+to \exposid{gather-signatures}.
+\end{note}
+
+\pnum
+\begin{codeblock}
+namespace std::execution {
+  template<@\exposconcept{completion-signature}@... Fns>
+    struct completion_signatures {};
+
+  template<class Sndr,
+           class Env = empty_env,
+           template<class...> class Tuple = @\exposid{decayed-tuple}@,
+           template<class...> class Variant = @\exposid{variant-or-empty}@>
+      requires @\libconcept{sender_in}@<Sndr, Env>
+    using value_types_of_t =
+      @\exposid{gather-signatures}@<set_value_t, completion_signatures_of_t<Sndr, Env>, Tuple, Variant>;
+
+  template<class Sndr,
+           class Env = empty_env,
+           template<class...> class Variant = @\exposid{variant-or-empty}@>
+      requires @\libconcept{sender_in}@<Sndr, Env>
+    using error_types_of_t =
+      @\exposid{gather-signatures}@<set_error_t, completion_signatures_of_t<Sndr, Env>,
+                        type_identity_t, Variant>;
+
+  template<class Sndr, class Env = empty_env>
+      requires @\libconcept{sender_in}@<Sndr, Env>
+    inline constexpr bool sends_stopped =
+      !@\libconcept{same_as}@<@\exposid{type-list}@<>,
+               @\exposid{gather-signatures}@<set_stopped_t, completion_signatures_of_t<Sndr, Env>,
+                                 @\exposid{type-list}@, @\exposid{type-list}@>>;
+}
+\end{codeblock}
+
+\rSec2[exec.util.cmplsig.trans]{execution::transform_completion_signatures}
+
+\pnum
+\tcode{transform_completion_signatures} is an alias template
+used to transform one set of completion signatures into another.
+It takes a set of completion signatures and
+several other template arguments
+that apply modifications to each completion signature in the set
+to generate a new specialization of \tcode{completion_signature}s.
+\pnum
+\begin{example}
+Given a sender \tcode{Sndr} and an environment \tcode{Env},
+adapt the completion signatures of \tcode{Sndr} by
+lvalue-ref qualifying the values,
+adding an additional \tcode{exception_ptr} error completion
+if its not already there, and
+leaving the other completion signatures alone.
+\begin{codeblock}
+template<class... Args>
+  using my_set_value_t =
+    completion_signatures<
+      set_value_t(add_lvalue_reference_t<Args>...)>;
+
+using my_completion_signatures =
+  transform_completion_signatures<
+    completion_signatures_of_t<Sndr, Env>,
+    completion_signatures<set_error_t(exception_ptr)>,
+    my_set_value_t>;
+\end{codeblock}
+\end{example}
+
+\pnum
+This subclause makes use of the following exposition-only entities:
+\begin{codeblock}
+template<class... As>
+  using default-set-value =
+    completion_signatures<set_value_t(As...)>;
+
+template<class Err>
+  using default-set-error =
+    completion_signatures<set_error_t(Err)>;
+\end{codeblock}
+
+\pnum
+\begin{codeblock}
+namespace std::execution {
+  template<@\exposconcept{valid-completion-signatures}@ InputSignatures,
+           @\exposconcept{valid-completion-signatures}@ AdditionalSignatures = completion_signatures<>,
+           template<class...> class SetValue = @\exposid{default-set-value}@,
+           template<class> class SetError = @\exposid{default-set-error}@,
+           @\exposconcept{valid-completion-signatures}@ SetStopped = completion_signatures<set_stopped_t()>>
+  using transform_completion_signatures = completion_signatures<@\seebelow@>;
+}
+\end{codeblock}
+
+\pnum
+\tcode{SetValue} shall name an alias template
+such that for any pack of types \tcode{As},
+the type \tcode{SetValue<As...>} is either ill-formed or else
+\tcode{\exposconcept{valid-completion-signatures}<SetValue<As...>>} is satisfied.
+\tcode{SetError} shall name an alias template
+such that for any type \tcode{Err},
+\tcode{SetError<Err>} is either ill-formed or else
+\tcode{\exposconcept{valid-completion-signatures}<SetError<Err>>} is satisfied.
+
+\pnum
+Let \tcode{Vs} be a pack of the types in the \exposid{type-list} named by
+\tcode{\exposid{gather-signatures}<set_value_t, InputSigna\-tures, SetValue, \exposid{type-list}>}.
+
+\pnum
+Let \tcode{Es} be a pack of the types in the \exposid{type-list} named by
+\tcode{\exposid{gather-signatures}<set_error_t, InputSigna\-tures, type_identity_t, \exposid{error-list}>},
+where \exposid{error-list} is an alias template
+such that \tcode{\exposid{error-list}<\linebreak Ts...>} is
+\tcode{\exposid{type-list}<SetError<Ts>...>}.
+
+\pnum
+Let \tcode{Ss} name the type \tcode{completion_signatures<>} if
+\tcode{\exposid{gather-signatures}<set_stopped_t, InputSigna\-tures, \exposid{type-list}, \exposid{type-list}>}
+is an alias for the type \tcode{\exposid{type-list}<>};
+otherwise, \tcode{SetStopped}.
+
+\pnum
+If any of the above types are ill-formed,
+then
+\begin{codeblock}
+transform_completion_signatures<InputSignatures, AdditionalSignatures,
+                                SetValue, SetError, SetStopped>
+\end{codeblock}
+is ill-formed.
+Otherwise,
+\begin{codeblock}
+transform_completion_signatures<InputSignatures, AdditionalSignatures,
+                                SetValue, SetError, SetStopped>
+\end{codeblock}
+is the type \tcode{completion_signatures<Sigs...>}
+where \tcode{Sigs...} is the unique set of types in all the template arguments
+of all the \tcode{completion_signatures} specializations in the set
+\tcode{AdditionalSignatures}, \tcode{Vs...}, \tcode{Es...}, \tcode{Ss}.
+
 \rSec1[exec.ctx]{Execution contexts}
 
 \rSec1[exec.coro.util]{Coroutine utilities}