fixup: add upto 34.9.11.14

Author: jensmaurer

source/exec.tex

@@ -4231,8 +4231,148 @@
 whose execution domain does not customize \tcode{when_all_with_variant}.
 \end{note}
 
-\rSec1[exec.util]{Sender/receiver utilities}
+\rSec3[exec.into.variant]{\tcode{execution::into_variant}}
+
+\pnum
+\tcode{into_variant} adapts a sender with multiple value completion signatures
+into a sender with just one value completion signature
+consisting of a \tcode{variant} of \tcode{tuple}s.
+
+\pnum
+The name \tcode{into_variant} denotes a pipeable sender adaptor object.
+For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
+If \tcode{Sndr} does not satisfy \libconcept{sender},
+\tcode{into_variant(sndr)} is ill-formed.
+
+\pnum
+Otherwise, the expression \tcode{into_variant(sndr)}
+is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(into_variant, {}, sndr))
+\end{codeblock}
+except that \tcode{sndr} is only evaluated once.
+
+\pnum
+The exposition-only class template \exposid{impls-for}\iref{exec.snd.general}
+is specialized for \tcode{into_variant} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<>
+  struct @\exposid{impls-for}@<into_variant_t> : @\exposid{default-impls}@ {
+    static constexpr auto @\exposid{get-state}@ = @\seebelow@;
+    static constexpr auto @\exposid{complete}@ = @\seebelow@;
+  };
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<into_variant_t>::\exposid{get-state}}
+is initialized with a callable object equivalent to the following lambda:
+\begin{codeblock}
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept
+  -> type_identity<value_types_of_t<@\exposid{child-type}@<Sndr>, env_of_t<Rcvr>>> {
+  return {};
+}
+\end{codeblock}
+
+\pnum
+The member \tcode{\exposid{impls-for}<into_variant_t>::\exposid{complete}}
+is initialized with a callable object equivalent to the following lambda:
+\begin{codeblock}
+[]<class State, class Rcvr, class Tag, class... Args>(
+    auto, State, Rcvr& rcvr, Tag, Args&&... args) noexcept -> void {
+  if constexpr (@\libconcept{same_as}@<Tag, set_value_t>) {
+    using variant_type = typename State::type;
+    @\exposid{TRY-SET-VALUE}@(rcvr, variant_type(@\exposid{decayed-tuple}@<Args...>{std::forward<Args>(args)...}));
+  } else {
+    Tag()(std::move(rcvr), std::forward<Args>(args)...);
+  }
+}
+\end{codeblock}
+
+\rSec3[exec.stopped.opt]{\tcode{execution::stopped_as_optional}}
+
+\pnum
+\tcode{stopped_as_optional} maps a sender's stopped completion operation
+into a value completion operation as an disengaged \tcode{optional}.
+The sender's value completion operation
+is also converted into an \tcode{optional}.
+The result is a sender that never completes with stopped,
+reporting cancellation by completing with an disengaged \tcode{optional}.
+
+\pnum
+The name \tcode{stopped_as_optional} denotes a pipeable sender adaptor object.
+For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
+The expression \tcode{stopped_as_optional(sndr)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(stopped_as_optional, {}, sndr))
+\end{codeblock}
+except that \tcode{sndr} is only evaluated once.
+
+\pnum
+Let \tcode{sndr} and \tcode{env} be subexpressions
+such that \tcode{Sndr} is \tcode{decltype((sndr))} and
+\tcode{Env} is \tcode{decltype((env))}.
+If \tcode{\exposconcept{sender-for}<Sndr, stopped_as_optional_t>}
+is \tcode{false}, or
+if the type \tcode{\exposid{single-sender-value-type}<Sndr, Env>}
+is ill-formed or \tcode{void},
+then the expression \tcode{stopped_as_optional.transform_sender(sndr, env)}
+is ill-formed;
+otherwise, it is equivalent to:
+\begin{codeblock}
+auto&& [_, _, child] = sndr;
+using V = @\exposid{single-sender-value-type}@<Sndr, Env>;
+return let_stopped(
+    then(std::forward_like<Sndr>(child),
+         []<class... Ts>(Ts&&... ts) noexcept(is_nothrow_constructible_v<V, Ts...>) {
+           return optional<V>(in_place, std::forward<Ts>(ts)...);
+         }),
+    []() noexcept { return just(optional<V>()); });
+\end{codeblock}
 
+\rSec3[exec.stopped.err]{\tcode{execution::stopped_as_error}}
+
+\pnum
+\tcode{stopped_as_error} maps an input sender's stopped completion operation
+into an error completion operation as a custom error type.
+The result is a sender that never completes with stopped,
+reporting cancellation by completing with an error.
+
+\pnum
+The name \tcode{stopped_as_error} denotes a pipeable sender adaptor object.
+For some subexpressions \tcode{sndr} and \tcode{err},
+let \tcode{Sndr} be \tcode{decltype((sndr))} and
+let \tcode{Err} be \tcode{decltype((err))}.
+If the type \tcode{Sndr} does not satisfy \libconcept{sender} or
+if the type \tcode{Err} does not satisfy \exposconcept{movable-value},
+\tcode{stopped_as_error(sndr, err)} is ill-formed.
+Otherwise, the expression \tcode{stopped_as_error(sndr, err)}
+is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(stopped_as_error, err, sndr))
+\end{codeblock}
+except that \tcode{sndr} is only evaluated once.
+
+\pnum
+Let \tcode{sndr} and \tcode{env} be subexpressions
+such that \tcode{Sndr} is \tcode{decltype((sndr))} and
+\tcode{Env} is \tcode{decltype((env))}.
+If \tcode{\exposconcept{sender-for}<Sndr, stopped_as_error_t>} is \tcode{false},
+then the expression \tcode{stopped_as_error.transform_sender(sndr, env)}
+is ill-formed;
+otherwise, it is equivalent to:
+\begin{codeblock}
+auto&& [_, err, child] = sndr;
+using E = decltype(auto(err));
+return let_stopped(
+    std::forward_like<Sndr>(child),
+    [err = std::forward_like<Sndr>(err)]() mutable noexcept(is_nothrow_move_constructible_v<E>) {
+      return just_error(std::move(err));
+    });
+\end{codeblock}
+
+\rSec1[exec.util]{Sender/receiver utilities}
 
 \rSec1[exec.ctx]{Execution contexts}