fixup: add upto 34.9.11.10

Author: jensmaurer

source/exec.tex

@@ -3574,6 +3574,375 @@
 propagates all completion operations sent by \tcode{sndr}.
 \end{itemize}
 
+\rSec3[exec.split]{\tcode{execution::split}}
+
+\pnum
+\tcode{split} adapts an arbitrary sender
+into a sender that can be connected multiple times.
+
+\pnum
+Let \exposid{split-env} be the type of an environment
+such that, given an instance \tcode{env},
+the expression \tcode{get_stop_token(env)} is well-formed and
+has type \tcode{inplace_stop_token.}
+
+\pnum
+The name \tcode{split} denotes a pipeable sender adaptor object.
+For a subexpression \tcode{sndr}, let \tcode{Sndr} be \tcode{decltype((sndr))}.
+If \tcode{\libconcept{sender_in}<Sndr, \exposid{split-env}>} is \tcode{false},
+\tcode{split(sndr)} is ill-formed.
+
+\pnum
+Otherwise, the expression \tcode{split(sndr)} is expression-equivalent to:
+\begin{codeblock}
+transform_sender(@\exposid{get-domain-early}@(sndr), @\exposid{make-sender}@(split, {}, sndr))
+\end{codeblock}
+except that \tcode{sndr} is evaluated only once.
+\begin{note}
+The default implementation of \tcode{transform_sender}
+will have the effect of connecting the sender to a receiver.
+It will return a sender with a different tag type.
+\end{note}
+
+\pnum
+Let \exposid{local-state} denote the following exposition-only class template:
+
+\begin{codeblock}
+namespace std::execution {
+  struct @\exposid{local-state-base}@ {                                     // \expos
+    virtual ~@\exposid{local-state-base}@() = default;
+    virtual void @\exposid{notify}@() noexcept = 0;                         // \expos
+  };
+
+  template<class Sndr, class Rcvr>
+  struct @\exposid{local-state}@ : @\exposid{local-state-base}@ {                 // \expos
+    using @\exposid{on-stop-callback}@ =                                    // \expos
+      stop_callback_of_t<stop_token_of_t<env_of_t<Rcvr>>, @\exposid{on-stop-request}@>;
+
+    @\exposid{local-state}@(Sndr&& sndr, Rcvr& rcvr) noexcept;
+    ~@\exposid{local-state}@();
+
+    void @\exposid{notify}@() noexcept override;
+
+  private:
+    optional<@\exposid{on-stop-callback}@> @\exposid{on_stop}@;                         // \expos
+    @\exposid{shared-state}@<Sndr>* @\exposid{sh_state}@;                         // \expos
+    Rcvr* @\exposid{rcvr}@;                                                 // \expos
+  };
+}
+\end{codeblock}
+
+\begin{itemdecl}
+local-state(Sndr&& sndr, Rcvr& rcvr) noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to:
+\begin{codeblock}
+auto& [_, data, _] = sndr;
+this->@\exposid{sh_state}@ = data.sh_state.get();
+this->@\exposid{sh_state}@->@\exposid{inc-ref}@();
+this->@\exposid{rcvr}@ = addressof(rcvr);
+\end{codeblock}
+\end{itemdescr}
+
+\begin{itemdecl}
+~@\exposid{local-state}@();
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to:
+\begin{codeblock}
+sh_state->@\exposid{dec-ref}@();
+\end{codeblock}
+\end{itemdescr}
+
+\begin{itemdecl}
+void @\exposid{notify}@() noexcept override;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Equivalent to:
+\begin{codeblock}
+@\exposid{on_stop}@.reset();
+visit(
+  [this](const auto& tupl) noexcept -> void {
+    apply(
+      [this](auto tag, const auto&... args) noexcept -> void {
+        tag(std::move(*@\exposid{rcvr}@), args...);
+      },
+      tupl);
+  },
+  @\exposid{sh_state}@->result);
+\end{codeblock}
+\end{itemdescr}
+
+\pnum
+Let \exposid{split-receiver} denote
+the following exposition-only class template:
+\begin{codeblock}
+namespace std::execution {
+  template<class Sndr>
+  struct @\exposid{split-receiver}@ {                                       // \expos
+    using receiver_concept = receiver_t;
+
+    template<class Tag, class... Args>
+    void @\exposid{complete}@(Tag, Args&&... args) noexcept {                           // \expos
+      using tuple_t = @\exposid{decayed-tuple}@<Tag, Args...>;
+      try {
+        @\exposid{sh_state}@->result.template emplace<tuple_t>(Tag(), std::forward<Args>(args)...);
+      } catch (...) {
+        using tuple_t = tuple<set_error_t, exception_ptr>;
+        @\exposid{sh_state}@->result.template emplace<tuple_t>(set_error, current_exception());
+      }
+      @\exposid{sh_state}@->notify();
+    }
+
+    template<class... Args>
+    void set_value(Args&&... args) && noexcept {
+      @\exposid{complete}@(execution::set_value, std::forward<Args>(args)...);
+    }
+
+    template<class Error>
+    void set_error(Error&& err) && noexcept {
+      @\exposid{complete}@(execution::set_error, std::forward<Error>(err));
+    }
+
+    void set_stopped() && noexcept {
+      @\exposid{complete}@(execution::set_stopped);
+    }
+
+    struct @\exposid{env}@ {                                                // \expos
+      @\exposid{shared-state}@<Sndr>* @\exposid{sh-state}@;                             // \expos
+
+      inplace_stop_token query(get_stop_token_t) const noexcept {
+        return @\exposid{sh-state}@->stop_src.get_token();
+      }
+    };
+
+    @\exposid{env}@ get_env() const noexcept {
+      return @\exposid{env}@{@\exposid{sh_state}@};
+    }
+
+    @\exposid{shared-state}@<Sndr>* @\exposid{sh_state}@;                               // \expos
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \exposid{shared-state} denote the following exposition-only class template:
+\begin{codeblock}
+namespace std::execution {
+  template<class Sndr>
+  struct @\exposid{shared-state}@ {
+    using @\exposid{variant-type}@ = @\seebelow@;                           // \expos
+    using @\exposid{state-list-type}@ = @\seebelow@;                        // \expos
+
+    explicit @\exposid{shared-state}@(Sndr&& sndr);
+
+    void @\exposid{start-op}@() noexcept;                                   // \expos
+    void @\exposid{notify}@() noexcept;                                     // \expos
+    void @\exposid{inc-ref}@() noexcept;                                    // \expos
+    void @\exposid{dec-ref}@() noexcept;                                    // \expos
+
+    inplace_stop_source @\exposid{stop_src}@{};                                         // \expos
+    @\exposid{variant-type}@ @\exposid{result}@{};                                      // \expos
+    @\exposid{state-list-type}@ @\exposid{waiting_states}@;                             // \expos
+    atomic<bool> @\exposid{completed}@{false};                              // \expos
+    atomic<size_t> @\exposid{ref_count}@{1};                                // \expos
+    connect_result_t<Sndr, @\exposid{split-receiver}@<Sndr>> @\exposid{op_state}@;      // \expos
+  };
+}
+\end{codeblock}
+
+\pnum
+Let \tcode{Sigs} be a pack of the arguments
+to the \tcode{completion_signatures} specialization
+named by \tcode{completion_signatures_of_t<Sndr>}.
+For type \tcode{Tag} and pack \tcode{Args},
+let \exposid{as-tuple} be an alias template
+such that \tcode{\exposid{as-tuple}<Tag(Args...)>} denotes
+the type \tcode{\exposid{decayed-tuple}<Tag, Args...>}.
+Then \exposid{variant-type} denotes the type
+\tcode{variant<tuple<set_stopped_t>, tuple<set_error_t, exception_ptr>, \exposid{as-tuple}<Sigs>...>},
+but with duplicate types removed.
+
+\pnum
+Let \exposid{state-list-type} be a type
+that stores a list of pointers to \exposid{local-state-base} objects and
+that permits atomic insertion.
+
+\begin{itemdecl}
+explicit @\exposid{shared-state}@(Sndr&& sndr);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Initializes \exposid{op_state} with the result of
+\tcode{connect(std::forward<Sndr>(sndr), \exposid{split-receiver}\{this\})}.
+
+\pnum
+\ensures
+\exposid{waiting_states} is empty, and \exposid{completed} is \tcode{false}.
+\end{itemdescr}
+
+\begin{itemdecl}
+void @\exposid{start-op}@() noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Evaluates \tcode{\exposid{inc-ref}()}.
+If \tcode{stop_src.stop_requested()} is \tcode{true},
+evaluates \tcode{\exposid{notify}()};
+otherwise, evaluates \tcode{start(\exposid{op_state})}.
+\end{itemdescr}
+
+\begin{itemdecl}
+void @\exposid{notify}@() noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Atomically does the following:
+\begin{itemize}
+\item
+Sets \tcode{completed} to \tcode{true}, and
+\item
+Exchanges \tcode{waiting_states} with an empty list,
+storing the old value in a local \tcode{prior_states}.
+\end{itemize}
+Then, for each pointer \tcode{p} in \tcode{prior_states},
+evaluates \tcode{p->\exposid{notify}()}.
+Finally, evaluates \tcode{\exposid{dec-ref}()}.
+\end{itemdescr}
+
+\begin{itemdecl}
+void @\exposid{inc-ref}@() noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Increments \exposid{ref_count}.
+\end{itemdescr}
+
+\begin{itemdecl}
+void @\exposid{dec-ref}@() noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\effects
+Decrements \exposid{ref_count}.
+If the new value of \exposid{ref_count} is \tcode{0},
+calls \tcode{delete this}.
+
+\pnum
+\sync
+If an evaluation of \tcode{\exposid{dec-ref}()} does not
+decrement the \tcode{ref_count} to \tcode{0} then
+synchronizes with the evaluation of \tcode{dec-ref()}
+that decrements \tcode{ref_count} to \tcode{0}.
+\end{itemdescr}
+
+\pnum
+Let \exposid{split-impl-tag} be an empty exposition-only class type.
+Given an expression \tcode{sndr},
+the expression \tcode{split.transform_sender(sndr)} is equivalent to:
+\begin{codeblock}
+auto&& [tag, _, child] = sndr;
+auto* sh_state = new @\exposid{shared-state}@{std::forward_like<decltype((sndr))>(child)};
+return @\exposid{make-sender}@(@\exposid{split-impl-tag}@(), @\exposid{shared-wrapper}@{sh_state, tag});
+\end{codeblock}
+where \exposid{shared-wrapper} is an exposition-only class
+that manages the reference count of the \exposid{shared-state} object
+pointed to by sh_state.
+\exposid{shared-wrapper} models copyable
+with move operations nulling out the moved-from object,
+copy operations incrementing the reference count
+by calling \tcode{sh_state->\exposid{inc-ref}()}, and
+assignment operations performing a copy-and-swap operation.
+The destructor has no effect if sh_state is null;
+otherwise, it decrements the reference count
+by evaluating \tcode{sh_state->\exposid{dec-ref}()}.
+
+\pnum
+The exposition-only class template \exposid{impls-for}\iref{exec.snd.general}
+is specialized for \exposid{split-impl-tag} as follows:
+\begin{codeblock}
+namespace std::execution {
+  template<>
+  struct @\exposid{impls-for}@<@\exposid{split-impl-tag}@> : @\exposid{default-impls}@ {
+    static constexpr auto @\exposid{get-state}@ = @\seebelow@;
+    static constexpr auto @\exposid{start}@ = @\seebelow@;
+  };
+}
+\end{codeblock}
+
+\pnum
+The member
+\tcode{\exposid{impls-for}<\exposid{split-impl-tag}>::\exposid{get-state}}
+is initialized with a callable object equivalent to
+the following lambda expression:
+\begin{codeblock}
+[]<class Sndr>(Sndr&& sndr, auto& rcvr) noexcept {
+  return @\exposid{local-state}@{std::forward<Sndr>(sndr), rcvr};
+}
+\end{codeblock}
+
+\pnum
+The member
+\tcode{\exposid{impls-for}<\exposid{split-impl-tag}>::\exposid{start}}
+is initialized with a callable object
+that has a function call operator equivalent to the following:
+\begin{codeblock}
+template<class Sndr, class Rcvr>
+void operator()(local-state<Sndr, Rcvr>& state, Rcvr& rcvr) const noexcept;
+\end{codeblock}
+
+\effects
+If \tcode{state.\exposid{sh_state}->\exposid{completed}} is \tcode{true},
+evaluates \tcode{state.\exposid{notify}()} and returns.
+Otherwise, does the following in order:
+\begin{itemize}
+\item
+Evaluates
+\begin{codeblock}
+state.@\exposid{on_stop}@.emplace(
+  get_stop_token(get_env(rcvr)),
+  @\exposid{on-stop-request}@{state.@\exposid{sh_state}@->@\exposid{stop_src}@});
+\end{codeblock}
+\item
+Then atomically does the following:
+\begin{itemize}
+\item
+Reads the value \tcode{c} of
+\tcode{state.\exposid{sh_state}->\exposid{completed}}, and
+\item
+Inserts \tcode{addressof(state)} into
+\tcode{state.\exposid{sh_state}->\exposid{waiting_states}}
+if \tcode{c} is \tcode{false}.
+\end{itemize}
+\item
+If \tcode{c} is \tcode{true},
+calls \tcode{state.\exposid{notify}()} and returns.
+\item
+Otherwise,
+if \tcode{addressof(state)} is the first item added to
+\tcode{state.\exposid{sh_state}->\exposid{waiting_states}},
+evaluates \tcode{state.\exposid{sh_state}->\exposid{start-op}()}.
+\end{itemize}
+
 \rSec1[exec.util]{Sender/receiver utilities}