fixup: add upto 34.9.11.11

Author: jensmaurer

source/exec.tex

@@ -3943,6 +3943,294 @@
 evaluates \tcode{state.\exposid{sh_state}->\exposid{start-op}()}.
 \end{itemize}
 
+\rSec3[exec.when.all]{\tcode{execution::when_all}}
+
+\pnum
+\tcode{when_all} and \tcode{when_all_with_variant}
+both adapt multiple input senders into a sender
+that completes when all input senders have completed.
+\tcode{when_all} only accepts senders
+with a single value completion signature and
+on success concatenates all the input senders' value result datums
+into its own value completion operation.
+\tcode{when_all_with_variant(sndrs...)} is semantically equivalent to
+w\tcode{hen_all(into_variant(sndrs)...)},
+where \tcode{sndrs} is a pack of subexpressions
+whose types model \libconcept{sender}.
+
+\pnum
+The names \tcode{when_all} and \tcode{when_all_with_variant} denote
+customization point objects.
+Let \tcode{sndrs} be a pack of subexpressions,
+let \tcode{Sndrs} be a pack of the types \tcode{decltype((sndrs))...}, and
+let \tcode{CD} be
+the type \tcode{common_type_t<decltype(\exposid{get-domain-early}(sndrs))...>}.
+The expressions \tcode{when_all(sndrs...)} and
+\tcode{when_all_with_variant(sndrs...)} are ill-formed
+if any of the following is \tcode{true}:
+\begin{itemize}
+\item
+\tcode{sizeof...(sndrs)} is \tcode{0}, or
+\item
+\tcode{(sender<Sndrs> \&\& ...)} is \tcode{false}, or
+\item
+\tcode{CD} is ill-formed.
+\end{itemize}
+
+\pnum
+The expression \tcode{when_all(sndrs...)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(CD(), @\exposid{make-sender}@(when_all, {}, sndrs...))
+\end{codeblock}
+
+\pnum
+The exposition-only class template \exposid{impls-for}\iref{exec.snd.general}
+is specialized for \tcode{when_all_t} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<>
+  struct @\exposid{impls-for}@<when_all_t> : @\exposid{default-impls}@ {
+    static constexpr auto @\exposid{get-attrs}@ = @\seebelow@;
+    static constexpr auto @\exposid{get-env}@ = @\seebelow@;
+    static constexpr auto @\exposid{get-state}@ = @\seebelow@;
+    static constexpr auto @\exposid{start}@ = @\seebelow@;
+    static constexpr auto @\exposid{complete}@ = @\seebelow@;
+  };
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<when_all_t>::\exposid{get-attrs}}
+is initialized with a callable object
+equivalent to the following lambda expression:
+\begin{codeblock}
+[](auto&&, auto&&... child) noexcept {
+  if constexpr (@\libconcept{same_as}@<CD, default_domain>) {
+    return empty_env();
+  } else {
+    return @\exposid{MAKE-ENV}@(get_domain, CD());
+  }
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<when_all_t>::\exposid{get-env}}
+is initialized with a callable object
+equivalent to the following lambda expression:
+\begin{codeblock}
+[]<class State, class Rcvr>(auto&&, State& state, const Receiver& rcvr) noexcept {
+  return @\exposid{JOIN-ENV}@(
+    @\exposid{MAKE-ENV}@(get_stop_token, state.@\exposid{stop_src}@.get_token()), get_env(rcvr));
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<when_all_t>::\exposid{get-state}}
+is initialized with a callable object
+equivalent to the following lambda expression:
+\begin{codeblock}
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept(@$e$@) -> decltype(e) {
+  return @$e$@;
+}
+\end{codeblock}
+where $e$ is the expression
+\begin{codeblock}
+std::forward<Sndr>(sndr).apply(@\exposid{make-state}@<Rcvr>())
+\end{codeblock}
+and where \exposid{make-state} is the following exposition-only class template:
+\begin{codeblock}
+template<class Sndr, class Env>
+concept @\defexposconcept{max-1-sender-in}@ = @\libconcept{sender_in}@<Sndr, Env> &&          // \expos
+  (tuple_size_v<value_types_of_t<Sndr, Env, tuple, tuple>> <= 1);
+
+enum class @\exposid{disposition}@ { @\exposid{started}@, @\exposid{error}@, @\exposid{stopped}@ };             // \expos
+
+template<class Rcvr>
+struct @\exposid{make-state}@ {
+  template<@\exposconcept{max-1-sender-in}@<env_of_t<Rcvr>>... Sndrs>
+  auto operator()(auto, auto, Sndrs&&... sndrs) const {
+    using values_tuple = @\seebelow@;
+    using errors_variant = @\seebelow@;
+    using stop_callback = stop_callback_of_t<stop_token_of_t<env_of_t<Rcvr>>, @\exposid{on-stop-request}@>;
+
+    struct @\exposid{state-type}@ {
+      void arrive(Rcvr& rcvr) noexcept {
+        if (0 == --count) {
+          @\exposid{complete}@(rcvr);
+        }
+      }
+
+      void @\exposid{complete}@(Rcvr& rcvr) noexcept;   // \seebelow
+
+      atomic<size_t> @\exposid{count}@{sizeof...(sndrs)};                   // \expos
+      inplace_stop_source @\exposid{stop_src}@{};                           // \expos
+      atomic<@\exposid{disposition}@> disp{@\exposid{disposition}@::@\exposid{started}@};                  // \expos
+      errors_variant @\exposid{errors}@{};                                  // \expos
+      values_tuple @\exposid{values}@{};                                    // \expos
+      optional<stop_callback> @\exposid{on_stop}@{nullopt};                 // \expos
+    };
+
+    return @\exposid{state-type}@{};
+  }
+};
+\end{codeblock}
+
+\pnum
+Let \exposid{copy-fail} be \tcode{exception_ptr}
+if decay-copying any of the child senders' result datums can potentially throw;
+otherwise, \exposid{none-such},
+where \exposid{none-such} is an unspecified empty class type.
+
+\pnum
+The alias \tcode{values_tuple} denotes the type
+\tcode{tuple<value_types_of_t<Sndrs, env_of_t<Rcvr>, decayed-tuple, optional>...>}
+if that type is well-formed; otherwise, \tcode{tuple<>}.
+
+\pnum
+The alias \tcode{errors_variant} denotes
+the type \tcode{variant<none-such, copy-fail, Es...>}
+with duplicate types removed,
+where \tcode{Es} is the pack of the decayed types
+of all the child senders' possible error result datums.
+
+\pnum
+The member
+\tcode{void \exposid{state-type}::\exposid{complete}(Rcvr\& rcvr) noexcept}
+behaves as follows:
+\begin{itemize}
+\item
+If \tcode{disp} is equal to \tcode{\exposid{disposition}::\exposid{started}},
+evaluates:
+\begin{codeblock}
+auto tie = []<class... T>(tuple<T...>& t) noexcept { return tuple<T&...>(t); };
+auto set = [&](auto&... t) noexcept { set_value(std::move(rcvr), std::move(t)...); };
+
+@\exposid{on_stop}@.reset();
+apply(
+  [&](auto&... opts) noexcept {
+    apply(set, tuple_cat(tie(*opts)...));
+  },
+  values);
+\end{codeblock}
+\item
+Otherwise,
+if \tcode{disp} is equal to \tcode{\exposid{disposition}::\exposid{error}},
+evaluates:
+\begin{codeblock}
+@\exposid{on_stop}@.reset();
+visit(
+  [&]<class Error>(Error& error) noexcept {
+    if constexpr (!@\libconcept{same_as}@<Error, @\exposid{none-such}@>) {
+      set_error(std::move(rcvr), std::move(error));
+    }
+  },
+  errors);
+\end{codeblock}
+\item
+Otherwise, evaluates:
+\begin{codeblock}
+@\exposid{on_stop}@.reset();
+set_stopped(std::move(rcvr));
+\end{codeblock}
+\end{itemize}
+
+\pnum
+The member \tcode{\exposid{impls-for}<when_all_t>::\exposid{start}}
+is initialized with a callable object
+equivalent to the following lambda expression:
+\begin{codeblock}
+[]<class State, class Rcvr, class... Ops>(
+    State& state, Rcvr& rcvr, Ops&... ops) noexcept -> void {
+  state.@\exposid{on_stop}@.emplace(
+    get_stop_token(get_env(rcvr)),
+    @\exposid{on-stop-request}@{state.@\exposid{stop_src}@});
+  if (state.@\exposid{stop_src}@.stop_requested()) {
+    state.@\exposid{on_stop.}@reset();
+    set_stopped(std::move(rcvr));
+  } else {
+    (start(ops), ...);
+  }
+}
+\end{codeblock}
+
+\pnum
+The member \exposid{\tcode{impls-for}<when_all_t>::\exposid{complete}}
+is initialized with a callable object
+equivalent to the following lambda expression:
+\begin{codeblock}
+[]<class Index, class State, class Rcvr, class Set, class... Args>(
+    this auto& complete, Index, State& state, Rcvr& rcvr, Set, Args&&... args) noexcept -> void {
+  if constexpr (@\libconcept{same_as}@<Set, set_error_t>) {
+    if (@\exposid{disposition}@::@\exposid{error}@ != state.disp.exchange(@\exposid{disposition}@::@\exposid{error}@)) {
+      state.@\exposid{stop_src}@.request_stop();
+      @\exposid{TRY-EMPLACE-ERROR}@(state.errors, std::forward<Args>(args)...);
+    }
+  } else if constexpr (@\libconcept{same_as}@<Set, set_stopped_t>) {
+    auto expected = @\exposid{disposition}@::@\exposid{started}@;
+    if (state.disp.compare_exchange_strong(expected, @\exposid{disposition}@::@\exposid{stopped}@)) {
+      state.@\exposid{stop_src}@.request_stop();
+    }
+  } else if constexpr (!@\libconcept{same_as}@<decltype(State::values), tuple<>>) {
+    if (state.disp == @\exposid{disposition}@::@\exposid{started}@) {
+      auto& opt = get<Index::value>(state.values);
+      @\exposid{TRY-EMPLACE-VALUE}@(complete, opt, std::forward<Args>(args)...);
+    }
+  }
+  state.@\exposid{arrive}@(rcvr);
+}
+\end{codeblock}
+where \tcode{\exposid{TRY-EMPLACE-ERROR}(v, e)},
+for subexpressions \tcode{v} and \tcode{e}, is equivalent to:
+\begin{codeblock}
+try {
+  v.template emplace<decltype(auto(e))>(e);
+} catch (...) {
+  v.template emplace<exception_ptr>(current_exception());
+}
+\end{codeblock}
+if the expression \tcode{decltype(auto(e))(e)} is potentially throwing;
+otherwise, \tcode{v.template emplace<decltype(auto(e))>(e)};
+and where \tcode{\exposid{TRY-EMPLACE-VALUE}(c, o, as...)},
+for subexpressions \tcode{c}, \tcode{o}, and pack of subexpressions \tcode{as},
+is equivalent to:
+\begin{codeblock}
+try {
+  o.emplace(as...);
+} catch (...) {
+  c(Index(), state, rcvr, set_error, current_exception());
+  return;
+}
+\end{codeblock}
+if the expression \tcode{decayed-tuple<decltype(as)...>\{as...\}}
+is potentially throwing;
+otherwise, \tcode{o.emplace(as...)}.
+
+\pnum
+The expression \tcode{when_all_with_variant(sndrs...)}
+is expression-equivalent to:
+\begin{codeblock}
+transform_sender(CD(), @\exposid{make-sender}@(when_all_with_variant, {}, sndrs...));
+\end{codeblock}
+
+\pnum
+Given subexpressions \tcode{sndr} and \tcode{env},
+if
+\tcode{\exposconcept{sender-for}<decltype((sndr)), when_all_with_variant_t>}
+is \tcode{false},
+then the expression \tcode{when_all_with_variant.transform_sender(sndr, env)}
+is ill-formed;
+otherwise, it is equivalent to:
+\begin{codeblock}
+auto&& [_, _, ...child] = sndr;
+return when_all(into_variant(std::forward_like<decltype((sndr))>(child))...);
+\end{codeblock}
+\begin{note}
+This causes the \tcode{when_all_with_variant(sndrs...)} sender
+to become \tcode{when_all(into_variant(sndrs)...)}
+when it is connected with a receiver
+whose execution domain does not customize \tcode{when_all_with_variant}.
+\end{note}
+
 \rSec1[exec.util]{Sender/receiver utilities}