P3557R3 High-Quality Sender Diagnostics with Constexpr Exceptions (Part 1 - up to [exec.snd.expos]p39)

Author: burblebee

source/exec.tex

@@ -372,6 +372,9 @@
 The type of the receiver does not affect
 an asynchronous operation's completion signatures,
 only the type of the receiver's environment.
+A \defnadj{non-dependent}{sender} is a sender type
+whose completion signatures are knowable
+independent of an execution environment.
 
 \pnum
 A sender algorithm is a function that takes and/or returns a sender.
@@ -528,23 +531,18 @@
   template<class Sndr>
     concept @\libconcept{sender}@ = @\seebelow@;
 
-  template<class Sndr, class Env = env<>>
+  template<class Sndr, class Env>
     concept @\libconcept{sender_in}@ = @\seebelow@;
 
+  template<class Sndr>
+    concept @\libconcept{dependent_sender}@ = @\seebelow@;
+
   template<class Sndr, class Rcvr>
     concept @\libconcept{sender_to}@ = @\seebelow@;
 
   template<class... Ts>
     struct @\exposidnc{type-list}@;                                           // \expos
 
-  // \ref{exec.getcomplsigs}, completion signatures
-  struct get_completion_signatures_t;
-  inline constexpr get_completion_signatures_t get_completion_signatures {};
-
-  template<class Sndr, class Env = env<>>
-      requires @\libconcept{sender_in}@<Sndr, Env>
-    using completion_signatures_of_t = @\exposid{call-result-t}@<get_completion_signatures_t, Sndr, Env>;
-
   template<class... Ts>
     using @\exposidnc{decayed-tuple}@ = tuple<decay_t<Ts>...>;                // \expos
 
@@ -655,7 +653,7 @@
   inline constexpr stopped_as_error_t @\libglobal{stopped_as_error}@{};
 
   // \ref{exec.util}, sender and receiver utilities
-  // \ref{exec.util.cmplsig}
+  // \ref{exec.util.cmplsig}, completion signatures
   template<class Fn>
     concept @\exposconceptnc{completion-signature}@ = @\seebelownc@;                   // \expos
 
@@ -665,27 +663,15 @@
   template<class Sigs>
     concept @\exposconceptnc{valid-completion-signatures}@ = @\seebelownc@;            // \expos
 
-  // \ref{exec.util.cmplsig.trans}
-  template<
-    @\exposconcept{valid-completion-signatures}@ InputSignatures,
-    @\exposconcept{valid-completion-signatures}@ AdditionalSignatures = completion_signatures<>,
-    template<class...> class SetValue = @\seebelow@,
-    template<class> class SetError = @\seebelow@,
-    @\exposconcept{valid-completion-signatures}@ SetStopped = completion_signatures<set_stopped_t()>>
-  using transform_completion_signatures = completion_signatures<@\seebelow@>;
+  struct dependent_sender_error : exception {};
 
-  template<
-    @\libconcept{sender}@ Sndr,
-    class Env = env<>,
-    @\exposconcept{valid-completion-signatures}@ AdditionalSignatures = completion_signatures<>,
-    template<class...> class SetValue = @\seebelow@,
-    template<class> class SetError = @\seebelow@,
-    @\exposconcept{valid-completion-signatures}@ SetStopped = completion_signatures<set_stopped_t()>>
-      requires @\libconcept{sender_in}@<Sndr, Env>
-  using transform_completion_signatures_of =
-    transform_completion_signatures<
-      completion_signatures_of_t<Sndr, Env>,
-      AdditionalSignatures, SetValue, SetError, SetStopped>;
+  // \ref{exec.getcomplsigs}
+  template<class Sndr, class... Env>
+    consteval auto get_completion_signatures() -> @\exposconcept{valid-completion-signatures}@ auto;
+
+  template<class Sndr, class... Env>
+      requires @\libconcept{sender_in}@<Sndr, Env...>
+    using completion_signatures_of_t = decltype(get_completion_signatures<Sndr, Env...>());
 
   // \ref{exec.run.loop}, run_loop
   class run_loop;
@@ -733,18 +719,22 @@
 \end{itemize}
 
 \pnum
