[exec.let] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpxxojwcyz/{from.md → to.md} +222 -0

tmp/tmpxxojwcyz/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,222 @@

+#### `execution::let_value`, `execution::let_error`, `execution::let_stopped` <a id="exec.let">[[exec.let]]</a>
+`let_value`, `let_error`, and `let_stopped` transform a sender’s value,
+error, and stopped completions, respectively, into a new child
+asynchronous operation by passing the sender’s result datums to a
+user-specified callable, which returns a new sender that is connected
+and started.
+For `let_value`, `let_error`, and `let_stopped`, let *`set-cpo`* be
+`set_value`, `set_error`, and `set_stopped`, respectively. Let the
+expression *`let-cpo`* be one of `let_value`, `let_error`, or
+`let_stopped`. For a subexpression `sndr`, let `let-env(sndr)` be
+expression-equivalent to the first well-formed expression below:
+- `\exposid{SCHED-ENV}(get_completion_scheduler<\exposid{decayed-typeof}<\exposid{set-cpo}>>(get_env(sndr)))`
+- `\exposid{MAKE-ENV}(get_domain, get_domain(get_env(sndr)))`
+- `(void(sndr), env<>{})`
+The names `let_value`, `let_error`, and `let_stopped` denote pipeable
+sender adaptor objects. For subexpressions `sndr` and `f`, let `F` be
+the decayed type of `f`. If `decltype((sndr))` does not satisfy `sender`
+or if `decltype((f))` does not satisfy `movable-value`, the expression
+`let-cpo(sndr, f)` is ill-formed. If `F` does not satisfy `invocable`,
+the expression `let_stopped(sndr, f)` is ill-formed.
+Otherwise, the expression `let-cpo(sndr, f)` is expression-equivalent
+to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(let-cpo, f, sndr))
+```
+except that `sndr` is evaluated only once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for *`let-cpo`* as follows:
+``` cpp
+namespace std::execution {
+  template<class State, class Rcvr, class... Args>
+  void let-bind(State& state, Rcvr& rcvr, Args&&... args);      // exposition only
+  template<>
+  struct impls-for<decayed-typeof<let-cpo>> : default-impls {
+    static constexpr auto get-state = see below;
+    static constexpr auto complete = see below;
+    template<class Sndr, class... Env>
+      static consteval void check-types();
+  };
+}
+```
+Let *`receiver2`* denote the following exposition-only class template:
+``` cpp
+namespace std::execution {
+  template<class Rcvr, class Env>
+  struct receiver2 {
+    using receiver_concept = receiver_t;
+    template<class... Args>
+    void set_value(Args&&... args) && noexcept {
+      execution::set_value(std::move(rcvr), std::forward<Args>(args)...);
+    }
+    template<class Error>
+    void set_error(Error&& err) && noexcept {
+      execution::set_error(std::move(rcvr), std::forward<Error>(err));
+    }
+    void set_stopped() && noexcept {
+      execution::set_stopped(std::move(rcvr));
+    }
+    decltype(auto) get_env() const noexcept {
+      return see below;
+    }
+    Rcvr& rcvr;                 // exposition only
+    Env env;                    // exposition only
+  };
+}
+```
+Invocation of the function `receiver2::get_env` returns an object `e`
+such that
+- `decltype(e)` models `queryable` and
+- given a query object `q`, the expression `e.query(q)` is
+  expression-equivalent to `env.query(q)` if that expression is valid;
+  otherwise, if the type of `q` satisfies `forwarding-query`,
+  `e.query(q)` is expression-equivalent to `get_env(rcvr).query(q)`;
+  otherwise, `e.query(q)` is ill-formed.
+``` cpp
+template<class Sndr, class... Env>
+  static consteval void check-types();
+```
+*Effects:* Equivalent to:
+``` cpp
+using LetFn = remove_cvref_t<data-type<Sndr>>;
+auto cs = get_completion_signatures<child-type<Sndr>, FWD-ENV-T(Env)...>();
+auto fn = []<class... Ts>(decayed-typeof<set-cpo>(*)(Ts...)) {
+  if constexpr (!is-valid-let-sender)   // see below
+    throw unspecified-exception();
+};
+cs.for-each(overload-set(fn, [](auto){}));
+```
+where *`unspecified-exception`* is a type derived from `exception`, and
+where *`is-valid-let-sender`* is `true` if and only if all of the
+following are `true`:
+- `(constructible_from<decay_t<Ts>, Ts> &&...)`
+- `invocable<LetFn, decay_t<Ts>&...>`
+- `sender<invoke_result_t<LetFn, decay_t<Ts>&...>>`
+- `sizeof...(Env) == 0 || sender_in<invoke_result_t<LetFn, decay_t<Ts>&...>, `*`env-t`*`...>`
+where *`env-t`* is the pack
+`decltype(`*`let-cpo`*`.transform_env(declval<Sndr>(), declval<Env>()))`.
+`\exposid{impls-for}<\exposid{decayed-typeof}<\exposid{let-cpo}>>::\exposid{get-state}`
+is initialized with a callable object equivalent to the following:
+``` cpp
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) requires see below {
+  auto& [_, fn, child] = sndr;
+  using fn_t = decay_t<decltype(fn)>;
+  using env_t = decltype(let-env(child));
+  using args_variant_t = see below;
+  using ops2_variant_t = see below;
+  struct state-type {
+    fn_t fn;                    // exposition only
+    env_t env;                  // exposition only
+    args_variant_t args;        // exposition only
+    ops2_variant_t ops2;        // exposition only
+  };
+  return state-type{allocator-aware-forward(std::forward_like<Sndr>(fn), rcvr),
+                    let-env(child), {}, {}};
+}
+```
+Let `Sigs` be a pack of the arguments to the `completion_signatures`
+specialization named by
+`completion_signatures_of_t<child-type<Sndr>, FWD-ENV-T(env_of_t<Rcvr>)>`.
+Let `LetSigs` be a pack of those types in `Sigs` with a return type of
+`decayed-typeof<set-cpo>`. Let *`as-tuple`* be an alias template such
+that `as-tuple<Tag(Args...)>` denotes the type `decayed-tuple<Args...>`.
+Then `args_variant_t` denotes the type
+`variant<monostate, as-tuple<LetSigs>...>` except with duplicate types
+removed.
+Given a type `Tag` and a pack `Args`, let *`as-sndr2`* be an alias
+template such that `as-sndr2<Tag(Args...)>` denotes the type
+`call-result-t<F, decay_t<Args>&...>`. Then `ops2_variant_t` denotes the
+type
+``` cpp
+variant<monostate, connect_result_t<as-sndr2<LetSigs>, receiver2<Rcvr, env_t>>...>
+```
+except with duplicate types removed.
+The *requires-clause* constraining the above lambda is satisfied if and
+only if the types `args_variant_t` and `ops2_variant_t` are well-formed.
+The exposition-only function template *`let-bind`* has effects
+equivalent to:
+``` cpp
+using args_t = decayed-tuple<Args...>;
+auto mkop2 = [&] {
+  return connect(
+    apply(std::move(state.fn),
+          state.args.template emplace<args_t>(std::forward<Args>(args)...)),
+    receiver2{rcvr, std::move(state.env)});
+};
+start(state.ops2.template emplace<decltype(mkop2())>(emplace-from{mkop2}));
+```
+`\exposid{impls-for}<\exposid{decayed-typeof}<\exposid{let-cpo}>>::\exposid{complete}`
+is initialized with a callable object equivalent to the following:
+``` cpp
+[]<class Tag, class... Args>
+  (auto, auto& state, auto& rcvr, Tag, Args&&... args) noexcept -> void {
+    if constexpr (same_as<Tag, decayed-typeof<set-cpo>>) {
+      TRY-EVAL(rcvr, let-bind(state, rcvr, std::forward<Args>(args)...));
+    } else {
+      Tag()(std::move(rcvr), std::forward<Args>(args)...);
+    }
+  }
+```
+Let `sndr` and `env` be subexpressions, and let `Sndr` be
+`decltype((sndr))`. If `sender-for<Sndr, decayed-typeof<let-cpo>>` is
+`false`, then the expression `let-cpo.transform_env(sndr, env)` is
+ill-formed. Otherwise, it is equal to:
+``` cpp
+auto& [_, _, child] = sndr;
+return JOIN-ENV(let-env(child), FWD-ENV(env));
+```
+Let the subexpression `out_sndr` denote the result of the invocation
+`let-cpo(sndr, f)` or an object equal to such, and let the subexpression
+`rcvr` denote a receiver such that the expression
+`connect(out_sndr, rcvr)` is well-formed. The expression
+`connect(out_sndr, rcvr)` has undefined behavior unless it creates an
+asynchronous operation [[exec.async.ops]] that, when started:
+- invokes `f` when *`set-cpo`* is called with `sndr`’s result datums,
+- makes its completion dependent on the completion of a sender returned
+  by `f`, and
+- propagates the other completion operations sent by `sndr`.

Diff to HTML by rtfpessoa