execution: with_awaitable_senders (#1384)

yohhoy · yohhoy · commit a6d6258134dc · 2025-05-30T17:05:52.000+09:00
single-sender-value-type
diff --git a/reference/execution/execution.md b/reference/execution/execution.md
@@ -152,7 +152,7 @@ Senderコンシューマは名前空間 `std::this_thread` で定義される。
 | 名前 | 説明 | 対応バージョン |
 |------|------|----------------|
 | [`execution::as_awaitable`](execution/as_awaitable.md.nolink) | Senderを[Awaitable型](/lang/cpp20/coroutines.md)へ変換 (customization point object) | C++26 |
-| [`execution::with_awaitable_senders`](execution/with_awaitable_senders.md.nolink) | [Promise型](/lang/cpp20/coroutines.md)の基底クラス (class template) | C++26 |
+| [`execution::with_awaitable_senders`](execution/with_awaitable_senders.md) | [Promise型](/lang/cpp20/coroutines.md)の基底クラス (class template) | C++26 |
 
 
 ## バージョン
diff --git a/reference/execution/execution/read_env.md b/reference/execution/execution/read_env.md
@@ -15,7 +15,7 @@ namespace std::execution {
 `read_env`は、非同期動作の[開始(start)](start.md)時に接続先[Receiver](receiver.md)の[環境](../queryable.md)に対して[クエリオブジェクト](../queryable.md)で問い合わせ、読み取った値を[値完了関数](set_value.md)で送信するSenderファクトリである。
 
 クエリオブジェクトによるReceiver環境への問い合わせは`read_env`[Sender](sender.md)の構築時ではなく、Receiverと接続されたのち非同期動作が開始されるタイミングまで遅延される。
-[`let_value`](let_value.md)Senderアダプタと組み合わせたり、[Sender Awaitableなコルーチン](with_awaitable_senders.md.nolink)での`co_await`式によって、[Scheduler](get_scheduler.md)や[停止トークン](../get_stop_token.md)を読み取ることができる。
+[`let_value`](let_value.md)Senderアダプタと組み合わせたり、[Sender Awaitableなコルーチン](with_awaitable_senders.md)での`co_await`式によって、[Scheduler](get_scheduler.md)や[停止トークン](../get_stop_token.md)を読み取ることができる。
 
 
 ## 効果
diff --git a/reference/execution/execution/sender_adaptor_closure.md b/reference/execution/execution/sender_adaptor_closure.md
@@ -10,6 +10,7 @@ namespace std::execution {
   struct sender_adaptor_closure { };
 }
 ```
+* class-type[link class-type.md.nolink]
 
 ## 概要
 `sender_adaptor_closure`は、ユーザ定義のパイプ可能Senderアダプタクロージャオブジェクトの実装を補助するクラステンプレートである。
diff --git a/reference/execution/execution/single-sender-value-type.md b/reference/execution/execution/single-sender-value-type.md
@@ -0,0 +1,35 @@
+# single-sender-value-type
+* execution[meta header]
+* type-alias[meta id-type]
+* std::execution[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+template<class Sndr, class Env>
+using single-sender-value-type = see below;  // exposition only
+```
+* see below[italic]
+
+## 概要
+`single-sender-value-type`は、実行制御ライブラリの仕様定義で用いられる説明専用のエイリアステンプレートである。
+
+型`Sndr`と`Env`に対して、`single-sender-value-type<Sndr, Env>`は下記のエイリアスとなる。
+
+- [`value_types_of_t`](value_types_of_t.md)`<Sndr, Env,` [`decay_t`](/reference/type_traits/decay.md)`,` [`type_identity_t`](/reference/type_traits/type_identity.md)`>`が適格であるならば、その型。
+- そうではなく、[`value_types_of_t`](value_types_of_t.md)`<Sndr, Env,` [`tuple`](/reference/tuple/tuple.md)`,` [`variant`](/reference/variant/variant.md)`>`が`variant<tuple<>>`もしくは`variant<>`ならば、`void`型。
+- [`value_types_of_t`](value_types_of_t.md)`<Sndr, Env,` [`decayed-tuple`](decayed-tuple.md)`,` [`type_identity_t`](/reference/type_traits/type_identity.md)>`が適格であるならば、その型。
+- そうでなければ、`single-sender-value-type<Sndr, Env>`は不適格。
+
+
+## バージョン
+### 言語
+- C++26
+
+
+## 関連項目
+- [`execution::stopped_as_optional`](stopped_as_optional.md)
+- [`sender-awaitable`](sender-awaitable.md.nolink)
+
+
+## 参照
+- [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
diff --git a/reference/execution/execution/stopped_as_optional.md b/reference/execution/execution/stopped_as_optional.md
@@ -30,7 +30,7 @@ transform_sender(get-domain-early(sndr), make-sender(stopped_as_optional, {}, sn
 
 
 ### Senderアルゴリズムタグ `stopped_as_optional`
-説明用の式`sndr`と`env`に対して、型`Sndr`を`decltype((sndr))`、型`Env`を`decltype((env))`とする。[`sender-for`](sender-for.md)`<Sndr, stopped_as_optional_t> == false`、もしくは[`single-sender-value-type`](single-sender-value-type.md.nolink)`<Sndr, Env>`が不適格または`void`のとき、式`stopped_as_optional.transform_sender(sndr, env)`は不適格となる。
+説明用の式`sndr`と`env`に対して、型`Sndr`を`decltype((sndr))`、型`Env`を`decltype((env))`とする。[`sender-for`](sender-for.md)`<Sndr, stopped_as_optional_t> == false`、もしくは[`single-sender-value-type`](single-sender-value-type.md)`<Sndr, Env>`が不適格または`void`のとき、式`stopped_as_optional.transform_sender(sndr, env)`は不適格となる。
 
 そうでなければ、式`stopped_as_optional.transform_sender(sndr, env)`は下記と等価。
 
@@ -44,7 +44,7 @@ return let_stopped(
          }),
     []() noexcept { return just(optional<V>()); });
 ```
-* single-sender-value-type[link single-sender-value-type.md.nolink]
+* single-sender-value-type[link single-sender-value-type.md]
 * let_stopped[link let_stopped.md.nolink]
 * then[link then.md]
 * just[link just.md]
diff --git a/reference/execution/execution/with_awaitable_senders.md b/reference/execution/execution/with_awaitable_senders.md
@@ -0,0 +1,183 @@
+# with_awaitable_senders
+* execution[meta header]
+* class template[meta id-type]
+* std::execution[meta namespace]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::execution {
+  template<class-type Promise>
+  struct with_awaitable_senders {
+    template<class OtherPromise>
+      requires (!same_as<OtherPromise, void>)
+    void set_continuation(coroutine_handle<OtherPromise> h) noexcept;
+
+    coroutine_handle<> continuation() const noexcept { return continuation; }
+
+    coroutine_handle<> unhandled_stopped() noexcept {
+      return stopped-handler(continuation.address());
+    }
+
+    template<class Value>
+    see below await_transform(Value&& value);
+
+  private:
+    [[noreturn]] static coroutine_handle<>
+      default-unhandled-stopped(void*) noexcept {  // exposition only
+      terminate();
+    }
+
+    coroutine_handle<> continuation{};                       // exposition only
+    coroutine_handle<> (*stopped-handler)(void*) noexcept =  // exposition only
+      &default-unhandled-stopped;
+  };
+}
+```
+* class-type[link class-type.md.nolink]
+* terminate()[link /reference/exception/terminate.md]
+* coroutine_handle[link /reference/coroutine/coroutine_handle.md]
+* address()[link /reference/coroutine/coroutine_handle/address.md]
+* see below[italic]
+
+## 概要
+`with_awaitable_senders`は、[コルーチンPromise型](/lang/cpp20/coroutines.md)の基底クラスとして利用することで、[Sender](sender.md)を`co_await`演算子でAwait可能とするクラステンプレートである。
+
+また`unhandled_stopped`のデフォルト実装を提供し、Senderが[`set_stopped`](set_stopped.md)を呼び出して停止完了したとき、Await式からキャッチできない "停止" 例外が送出されたかのように取り扱う。
+
+
+## メンバ関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|-------|
+| `(constructor)` | コンストラクタ | C++26 |
+| `(destructor)` | デストラクタ | C++26 |
+| [`set_continuation`](with_awaitable_senders/set_continuation.md) | 継続ハンドラを設定する | C++26 |
+| `continuation` | 継続ハンドラを返す | C++26 |
+| `unhandled_stopped` | 停止ハンドラを返す | C++26 |
+| [`await_transform`](with_awaitable_senders/await_transform.md) | [`co_await`演算子](/lang/cpp20/coroutines.md)へアダプトしAwaitableオブジェクトを返す | C++26 |
+
+
+## 静的メンバ関数
+
+| 名前 | 説明 | 対応バージョン |
+|------|------|-------|
+| `default-unhandled-stopped` | 説明専用のデフォルト停止ハンドラ | C++26 |
+
+
+## 例
+```cpp example
+#include <coroutine>
+#include <print>
+#include <execution>
+namespace ex = std::execution;
+
+template<typename T>
+class Lazy {
+public:
+  struct promise_type;
+  using value_type = T;
+  using handle_type = std::coroutine_handle<promise_type>;
+
+  struct promise_type : ex::with_awaitable_senders<promise_type> {
+    value_type value_;
+    auto get_return_object() { return Lazy{handle_type::from_promise(*this)}; }
+    auto initial_suspend() noexcept { return std::suspend_always{}; }
+    auto final_suspend() noexcept { return std::suspend_always{}; }
+    void unhandled_exception() { throw; }
+    void return_value(value_type v) noexcept { value_ = v; }
+  };
+
+private:
+  Lazy(handle_type h) : coro_{h} {}
+
+public:
+  Lazy(Lazy&& rhs)
+    : coro_{std::exchange(rhs.coro_, nullptr)} {}
+  Lazy& operator=(Lazy&& rhs) {
+    if (coro_) { std::exchange(coro_, nullptr).destroy(); }
+    std::swap(rhs.coro_, coro_);
+    return *this;
+  }
+  ~Lazy()
+    { if (coro_) { coro_.destroy(); } }
+
+  value_type get() {
+    assert(coro_);
+    if (!coro_.done()) {
+      coro_.resume();
+    }
+    return coro_.promise().value_;
+  }
+
+private:
+  handle_type coro_;
+};
+
+// SenderをAwait可能なコルーチン
+Lazy<int> coro(int n)
+{
+  std::println("coro start");
+  ex::sender auto sndr =
+    ex::just(n)
+    | ex::then([](int m){ return m * 3; });
+
+  // Senderを開始して値取得を待機
+  int val = co_await sndr;
+
+  std::println("coro end");
+  co_return val * 7;
+}
+
+int main()
+{
+  try {
+    auto task = coro(2);
+    std::println("get");
+    auto value = task.get();
+    std::println("value={}", value);
+  } catch (...) {
+    std::println("<exception>");
+  }
+}
+```
+* ex::with_awaitable_senders[color ff0000]
+* ex::sender[link sender.md]
+* ex::just[link just.md]
+* ex::then[link then.md]
+* std::coroutine_handle[link /reference/coroutine/coroutine_handle.md]
+* from_promise[link /reference/coroutine/coroutine_handle/from_promise.md]
+* destroy()[link /reference/coroutine/coroutine_handle/destroy.md]
+* done()[link /reference/coroutine/coroutine_handle/done.md]
+* resume()[link /reference/coroutine/coroutine_handle/resume.md]
+* promise()[link /reference/coroutine/coroutine_handle/promise.md]
+* std::suspend_always[link /reference/coroutine/suspend_always.md]
+
+### 出力
+```
+get
+coro start
+coro end
+value=42
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::​as_awaitable`](​as_awaitable.md.nolink)
+- [コルーチン](/lang/cpp20/coroutines.md)
+
+
+## 参照
+- [P3325R5 A Utility for Creating Execution Environments](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3325r5.html)
+
+
diff --git a/reference/execution/execution/with_awaitable_senders/await_transform.md b/reference/execution/execution/with_awaitable_senders/await_transform.md
@@ -0,0 +1,45 @@
+# await_transform
+* execution[meta header]
+* function template[meta id-type]
+* std::execution[meta namespace]
+* with_awaitable_senders[meta class]
+* cpp26[meta cpp]
+
+```cpp
+template<class Value>
+call-result-t<as_awaitable_t, Value, Promise&>
+  await_transform(Value&& value);
+```
+* call-result-t[link /reference/functional/call-result-t.md]
+* as_awaitable_t[link ../as_awaitable.md.nolink]
+
+## 概要
+コルーチンの[`co_await`演算子](/lang/cpp20/coroutines.md)にアダプトし、[`as_awaitable`](../as_awaitable.md.nolink)で変換したAwaitableオブジェクトを返す。
+
+
+## 効果
+下記と等価。
+
+```cpp
+return as_awaitable(std::forward<Value>(value), static_cast<Promise&>(*this));
+```
+* as_awaitable[link ../as_awaitable.md.nolink]
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`execution::as_awaitable`](../as_awaitable.md.nolink)
+
+
+## 参照
+- [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)
diff --git a/reference/execution/execution/with_awaitable_senders/set_continuation.md b/reference/execution/execution/with_awaitable_senders/set_continuation.md
@@ -0,0 +1,58 @@
+# set_continuation
+* execution[meta header]
+* function template[meta id-type]
+* std::execution[meta namespace]
+* with_awaitable_senders[meta class]
+* cpp26[meta cpp]
+
+```cpp
+template<class OtherPromise>
+  requires (!same_as<OtherPromise, void>)
+void set_continuation(coroutine_handle<OtherPromise> h) noexcept;
+```
+* coroutine_handle[link /reference/coroutine/coroutine_handle.md]
+
+## 概要
+継続処理のコルーチンハンドルを設定する。
+
+
+## テンプレートパラメータ制約
+`!`[`same_as`](/reference/concepts/same_as.md)`<OtherPromise, void>`
+
+
+## 効果
+下記と等価。
+
+```cpp
+continuation = h;
+if constexpr ( requires(OtherPromise& other) { other.unhandled_stopped(); } ) {
+  stopped-handler = [](void* p) noexcept -> coroutine_handle<> {
+    return coroutine_handle<OtherPromise>::from_address(p)
+      .promise().unhandled_stopped();
+  };
+} else {
+  stopped-handler = &default-unhandled-stopped;
+}
+```
+* coroutine_handle[link /reference/coroutine/coroutine_handle.md]
+* from_address[link /reference/coroutine/coroutine_handle/from_address.md]
+* promise()[link /reference/coroutine/coroutine_handle/promise.md]
+
+
+## 例外
+投げない
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [ICC](/implementation.md#icc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 参照
+- [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html)

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace std::execution {`
`10`	`10`	`struct sender_adaptor_closure { };`
`11`	`11`	`}`
`12`	`12`	```
	`13`	`+* class-type[link class-type.md.nolink]`
`13`	`14`
`14`	`15`	`## 概要`
`15`	`16`	`sender_adaptor_closure`は、ユーザ定義のパイプ可能Senderアダプタクロージャオブジェクトの実装を補助するクラステンプレートである。