-For types \tcode{Sndr} and \tcode{Env},
-\tcode{\exposid{single-sender-value-type}<Sndr, Env>} is an alias for:
+For type \tcode{Sndr} and pack of types \tcode{Env},
+let \tcode{CS} be \tcode{completion_signatures_of_t<Sndr, Env...>}.
+Then \tcode{\exposid{single-sender-value-type}<Sndr, Env>} is ill-formed
+if \tcode{CS} is ill-formed or
+if \tcode{sizeof...(Env) > 1} is \tcode{true};
+otherwise, it is an alias for:
 \begin{itemize}
 \item
-\tcode{value_types_of_t<Sndr, Env, decay_t, type_identity_t>}
+\tcode{\exposid{gather-signatures}<set_value_t, CS, decay_t, type_identity_t>}
 if that type is well-formed,
 \item
 Otherwise, \tcode{void}
-if \tcode{value_types_of_t<Sndr, Env, tuple, variant>} is
+if \tcode{\exposid{gather-signatures}<set_value_t, CS, tuple, variant>} is
 \tcode{variant<tuple<>>} or \tcode{vari\-ant<>},
 \item
-Otherwise, \tcode{value_types_of_t<Sndr, Env, \exposid{decayed-tuple}, type_identity_t>}
+Otherwise, \tcode{\exposid{gather-signatures}<set_value_t, CS, \exposid{decayed-tuple}, type_identity_t>}
 if that type is well-formed,
 \item
 Otherwise, \tcode{\exposid{single-sender-value-type}<Sndr, Env>} is ill-formed.
@@ -762,6 +752,11 @@
 }
 \end{codeblock}
 
+\pnum
+A type satisfies and models the exposition-only concept
+\exposconcept{valid-completion-signatures} if
+it is a specialization of the \tcode{completion_signatures} class template.
+
 \rSec1[exec.queries]{Queries}
 
 \rSec2[exec.fwd.env]{\tcode{forwarding_query}}
@@ -1251,20 +1246,35 @@
 a set of completion operations
 whose first argument is a subexpression equal to \tcode{rcvr}.
 Let \tcode{Sigs} be a pack of completion signatures corresponding to
-this set of completion operations.
-Then the type of the expression \tcode{get_completion_signatures(sndr, env)} is
+this set of completion operations, and
+let \tcode{CS} be
+the type of the expression \tcode{get_completion_signatures(Sndr, Env)()}.
+Then \tcode{CS} is
 a specialization of
 the class template \tcode{completion_signatures}\iref{exec.util.cmplsig},
 the set of whose template arguments is \tcode{Sigs}.
+If none of the types in \tcode{Sigs} are dependent on the type \tcode{Env}, then
+the expression \tcode{get_completion_signatures<Sndr>()} is well-formed and
+its type is \tcode{CS}.
 If a user-provided implementation of the algorithm
-that produced \tcode{sndr} is selected instead of the default,
-any completion signature
+that produced \tcode{sndr} is selected instead of the default:
+
+\begin{itemize}
+\item
+Any completion signature
 that is in the set of types
 denoted by \tcode{completion_signatures_of_t<Sndr, Env>} and
 that is not part of \tcode{Sigs} shall correspond to
 error or stopped completion operations,
 unless otherwise specified.
 
+\item
+If none of the types in \tcode{Sigs} are dependent on the type \tcode{Env}, then
+\tcode{completion_signatures_of_t<Sndr>} and
+\tcode{completion_signatures_of_t<Sndr, Env>}
+shall denote the same type.
+\end{itemize}
+
 \rSec2[exec.snd.expos]{Exposition-only entities}
 
 \pnum
@@ -1279,6 +1289,9 @@
 the expression \tcode{\exposid{FWD-ENV}(env).query(q, as...)} is ill-formed
 if \tcode{forwarding_query(q)} is \tcode{false};
 otherwise, it is expression-equivalent to \tcode{env.query(q, as...)}.
+%%FIXME: Where did FWD-ENV-T come from?
+The type \tcode{\exposid{FWD-ENV-T}(Env)} is
+\tcode{decltype(\exposid{FWD-ENV}(declval<Env>()))}.
 
 \pnum
 For a query object \tcode{q} and \tcode{a} subexpression \tcode{v},
