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

Files changed (1) hide show

tmp/tmp10hz0qea/{from.md → to.md} +2117 -0

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

	@@ -0,0 +1,2117 @@

+### Sender adaptors <a id="exec.adapt">[[exec.adapt]]</a>
+#### General <a id="exec.adapt.general">[[exec.adapt.general]]</a>
+Subclause [[exec.adapt]] specifies a set of sender adaptors.
+The bitwise inclusive operator is overloaded for the purpose of creating
+sender chains. The adaptors also support function call syntax with
+equivalent semantics.
+Unless otherwise specified:
+- A sender adaptor is prohibited from causing observable effects, apart
+  from moving and copying its arguments, before the returned sender is
+  connected with a receiver using `connect`, and `start` is called on
+  the resulting operation state.
+- A parent sender [[exec.async.ops]] with a single child sender `sndr`
+  has an associated attribute object equal to `FWD-ENV(get_env(sndr))`
+  [[exec.fwd.env]].
+- A parent sender with more than one child sender has an associated
+  attributes object equal to `env<>{}`.
+- When a parent sender is connected to a receiver `rcvr`, any receiver
+  used to connect a child sender has an associated environment equal to
+  `FWD-ENV(get_env(rcvr))`.
+- An adaptor whose child senders are all non-dependent
+  [[exec.async.ops]] is itself non-dependent.
+- These requirements apply to any function that is selected by the
+  implementation of the sender adaptor.
+- *Recommended practice:* Implementations should use the completion
+  signatures of the adaptors to communicate type errors to users and to
+  propagate any such type errors from child senders.
+If a sender returned from a sender adaptor specified in [[exec.adapt]]
+is specified to include `set_error_t(Err)` among its set of completion
+signatures where `decay_t<Err>` denotes the type `exception_ptr`, but
+the implementation does not potentially evaluate an error completion
+operation with an `exception_ptr` argument, the implementation is
+allowed to omit the `exception_ptr` error completion signature from the
+set.
+#### Closure objects <a id="exec.adapt.obj">[[exec.adapt.obj]]</a>
+A *pipeable sender adaptor closure object* is a function object that
+accepts one or more `sender` arguments and returns a `sender`. For a
+pipeable sender adaptor closure object `c` and an expression `sndr` such
+that `decltype((sndr))` models `sender`, the following expressions are
+equivalent and yield a `sender`:
+``` cpp
+c(sndr)
+sndr | c
+```
+Given an additional pipeable sender adaptor closure object `d`, the
+expression `c | d` produces another pipeable sender adaptor closure
+object `e`:
+`e` is a perfect forwarding call wrapper [[func.require]] with the
+following properties:
+- Its target object is an object `d2` of type `decltype(auto(d))`
+  direct-non-list-initialized with `d`.
+- It has one bound argument entity, an object `c2` of type
+  `decltype(auto(c))` direct-non-list-initialized with `c`.
+- Its call pattern is `d2(c2(arg))`, where arg is the argument used in a
+  function call expression of `e`.
+The expression `c | d` is well-formed if and only if the initializations
+of the state entities [[func.def]] of `e` are all well-formed.
+An object `t` of type `T` is a pipeable sender adaptor closure object if
+`T` models `derived_from<sender_adaptor_closure<T>>`, `T` has no other
+base classes of type `sender_adaptor_closure<U>` for any other type `U`,
+and `T` does not satisfy `sender`.
+The template parameter `D` for `sender_adaptor_closure` can be an
+incomplete type. Before any expression of type cv `D` appears as an
+operand to the `|` operator, `D` shall be complete and model
+`derived_from<sender_adaptor_closure<D>>`. The behavior of an expression
+involving an object of type cv `D` as an operand to the `|` operator is
+undefined if overload resolution selects a program-defined `operator|`
+function.
+A *pipeable sender adaptor object* is a customization point object that
+accepts a `sender` as its first argument and returns a `sender`. If a
+pipeable sender adaptor object accepts only one argument, then it is a
+pipeable sender adaptor closure object.
+If a pipeable sender adaptor object adaptor accepts more than one
+argument, then let `sndr` be an expression such that `decltype((sndr))`
+models `sender`, let `args...` be arguments such that
+`adaptor(sndr, args...)` is a well-formed expression as specified below,
+and let `BoundArgs` be a pack that denotes `decltype(auto(args))...`.
+The expression `adaptor(args...)` produces a pipeable sender adaptor
+closure object `f` that is a perfect forwarding call wrapper with the
+following properties:
+- Its target object is a copy of adaptor.
+- Its bound argument entities `bound_args` consist of objects of types
+  `BoundArgs...` direct-non-list-initialized with
+  `std::forward<decltype((args))>(args)...`, respectively.
+- Its call pattern is `adaptor(rcvr, bound_args...)`, where `rcvr` is
+  the argument used in a function call expression of `f`.
+The expression `adaptor(args...)` is well-formed if and only if the
+initializations of the bound argument entities of the result, as
+specified above, are all well-formed.
+#### `execution::write_env` <a id="exec.write.env">[[exec.write.env]]</a>
+`write_env` is a sender adaptor that accepts a sender and a queryable
+object, and that returns a sender that, when connected with a receiver
+`rcvr`, connects the adapted sender with a receiver whose execution
+environment is the result of joining the `queryable` object to the
+result of `get_env(rcvr)`.
+`write_env` is a customization point object. For some subexpressions
+`sndr` and `env`, if `decltype((sndr))` does not satisfy `sender` or if
+`decltype((env))` does not satisfy `queryable`, the expression
+`write_env(sndr, env)` is ill-formed. Otherwise, it is
+expression-equivalent to `make-sender(write_env, env, sndr)`.
+Let *`write-env-t`* denote the type `decltype(auto(write_env))`. The
+exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for *`write-env-t`* as follows:
+``` cpp
+template<>
+struct impls-for<write-env-t> : default-impls {
+  static constexpr auto join-env(const auto& state, const auto& env) noexcept {
+    return see below;
+  }
+  static constexpr auto get-env =
+    [](auto, const auto& state, const auto& rcvr) noexcept {
+      return join-env(state, FWD-ENV(get_env(rcvr)));
+    };
+  template<class Sndr, class... Env>
+    static consteval void check-types();
+};
+```
+Invocation of `impls-for<write-env-t>::join-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 `state.query(q)` if that expression is valid,
+  otherwise, `e.query(q)` is expression-equivalent to `env.query(q)`.
+For a type `Sndr` and a pack of types `Env`, let `State` be
+`data-type<Sndr>` and let `JoinEnv` be the pack
+`decltype(join-env(declval<State>(), FWD-ENV(declval<Env>())))`. Then
+`impls-for<write-env-{t}>::check-types<Sndr, Env...>()` is
+expression-equivalent to
+`get_completion_signatures<child-{type}<Sndr>, JoinEnv...>()`.
+#### `execution::unstoppable` <a id="exec.unstoppable">[[exec.unstoppable]]</a>
+`unstoppable` is a sender adaptor that connects its inner sender with a
+receiver that has the execution environment of the outer receiver but
+with an object of type `never_stop_token` as the result of the
+`get_stop_token query`.
+For a subexpression `sndr`, `unstoppable(sndr)` is expression-equivalent
+to `write_env(sndr, prop(get_stop_token, never_stop_token{}))`.
+#### `execution::starts_on` <a id="exec.starts.on">[[exec.starts.on]]</a>
+`starts_on` adapts an input sender into a sender that will start on an
+execution agent belonging to a particular scheduler’s associated
+execution resource.
+The name `starts_on` denotes a customization point object. For
+subexpressions `sch` and `sndr`, if `decltype(( sch))` does not satisfy
+`scheduler`, or `decltype((sndr))` does not satisfy `sender`,
+`starts_on(sch, sndr)` is ill-formed.
+Otherwise, the expression `starts_on(sch, sndr)` is
+expression-equivalent to:
+``` cpp
+transform_sender(
+  query-with-default(get_domain, sch, default_domain()),
+  make-sender(starts_on, sch, sndr))
+```
+except that `sch` is evaluated only once.
+Let `out_sndr` and `env` be subexpressions such that `OutSndr` is
+`decltype((out_sndr))`. If `sender-for<OutSndr, starts_on_t>` is
+`false`, then the expressions `starts_on.transform_env(out_sndr, env)`
+and `starts_on.transform_sender(out_sndr, env)` are ill-formed;
+otherwise
+- `starts_on.transform_env(out_sndr, env)` is equivalent to:
+  ``` cpp
+  auto&& [_, sch, _] = out_sndr;
+  return JOIN-ENV(SCHED-ENV(sch), FWD-ENV(env));
+  ```
+- `starts_on.transform_sender(out_sndr, env)` is equivalent to:
+  ``` cpp
+  auto&& [_, sch, sndr] = out_sndr;
+  return let_value(
+    schedule(sch),
+    [sndr = std::forward_like<OutSndr>(sndr)]() mutable
+      noexcept(is_nothrow_move_constructible_v<decay_t<OutSndr>>) {
+      return std::move(sndr);
+    });
+  ```
+Let `out_sndr` be a subexpression denoting a sender returned from
+`starts_on(sch, sndr)` or one equal to such, and let `OutSndr` be the
+type `decltype((out_sndr))`. Let `out_rcvr` be a subexpression denoting
+a receiver that has an environment of type `Env` such that
+`sender_in<OutSndr, Env>` is `true`. Let `op` be an lvalue referring to
+the operation state that results from connecting `out_sndr` with
+`out_rcvr`. Calling `start(op)` shall start `sndr` on an execution agent
+of the associated execution resource of `sch`. If scheduling onto `sch`
+fails, an error completion on `out_rcvr` shall be executed on an
+unspecified execution agent.
+#### `execution::continues_on` <a id="exec.continues.on">[[exec.continues.on]]</a>
+`continues_on` adapts a sender into one that completes on the specified
+scheduler.
+The name `continues_on` denotes a pipeable sender adaptor object. For
+subexpressions `sch` and `sndr`, if `decltype((sch))` does not satisfy
+`scheduler`, or `decltype((sndr))` does not satisfy `sender`,
+`continues_on(sndr, sch)` is ill-formed.
+Otherwise, the expression `continues_on(sndr, sch)` is
+expression-equivalent to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(continues_on, sch, sndr))
+```
+except that `sndr` is evaluated only once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `continues_on_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<continues_on_t> : default-impls {
+    static constexpr auto get-attrs =
+      [](const auto& data, const auto& child) noexcept -> decltype(auto) {
+        return JOIN-ENV(SCHED-ATTRS(data), FWD-ENV(get_env(child)));
+      };
+  };
+}
+```
+Let `sndr` and `env` be subexpressions such that `Sndr` is
+`decltype((sndr))`. If `sender-for<Sndr, continues_on_t>` is `false`,
+then the expression `continues_on.transform_sender(sndr, env)` is
+ill-formed; otherwise, it is equal to:
+``` cpp
+auto [_, data, child] = sndr;
+return schedule_from(std::move(data), std::move(child));
+```
+[*Note 1*: This causes the `continues_on(sndr, sch)` sender to become
+`schedule_from(sch, sndr)` when it is connected with a receiver whose
+execution domain does not customize `continues_on`. — *end note*]
+Let `out_sndr` be a subexpression denoting a sender returned from
+`continues_on(sndr, sch)` or one equal to such, and let `OutSndr` be the
+type `decltype((out_sndr))`. Let `out_rcvr` be a subexpression denoting
+a receiver that has an environment of type `Env` such that
+`sender_in<OutSndr, Env>` is `true`. Let `op` be an lvalue referring to
+the operation state that results from connecting `out_sndr` with
+`out_rcvr`. Calling `start(op)` shall start `sndr` on the current
+execution agent and execute completion operations on `out_rcvr` on an
+execution agent of the execution resource associated with `sch`. If
+scheduling onto `sch` fails, an error completion on `out_rcvr` shall be
+executed on an unspecified execution agent.
+#### `execution::schedule_from` <a id="exec.schedule.from">[[exec.schedule.from]]</a>
+`schedule_from` schedules work dependent on the completion of a sender
+onto a scheduler’s associated execution resource.
+[*Note 1*: `schedule_from` is not meant to be used in user code; it is
+used in the implementation of `continues_on`. — *end note*]
+The name `schedule_from` denotes a customization point object. For some
+subexpressions `sch` and `sndr`, let `Sch` be `decltype((sch))` and
+`Sndr` be `decltype((sndr))`. If `Sch` does not satisfy `scheduler`, or
+`Sndr` does not satisfy `sender`, `schedule_from(sch, sndr)` is
+ill-formed.
+Otherwise, the expression `schedule_from(sch, sndr)` is
+expression-equivalent to:
+``` cpp
+transform_sender(
+  query-with-default(get_domain, sch, default_domain()),
+  make-sender(schedule_from, sch, sndr))
+```
+except that `sch` is evaluated only once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `schedule_from_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<schedule_from_t> : default-impls {
+    static constexpr auto get-attrs = see below;
+    static constexpr auto get-state = see below;
+    static constexpr auto complete = see below;
+    template<class Sndr, class... Env>
+      static consteval void check-types();
+  };
+}
+```
+The member `impls-for<schedule_from_t>::get-attrs` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[](const auto& data, const auto& child) noexcept -> decltype(auto) {
+  return JOIN-ENV(SCHED-ATTRS(data), FWD-ENV(get_env(child)));
+}
+```
+The member `impls-for<schedule_from_t>::get-state` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept(see below)
+    requires sender_in<child-type<Sndr>, FWD-ENV-T(env_of_t<Rcvr>)> {
+  auto& [_, sch, child] = sndr;
+  using sched_t = decltype(auto(sch));
+  using variant_t = see below;
+  using receiver_t = see below;
+  using operation_t = connect_result_t<schedule_result_t<sched_t>, receiver_t>;
+  constexpr bool nothrow = noexcept(connect(schedule(sch), receiver_t{nullptr}));
+  struct state-type {
+    Rcvr& rcvr;                 // exposition only
+    variant_t async-result;     // exposition only
+    operation_t op-state;       // exposition only
+    explicit state-type(sched_t sch, Rcvr& rcvr) noexcept(nothrow)
+      : rcvr(rcvr), op-state(connect(schedule(sch), receiver_t{this})) {}
+  };
+  return state-type{sch, rcvr};
+}
+```
+``` cpp
+template<class Sndr, class... Env>
+  static consteval void check-types();
+```
+*Effects:* Equivalent to:
+``` cpp
+get_completion_signatures<schedule_result_t<data-type<Sndr>>, FWD-ENV-T(Env)...>();
+auto cs = get_completion_signatures<child-type<Sndr>, FWD-ENV-T(Env)...>();
+decay-copyable-result-datums(cs);   // see [exec.snd.expos]
+```
+Objects of the local class *`state-type`* can be used to initialize a
+structured binding.
+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 *`as-tuple`* be an alias template such that `as-tuple<Tag(Args...)>`
+denotes the type `decayed-tuple<Tag, Args...>`, and let
+*`is-nothrow-decay-copy-sig`* be a variable template such that
+`auto(is-nothrow-decay-copy-sig<Tag(Args...{})>)` is a constant
+expression of type `bool` and equal to
+`(is_nothrow_constructible_v<decay_t<Args>, Args> && ...)`. Let
+*`error-completion`* be a pack consisting of the type
+`set_error_t(exception_ptr)` if
+`(is-nothrow-decay-copy-sig<Sigs> &&...)` is `false`, and an empty pack
+otherwise. Then `variant_t` denotes the type
+`variant<monostate, as-tuple<Sigs>..., error-completion...>`, except
+with duplicate types removed.
+`receiver_t` is an alias for the following exposition-only class:
+``` cpp
+namespace std::execution {
+  struct receiver-type {
+    using receiver_concept = receiver_t;
+    state-type* state;          // exposition only
+    void set_value() && noexcept {
+      visit(
+        [this]<class Tuple>(Tuple& result) noexcept -> void {
+          if constexpr (!same_as<monostate, Tuple>) {
+            auto& [tag, ...args] = result;
+            tag(std::move(state->rcvr), std::move(args)...);
+          }
+        },
+        state->async-result);
+    }
+    template<class Error>
+    void set_error(Error&& err) && noexcept {
+      execution::set_error(std::move(state->rcvr), std::forward<Error>(err));
+    }
+    void set_stopped() && noexcept {
+      execution::set_stopped(std::move(state->rcvr));
+    }
+    decltype(auto) get_env() const noexcept {
+      return FWD-ENV(execution::get_env(state->rcvr));
+    }
+  };
+}
+```
+The expression in the `noexcept` clause of the lambda is `true` if the
+construction of the returned *`state-type`* object is not potentially
+throwing; otherwise, `false`.
+The member `impls-for<schedule_from_t>::complete` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Tag, class... Args>(auto, auto& state, auto& rcvr, Tag, Args&&... args) noexcept
+    -> void {
+  using result_t = decayed-tuple<Tag, Args...>;
+  constexpr bool nothrow = (is_nothrow_constructible_v<decay_t<Args>, Args> && ...);
+  try {
+    state.async-result.template emplace<result_t>(Tag(), std::forward<Args>(args)...);
+  } catch (...) {
+    if constexpr (!nothrow)
+      state.async-result.template emplace<tuple<set_error_t,
+                                                exception_ptr>>(set_error, current_exception());
+  }
+  start(state.op-state);
+};
+```
+Let `out_sndr` be a subexpression denoting a sender returned from
+`schedule_from(sch, sndr)` or one equal to such, and let `OutSndr` be
+the type `decltype((out_sndr))`. Let `out_rcvr` be a subexpression
+denoting a receiver that has an environment of type `Env` such that
+`sender_in<OutSndr, Env>` is `true`. Let `op` be an lvalue referring to
+the operation state that results from connecting `out_sndr` with
+`out_rcvr`. Calling `start(op)` shall start `sndr` on the current
+execution agent and execute completion operations on `out_rcvr` on an
+execution agent of the execution resource associated with `sch`. If
+scheduling onto `sch` fails, an error completion on `out_rcvr` shall be
+executed on an unspecified execution agent.
+#### `execution::on` <a id="exec.on">[[exec.on]]</a>
+The `on` sender adaptor has two forms:
+- `on(sch, sndr)`, which starts a sender `sndr` on an execution agent
+  belonging to a scheduler `sch`’s associated execution resource and
+  that, upon `sndr`’s completion, transfers execution back to the
+  execution resource on which the `on` sender was started.
+- `on(sndr, sch, closure)`, which upon completion of a sender `sndr`,
+  transfers execution to an execution agent belonging to a scheduler
+  `sch`’s associated execution resource, then executes a sender adaptor
+  closure `closure` with the async results of the sender, and that then
+  transfers execution back to the execution resource on which `sndr`
+  completed.
+The name `on` denotes a pipeable sender adaptor object. For
+subexpressions `sch` and `sndr`, `on(sch, sndr)` is ill-formed if any of
+the following is `true`:
+- `decltype((sch))` does not satisfy `scheduler`, or
+- `decltype((sndr))` does not satisfy `sender` and `sndr` is not a
+  pipeable sender adaptor closure object [[exec.adapt.obj]], or
+- `decltype((sndr))` satisfies `sender` and `sndr `is also a pipeable
+  sender adaptor closure object.
+Otherwise, if `decltype((sndr))` satisfies `sender`, the expression
+`on(sch, sndr)` is expression-equivalent to:
+``` cpp
+transform_sender(
+  query-with-default(get_domain, sch, default_domain()),
+  make-sender(on, sch, sndr))
+```
+except that `sch` is evaluated only once.
+For subexpressions `sndr`, `sch`, and `closure`, if
+- `decltype((sch))` does not satisfy `scheduler`, or
+- `decltype((sndr))` does not satisfy `sender`, or
+- `closure` is not a pipeable sender adaptor closure object
+  [[exec.adapt.obj]],
+the expression `on(sndr, sch, closure)` is ill-formed; otherwise, it is
+expression-equivalent to:
+``` cpp
+transform_sender(
+  get-domain-early(sndr),
+  make-sender(on, product-type{sch, closure}, sndr))
+```
+except that `sndr` is evaluated only once.
+Let `out_sndr` and `env` be subexpressions, let `OutSndr` be
+`decltype((out_sndr))`, and let `Env` be `decltype((env))`. If
+`sender-for<OutSndr, on_t>` is `false`, then the expressions
+`on.transform_env(out_sndr, env)` and
+`on.transform_sender(out_sndr, env)` are ill-formed.
+Otherwise: Let *`not-a-scheduler`* be an unspecified empty class type.
+The expression `on.transform_env(out_sndr, env)` has effects equivalent
+to:
+``` cpp
+auto&& [_, data, _] = out_sndr;
+if constexpr (scheduler<decltype(data)>) {
+  return JOIN-ENV(SCHED-ENV(std::forward_like<OutSndr>(data)), FWD-ENV(std::forward<Env>(env)));
+} else {
+  return std::forward<Env>(env);
+}
+```
+The expression `on.transform_sender(out_sndr, env)` has effects
+equivalent to:
+``` cpp
+auto&& [_, data, child] = out_sndr;
+if constexpr (scheduler<decltype(data)>) {
+  auto orig_sch =
+    query-with-default(get_scheduler, env, not-a-scheduler());
+  if constexpr (same_as<decltype(orig_sch), not-a-scheduler>) {
+    return not-a-sender{};
+  } else {
+    return continues_on(
+      starts_on(std::forward_like<OutSndr>(data), std::forward_like<OutSndr>(child)),
+      std::move(orig_sch));
+  }
+} else {
+  auto& [sch, closure] = data;
+  auto orig_sch = query-with-default(
+    get_completion_scheduler<set_value_t>,
+    get_env(child),
+    query-with-default(get_scheduler, env, not-a-scheduler()));
+  if constexpr (same_as<decltype(orig_sch), not-a-scheduler>) {
+    return not-a-sender{};
+  } else {
+    return write_env(
+      continues_on(
+        std::forward_like<OutSndr>(closure)(
+          continues_on(
+            write_env(std::forward_like<OutSndr>(child), SCHED-ENV(orig_sch)),
+            sch)),
+        orig_sch),
+      SCHED-ENV(sch));
+  }
+}
+```
+Let `out_sndr` be a subexpression denoting a sender returned from
+`on(sch, sndr)` or one equal to such, and let `OutSndr` be the type
+`decltype((out_sndr))`. Let `out_rcvr` be a subexpression denoting a
+receiver that has an environment of type `Env` such that
+`sender_in<OutSndr, Env>` is `true`. Let `op` be an lvalue referring to
+the operation state that results from connecting `out_sndr` with
+`out_rcvr`. Calling `start(op)` shall
+- remember the current scheduler, `get_scheduler(get_env(rcvr))`;
+- start `sndr` on an execution agent belonging to `sch`’s associated
+  execution resource;
+- upon `sndr`’s completion, transfer execution back to the execution
+  resource associated with the scheduler remembered in step 1; and
+- forward `sndr`’s async result to `out_rcvr`.
+If any scheduling operation fails, an error completion on `out_rcvr`
+shall be executed on an unspecified execution agent.
+Let `out_sndr` be a subexpression denoting a sender returned from
+`on(sndr, sch, closure)` or one equal to such, and let `OutSndr` be the
+type `decltype((out_sndr))`. Let `out_rcvr` be a subexpression denoting
+a receiver that has an environment of type `Env` such that
+`sender_in<OutSndr, Env>` is `true`. Let `op` be an lvalue referring to
+the operation state that results from connecting `out_sndr` with
+`out_rcvr`. Calling `start(op)` shall
+- remember the current scheduler, which is the first of the following
+  expressions that is well-formed:
+  - `get_completion_scheduler<set_value_t>(get_env(sndr))`
+  - `get_scheduler(get_env(rcvr))`;
+- start `sndr` on the current execution agent;
+- upon `sndr`’s completion, transfer execution to an agent owned by
+  `sch`’s associated execution resource;
+- forward `sndr`’s async result as if by connecting and starting a
+  sender `closure(S)`, where `S` is a sender that completes
+  synchronously with `sndr`’s async result; and
+- upon completion of the operation started in the previous step,
+  transfer execution back to the execution resource associated with the
+  scheduler remembered in step 1 and forward the operation’s async
+  result to `out_rcvr`.
+If any scheduling operation fails, an error completion on `out_rcvr`
+shall be executed on an unspecified execution agent.
+#### `execution::then`, `execution::upon_error`, `execution::upon_stopped` <a id="exec.then">[[exec.then]]</a>
+`then` attaches an invocable as a continuation for an input sender’s
+value completion operation. `upon_error` and `upon_stopped` do the same
+for the error and stopped completion operations, respectively, sending
+the result of the invocable as a value completion.
+The names `then`, `upon_error`, and `upon_stopped` denote pipeable
+sender adaptor objects. Let the expression *`then-cpo`* be one of
+`then`, `upon_error`, or `upon_stopped`. For subexpressions `sndr` and
+`f`, if `decltype((sndr))` does not satisfy `sender`, or `decltype((f))`
+does not satisfy `movable-value`, `then-cpo(sndr, f) `is ill-formed.
+Otherwise, the expression `then-cpo(sndr, f)` is expression-equivalent
+to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(then-cpo, f, sndr))
+```
+except that `sndr` is evaluated only once.
+For `then`, `upon_error`, and `upon_stopped`, let *`set-cpo`* be
+`set_value`, `set_error`, and `set_stopped`, respectively. The
+exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for *`then-cpo`* as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<decayed-typeof<then-cpo>> : default-impls {
+    static constexpr auto complete =
+      []<class Tag, class... Args>
+        (auto, auto& fn, auto& rcvr, Tag, Args&&... args) noexcept -> void {
+          if constexpr (same_as<Tag, decayed-typeof<set-cpo>>) {
+            TRY-SET-VALUE(rcvr,
+                          invoke(std::move(fn), std::forward<Args>(args)...));
+          } else {
+            Tag()(std::move(rcvr), std::forward<Args>(args)...);
+          }
+        };
+    template<class Sndr, class... Env>
+      static consteval void check-types();
+  };
+}
+```
+``` cpp
+template<class Sndr, class... Env>
+  static consteval void check-types();
+```
+*Effects:* Equivalent to:
+``` cpp
+auto cs = get_completion_signatures<child-type<Sndr>, FWD-ENV-T(Env)...>();
+auto fn = []<class... Ts>(set_value_t(*)(Ts...)) {
+  if constexpr (!invocable<remove_cvref_t<data-type<Sndr>>, Ts...>)
+    throw unspecified-exception();
+};
+cs.for-each(overload-set{fn, [](auto){}});
+```
+where *`unspecified-exception`* is a type derived from `exception`.
+The expression `then-cpo(sndr, f)` has undefined behavior unless it
+returns a sender `out_sndr` that
+- invokes `f` or a copy of such with the value, error, or stopped result
+  datums of `sndr` for `then`, `upon_error`, and `upon_stopped`,
+  respectively, using the result value of `f` as `out_sndr`’s value
+  completion, and
+- forwards all other completion operations unchanged.
+#### `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`.
+#### `execution::bulk`, `execution::bulk_chunked`, and `execution::bulk_unchunked` <a id="exec.bulk">[[exec.bulk]]</a>
+`bulk`, `bulk_chunked`, and `bulk_unchunked` run a task repeatedly for
+every index in an index space.
+The names `bulk`, `bulk_chunked`, and `bulk_unchunked` denote pipeable
+sender adaptor objects. Let `bulk-algo` be either `bulk`,
+`bulk_chunked`, or `bulk_unchunked`. For subexpressions `sndr`,
+`policy`, `shape`, and `f`, let `Policy` be
+`remove_cvref_t<decltype(policy)>`, `Shape` be `decltype(auto(shape))`,
+and `Func` be `decay_t<decltype((f))>`. If
+- `decltype((sndr))` does not satisfy `sender`, or
+- `is_execution_policy_v<Policy>` is `false`, or
+- `Shape` does not satisfy `integral`, or
+- `Func` does not model `copy_constructible`,
+`bulk-algo(sndr, policy, shape, f)` is ill-formed.
+Otherwise, the expression `bulk-algo(sndr, policy, shape, f)` is
+expression-equivalent to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(
+    bulk-algo, product-type<see below, Shape, Func>{policy, shape, f}, sndr))
+```
+except that `sndr` is evaluated only once. The first template argument
+of *`product-type`* is `Policy` if `Policy` models `copy_constructible`,
+and `const Policy&` otherwise.
+Let `sndr` and `env` be subexpressions such that `Sndr` is
+`decltype((sndr))`. If `sender-for<Sndr, bulk_t>` is `false`, then the
+expression `bulk.transform_sender(sndr, env)` is ill-formed; otherwise,
+it is equivalent to:
+``` cpp
+auto [_, data, child] = sndr;
+auto& [policy, shape, f] = data;
+auto new_f = [func = std::move(f)](Shape begin, Shape end, auto&&... vs)
+    noexcept(noexcept(f(begin, vs...))) {
+  while (begin != end) func(begin++, vs...);
+}
+return bulk_chunked(std::move(child), policy, shape, std::move(new_f));
+```
+[*Note 1*: This causes the `bulk(sndr, policy, shape, f)` sender to be
+expressed in terms of `bulk_chunked(sndr, policy, shape, f)` when it is
+connected to a receiver whose execution domain does not customize
+`bulk`. — *end note*]
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `bulk_chunked_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<bulk_chunked_t> : default-impls {
+    static constexpr auto complete = see below;
+    template<class Sndr, class... Env>
+      static consteval void check-types();
+  };
+}
+```
+The member `impls-for<bulk_chunked_t>::complete` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Index, class State, class Rcvr, class Tag, class... Args>
+  (Index, State& state, Rcvr& rcvr, Tag, Args&&... args) noexcept
+  -> void requires see below {
+    if constexpr (same_as<Tag, set_value_t>) {
+      auto& [policy, shape, f] = state;
+      constexpr bool nothrow = noexcept(f(auto(shape), auto(shape), args...));
+      TRY-EVAL(rcvr, [&]() noexcept(nothrow) {
+        f(static_cast<decltype(auto(shape))>(0), auto(shape), args...);
+        Tag()(std::move(rcvr), std::forward<Args>(args)...);
+      }());
+    } else {
+      Tag()(std::move(rcvr), std::forward<Args>(args)...);
+    }
+  }
+```
+The expression in the *requires-clause* of the lambda above is `true` if
+and only if `Tag` denotes a type other than `set_value_t` or if the
+expression `f(auto(shape), auto(shape), args...)` is well-formed.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `bulk_unchunked_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<bulk_unchunked_t> : default-impls {
+    static constexpr auto complete = see below;
+  };
+}
+```
+The member `impls-for<bulk_unchunked_t>::complete` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Index, class State, class Rcvr, class Tag, class... Args>
+  (Index, State& state, Rcvr& rcvr, Tag, Args&&... args) noexcept
+  -> void requires see below {
+    if constexpr (same_as<Tag, set_value_t>) {
+      auto& [policy, shape, f] = state;
+      constexpr bool nothrow = noexcept(f(auto(shape), args...));
+      TRY-EVAL(rcvr, [&]() noexcept(nothrow) {
+        for (decltype(auto(shape)) i = 0; i < shape; ++i) {
+          f(auto(i), args...);
+        }
+        Tag()(std::move(rcvr), std::forward<Args>(args)...);
+      }());
+    } else {
+      Tag()(std::move(rcvr), std::forward<Args>(args)...);
+    }
+  }
+```
+The expression in the *requires-clause* of the lambda above is `true` if
+and only if `Tag` denotes a type other than `set_value_t` or if the
+expression `f(auto(shape), args...)` is well-formed.
+``` cpp
+template<class Sndr, class... Env>
+  static consteval void check-types();
+```
+*Effects:* Equivalent to:
+``` cpp
+auto cs = get_completion_signatures<child-type<Sndr>, FWD-ENV-T(Env)...>();
+auto fn = []<class... Ts>(set_value_t(*)(Ts...)) {
+  if constexpr (!invocable<remove_cvref_t<data-type<Sndr>>, Ts&...>)
+    throw unspecified-exception();
+};
+cs.for-each(overload-set(fn, [](auto){}));
+```
+where *`unspecified-exception`* is a type derived from `exception`.
+Let the subexpression `out_sndr` denote the result of the invocation
+`bulk-algo(sndr, policy, shape, 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:
+- If `sndr` has a successful completion, where `args` is a pack of
+  lvalue subexpressions referring to the value completion result datums
+  of `sndr`, or decayed copies of those values if they model
+  `copy_constructible`, then:
+  - If `out_sndr` also completes successfully, then:
+    - for `bulk`, invokes `f(i, args...)` for every i of type `Shape`
+      from `0` to `shape`;
+    - for `bulk_unchunked`, invokes `f(i, args...)` for every i of type
+      `Shape` from `0` to `shape`; *Recommended practice:* The
+      underlying scheduler should execute each iteration on a distinct
+      execution agent.
+    - for `bulk_chunked`, invokes `f(b, e, args...)` zero or more times
+      with pairs of b and e of type `Shape` in range \[`0`, `shape`\],
+      such that b < e and for every i of type `Shape` from `0` to
+      `shape`, there is exactly one invocation with a pair b and e, such
+      that i is in the range \[b, e).
+  - If `out_sndr` completes with `set_error(rcvr, eptr)`, then the
+    asynchronous operation may invoke a subset of the invocations of `f`
+    before the error completion handler is called, and `eptr` is an
+    `exception_ptr` containing either:
+    - an exception thrown by an invocation of `f`, or
+    - a `bad_alloc` exception if the implementation fails to allocate
+      required resources, or
+    - an exception derived from `runtime_error`.
+  - If `out_sndr` completes with `set_stopped(rcvr)`, then the
+    asynchronous operation may invoke a subset of the invocations of `f`
+    before the stopped completion handler.
+- If `sndr` does not complete with `set_value`, then the completion is
+  forwarded to `recv`.
+- For `bulk-algo`, the parameter `policy` describes the manner in which
+  the execution of the asynchronous operations corresponding to these
+  algorithms may be parallelized and the manner in which they apply `f`.
+  Permissions and requirements on parallel algorithm element access
+  functions [[algorithms.parallel.exec]] apply to `f`.
+[*Note 2*: The asynchronous operation corresponding to
+`bulk-algo(sndr, policy, shape, f)` can complete with `set_stopped` if
+cancellation is requested or ignore cancellation
+requests. — *end note*]
+#### `execution::when_all` <a id="exec.when.all">[[exec.when.all]]</a>
+`when_all` and `when_all_with_variant` both adapt multiple input senders
+into a sender that completes when all input senders have completed.
+`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.
+`when_all_with_variant(sndrs...)` is semantically equivalent to
+w`hen_all(into_variant(sndrs)...)`, where `sndrs` is a pack of
+subexpressions whose types model `sender`.
+The names `when_all` and `when_all_with_variant` denote customization
+point objects. Let `sndrs` be a pack of subexpressions, let `Sndrs` be a
+pack of the types `decltype((sndrs))...`, and let `CD` be the type
+`common_type_t<decltype(get-domain-early(sndrs))...>`. Let `CD2` be `CD`
+if `CD` is well-formed, and `default_domain` otherwise. The expressions
+`when_all(sndrs...)` and `when_all_with_variant(sndrs...)` are
+ill-formed if any of the following is `true`:
+- `sizeof...(sndrs)` is `0`, or
+- `(sender<Sndrs> && ...)` is `false`.
+The expression `when_all(sndrs...)` is expression-equivalent to:
+``` cpp
+transform_sender(CD2(), make-sender(when_all, {}, sndrs...))
+```
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `when_all_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<when_all_t> : default-impls {
+    static constexpr auto get-attrs = see below;
+    static constexpr auto get-env = see below;
+    static constexpr auto get-state = see below;
+    static constexpr auto start = see below;
+    static constexpr auto complete = see below;
+    template<class Sndr, class... Env>
+      static consteval void check-types();
+  };
+}
+```
+Let *`make-when-all-env`* be the following exposition-only function
+template:
+``` cpp
+template<class Env>
+  constexpr auto make-when-all-env(inplace_stop_source& stop_src,               // exposition only
+                                   Env&& env) noexcept {
+  return see below;
+}
+```
+Returns an object `e` such that
+- `decltype(e)` models `queryable`, and
+- `e.query(get_stop_token)` is expression-equivalent to
+  `state.stop-src.get_token()`, and
+- given a query object `q` with type other than cv `get_stop_token_t`
+  and whose type satisfies *`forwarding-query`*, `e.query(q)` is
+  expression-equivalent to `get_env(rcvr).query(q)`.
+Let `when-all-env` be an alias template such that `when-all-env<Env>`
+denotes the type
+`decltype(make-{when-all-env}(declval<inplace_stop_source&>(), declval<Env>()))`.
+``` cpp
+template<class Sndr, class... Env>
+  static consteval void check-types();
+```
+Let `Is` be the pack of integral template arguments of the
+`integer_sequence` specialization denoted by *`indices-for`*`<Sndr>`.
+*Effects:* Equivalent to:
+``` cpp
+auto fn = []<class Child>() {
+  auto cs = get_completion_signatures<Child, when-all-env<Env>...>();
+  if constexpr (cs.count-of(set_value) >= 2)
+    throw unspecified-exception();
+  decay-copyable-result-datums(cs); // see [exec.snd.expos]
+};
+(fn.template operator()<child-type<Sndr, Is>>(), ...);
+```
+where *`unspecified-exception`* is a type derived from `exception`.
+*Throws:* Any exception thrown as a result of evaluating the *Effects*,
+or an exception of an unspecified type derived from `exception` when
+`CD` is ill-formed.
+The member `impls-for<when_all_t>::get-attrs` is initialized with a
+callable object equivalent to the following lambda expression:
+``` cpp
+[](auto&&, auto&&... child) noexcept {
+  if constexpr (same_as<CD, default_domain>) {
+    return env<>();
+  } else {
+    return MAKE-ENV(get_domain, CD());
+  }
+}
+```
+The member `impls-for<when_all_t>::get-env` is initialized with a
+callable object equivalent to the following lambda expression:
+``` cpp
+[]<class State, class Rcvr>(auto&&, State& state, const Receiver& rcvr) noexcept {
+  return make-when-all-env(state.stop-src, get_env(rcvr));
+}
+```
+The member `impls-for<when_all_t>::get-state` is initialized with a
+callable object equivalent to the following lambda expression:
+``` cpp
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept(noexcept(e)) -> decltype(e) {
+  return e;
+}
+```
+where e is the expression
+``` cpp
+std::forward<Sndr>(sndr).apply(make-state<Rcvr>())
+```
+and where *`make-state`* is the following exposition-only class
+template:
+``` cpp
+enum class disposition { started, error, stopped };             // exposition only
+template<class Rcvr>
+struct make-state {
+  template<class... Sndrs>
+  auto operator()(auto, auto, Sndrs&&... sndrs) const {
+    using values_tuple = see below;
+    using errors_variant = see below;
+    using stop_callback = stop_callback_for_t<stop_token_of_t<env_of_t<Rcvr>>, on-stop-request>;
+    struct state-type {
+      void arrive(Rcvr& rcvr) noexcept {                        // exposition only
+        if (0 == --count) {
+          complete(rcvr);
+        }
+      }
+      void complete(Rcvr& rcvr) noexcept;                       // exposition only
+      atomic<size_t> count{sizeof...(sndrs)};                   // exposition only
+      inplace_stop_source stop_src{};                           // exposition only
+      atomic<disposition> disp{disposition::started};           // exposition only
+      errors_variant errors{};                                  // exposition only
+      values_tuple values{};                                    // exposition only
+      optional<stop_callback> on_stop{nullopt};                 // exposition only
+    };
+    return state-type{};
+  }
+};
+```
+Let *`copy-fail`* be `exception_ptr` if decay-copying any of the child
+senders’ result datums can potentially throw; otherwise, `none-such`,
+where `none-such` is an unspecified empty class type.
+The alias `values_tuple` denotes the type
+``` cpp
+tuple<value_types_of_t<Sndrs, FWD-ENV-T(env_of_t<Rcvr>), decayed-tuple, optional>...>
+```
+if that type is well-formed; otherwise, `tuple<>`.
+The alias `errors_variant` denotes the type
+`variant<none-such, copy-fail, Es...>` with duplicate types removed,
+where `Es` is the pack of the decayed types of all the child senders’
+possible error result datums.
+The member `void state-type::complete(Rcvr& rcvr) noexcept` behaves as
+follows:
+- If `disp` is equal to `disposition::started`, evaluates:
+  ``` cpp
+  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)...); };
+  on_stop.reset();
+  apply(
+    [&](auto&... opts) noexcept {
+      apply(set, tuple_cat(tie(*opts)...));
+    },
+    values);
+  ```
+- Otherwise, if `disp` is equal to `disposition::error`, evaluates:
+  ``` cpp
+  on_stop.reset();
+  visit(
+    [&]<class Error>(Error& error) noexcept {
+      if constexpr (!same_as<Error, none-such>) {
+        set_error(std::move(rcvr), std::move(error));
+      }
+    },
+    errors);
+  ```
+- Otherwise, evaluates:
+  ``` cpp
+  on_stop.reset();
+  set_stopped(std::move(rcvr));
+  ```
+The member `impls-for<when_all_t>::start` is initialized with a callable
+object equivalent to the following lambda expression:
+``` cpp
+[]<class State, class Rcvr, class... Ops>(
+    State& state, Rcvr& rcvr, Ops&... ops) noexcept -> void {
+  state.on_stop.emplace(
+    get_stop_token(get_env(rcvr)),
+    on-stop-request{state.stop_src});
+  if (state.stop_src.stop_requested()) {
+    state.on_stop.reset();
+    set_stopped(std::move(rcvr));
+  } else {
+    (start(ops), ...);
+  }
+}
+```
+The member `impls-for<when_all_t>::complete` is initialized with a
+callable object equivalent to the following lambda expression:
+``` cpp
+[]<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 (same_as<Set, set_error_t>) {
+    if (disposition::error != state.disp.exchange(disposition::error)) {
+      state.stop_src.request_stop();
+      TRY-EMPLACE-ERROR(state.errors, std::forward<Args>(args)...);
+    }
+  } else if constexpr (same_as<Set, set_stopped_t>) {
+    auto expected = disposition::started;
+    if (state.disp.compare_exchange_strong(expected, disposition::stopped)) {
+      state.stop_src.request_stop();
+    }
+  } else if constexpr (!same_as<decltype(State::values), tuple<>>) {
+    if (state.disp == disposition::started) {
+      auto& opt = get<Index::value>(state.values);
+      TRY-EMPLACE-VALUE(complete, opt, std::forward<Args>(args)...);
+    }
+  }
+  state.arrive(rcvr);
+}
+```
+where `TRY-EMPLACE-ERROR(v, e)`, for subexpressions `v` and `e`, is
+equivalent to:
+``` cpp
+try {
+  v.template emplace<decltype(auto(e))>(e);
+} catch (...) {
+  v.template emplace<exception_ptr>(current_exception());
+}
+```
+if the expression `decltype(auto(e))(e)` is potentially throwing;
+otherwise, `v.template emplace<decltype(auto(e))>(e)`; and where
+`TRY-EMPLACE-VALUE(c, o, as...)`, for subexpressions `c`, `o`, and pack
+of subexpressions `as`, is equivalent to:
+``` cpp
+try {
+  o.emplace(as...);
+} catch (...) {
+  c(Index(), state, rcvr, set_error, current_exception());
+  return;
+}
+```
+if the expression `decayed-tuple<decltype(as)...>{as...}` is potentially
+throwing; otherwise, `o.emplace(as...)`.
+The expression `when_all_with_variant(sndrs...)` is
+expression-equivalent to:
+``` cpp
+transform_sender(CD2(), make-sender(when_all_with_variant, {}, sndrs...));
+```
+Given subexpressions `sndr` and `env`, if
+`sender-for<decltype((sndr)), when_all_with_variant_t>` is `false`, then
+the expression `when_all_with_variant.transform_sender(sndr, env)` is
+ill-formed; otherwise, it is equivalent to:
+``` cpp
+auto&& [_, _, ...child] = sndr;
+return when_all(into_variant(std::forward_like<decltype((sndr))>(child))...);
+```
+[*Note 1*: This causes the `when_all_with_variant(sndrs...)` sender to
+become `when_all(into_variant(sndrs)...)` when it is connected with a
+receiver whose execution domain does not customize
+`when_all_with_variant`. — *end note*]
+#### `execution::into_variant` <a id="exec.into.variant">[[exec.into.variant]]</a>
+`into_variant` adapts a sender with multiple value completion signatures
+into a sender with just one value completion signature consisting of a
+`variant` of `tuple`s.
+The name `into_variant` denotes a pipeable sender adaptor object. For a
+subexpression `sndr`, let `Sndr` be `decltype((sndr))`. If `Sndr` does
+not satisfy `sender`, `into_variant(sndr)` is ill-formed.
+Otherwise, the expression `into_variant(sndr)` is expression-equivalent
+to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(into_variant, {}, sndr))
+```
+except that `sndr` is only evaluated once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `into_variant` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<into_variant_t> : 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() {
+        auto cs = get_completion_signatures<child-type<Sndr>, FWD-ENV-T(Env)...>();
+        decay-copyable-result-datums(cs);   // see [exec.snd.expos]
+      }
+  };
+}
+```
+The member `impls-for<into_variant_t>::get-state` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept
+  -> type_identity<value_types_of_t<child-type<Sndr>, FWD-ENV-T(env_of_t<Rcvr>)>> {
+  return {};
+}
+```
+The member `impls-for<into_variant_t>::complete` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class State, class Rcvr, class Tag, class... Args>(
+    auto, State, Rcvr& rcvr, Tag, Args&&... args) noexcept -> void {
+  if constexpr (same_as<Tag, set_value_t>) {
+    using variant_type = State::type;
+    TRY-SET-VALUE(rcvr, variant_type(decayed-tuple<Args...>{std::forward<Args>(args)...}));
+  } else {
+    Tag()(std::move(rcvr), std::forward<Args>(args)...);
+  }
+}
+```
+#### `execution::stopped_as_optional` <a id="exec.stopped.opt">[[exec.stopped.opt]]</a>
+`stopped_as_optional` maps a sender’s stopped completion operation into
+a value completion operation as a disengaged `optional`. The sender’s
+value completion operation is also converted into an `optional`. The
+result is a sender that never completes with stopped, reporting
+cancellation by completing with a disengaged `optional`.
+The name `stopped_as_optional` denotes a pipeable sender adaptor object.
+For a subexpression `sndr`, let `Sndr` be `decltype((sndr))`. The
+expression `stopped_as_optional(sndr)` is expression-equivalent to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(stopped_as_optional, {}, sndr))
+```
+except that `sndr` is only evaluated once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `stopped_as_optional_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<stopped_as_optional_t> : default-impls {
+    template<class Sndr, class... Env>
+      static consteval void check-types() {
+        default-impls::check-types<Sndr, Env...>();
+        if constexpr (!requires {
+          requires (!same_as<void, single-sender-value-type<child-type<Sndr>,
+                                                            FWD-ENV-T(Env)...>>); })
+          throw unspecified-exception();
+      }
+  };
+}
+```
+where `unspecified-exception` is a type derived from `exception`.
+Let `sndr` and `env` be subexpressions such that `Sndr` is
+`decltype((sndr))` and `Env` is `decltype((env))`. If
+`sender-for<Sndr, stopped_as_optional_t>` is `false` then the expression
+`stopped_as_optional.transform_sender(sndr, env)` is ill-formed;
+otherwise, if `sender_in<child-type<Sndr>, FWD-ENV-T(Env)>` is `false`,
+the expression `stopped_as_optional.transform_sender(sndr, env)` is
+equivalent to `not-a-sender()`; otherwise, it is equivalent to:
+``` cpp
+auto&& [_, _, child] = sndr;
+using V = single-sender-value-type<child-type<Sndr>, FWD-ENV-T(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>()); });
+```
+#### `execution::stopped_as_error` <a id="exec.stopped.err">[[exec.stopped.err]]</a>
+`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.
+The name `stopped_as_error` denotes a pipeable sender adaptor object.
+For some subexpressions `sndr` and `err`, let `Sndr` be
+`decltype((sndr))` and let `Err` be `decltype((err))`. If the type
+`Sndr` does not satisfy `sender` or if the type `Err` does not satisfy
+`movable-value`, `stopped_as_error(sndr, err)` is ill-formed. Otherwise,
+the expression `stopped_as_error(sndr, err)` is expression-equivalent
+to:
+``` cpp
+transform_sender(get-domain-early(sndr), make-sender(stopped_as_error, err, sndr))
+```
+except that `sndr` is only evaluated once.
+Let `sndr` and `env` be subexpressions such that `Sndr` is
+`decltype((sndr))` and `Env` is `decltype((env))`. If
+`sender-for<Sndr, stopped_as_error_t>` is `false`, then the expression
+`stopped_as_error.transform_sender(sndr, env)` is ill-formed; otherwise,
+it is equivalent to:
+``` cpp
+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));
+  });
+```
+#### `execution::associate` <a id="exec.associate">[[exec.associate]]</a>
+`associate` tries to associate a sender with an async scope such that
+the scope can track the lifetime of any asynchronous operations created
+with the sender.
+Let *`associate-data`* be the following exposition-only class template:
+``` cpp
+namespace std::execution {
+  template<scope_token Token, sender Sender>
+  struct associate-data {                                       // exposition only
+    using wrap-sender =                                         // exposition only
+      remove_cvref_t<decltype(declval<Token&>().wrap(declval<Sender>()))>;
+    explicit associate-data(Token t, Sender&& s)
+      : sndr(t.wrap(std::forward<Sender>(s))),
+        token(t) {
+      if (!token.try_associate())
+        sndr.reset();
+    }
+    associate-data(const associate-data& other)
+      noexcept(is_nothrow_copy_constructible_v<wrap-sender> &&
+               noexcept(other.token.try_associate()));
+    associate-data(associate-data&& other)
+      noexcept(is_nothrow_move_constructible_v<wrap-sender>);
+    ~associate-data();
+    optional<pair<Token, wrap-sender>>
+      release() && noexcept(is_nothrow_move_constructible_v<wrap-sender>);
+  private:
+    optional<wrap-sender> sndr;  // exposition only
+    Token token;                 // exposition only
+  };
+  template<scope_token Token, sender Sender>
+    associate-data(Token, Sender&&) -> associate-data<Token, Sender>;
+}
+```
+For an *`associate-data`* object `a`, `a.sndr.has_value()` is `true` if
+and only if an association was successfully made and is owned by `a`.
+``` cpp
+associate-data(const associate-data& other)
+  noexcept(is_nothrow_copy_constructible_v<wrap-sender> &&
+           noexcept(other.token.try_associate()));
+```
+*Constraints:* `copy_constructible<`*`wrap-sender`*`>` is `true`.
+*Effects:* Value-initializes *sndr* and initializes *token* with
+`other.`*`token`*. If `other.`*`sndr`*`.has_value()` is `false`, no
+further effects; otherwise, calls *`token`*`.try_associate()` and, if
+that returns `true`, calls *`sndr`*`.emplace(*other.`*`sndr`*`)` and, if
+that exits with an exception, calls *`token`*`.disassociate()` before
+propagating the exception.
+``` cpp
+associate-data(associate-data&& other)
+  noexcept(is_nothrow_move_constructible_v<wrap-sender>);
+```
+*Effects:* Initializes *sndr* with `std::move(other.`*`sndr`*`)` and
+initializes *token* with `std::move(other.`*`token`*`)` and then calls
+`other.`*`sndr`*`.reset()`.
+``` cpp
+~associate-data();
+```
+*Effects:* If *`sndr`*`.has_value()` returns `false` then no effect;
+otherwise, invokes *`sndr`*`.reset()` before invoking
+*`token`*`.disassociate()`.
+``` cpp
+optional<pair<Token, wrap-sender>>
+  release() && noexcept(is_nothrow_move_constructible_v<wrap-sender>);
+```
+*Effects:* If *`sndr`*`.has_value()` returns `false` then returns an
+`optional` that does not contain a value; otherwise returns an
+`optional` containing a value of type `pair<Token, `*`wrap-sender`*`>`
+as if by:
+``` cpp
+return optional(pair(token, std::move(*sndr)));
+```
+*Ensures:* *sndr* does not contain a value.
+The name `associate` denotes a pipeable sender adaptor object. For
+subexpressions `sndr` and `token`:
+- If `decltype((sndr))` does not satisfy `sender`, or
+  `remove_cvref_t<decltype((token))>` does not satisfy `scope_token`,
+  then `associate(sndr, token)` is ill-formed.
+- Otherwise, the expression `associate(sndr, token)` is
+  expression-equivalent to:
+  ``` cpp
+  transform_sender(get-domain-early(sndr),
+                   make-sender(associate, associate-data(token, sndr)))
+  ```
+  except that `sndr` is evaluated only once.
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `associate_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<associate_t> : default-impls {
+    static constexpr auto get-state = see below;                // exposition only
+    static constexpr auto start = see below;                    // exposition only
+    template<class Sndr, class... Env>
+      static consteval void check-types() {                     // exposition only
+        using associate_data_t = remove_cvref_t<data-type<Sndr>>;
+        using child_type_t = associate_data_t::wrap-sender;
+        (void)get_completion_signatures<child_type_t, FWD-ENV-T(Env)...>();
+    }
+  };
+}
+```
+The member `impls-for<associate_t>::get-state` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[]<class Sndr, class Rcvr>(Sndr&& sndr, Rcvr& rcvr) noexcept(see below) {
+  auto [_, data] = std::forward<Sndr>(sndr);
+  auto dataParts = std::move(data).release();
+  using scope_tkn = decltype(dataParts->first);
+  using wrap_sender = decltype(dataParts->second);
+  using op_t = connect_result_t<wrap_sender, Rcvr>;
+  struct op_state {
+    bool associated = false;    // exposition only
+    union {
+      Rcvr* rcvr;               // exposition only
+      struct {
+        scope_tkn token;        // exposition only
+        op_t op;                // exposition only
+      } assoc;                  // exposition only
+    };
+    explicit op_state(Rcvr& r) noexcept
+      : rcvr(addressof(r)) {}
+    explicit op_state(scope_tkn tkn, wrap_sender&& sndr, Rcvr& r) try
+      : associated(true),
+        assoc(tkn, connect(std::move(sndr), std::move(r))) {
+    }
+    catch (...) {
+      tkn.disassociate();
+      throw;
+    }
+    op_state(op_state&&) = delete;
+    ~op_state() {
+      if (associated) {
+        assoc.op.~op_t();
+        assoc.token.disassociate();
+        assoc.token.~scope_tkn();
+      }
+    }
+    void run() noexcept {       // exposition only
+      if (associated)
+        start(assoc.op);
+      else
+        set_stopped(std::move(*rcvr));
+    }
+  };
+  if (dataParts)
+    return op_state{std::move(dataParts->first), std::move(dataParts->second), rcvr};
+  else
+    return op_state{rcvr};
+}
+```
+The expression in the `noexcept` clause of
+`impls-for<associate_t>::get-state` is
+``` cpp
+is_nothrow_constructible_v<remove_cvref_t<Sndr>, Sndr> &&
+is_nothrow_move_constructible_v<wrap-sender> &&
+nothrow-callable<connect_t, wrap-sender, Rcvr>
+```
+where *`wrap-sender`* is the type
+`remove_cvref_t<data-type<Sndr>>::wrap-sender`.
+The member `impls-for<associate_t>::start` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[](auto& state, auto&) noexcept -> void {
+  state.run();
+}
+```
+The evaluation of `associate(sndr, token)` may cause side effects
+observable via `token`'s associated async scope object.
+#### Exposition-only `execution::stop-when` <a id="exec.stop.when">[[exec.stop.when]]</a>
+*`stop-when`* fuses an additional stop token `t` into a sender so that,
+upon connecting to a receiver `r`, the resulting operation state
+receives stop requests from both `t` and the token returned from
+`get_stop_token(get_env(r))`.
+The name *`stop-when`* denotes an exposition-only sender adaptor. For
+subexpressions `sndr` and `token`:
+- If `decltype((sndr))` does not satisfy `sender`, or
+  `remove_cvref_t<decltype((token))>` does not satisfy
+  `stoppable_token`, then `stop-when(sndr, token)` is ill-formed.
+- Otherwise, if `remove_cvref_t<decltype((token))>` models
+  `unstoppable_token` then `stop-when({}sndr, token)` is
+  expression-equivalent to `sndr`.
+- Otherwise, `stop-when(sndr, token)` returns a sender `osndr`. If
+  `osndr` is connected to a receiver `r`, let `rtoken` be the result of
+  `get_stop_token(get_env(r))`.
+  - If the type of `rtoken` models `unstoppable_token` then the effects
+    of connecting `osndr` to `r` are equivalent to
+    `connect(write_env(sndr, prop(get_stop_token, token)), r)`.
+  - Otherwise, the effects of connecting `osndr` to `r` are equivalent
+    to `connect(write_env(sndr, prop(get_stop_token, stoken)), r)` where
+    `stoken` is an object of an exposition-only type *`stoken-t`* such
+    that:
+    - *`stoken-t`* models `stoppable_token`;
+    - `stoken.stop_requested()` returns
+      `token.stop_requested() || rtoken.stop_reques-{}ted()`;
+    - `stoken.stop_possible()` returns
+      `token.stop_possible() || rtoken.stop_possible()`; and
+    - for types `Fn` and `Init` such that both `invocable<Fn>` and
+      `constructible_from<Fn, Init>` are modeled,
+      `stoken-t::callback_type<Fn>` models
+      `stoppable-callback-for<Fn, stoken-t, Init>`.\begin{tailnote}
+        For an object \texttt{fn} of type \texttt{Fn}
+        constructed from a value, \texttt{init}, of type \texttt{Init},
+        registering \texttt{fn} using
+        \texttt{\exposid{stoken-t}::callback_type\<Fn\>(stoken, init)}
+        results in an invocation of \texttt{fn} when
+        a callback registered with \texttt{token} or \texttt{rtoken} would be invoked.
+        \texttt{fn} is invoked at most once.
+        \end{tailnote}
+#### `execution::spawn_future` <a id="exec.spawn.future">[[exec.spawn.future]]</a>
+`spawn_future` attempts to associate the given input sender with the
+given token’s async scope and, on success, eagerly starts the input
+sender; the return value is a sender that, when connected and started,
+completes with either the result of the eagerly-started input sender or
+with `set_stopped` if the input sender was not started.
+The name `spawn_future` denotes a customization point object. For
+subexpressions `sndr`, `token`, and `env`,
+- let `Sndr` be `decltype((sndr))`,
+- let `Token` be `remove_cvref_t<decltype((token))>`, and
+- let `Env` be `remove_cvref_t<decltype((env))>`.
+If any of `sender<Sndr>`, `scope_token<Token>`, or `queryable<Env>` are
+not satisfied, the expression `spawn_future(sndr, token, env)` is
+ill-formed.
+Let *`spawn-future-state-base`* be the exposition-only class template:
+``` cpp
+namespace std::execution {
+  template<class Completions>
+  struct spawn-future-state-base;                                   // exposition only
+  template<class... Sigs>
+  struct spawn-future-state-base<completion_signatures<Sigs...>> {  // exposition only
+    using variant-t = see below;                                    // exposition only
+    variant-t result;                                               // exposition only
+    virtual void complete() noexcept = 0;                           // exposition only
+  };
+}
+```
+Let `Sigs` be the pack of arguments to the `completion_signatures`
+specialization provided as a parameter to the
+*`spawn-future-state-base`* class template. Let *`as-tuple`* be an alias
+template that transforms a completion signature `Tag(Args...)` into the
+tuple specialization `decayed-tuple<Tag, Args...>`.
+- If `is_nothrow_constructible_v<decay_t<Arg>, Arg>` is `true` for every
+  type `Arg` in every parameter pack `Args` in every completion
+  signature `Tag(Args...)` in `Sigs` then *`variant-t`* denotes the type
+  `variant<monostate, tuple<set_stopped_t>, as-tuple<Sigs>...>`, except
+  with duplicate types removed.
+- Otherwise *`variant-t`* denotes the type
+  `variant<monostate, tuple<set_stopped_t>, tuple<set_error_t, exception_ptr>, as-tuple<Sigs>...>`,
+  except with duplicate types removed.
+Let *`spawn-future-receiver`* be the exposition-only class template:
+``` cpp
+namespace std::execution {
+  template<class Completions>
+  struct spawn-future-receiver {                                // exposition only
+    using receiver_concept = receiver_t;
+    spawn-future-state-base<Completions>* state;                // exposition only
+    template<class... T>
+      void set_value(T&&... t) && noexcept {
+        set-complete<set_value_t>(std::forward<T>(t)...);
+      }
+    template<class E>
+      void set_error(E&& e) && noexcept {
+        set-complete<set_error_t>(std::forward<E>(e));
+      }
+    void set_stopped() && noexcept {
+      set-complete<set_stopped_t>();
+    }
+  private:
+    template<class CPO, class... T>
+      void set-complete(T&&... t) noexcept {                    // exposition only
+        constexpr bool nothrow = (is_nothrow_constructible_v<decay_t<T>, T> && ...);
+        try {
+          state->result.template emplace<decayed-tuple<CPO, T...>>(CPO{},
+                                                                   std::forward<T>(t)...);
+        }
+        catch (...) {
+          if constexpr (!nothrow) {
+            using tuple_t = decayed-tuple<set_error_t, exception_ptr>;
+            state->result.template emplace<tuple_t>(set_error_t{}, current_exception());
+          }
+        }
+        state->complete();
+      }
+  };
+}
+```
+Let `ssource-t` be an unspecified type that models `stoppable-source`
+and let `ssource` be an lvalue of type `ssource-t`. Let `stoken-t` be
+`decltype(ssource.get_token())`. Let *`future-spawned-sender`* be the
+alias template:
+``` cpp
+template<sender Sender, class Env>
+using future-spawned-sender =                                   // exposition only
+  decltype(write_env(stop-when(declval<Sender>(), declval<stoken-t>()), declval<Env>()));
+```
+Let *`spawn-future-state`* be the exposition-only class template:
+``` cpp
+namespace std::execution {
+  template<class Alloc, scope_token Token, sender Sender, class Env>
+  struct spawn-future-state                                                 // exposition only
+    : spawn-future-state-base<completion_signatures_of_t<future-spawned-sender<Sender, Env>>> {
+    using sigs-t =                                                          // exposition only
+      completion_signatures_of_t<future-spawned-sender<Sender, Env>>;
+    using receiver-t =                                                      // exposition only
+      spawn-future-receiver<sigs-t>;
+    using op-t =                                                            // exposition only
+      connect_result_t<future-spawned-sender<Sender, Env>, receiver-t>;
+    spawn-future-state(Alloc alloc, Sender&& sndr, Token token, Env env)    // exposition only
+      : alloc(std::move(alloc)),
+        op(connect(
+          write_env(stop-when(std::forward<Sender>(sndr), ssource.get_token()), std::move(env)),
+          receiver-t(this))),
+        token(std::move(token)),
+        associated(token.try_associate()) {
+          if (associated)
+            start(op);
+          else
+            set_stopped(receiver-t(this));
+        }
+    void complete() noexcept override;                                      // exposition only
+    void consume(receiver auto& rcvr) noexcept;                             // exposition only
+    void abandon() noexcept;                                                // exposition only
+  private:
+    using alloc-t =                                                         // exposition only
+      allocator_traits<Alloc>::template rebind_alloc<spawn-future-state>;
+    alloc-t alloc;                                                          // exposition only
+    ssource-t ssource;                                                      // exposition only
+    op-t op;                                                                // exposition only
+    Token token;                                                            // exposition only
+    bool associated;                                                        // exposition only
+    void destroy() noexcept;                                                // exposition only
+  };
+}
+```
+For purposes of determining the existence of a data race, *`complete`*,
+*`consume`*, and *`abandon`* behave as atomic operations
+[[intro.multithread]]. These operations on a single object of a type
+that is a specialization of *`spawn-future-state`* appear to occur in a
+single total order.
+``` cpp
+void complete() noexcept;
+```
+*Effects:*
+- No effects if this invocation of *complete* happens before an
+  invocation of *consume* or *abandon* on `*this`;
+- otherwise, if an invocation of *consume* on `*this` happens before
+  this invocation of *complete* then there is a receiver, `rcvr`,
+  registered and that receiver is completed as if by
+  *`consume`*`(rcvr)`;
+- otherwise, *destroy* is invoked.
+``` cpp
+void consume(receiver auto& rcvr) noexcept;
+```
+*Effects:*
+- If this invocation of *consume* happens before an invocation of
+  *complete* on `*this` then `rcvr` is registered to be completed when
+  *complete* is subsequently invoked on `*this`;
+- otherwise, `rcvr` is completed as if by:
+  ``` cpp
+  std::move(this->result).visit(
+    [&rcvr](auto&& tuple) noexcept {
+      if constexpr (!same_as<remove_reference_t<decltype(tuple)>, monostate>) {
+        apply([&rcvr](auto cpo, auto&&... vals) {
+          cpo(std::move(rcvr), std::move(vals)...);
+        }, std::move(tuple));
+      }
+    });
+  ```
+``` cpp
+void abandon() noexcept;
+```
+*Effects:*
+- If this invocation of *abandon* happens before an invocation of
+  *complete* on `*this` then equivalent to:
+  ``` cpp
+  ssource.request_stop();
+  ```
+- otherwise, *destroy* is invoked.
+``` cpp
+void destroy() noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+auto token = std::move(this->token);
+bool associated = this->associated;
+{
+  auto alloc = std::move(this->alloc);
+  allocator_traits<alloc-t>::destroy(alloc, this);
+  allocator_traits<alloc-t>::deallocate(alloc, this, 1);
+}
+if (associated)
+  token.disassociate();
+```
+The exposition-only class template *`impls-for`* [[exec.snd.expos]] is
+specialized for `spawn_future_t` as follows:
+``` cpp
+namespace std::execution {
+  template<>
+  struct impls-for<spawn_future_t> : default-impls {
+    static constexpr auto start = see below;                    // exposition only
+  };
+}
+```
+The member `impls-for<spawn_future_t>::start` is initialized with a
+callable object equivalent to the following lambda:
+``` cpp
+[](auto& state, auto& rcvr) noexcept -> void {
+  state->consume(rcvr);
+}
+```
+For the expression `spawn_future(sndr, token, env)` let `new_sender` be
+the expression `token.wrap(sndr)` and let `alloc` and `senv` be defined
+as follows:
+- if the expression `get_allocator(env)` is well-formed, then `alloc` is
+  the result of `get_allocator(env)` and `senv` is the expression `env`;
+- otherwise, if the expression `get_allocator(get_env(new_sender))` is
+  well-formed, then `alloc` is the result of
+  `get_allocator(get_env(new_sender))` and `senv` is the expression
+  `JOIN-ENV(prop(get_allocator, alloc), env)`;
+- otherwise, `alloc` is `allocator<void>()` and `senv` is the expression
+  `env`.
+The expression `spawn_future(sndr, token, env)` has the following
+effects:
+- Uses `alloc` to allocate and construct an object `s` of a type that is
+  a specialization of *`spawn-future-{}state`* from `alloc`,
+  `token.wrap(sndr)`, `token`, and `senv`. If an exception is thrown
+  then any constructed objects are destroyed and any allocated memory is
+  deallocated.
+- Constructs an object `u` of a type that is a specialization of
+  `unique_ptr` such that:
+  - `u.get()` is equal to the address of `s`, and
+  - `u.get_deleter()(u.release())` is equivalent to
+    `u.release()->abandon()`.
+- Returns `make-sender(spawn_future, std::move(u))`.
+The expression `spawn_future(sndr, token)` is expression-equivalent to
+`spawn_future(sndr, token, execution::env<>())`.

Diff to HTML by rtfpessoa