@@ -1568,6 +1581,16 @@
 otherwise, \tcode{false}.
 \end{itemdescr}
 
+\pnum
+Let \exposconcept{valid-specialization} be the following concept:
+\begin{codeblock}
+namespace std::execution {
+  template<template<class...> class T, class... Args>
+  concept @\defexposconceptnc{valid-specialization}@ =                                // \expos
+    requires { typename T<Args...>; };
+}
+\end{codeblock}
+
 \begin{itemdecl}
 template<class Tag, class Data = @\seebelow@, class... Child>
   constexpr auto @\exposid{make-sender}@(Tag tag, Data&& data, Child&&... child);
@@ -1581,6 +1604,19 @@
 \item \tcode{\libconcept{semiregular}<Tag>}
 \item \tcode{\exposconcept{movable-value}<Data>}
 \item \tcode{(\libconcept{sender}<Child> \&\& ...)}
+\item%
+\tcode{\libconcept{dependent_sender}<Sndr> || \libconcept{sender_in}<Sndr>},
+where \tcode{Sndr} is \tcode{\exposid{basic-sender}<Tag, Data, Child...>}
+as defined below.
+
+%%FIXME: OK to have \recommended inside an itemized list like this?
+\pnum
+\recommended
+If evaluation of \tcode{\libconcept{sender_in}<Sndr>} results in
+an uncaught exception from
+the evaluation of \tcode{get_completion_signatures<Sndr>()},
+the implementation should include information about that exception in
+the resulting diagnostic.
 \end{itemize}
 
 \pnum
@@ -1597,16 +1633,15 @@
   concept @\defexposconceptnc{completion-tag}@ =                                      // \expos
     @\libconcept{same_as}@<Tag, set_value_t> || @\libconcept{same_as}@<Tag, set_error_t> || @\libconcept{same_as}@<Tag, set_stopped_t>;
 
-  template<template<class...> class T, class... Args>
-  concept @\defexposconceptnc{valid-specialization}@ =                                // \expos
-    requires { typename T<Args...>; };
-
   struct @\exposidnc{default-impls}@ {                                        // \expos
     static constexpr auto @\exposidnc{get-attrs}@ = @\seebelownc@;                // \expos
     static constexpr auto @\exposidnc{get-env}@ = @\seebelownc@;                  // \expos
     static constexpr auto @\exposidnc{get-state}@ = @\seebelownc@;                // \expos
     static constexpr auto @\exposidnc{start}@ = @\seebelownc@;                    // \expos
     static constexpr auto @\exposidnc{complete}@ = @\seebelownc@;                 // \expos
+
+    template<class Sndr, class... Env>
+      static consteval void @\exposidnc{check-types}@();                      // \expos
   };
 
   template<class Tag>
@@ -1621,6 +1656,9 @@
     decltype(@\exposid{impls-for}@<tag_of_t<Sndr>>::@\exposid{get-env}@), Index,
     @\exposid{state-type}@<Sndr, Rcvr>&, const Rcvr&>;
 
+  template<class Sndr>
+  using @\exposidnc{data-type}@ = decltype(declval<Sndr>().template @\exposidnc{get}@<1>());                // \expos
+
   template<class Sndr, size_t I = 0>
   using @\exposidnc{child-type}@ = decltype(declval<Sndr>().template @\exposidnc{get}@<I+2>());             // \expos
 
@@ -1696,9 +1734,6 @@
     }
   };
 
-  template<class Sndr, class Env>
-  using @\exposidnc{completion-signatures-for}@ = @\seebelownc@;                  // \expos
-
   template<class Tag, class Data, class... Child>
   struct @\exposidnc{basic-sender}@ : @\exposidnc{product-type}@<Tag, Data, Child...> {     // \expos
     using sender_concept = sender_t;
@@ -1716,10 +1751,7 @@
     }
 
     template<@\exposconcept{decays-to}@<@\exposid{basic-sender}@> Self, class Env>
-    auto get_completion_signatures(this Self&& self, Env&& env) noexcept
-      -> @\exposid{completion-signatures-for}@<Self, Env> {
-      return {};
-    }
+    static constexpr auto get_completion_signatures();
   };
 }
 \end{codeblock}