From 42a745b72d919c817a5ecd390eb4e70820942401 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Sat, 19 Jul 2025 00:49:07 +0800
Subject: [PATCH 01/12] =?UTF-8?q?=E4=BC=98=E5=8C=96=20rcvr=5Fref,=E4=B8=8D?=
 =?UTF-8?q?=E9=9C=80=E8=A6=81=E4=BC=A0=5FEnv?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/ustdex/detail/conditional.hpp  | 2 +-
 include/ustdex/detail/continues_on.hpp | 2 +-
 include/ustdex/detail/let_value.hpp    | 2 +-
 include/ustdex/detail/rcvr_ref.hpp     | 4 ++--
 include/ustdex/detail/sequence.hpp     | 2 +-
 include/ustdex/detail/then.hpp         | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/ustdex/detail/conditional.hpp b/include/ustdex/detail/conditional.hpp
index c7ece94..a530afc 100644
--- a/include/ustdex/detail/conditional.hpp
+++ b/include/ustdex/detail/conditional.hpp
@@ -165,7 +165,7 @@ struct _cond_t
 
     Rcvr _rcvr_;
     _data_t _data_;
-    connect_result_t<Sndr, _rcvr_ref<_opstate, _env_t>> _op_;
+    connect_result_t<Sndr, _rcvr_ref<_opstate>> _op_;
     _next_ops_variant_t _ops_;
   };
 
diff --git a/include/ustdex/detail/continues_on.hpp b/include/ustdex/detail/continues_on.hpp
index 87a5bcb..65c4871 100644
--- a/include/ustdex/detail/continues_on.hpp
+++ b/include/ustdex/detail/continues_on.hpp
@@ -155,7 +155,7 @@ struct USTDEX_TYPE_VISIBILITY_DEFAULT continue_on_t
     }
 
     _rcvr_t<Rcvr, _result_t> _rcvr_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate1_;
     connect_result_t<schedule_result_t<Sch>, _rcvr_ref<_rcvr_t<Rcvr, _result_t>>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/let_value.hpp b/include/ustdex/detail/let_value.hpp
index 4dbfb8b..647295f 100644
--- a/include/ustdex/detail/let_value.hpp
+++ b/include/ustdex/detail/let_value.hpp
@@ -167,7 +167,7 @@ struct _let
     Rcvr _rcvr_;
     Fn _fn_;
     _results<CvSndr, _env_t> _result_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate1_;
     _opstate_variant_t _opstate2_;
   };
 
diff --git a/include/ustdex/detail/rcvr_ref.hpp b/include/ustdex/detail/rcvr_ref.hpp
index 6ec59e5..bbbc7bd 100644
--- a/include/ustdex/detail/rcvr_ref.hpp
+++ b/include/ustdex/detail/rcvr_ref.hpp
@@ -25,7 +25,7 @@
 
 namespace ustdex
 {
-template <class _Rcvr, class _Env = env_of_t<_Rcvr>>
+template <class _Rcvr>
 struct _rcvr_ref
 {
   using receiver_concept = receiver_t;
@@ -48,7 +48,7 @@ struct _rcvr_ref
     static_cast<_Rcvr&&>(_rcvr_).set_stopped();
   }
 
-  USTDEX_API auto get_env() const noexcept -> _Env
+  USTDEX_API auto get_env() const noexcept
   {
     return ustdex::get_env(_rcvr_);
   }
diff --git a/include/ustdex/detail/sequence.hpp b/include/ustdex/detail/sequence.hpp
index 11c036b..767700e 100644
--- a/include/ustdex/detail/sequence.hpp
+++ b/include/ustdex/detail/sequence.hpp
@@ -82,7 +82,7 @@ struct _seq
     }
 
     _rcvr_t _rcvr_;
-    connect_result_t<_sndr1_t, _rcvr_ref<_opstate, _env_t>> _opstate1_;
+    connect_result_t<_sndr1_t, _rcvr_ref<_opstate>> _opstate1_;
     connect_result_t<_sndr2_t, _rcvr_ref<_rcvr_t>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/then.hpp b/include/ustdex/detail/then.hpp
index 16da99e..4b4b576 100644
--- a/include/ustdex/detail/then.hpp
+++ b/include/ustdex/detail/then.hpp
@@ -176,7 +176,7 @@ struct _upon_t
 
     Rcvr _rcvr_;
     Fn _fn_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
   };
 
   template <class Fn>

From b5e66b13a086804241ead5546c2084f23bd4af21 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Tue, 22 Jul 2025 20:18:02 +0800
Subject: [PATCH 02/12] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E9=94=99=E8=AF=AF=EF=BC=8C=E6=B7=BB=E5=8A=A0=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E7=AE=97=E6=B3=95=20when=5Fany,=20staop=5Fwhen,=20stop=5Fwith?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakePresets.json                             |  83 ++--
 examples/scratch.cpp                          | 217 ++++++---
 include/ustdex/detail/binder_closure.hpp      |  43 ++
 .../ustdex/detail/completion_signatures.hpp   |   6 +-
 include/ustdex/detail/exclusive_scan.hpp      |   2 +-
 include/ustdex/detail/lazy.hpp                |   8 +-
 include/ustdex/detail/meta.hpp                |  10 +-
 include/ustdex/detail/starts_on.hpp           |   2 +-
 include/ustdex/detail/stop_when.hpp           | 155 +++++++
 include/ustdex/detail/stop_with.hpp           | 198 ++++++++
 include/ustdex/detail/tuple.hpp               |  16 +-
 include/ustdex/detail/when_any.hpp            | 427 ++++++++++++++++++
 include/ustdex/ustdex.hpp                     |   3 +
 13 files changed, 1048 insertions(+), 122 deletions(-)
 create mode 100644 include/ustdex/detail/binder_closure.hpp
 create mode 100644 include/ustdex/detail/stop_when.hpp
 create mode 100644 include/ustdex/detail/stop_with.hpp
 create mode 100644 include/ustdex/detail/when_any.hpp

diff --git a/CMakePresets.json b/CMakePresets.json
index 9704f3b..fc779f1 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -1,36 +1,57 @@
 {
-    "version": 3,
-    "cmakeMinimumRequired": {
-      "major": 3,
-      "minor": 21,
-      "patch": 3
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 21,
+    "patch": 3
+  },
+  "configurePresets": [
+    {
+      "name": "Debug",
+      "binaryDir": "${sourceDir}/build/Debug",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_STANDARD": "17"
+      }
     },
-    "configurePresets": [
-      {
-        "name": "Debug",
-        "binaryDir": "${sourceDir}/build/Debug",
-        "cacheVariables": {
-          "CMAKE_BUILD_TYPE": "Debug",
-          "CMAKE_CXX_STANDARD": "17"
-        }
+    {
+      "name": "Release",
+      "binaryDir": "${sourceDir}/build/Release",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_CXX_STANDARD": "17"
+      }
+    },
+    {
+      "name": "clang-x64-debug",
+      "displayName": "Clang x64 Debug",
+      "binaryDir": "${sourceDir}/out/build/${presetName}",
+      "installDir": "${sourceDir}/out/install/${presetName}",
+      "architecture": {
+        "value": "x64",
+        "strategy": "external"
       },
-      {
-        "name": "Release",
-        "binaryDir": "${sourceDir}/build/Release",
-        "cacheVariables": {
-          "CMAKE_BUILD_TYPE": "Release",
-          "CMAKE_CXX_STANDARD": "17"
+      "cacheVariables": {
+        "CMAKE_C_COMPILER": "clang.exe",
+        "CMAKE_CXX_COMPILER": "clang++.exe",
+        "CMAKE_BUILD_TYPE": "Debug"
+      },
+      "vendor": {
+        "microsoft.com/VisualStudioSettings/CMake/1.0": {
+          "intelliSenseMode": "windows-clang-x64"
         }
       }
-    ],
-    "buildPresets": [
-        {
-          "name": "Debug",
-          "configurePreset": "Debug"
-        },
-        {
-            "name": "Release",
-            "configurePreset": "Release"
-        }
-    ]
-  }
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "Debug",
+      "configurePreset": "Debug"
+    },
+    {
+      "name": "Release",
+      "configurePreset": "Release"
+    },
+    
+  ]
+}
\ No newline at end of file
diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 46d5da4..f25c52f 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -19,29 +19,34 @@
 #include <iostream>
 
 #include "ustdex/ustdex.hpp"
+#include <variant>
+#include <any>
 
 using namespace ustdex;
 
+template<typename... Args>
+void _whatis();
+
 struct sink
 {
-  using receiver_concept = receiver_t;
+	using receiver_concept = receiver_t;
 
-  void set_value() noexcept {}
+	void set_value() noexcept {}
 
-  void set_value(int a) noexcept
-  {
-    std::printf("%d\n", a);
-  }
+	void set_value(int a) noexcept
+	{
+		std::printf("%d\n", a);
+	}
 
-  template <class... As>
-  void set_value(As&&...) noexcept
-  {
-    std::puts("In sink::set_value(auto&&...)");
-  }
+	template <class... As>
+	void set_value(As&&...) noexcept
+	{
+		std::puts("In sink::set_value(auto&&...)");
+	}
 
-  void set_error(std::exception_ptr) noexcept {}
+	void set_error(std::exception_ptr) noexcept {}
 
-  void set_stopped() noexcept {}
+	void set_stopped() noexcept {}
 };
 
 template <class>
@@ -50,56 +55,142 @@ template <class>
 
 static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
+
 int main()
 {
-  thread_context ctx;
-  auto sch  = ctx.get_scheduler();
-
-  auto work = just(1, 2, 3) //
-            | then([](int a, int b, int c) {
-                std::printf("%d %d %d\n", a, b, c);
-                return a + b + c;
-              });
-  auto s = starts_on(sch, std::move(work));
-  static_assert(!dependent_sender<decltype(s)>);
-  std::puts("Hello, world!");
-  sync_wait(s);
-
-  auto s3 = just(42) | let_value([](int a) {
-              std::puts("here");
-              return just(a + 1);
-            });
-  sync_wait(s3);
-
-  auto [sch2]   = sync_wait(read_env(get_scheduler)).value();
-
-  auto [i1, i2] = sync_wait(when_all(just(42), just(43))).value();
-  std::cout << i1 << ' ' << i2 << '\n';
-
-  auto s4        = just(42) | then([](int) {}) | upon_error([](auto) { /*return 42;*/ });
-  auto s5        = when_all(std::move(s4), just(42, 43), just(+"hello"));
-  auto [i, j, k] = sync_wait(std::move(s5)).value();
-  std::cout << i << ' ' << j << ' ' << k << '\n';
-
-  auto s6 = sequence(just(42) | then([](int) {
-                       std::cout << "sequence sender 1\n";
-                     }),
-                     just(42) | then([](int) {
-                       std::cout << "sequence sender 2\n";
-                     }));
-  sync_wait(std::move(s6));
-
-  auto s7 =
-    just(42)
-    | conditional(
-      [](int i) {
-        return i % 2 == 0;
-      },
-      then([](int) {
-        std::cout << "even\n";
-      }),
-      then([](int) {
-        std::cout << "odd\n";
-      }));
-  sync_wait(std::move(s7));
+	{
+		using CS = completion_signatures<set_value_t(int, double), set_value_t(float, char)>;
+		CS cs{};
+		auto c = cs.select(set_value);
+
+		_whatis<decltype(c)>();
+	}
+
+	thread_context ctx;
+	auto sch = ctx.get_scheduler();
+
+	auto work = just(1, 2, 3) //
+		| then([](int a, int b, int c)
+			{
+				std::printf("%d %d %d\n", a, b, c);
+				return a + b + c;
+			});
+	auto s = starts_on(sch, std::move(work));
+	static_assert(!dependent_sender<decltype(s)>);
+	std::puts("Hello, world!");
+	sync_wait(s);
+
+	auto s3 = just(42) | let_value([](int a)
+		{
+			std::puts("here");
+			return just(a + 1);
+		});
+	sync_wait(s3);
+
+	auto [sch2] = sync_wait(read_env(get_scheduler)).value();
+
+	auto [i1, i2] = sync_wait(when_all(just(42), just(43))).value();
+	std::cout << i1 << ' ' << i2 << '\n';
+
+	auto s4 = just(42) | then([](int) {}) | upon_error([](auto) { /*return 42;*/ });
+	auto s5 = when_all(std::move(s4), just(42, 43), just(+"hello"));
+	auto [i, j, k] = sync_wait(std::move(s5)).value();
+	std::cout << i << ' ' << j << ' ' << k << '\n';
+
+	auto s6 = sequence(just(42) | then([](int)
+		{
+			std::cout << "sequence sender 1\n";
+		}),
+		just(42) | then([](int)
+			{
+				std::cout << "sequence sender 2\n";
+			}));
+	sync_wait(std::move(s6));
+
+	auto s7 =
+		just(42)
+		| conditional(
+			[](int i)
+			{
+				return i % 2 == 0;
+			},
+			then([](int)
+				{
+					std::cout << "even\n";
+				}),
+			then([](int)
+				{
+					std::cout << "odd\n";
+				}));
+	sync_wait(std::move(s7));
+
+
+	{
+		inplace_stop_source stop_source;
+
+		auto task = just(100)
+			| then([&stop_source](int i)
+				{
+					stop_source.request_stop();
+					std::cout << "111_Value: " << i << '\n';
+					return i;
+				})
+			//| stop_when(stop_source.get_token())
+			| stop_with([](const int& i)
+				{
+					if (i == 100)
+					{
+						return false;
+					}
+					else
+					{
+						return false;
+					}
+				})
+			| then([](int i)
+				{
+					std::cout << "222_Value: " << i << '\n';
+					return i;
+				})
+			| upon_stopped([]()
+				{
+					std::cout << "Stopped!\n";
+				})
+			| upon_error([](std::exception_ptr e)
+				{
+					try
+					{
+						std::rethrow_exception(e);
+					}
+					catch (const std::exception& ex)
+					{
+						std::cout << "Error: " << ex.what() << '\n';
+					}
+				});
+		
+		auto op = connect(std::move(task), sink{});
+		start(op);
+		//sync_wait(std::move(task));
+
+	}
+
+	{
+		/*auto task = when_any(just(5), just('a'), just(3.14)) | 
+			then([](std::any v)
+				{
+					int aa = 0;
+				});
+
+		auto op = connect(std::move(task), sink{});
+		start(op);*/
+
+		//using TA = completion_signatures_of_t<decltype(task)>;
+		//_m_self_or<_nil>::call
+		//using TB = _value_types<TA, _tupl, _variant>;
+
+		//_whatis<TB>();
+	}
+
+
+
 }
diff --git a/include/ustdex/detail/binder_closure.hpp b/include/ustdex/detail/binder_closure.hpp
new file mode 100644
index 0000000..48c93b9
--- /dev/null
+++ b/include/ustdex/detail/binder_closure.hpp
@@ -0,0 +1,43 @@
+#ifndef USTDEX_ASYNC_DETAIL_BINDER_CLOSURE
+#define USTDEX_ASYNC_DETAIL_BINDER_CLOSURE
+
+#include "config.hpp"
+#include "tuple.hpp"
+
+#include "prologue.hpp"
+
+namespace ustdex
+{
+
+	template<class bind_t, typename... Args>
+	struct binder_closure
+	{
+		_tuple<Args...> _args_;
+
+		binder_closure(Args... args) noexcept :_args_({ static_cast<Args&&>(args)... })
+		{}
+
+		template<class Sndr, std::size_t... I>
+		static auto make(Sndr&& sndr, _tuple<Args...> _args, std::index_sequence<I...>) noexcept ->_call_result_t<bind_t, Sndr, Args...>
+		{
+			return bind_t()(static_cast<Sndr&&>(sndr), static_cast<Args&&>(const_cast<Args&>(_cget<I, Args>(_args)))...);
+		}
+
+		template <class Sndr>
+		USTDEX_TRIVIAL_API auto operator()(Sndr _sndr) noexcept ->_call_result_t<bind_t, Sndr, Args...>
+		{
+			return this->make<Sndr>(static_cast<Sndr&&>(_sndr), static_cast<_tuple<Args...>&&>(_args_), std::make_index_sequence<sizeof...(Args)>());
+		}
+
+		template <class Sndr>
+		USTDEX_TRIVIAL_API friend auto operator|(Sndr sndr, binder_closure&& self) noexcept ->_call_result_t<bind_t, Sndr, Args...>
+		{
+			return self.make(static_cast<Sndr&&>(sndr), static_cast<_tuple<Args...>&&>(self._args_), std::make_index_sequence<sizeof...(Args)>());
+		}
+	};
+
+}
+
+#include "epilogue.hpp"
+
+#endif // USTDEX_ASYNC_DETAIL_BINDER_CLOSURE
\ No newline at end of file
diff --git a/include/ustdex/detail/completion_signatures.hpp b/include/ustdex/detail/completion_signatures.hpp
index eeaf109..abb1543 100644
--- a/include/ustdex/detail/completion_signatures.hpp
+++ b/include/ustdex/detail/completion_signatures.hpp
@@ -169,15 +169,15 @@ USTDEX_API constexpr auto completion_signatures<Sigs...>::select(Tag) const noex
 {
   if constexpr (Tag() == set_value)
   {
-    return _partitioned::template _value_types<_m_quote_f<set_value_t>::call, completion_signatures>();
+      return typename _partitioned::template _value_types<_m_quote_f<set_value_t>::call, completion_signatures>();
   }
   else if constexpr (Tag() == set_error)
   {
-    return _partitioned::template _error_types<completion_signatures, _m_quote_f<set_error_t>::call>();
+    return typename _partitioned::template _error_types<completion_signatures, _m_quote_f<set_error_t>::call>();
   }
   else
   {
-    return _partitioned::template _stopped_types<completion_signatures>();
+    return typename _partitioned::template _stopped_types<completion_signatures>();
   }
 }
 
diff --git a/include/ustdex/detail/exclusive_scan.hpp b/include/ustdex/detail/exclusive_scan.hpp
index fbdb26b..48632d9 100644
--- a/include/ustdex/detail/exclusive_scan.hpp
+++ b/include/ustdex/detail/exclusive_scan.hpp
@@ -24,7 +24,7 @@
 
 namespace ustdex
 {
-#if __cplusplus >= 202002L
+#if __cplusplus >= 202302L
 // exclusive_scan is constexpr in C++20
 using std::exclusive_scan;
 #else
diff --git a/include/ustdex/detail/lazy.hpp b/include/ustdex/detail/lazy.hpp
index 7c11c80..eb254b0 100644
--- a/include/ustdex/detail/lazy.hpp
+++ b/include/ustdex/detail/lazy.hpp
@@ -38,16 +38,16 @@ struct _lazy
   template <class... Ts>
   USTDEX_API Ty& construct(Ts&&... _ts) noexcept(_nothrow_constructible<Ty, Ts...>)
   {
-    Ty* _value_ = ::new (static_cast<void*>(std::addressof(_value_))) Ty{static_cast<Ts&&>(_ts)...};
-    return *std::launder(_value_);
+    Ty* rst = ::new (static_cast<void*>(std::addressof(_value_))) Ty{static_cast<Ts&&>(_ts)...};
+    return *std::launder(rst);
   }
 
   template <class Fn, class... Ts>
   USTDEX_API Ty& construct_from(Fn&& _fn, Ts&&... _ts) noexcept(_nothrow_callable<Fn, Ts...>)
   {
-    Ty* _value_ = ::new (static_cast<void*>(std::addressof(_value_)))
+    Ty* rst = ::new (static_cast<void*>(std::addressof(_value_)))
       Ty{static_cast<Fn&&>(_fn)(static_cast<Ts&&>(_ts)...)};
-    return *std::launder(_value_);
+    return *std::launder(rst);
   }
 
   USTDEX_API void destroy() noexcept
diff --git a/include/ustdex/detail/meta.hpp b/include/ustdex/detail/meta.hpp
index 456be3f..86798ab 100644
--- a/include/ustdex/detail/meta.hpp
+++ b/include/ustdex/detail/meta.hpp
@@ -448,16 +448,16 @@ template <template <class...> class Fn, class List, class = void>
 extern _m_undefined<List> _m_apply_q_;
 
 template <template <class...> class Fn, template <class...> class List, class... Ts>
-extern _fn_t<Fn<Ts...>>* _m_apply_q_<Fn, List<Ts...>, _m_void<Fn<Ts...>>>;
+extern _fn_t<_m_always<Fn<Ts...>>>* _m_apply_q_<Fn, List<Ts...>, _m_void<Fn<Ts...>>>;
 
 template <template <class...> class Fn, class Ret, class... As>
-extern _fn_t<Fn<Ret, As...>>* _m_apply_q_<Fn, Ret(As...), _m_void<Fn<Ret, As...>>>;
+extern _fn_t<_m_always<Fn<Ret, As...>>>* _m_apply_q_<Fn, Ret(As...), _m_void<Fn<Ret, As...>>>;
 
 template <template <class...> class Fn, class List>
-using _m_apply_q USTDEX_ATTR_NODEBUG_ALIAS = decltype(_m_apply_q_<Fn, List>());
+using _m_apply_q USTDEX_ATTR_NODEBUG_ALIAS = _m_call<decltype(_m_apply_q_<Fn, List>())>;
 
 template <class Fn, class List>
-using _m_apply USTDEX_ATTR_NODEBUG_ALIAS = decltype(_m_apply_q_<Fn::template call, List>());
+using _m_apply USTDEX_ATTR_NODEBUG_ALIAS = _m_call<decltype(_m_apply_q_<Fn::template call, List>())>;
 
 template <std::size_t Count>
 struct USTDEX_TYPE_VISIBILITY_DEFAULT _m_maybe_concat_fn
@@ -552,7 +552,7 @@ template <class Ret>
 struct _m_quote_function
 {
   template <class... Args>
-  using call USTDEX_ATTR_NODEBUG_ALIAS = Ret(Args...);
+  using call USTDEX_ATTR_NODEBUG_ALIAS = Ret(*)(Args...);
 };
 
 template <class _Set, class... _Ts>
diff --git a/include/ustdex/detail/starts_on.hpp b/include/ustdex/detail/starts_on.hpp
index ac7f0e4..7224785 100644
--- a/include/ustdex/detail/starts_on.hpp
+++ b/include/ustdex/detail/starts_on.hpp
@@ -72,7 +72,7 @@ inline constexpr struct start_on_t
       return ustdex::get_env(this->base());
     }
 
-    connect_result_t<schedule_result_t<Sch&>, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
+    connect_result_t<schedule_result_t<Sch&>, _rcvr_ref<_opstate_t>> _opstate1_;
     connect_result_t<CvSndr, _rcvr_ref<_rcvr_with_sch_t>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/stop_when.hpp b/include/ustdex/detail/stop_when.hpp
new file mode 100644
index 0000000..697c3d6
--- /dev/null
+++ b/include/ustdex/detail/stop_when.hpp
@@ -0,0 +1,155 @@
+#pragma once
+
+#include "config.hpp"
+#include "meta.hpp"
+#include "completion_signatures.hpp"
+#include "binder_closure.hpp"
+#include "lazy.hpp"
+#include "stop_token.hpp"
+#include "cpos.hpp"
+
+#include "prologue.hpp"
+
+namespace ustdex
+{
+
+	struct stop_when_t
+	{
+    private:
+        template <class Rcvr, class CvSndr, class Token>
+        struct USTDEX_TYPE_VISIBILITY_DEFAULT _opstate_t
+        {
+            using operation_state_concept = operation_state_t;
+            using _env_t = env<env_of_t<Rcvr>, prop<get_stop_token_t, Token>>;
+
+			using _stop_token_of_rcvr = stop_token_of_t<env_of_t<Rcvr>>;
+			using _stop_callback_t1 = stop_callback_for_t<_stop_token_of_rcvr, _on_stop_request>;
+			using _stop_callback_t2 = stop_callback_for_t<Token, _on_stop_request>;
+
+            USTDEX_API _opstate_t(CvSndr&& _sndr, Rcvr _rcvr, Token _token)
+                : _rcvr_{ static_cast<Rcvr&&>(_rcvr) }
+                , _token_{ static_cast<Token&&>(_token) }
+                , _opstate_{ ustdex::connect(static_cast<CvSndr&&>(_sndr), _rcvr_ref{*this}) }
+            {}
+
+            USTDEX_IMMOVABLE(_opstate_t);
+
+            USTDEX_API void start() & noexcept
+            {
+                _on_stop1_.construct(ustdex::get_stop_token(_rcvr_), _on_stop_request{_stop_source_});
+                _on_stop2_.construct(_token_, _on_stop_request{ _stop_source_ });
+                ustdex::start(_opstate_);
+            }
+
+            template <class... Ts>
+            USTDEX_API void set_value(Ts&&... _ts) noexcept
+            {
+				_on_stop1_.destroy();
+				_on_stop2_.destroy();
+                if (_stop_source_.stop_requested())
+                {
+                    ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
+                }
+                else
+                {
+                    ustdex::set_value(static_cast<Rcvr&&>(_rcvr_), static_cast<Ts&&>(_ts)...);
+                }
+            }
+
+            template <class Error>
+            USTDEX_API void set_error(Error&& _error) noexcept
+            {
+                _on_stop1_.destroy();
+                _on_stop2_.destroy();
+                ustdex::set_error(static_cast<Rcvr&&>(_rcvr_), static_cast<Error&&>(_error));
+            }
+
+            USTDEX_API void set_stopped() noexcept
+            {
+                _on_stop1_.destroy();
+                _on_stop2_.destroy();
+                ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
+            }
+
+            USTDEX_API auto get_env() const noexcept -> _env_t
+            {
+                return  _env_t{ ustdex::get_env(_rcvr_), prop{get_stop_token, _token_} };
+            }
+
+            Rcvr _rcvr_;
+            Token _token_;
+			inplace_stop_source _stop_source_;
+            _lazy<_stop_callback_t1> _on_stop1_;
+            _lazy<_stop_callback_t2> _on_stop2_;
+            connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
+        };
+
+        template <class Sndr, class Token>
+        struct USTDEX_TYPE_VISIBILITY_DEFAULT _sndr_t
+        {
+            using sender_concept = sender_t;
+            Sndr _sndr_;
+            Token _token_;
+
+            template <class Self, class... Env>
+            USTDEX_API static constexpr auto get_completion_signatures()
+            {
+                USTDEX_LET_COMPLETIONS(auto(_child_completions) = get_child_completion_signatures<Self, Sndr, Env...>())
+                {
+                    return concat_completion_signatures(_child_completions, completion_signatures<set_stopped_t()>{});
+                }
+            }
+
+            template <class Rcvr>
+            USTDEX_API auto connect(Rcvr _rcvr) &&                                         //
+                noexcept(_nothrow_constructible<_opstate_t<Rcvr, Sndr, Token>, Sndr, Rcvr, Token>) //
+                -> _opstate_t<Rcvr, Sndr, Token>
+            {
+                return _opstate_t<Rcvr, Sndr, Token>{
+                    static_cast<Sndr&&>(_sndr_), static_cast<Rcvr&&>(_rcvr), static_cast<Token&&>(_token_)};
+            }
+
+            template <class Rcvr>
+            USTDEX_API auto connect(Rcvr _rcvr) const& //
+                noexcept(_nothrow_constructible<_opstate_t<Rcvr, const Sndr&, Token>,
+                    const Sndr&,
+                    Rcvr,
+                    const Token&>) //
+                -> _opstate_t<Rcvr, const Sndr&, Token>
+            {
+                return _opstate_t<Rcvr, const Sndr&, Token>{_sndr_, static_cast<Rcvr&&>(_rcvr), _token_};
+            }
+
+            USTDEX_API env_of_t<Sndr> get_env() const noexcept
+            {
+                return ustdex::get_env(_sndr_);
+            }
+        };
+
+    public:
+        template <class Sndr, class Token>
+        USTDEX_TRIVIAL_API auto operator()(Sndr _sndr, Token _token) const noexcept //
+            -> _sndr_t<Sndr, Token>
+        {
+            // If the incoming sender is non-dependent, we can check the completion
+            // signatures of the composed sender immediately.
+            if constexpr (!dependent_sender<Sndr>)
+            {
+                using _completions = completion_signatures_of_t<_sndr_t<Sndr, Token>>;
+                static_assert(_valid_completion_signatures<_completions>);
+            }
+            return _sndr_t<Sndr, Token>{static_cast<Sndr&&>(_sndr), static_cast<Token&&>(_token)};
+        }
+
+        template <class Token>
+        USTDEX_TRIVIAL_API auto operator()(Token _token) const noexcept -> binder_closure<stop_when_t, Token>
+        {
+            return binder_closure<stop_when_t, Token>{static_cast<Token&&>(_token)};
+        }
+	};
+
+
+	inline constexpr stop_when_t stop_when{};
+}
+
+#include "epilogue.hpp"
\ No newline at end of file
diff --git a/include/ustdex/detail/stop_with.hpp b/include/ustdex/detail/stop_with.hpp
new file mode 100644
index 0000000..e502b96
--- /dev/null
+++ b/include/ustdex/detail/stop_with.hpp
@@ -0,0 +1,198 @@
+#pragma once
+
+#include "config.hpp"
+#include "meta.hpp"
+#include "completion_signatures.hpp"
+#include "binder_closure.hpp"
+#include "lazy.hpp"
+#include "cpos.hpp"
+
+#include "prologue.hpp"
+
+namespace ustdex
+{
+
+    namespace _stop_with
+    {
+        template<bool Nothrow>
+        struct _completion_fn_
+        {
+            //non-throwing case
+            template<typename... Ts>
+			using call = completion_signatures<set_value_t(Ts...)>;
+        };
+
+        template<>
+        struct _completion_fn_<false>
+        {
+            //potentially throwing case
+            template<typename... Ts>
+            using call = completion_signatures<set_value_t(Ts...), set_error_t(::std::exception_ptr)>;
+        };
+
+        template <bool Nothrow, class... Ts>
+        using _completion_ = _m_call<_completion_fn_<Nothrow>, Ts...>;
+
+        template <class Fn, class... Ts>
+        using _completion = _completion_<_nothrow_callable<Fn, Ts...>, Ts...>;
+    }
+
+    struct stop_with_t
+    {
+    private:
+        template <class Rcvr, class CvSndr, class Fn>
+        struct USTDEX_TYPE_VISIBILITY_DEFAULT _opstate_t
+        {
+            using operation_state_concept = operation_state_t;
+
+            USTDEX_API _opstate_t(CvSndr&& _sndr, Rcvr _rcvr, Fn _fn)
+                : _rcvr_{ static_cast<Rcvr&&>(_rcvr) }
+                , _fn_{ static_cast<Fn&&>(_fn) }
+                , _opstate_{ ustdex::connect(static_cast<CvSndr&&>(_sndr), _rcvr_ref{*this}) }
+            {}
+
+            USTDEX_IMMOVABLE(_opstate_t);
+
+            USTDEX_API void start() & noexcept
+            {
+                ustdex::start(_opstate_);
+            }
+
+            template <class... Ts>
+            USTDEX_API void set_value(Ts&&... _ts) noexcept
+            {
+                if (static_cast<Fn&&>(_fn_)(static_cast<const Ts&>(_ts)...))
+                {
+                    ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
+                }
+                else
+                {
+                    if constexpr (_nothrow_callable<Fn, Ts...>)
+                    {
+                        ustdex::set_value(static_cast<Rcvr&&>(_rcvr_), static_cast<Ts&&>(_ts)...); //
+                    }
+                    else
+                    {
+                        USTDEX_TRY(                                //
+                            ({                                       //
+                              ustdex::set_value(static_cast<Rcvr&&>(_rcvr_), static_cast<Ts&&>(_ts)...); //
+                                }),                                      //
+                            USTDEX_CATCH(...)                        //
+                            ({                                       //
+                              ustdex::set_error(static_cast<Rcvr&&>(_rcvr_), ::std::current_exception());
+                                })                                       //
+                        )
+                    }
+                }
+            }
+
+            template <class Error>
+            USTDEX_API void set_error(Error&& _error) noexcept
+            {
+                ustdex::set_error(static_cast<Rcvr&&>(_rcvr_), static_cast<Error&&>(_error));
+            }
+
+            USTDEX_API void set_stopped() noexcept
+            {
+                ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
+            }
+
+            USTDEX_API auto get_env() const noexcept -> env_of_t<Rcvr>
+            {
+                return  ustdex::get_env(_rcvr_);
+            }
+
+            Rcvr _rcvr_;
+            Fn _fn_;
+            connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
+        };
+
+        template <class Fn>
+        struct _transform_args_fn
+        {
+            template <class... Ts>
+            USTDEX_API constexpr auto operator()() const
+            {
+                if constexpr (_callable<Fn, Ts...> && std::is_same_v<_call_result_t<Fn, const Ts&...>, bool>)
+                {
+                    return _stop_with::_completion<Fn, Ts...>();
+                }
+                else
+                {
+                    return invalid_completion_signature<WHERE(IN_ALGORITHM, stop_with_t),
+                        WHAT(FUNCTION_IS_NOT_CALLABLE),
+                        WITH_FUNCTION(Fn),
+                        WITH_ARGUMENTS(Ts...)>();
+                }
+            }
+        };
+
+        template <class Sndr, class Fn>
+        struct USTDEX_TYPE_VISIBILITY_DEFAULT _sndr_t
+        {
+            using sender_concept = sender_t;
+            Sndr _sndr_;
+            Fn _fn_;
+
+            template <class Self, class... Env>
+            USTDEX_API static constexpr auto get_completion_signatures()
+            {
+                USTDEX_LET_COMPLETIONS(auto(_child_completions) = get_child_completion_signatures<Self, Sndr, Env...>())
+                {
+                    return transform_completion_signatures(_child_completions, _transform_args_fn<Fn>{}, {}, {}, completion_signatures<set_stopped_t()>{});
+                }
+            }
+
+            template <class Rcvr>
+            USTDEX_API auto connect(Rcvr _rcvr) &&                                         //
+                noexcept(_nothrow_constructible<_opstate_t<Rcvr, Sndr, Fn>, Sndr, Rcvr, Fn>) //
+                -> _opstate_t<Rcvr, Sndr, Fn>
+            {
+                return _opstate_t<Rcvr, Sndr, Fn>{
+                    static_cast<Sndr&&>(_sndr_), static_cast<Rcvr&&>(_rcvr), static_cast<Fn&&>(_fn_)};
+            }
+
+            template <class Rcvr>
+            USTDEX_API auto connect(Rcvr _rcvr) const& //
+                noexcept(_nothrow_constructible<_opstate_t<Rcvr, const Sndr&, Fn>,
+                    const Sndr&,
+                    Rcvr,
+                    const Fn&>) //
+                -> _opstate_t<Rcvr, const Sndr&, Fn>
+            {
+                return _opstate_t<Rcvr, const Sndr&, Fn>{_sndr_, static_cast<Rcvr&&>(_rcvr), _fn_};
+            }
+
+            USTDEX_API env_of_t<Sndr> get_env() const noexcept
+            {
+                return ustdex::get_env(_sndr_);
+            }
+        };
+
+    public:
+        template <class Sndr, class Fn>
+        USTDEX_TRIVIAL_API auto operator()(Sndr _sndr, Fn _fn) const noexcept //
+            -> _sndr_t<Sndr, Fn>
+        {
+            // If the incoming sender is non-dependent, we can check the completion
+            // signatures of the composed sender immediately.
+            if constexpr (!dependent_sender<Sndr>)
+            {
+                using _completions = completion_signatures_of_t<_sndr_t<Sndr, Fn>>;
+                static_assert(_valid_completion_signatures<_completions>);
+            }
+            return _sndr_t<Sndr, Fn>{static_cast<Sndr&&>(_sndr), static_cast<Fn&&>(_fn)};
+        }
+
+        template <class Fn>
+        USTDEX_TRIVIAL_API auto operator()(Fn _fn) const noexcept -> binder_closure<stop_with_t, Fn>
+        {
+            return binder_closure<stop_with_t, Fn>{static_cast<Fn&&>(_fn)};
+        }
+    };
+
+
+    inline constexpr stop_with_t stop_with{};
+}
+
+#include "epilogue.hpp"
\ No newline at end of file
diff --git a/include/ustdex/detail/tuple.hpp b/include/ustdex/detail/tuple.hpp
index b97f3b8..3037bf0 100644
--- a/include/ustdex/detail/tuple.hpp
+++ b/include/ustdex/detail/tuple.hpp
@@ -75,20 +75,8 @@ using _apply_result_t = decltype(declval<Tupl>().apply(declval<Fn>(), declval<Tu
 
 namespace detail
 {
-#if USTDEX_MSVC()
-template <class... Ts>
-struct _mk_tuple_
-{
-  using _indices_t = std::make_index_sequence<sizeof...(Ts)>;
-  using type       = _tupl<_indices_t, Ts...>;
-};
-
-template <class... Ts>
-using _tuple = typename _mk_tuple_<Ts...>::type;
-#else
-template <class... Ts>
-using _tuple = _tupl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
-#endif
+    template <class... Ts>
+    using _tuple = _tupl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;
 } // namespace detail
 
 template <class... Ts>
diff --git a/include/ustdex/detail/when_any.hpp b/include/ustdex/detail/when_any.hpp
new file mode 100644
index 0000000..283c0ea
--- /dev/null
+++ b/include/ustdex/detail/when_any.hpp
@@ -0,0 +1,427 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef USTDEX_ASYNC_DETAIL_WHEN_ANY
+#define USTDEX_ASYNC_DETAIL_WHEN_ANY
+
+#include "completion_signatures.hpp"
+#include "concepts.hpp"
+#include "config.hpp"
+#include "cpos.hpp"
+#include "env.hpp"
+#include "exception.hpp"
+#include "exclusive_scan.hpp"
+#include "lazy.hpp"
+#include "meta.hpp"
+#include "stop_token.hpp"
+#include "tuple.hpp"
+#include "type_traits.hpp"
+#include "utility.hpp"
+#include "variant.hpp"
+
+#include <array>
+#include <utility>
+
+#include "prologue.hpp"
+
+namespace ustdex
+{
+
+	namespace _when_any 
+	{
+		template <class Rcvr>
+		struct visitor_fn
+		{
+			Rcvr& _rcvr;
+
+			template <std::size_t... I, class Tag, class... As>
+			void operator()(_tupl<std::index_sequence<I...>, Tag, As...> result) noexcept
+			{
+				result.apply(
+					[this](Tag tag, As&... args) noexcept
+					{
+						tag(static_cast<Rcvr&&>(_rcvr), static_cast<As&&>(args)...);
+					},
+					result);
+			}
+		};
+
+		template <class Rcvr>
+		auto _make_visitor_fn(Rcvr& _rcvr) noexcept
+		{
+			return visitor_fn<Rcvr>{_rcvr};
+		}
+	}
+
+	struct USTDEX_TYPE_VISIBILITY_DEFAULT when_any_t
+	{
+	private:
+		template <class... Sndrs>
+		struct USTDEX_TYPE_VISIBILITY_DEFAULT _sndr_t;
+
+		// Extract the first template parameter of the _state_t specialization.
+		// The first template parameter is the receiver type.
+		template <class State>
+		using _rcvr_from_state_t = _m_apply<_m_at<0>, State>;
+
+		// Returns the completion signatures of a child sender. Throws an exception if
+		// the child sender has more than one set_value completion signature.
+		template <class Child, class... Env>
+		USTDEX_API static constexpr auto _child_completions();
+
+		// Merges the completion signatures of the child senders into a single set of
+		// completion signatures for the when_all sender.
+		template <class... Completions>
+		USTDEX_API static constexpr auto _merge_completions(Completions...);
+
+		/// The receivers connected to the when_all's sub-operations expose this as
+		/// their environment. Its `get_stop_token` query returns the token from
+		/// when_all's stop source. All other queries are forwarded to the outer
+		/// receiver's environment.
+		template <class StateZip>
+		struct USTDEX_TYPE_VISIBILITY_DEFAULT _env_t
+		{
+			using _state_t = _unzip<StateZip>;
+			using _rcvr_t = _rcvr_from_state_t<_state_t>;
+
+			_state_t& _state_;
+
+			USTDEX_API inplace_stop_token query(get_stop_token_t) const noexcept
+			{
+				return _state_._stop_token_;
+			}
+
+			// TODO: only forward the "forwarding" queries
+			template <class Tag>
+			USTDEX_API auto query(Tag) const noexcept -> _query_result_t<Tag, env_of_t<_rcvr_t>>
+			{
+				return ustdex::get_env(_state_._rcvr_).query(Tag());
+			}
+		};
+
+		template <class StateZip>
+		struct USTDEX_TYPE_VISIBILITY_DEFAULT _rcvr_t
+		{
+			using receiver_concept = receiver_t;
+			using _state_t = _unzip<StateZip>;
+
+			_state_t& _state_;
+
+			template <class... Ts>
+			USTDEX_TRIVIAL_API void set_value(Ts&&... _ts) noexcept
+			{
+				_state_.notify(ustdex::set_value, static_cast<Ts&&>(_ts)...);
+			}
+
+			template <class Error>
+			USTDEX_TRIVIAL_API void set_error(Error&& _error) noexcept
+			{
+				_state_.notify(ustdex::set_error, static_cast<Error&&>(_error));
+			}
+
+			USTDEX_API void set_stopped() noexcept
+			{
+				_state_.notify(ustdex::set_stopped);
+			}
+
+			USTDEX_API auto get_env() const noexcept -> _env_t<StateZip>
+			{
+				return { _state_ };
+			}
+		};
+
+		/// @brief The data stored in the operation state and referred to
+		/// by the receiver.
+		/// @tparam Rcvr The receiver connected to the when_all sender.
+		/// @tparam CvFn A metafunction to apply cv- and ref-qualifiers to the senders
+		/// @tparam Sndrs A tuple of the when_all sender's child senders.
+		template <class Rcvr, class CvFn, class Sndrs>
+		struct _state_t;
+
+		template<typename Tag>
+		struct transform_impl
+		{
+			template <class... Ts>
+			auto operator ()() const
+			{
+				return _tuple<Tag, Ts...>{};
+			}
+		};
+
+
+		template <class Rcvr, class CvFn, class Idx, class... Sndrs>
+		struct _state_t<Rcvr, CvFn, _tupl<Idx, Sndrs...>>
+		{
+			using _env_t = when_any_t::_env_t<_zip<_state_t>>;
+			using _sndr_t = when_any_t::_sndr_t<Sndrs...>;
+			using _cv_sndr_t = _m_call1<CvFn, _sndr_t>;
+
+			using _completions_t = completion_signatures_of_t<_sndr_t, _env_t>;
+
+			using _result_t = typename _completions_t::template _transform_q<_decayed_tuple, _variant>;
+			using _stop_tok_t = stop_token_of_t<env_of_t<Rcvr>>;
+			using _stop_callback_t = stop_callback_for_t<_stop_tok_t, _on_stop_request>;
+
+			USTDEX_API explicit _state_t(Rcvr _rcvr, std::size_t _count)
+				: _rcvr_{ static_cast<Rcvr&&>(_rcvr) }
+				, _count_{ _count }
+				, _stop_source_{}
+				, _stop_token_{ _stop_source_.get_token() }
+				, _result_{}
+				, _on_stop_{}
+			{}
+
+			template <class Tag, class... Args>
+			void notify(Tag tag, Args&&... args) noexcept
+			{
+				using result_t = _decayed_tuple<Tag, Args...>;
+				bool expect = false;
+				if (_emplaced_.compare_exchange_strong(expect, true, std::memory_order_relaxed, std::memory_order_relaxed))
+				{
+					// This emplacement can happen only once
+					if constexpr ((_nothrow_decay_copyable<Args> && ...))
+					{
+						_result_.template _emplace<result_t>(tag, static_cast<Args&&>(args)...);
+					}
+					else
+					{
+						try
+						{
+							_result_.template _emplace<result_t>(tag, static_cast<Args&&>(args)...);
+						}
+						catch (...)
+						{
+							using error_t = _tuple<set_error_t, std::exception_ptr>;
+							_result_.template _emplace<error_t>(set_error, std::current_exception());
+						}
+					}
+					// stop pending operations
+					_stop_source_.request_stop();
+				}
+				// make __result_ emplacement visible when __count_ goes from one to zero
+				// This relies on the fact that each sender will call notify() at most once
+				if (_count_.fetch_sub(1, std::memory_order_acq_rel) == 1)
+				{
+					_on_stop_.destroy();
+					auto stop_token = get_stop_token(get_env(_rcvr_));
+					if (stop_token.stop_requested())
+					{
+						ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
+						return;
+					}
+					_result_._visit(_when_any::_make_visitor_fn(_rcvr_), static_cast<_result_t&&>(_result_));
+				}
+			}
+
+			Rcvr _rcvr_;
+			std::atomic<std::size_t> _count_;
+			inplace_stop_source _stop_source_;
+			inplace_stop_token _stop_token_;
+			// USTDEX_NO_UNIQUE_ADDRESS // gcc doesn't like this
+			_result_t _result_;
+			_lazy<_stop_callback_t> _on_stop_;
+			std::atomic<bool> _emplaced_{ false };
+		};
+
+		/// The operation state for when_all
+		template <class, class, class>
+		struct USTDEX_TYPE_VISIBILITY_DEFAULT _opstate_t;
+
+		template <class Rcvr, class CvFn, class... Sndrs>
+		struct USTDEX_TYPE_VISIBILITY_DEFAULT _opstate_t<Rcvr, CvFn, _tuple<Sndrs...>>
+		{
+			using operation_state_concept = operation_state_t;
+			using _sndrs_t = _m_call<CvFn, _tuple<Sndrs...>>;
+			using _state_t = when_any_t::_state_t<Rcvr, CvFn, _tuple<Sndrs...>>;
+
+			// This function object is used to connect all the sub-operations with
+			// receivers, each of which knows which elements in the values tuple it
+			// is responsible for setting.
+			struct _connect_subs_fn
+			{
+				template <class... CvSndrs>
+				USTDEX_API auto operator()(_state_t& _state, CvSndrs&&... _sndrs_) const
+				{
+					using _state_ref_t = _zip<_state_t>;
+					return _tupl{
+					  ustdex::connect(static_cast<CvSndrs&&>(_sndrs_), _rcvr_t<_state_ref_t>{_state})... };
+				}
+			};
+
+			// This is a tuple of operation states for the sub-operations.
+			using _sub_opstates_t = _apply_result_t<_connect_subs_fn, _sndrs_t, _state_t&>;
+
+			_state_t _state_;
+			_sub_opstates_t _sub_ops_;
+
+			/// Initialize the data member, connect all the sub-operations and
+			/// save the resulting operation states in _sub_ops_.
+			USTDEX_API _opstate_t(_sndrs_t&& _sndrs_, Rcvr _rcvr)
+				: _state_{ static_cast<Rcvr&&>(_rcvr), sizeof...(Sndrs) }
+				, _sub_ops_{ _sndrs_.apply(_connect_subs_fn(), static_cast<_sndrs_t&&>(_sndrs_), _state_) }
+			{}
+
+			USTDEX_IMMOVABLE(_opstate_t);
+
+			/// Start all the sub-operations.
+			USTDEX_API void start() & noexcept
+			{
+				// register stop callback:
+				_state_._on_stop_.construct(
+					get_stop_token(ustdex::get_env(_state_._rcvr_)), _on_stop_request{ _state_._stop_source_ });
+
+				if (_state_._stop_source_.stop_requested())
+				{
+					// Manually clean up the stop callback. We won't be starting the
+					// sub-operations, so they won't complete and clean up for us.
+					_state_._on_stop_.destroy();
+
+					// Stop has already been requested. Don't bother starting the child
+					// operations.
+					ustdex::set_stopped(static_cast<Rcvr&&>(_state_._rcvr_));
+				}
+				else
+				{
+					// Start all the sub-operations.
+					_sub_ops_.for_each(ustdex::start, _sub_ops_);
+
+					// If there are no sub-operations, we're done.
+					if constexpr (sizeof...(Sndrs) == 0)
+					{
+						_state_._complete();
+					}
+				}
+			}
+		};
+
+		template <class... Ts>
+		using _decay_all = _m_list<std::decay_t<Ts>...>;
+
+	public:
+		template <class... Sndrs>
+		USTDEX_API auto operator()(Sndrs... _sndrs) const->_sndr_t<Sndrs...>;
+	};
+
+	template <class Child, class... Env>
+	USTDEX_API constexpr auto when_any_t::_child_completions()
+	{
+		using _env_t = prop<get_stop_token_t, inplace_stop_token>;
+		USTDEX_LET_COMPLETIONS(auto(_completions) = get_completion_signatures<Child, env<_env_t, FWD_ENV_T<Env>...>>())
+		{
+			if constexpr (_completions.count(set_value) > 1)
+			{
+				return invalid_completion_signature<WHERE(IN_ALGORITHM, when_any_t),
+					WHAT(SENDER_HAS_TOO_MANY_SUCCESS_COMPLETIONS),
+					WITH_SENDER(Child)>();
+			}
+			else
+			{
+				return _completions;
+			}
+		}
+	}
+
+	USTDEX_PRAGMA_PUSH()
+		USTDEX_PRAGMA_IGNORE_GNU("-Wunused-value")
+
+		template <class... Completions>
+	USTDEX_API constexpr auto when_any_t::_merge_completions(Completions... _cs)
+	{
+		// Use USTDEX_LET_COMPLETIONS to ensure all completions are valid:
+		USTDEX_LET_COMPLETIONS(auto(_tmp) = (completion_signatures{}, ..., _cs)) // NB: uses overloaded comma operator
+		{
+			std::ignore = _tmp;                                    // silence unused variable warning
+			auto _non_value_completions = concat_completion_signatures(
+				completion_signatures<set_stopped_t()>(),
+				transform_completion_signatures(_cs, _swallow_transform(), _decay_transform<set_error_t>())...);
+
+			if constexpr (((0 == _cs.count(set_value)) || ...))
+			{
+				// at least one child sender has no value completions at all, so the
+				// when_all will never complete with set_value. return just the error and
+				// stopped completions.
+				return _non_value_completions;
+			}
+			else
+			{
+				// All child senders have exactly one value completion signature, each of
+				// which may have multiple arguments. Concatenate all the arguments into a
+				// single set_value_t completion signature.
+				auto _values = concat_completion_signatures(_cs.select(ustdex::set_value)...);
+				//auto mm = std::make_tuple(_cs.select<set_value_t>(ustdex::set_value)...);
+				// Add the value completion to the error and stopped completions.
+				auto _local = _non_value_completions + _values;
+				// Check if any of the values or errors are not nothrow decay-copyable.
+				constexpr bool _all_nothrow_decay_copyable =
+					(_value_types<Completions, _nothrow_decay_copyable_t, _identity_t>::value && ...);
+				return _local + _eptr_completion_if<!_all_nothrow_decay_copyable>();
+			}
+		}
+	}
+
+	USTDEX_PRAGMA_POP()
+
+		// The sender for when_all
+		template <class... Sndrs>
+	struct USTDEX_TYPE_VISIBILITY_DEFAULT when_any_t::_sndr_t
+	{
+		using sender_concept = sender_t;
+		using _sndrs_t = _tuple<Sndrs...>;
+
+		USTDEX_NO_UNIQUE_ADDRESS when_any_t _tag_;
+		USTDEX_NO_UNIQUE_ADDRESS _ignore _ignore1_;
+		_sndrs_t _sndrs_;
+
+		template <class Self, class... Env>
+		USTDEX_API static constexpr auto get_completion_signatures()
+		{
+			return _merge_completions(_child_completions<_copy_cvref_t<Self, Sndrs>, Env...>()...);
+		}
+
+		template <class Rcvr>
+		USTDEX_API auto connect(Rcvr _rcvr) && -> _opstate_t<Rcvr, _cp, _sndrs_t>
+		{
+			return _opstate_t<Rcvr, _cp, _sndrs_t>(static_cast<_sndrs_t&&>(_sndrs_), static_cast<Rcvr&&>(_rcvr));
+		}
+
+		template <class Rcvr>
+		USTDEX_API auto connect(Rcvr _rcvr) const& -> _opstate_t<Rcvr, _cpclr, _sndrs_t>
+		{
+			return _opstate_t<Rcvr, _cpclr, _sndrs_t>(_sndrs_, static_cast<Rcvr&&>(_rcvr));
+		}
+	};
+
+	template <class... Sndrs>
+	USTDEX_API auto when_any_t::operator()(Sndrs... _sndrs) const -> _sndr_t<Sndrs...>
+	{
+		// If the incoming senders are non-dependent, we can check the completion
+		// signatures of the composed sender immediately.
+		if constexpr (((!dependent_sender<Sndrs>) && ...))
+		{
+			using _completions = completion_signatures_of_t<_sndr_t<Sndrs...>>;
+			static_assert(_valid_completion_signatures<_completions>);
+		}
+		return _sndr_t<Sndrs...>{{}, {}, { static_cast<Sndrs&&>(_sndrs)... }};
+	}
+
+	inline constexpr when_any_t when_any{};
+
+} // namespace ustdex
+
+#include "epilogue.hpp"
+
+#endif
diff --git a/include/ustdex/ustdex.hpp b/include/ustdex/ustdex.hpp
index ab738d8..3133002 100644
--- a/include/ustdex/ustdex.hpp
+++ b/include/ustdex/ustdex.hpp
@@ -34,4 +34,7 @@
 #include "detail/then.hpp"           // IWYU pragma: export
 #include "detail/thread_context.hpp" // IWYU pragma: export
 #include "detail/when_all.hpp"       // IWYU pragma: export
+#include "detail/when_any.hpp"      // IWYU pragma: export
 #include "detail/write_env.hpp"      // IWYU pragma: export
+#include "detail/stop_when.hpp"      // IWYU pragma: export
+#include "detail/stop_with.hpp"      // IWYU pragma: export
\ No newline at end of file

From 40b087f37d3c595cc530b13a55f6611f93a36c0d Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Sun, 27 Jul 2025 15:44:25 +0800
Subject: [PATCH 03/12] =?UTF-8?q?=E4=BC=98=E5=8C=96?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/scratch.cpp                     |  8 +--
 include/ustdex/detail/binder_closure.hpp |  4 +-
 include/ustdex/detail/starts_on.hpp      |  4 +-
 include/ustdex/detail/when_any.hpp       | 75 ++++--------------------
 4 files changed, 21 insertions(+), 70 deletions(-)

diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index f25c52f..daacee9 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -58,13 +58,13 @@ static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
 int main()
 {
-	{
+	/*{
 		using CS = completion_signatures<set_value_t(int, double), set_value_t(float, char)>;
 		CS cs{};
 		auto c = cs.select(set_value);
 
 		_whatis<decltype(c)>();
-	}
+	}*/
 
 	thread_context ctx;
 	auto sch = ctx.get_scheduler();
@@ -175,14 +175,14 @@ int main()
 	}
 
 	{
-		/*auto task = when_any(just(5), just('a'), just(3.14)) | 
+		auto task = when_any(just(5), just('a'), just(3.14)) | 
 			then([](std::any v)
 				{
 					int aa = 0;
 				});
 
 		auto op = connect(std::move(task), sink{});
-		start(op);*/
+		start(op);
 
 		//using TA = completion_signatures_of_t<decltype(task)>;
 		//_m_self_or<_nil>::call
diff --git a/include/ustdex/detail/binder_closure.hpp b/include/ustdex/detail/binder_closure.hpp
index 48c93b9..e921923 100644
--- a/include/ustdex/detail/binder_closure.hpp
+++ b/include/ustdex/detail/binder_closure.hpp
@@ -14,7 +14,7 @@ namespace ustdex
 	{
 		_tuple<Args...> _args_;
 
-		binder_closure(Args... args) noexcept :_args_({ static_cast<Args&&>(args)... })
+		binder_closure(Args... args) noexcept : _args_({ static_cast<Args&&>(args)... })
 		{}
 
 		template<class Sndr, std::size_t... I>
@@ -30,7 +30,7 @@ namespace ustdex
 		}
 
 		template <class Sndr>
-		USTDEX_TRIVIAL_API friend auto operator|(Sndr sndr, binder_closure&& self) noexcept ->_call_result_t<bind_t, Sndr, Args...>
+		USTDEX_TRIVIAL_API friend auto operator|(Sndr sndr, binder_closure self) noexcept ->_call_result_t<bind_t, Sndr, Args...>
 		{
 			return self.make(static_cast<Sndr&&>(sndr), static_cast<_tuple<Args...>&&>(self._args_), std::make_index_sequence<sizeof...(Args)>());
 		}
diff --git a/include/ustdex/detail/starts_on.hpp b/include/ustdex/detail/starts_on.hpp
index 7224785..ecc4c84 100644
--- a/include/ustdex/detail/starts_on.hpp
+++ b/include/ustdex/detail/starts_on.hpp
@@ -122,9 +122,9 @@ struct USTDEX_TYPE_VISIBILITY_DEFAULT start_on_t::_sndr_t
     return _opstate_t<Rcvr, Sch, const Sndr&>{_sch_, static_cast<Rcvr&&>(_rcvr), _sndr_};
   }
 
-  USTDEX_API env_of_t<Sndr> get_env() const noexcept
+  USTDEX_API env<env_of_t<Sndr>, prop<get_scheduler_t, Sch>> get_env() const noexcept
   {
-    return ustdex::get_env(_sndr_);
+    return env{ ustdex::get_env(_sndr_), prop(get_scheduler, _sch_) };
   }
 };
 
diff --git a/include/ustdex/detail/when_any.hpp b/include/ustdex/detail/when_any.hpp
index 283c0ea..2d330ef 100644
--- a/include/ustdex/detail/when_any.hpp
+++ b/include/ustdex/detail/when_any.hpp
@@ -46,7 +46,7 @@ namespace ustdex
 		template <class Rcvr>
 		struct visitor_fn
 		{
-			Rcvr& _rcvr;
+			Rcvr _rcvr;
 
 			template <std::size_t... I, class Tag, class... As>
 			void operator()(_tupl<std::index_sequence<I...>, Tag, As...> result) noexcept
@@ -60,11 +60,6 @@ namespace ustdex
 			}
 		};
 
-		template <class Rcvr>
-		auto _make_visitor_fn(Rcvr& _rcvr) noexcept
-		{
-			return visitor_fn<Rcvr>{_rcvr};
-		}
 	}
 
 	struct USTDEX_TYPE_VISIBILITY_DEFAULT when_any_t
@@ -80,14 +75,9 @@ namespace ustdex
 
 		// Returns the completion signatures of a child sender. Throws an exception if
 		// the child sender has more than one set_value completion signature.
-		template <class Child, class... Env>
+		template <class Parent, class Child, class... Env>
 		USTDEX_API static constexpr auto _child_completions();
 
-		// Merges the completion signatures of the child senders into a single set of
-		// completion signatures for the when_all sender.
-		template <class... Completions>
-		USTDEX_API static constexpr auto _merge_completions(Completions...);
-
 		/// The receivers connected to the when_all's sub-operations expose this as
 		/// their environment. Its `get_stop_token` query returns the token from
 		/// when_all's stop source. All other queries are forwarded to the outer
@@ -152,17 +142,6 @@ namespace ustdex
 		template <class Rcvr, class CvFn, class Sndrs>
 		struct _state_t;
 
-		template<typename Tag>
-		struct transform_impl
-		{
-			template <class... Ts>
-			auto operator ()() const
-			{
-				return _tuple<Tag, Ts...>{};
-			}
-		};
-
-
 		template <class Rcvr, class CvFn, class Idx, class... Sndrs>
 		struct _state_t<Rcvr, CvFn, _tupl<Idx, Sndrs...>>
 		{
@@ -223,7 +202,7 @@ namespace ustdex
 						ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
 						return;
 					}
-					_result_._visit(_when_any::_make_visitor_fn(_rcvr_), static_cast<_result_t&&>(_result_));
+					_result_._visit(_when_any::visitor_fn<Rcvr>{static_cast<Rcvr&&>(_rcvr_)}, static_cast<_result_t&&>(_result_));
 				}
 			}
 
@@ -316,11 +295,11 @@ namespace ustdex
 		USTDEX_API auto operator()(Sndrs... _sndrs) const->_sndr_t<Sndrs...>;
 	};
 
-	template <class Child, class... Env>
+	template <class Parent, class Child, class... Env>
 	USTDEX_API constexpr auto when_any_t::_child_completions()
 	{
 		using _env_t = prop<get_stop_token_t, inplace_stop_token>;
-		USTDEX_LET_COMPLETIONS(auto(_completions) = get_completion_signatures<Child, env<_env_t, FWD_ENV_T<Env>...>>())
+		USTDEX_LET_COMPLETIONS(auto(_completions) = ustdex::get_child_completion_signatures<Parent, Child, env<_env_t, FWD_ENV_T<Env>...>>())
 		{
 			if constexpr (_completions.count(set_value) > 1)
 			{
@@ -338,41 +317,6 @@ namespace ustdex
 	USTDEX_PRAGMA_PUSH()
 		USTDEX_PRAGMA_IGNORE_GNU("-Wunused-value")
 
-		template <class... Completions>
-	USTDEX_API constexpr auto when_any_t::_merge_completions(Completions... _cs)
-	{
-		// Use USTDEX_LET_COMPLETIONS to ensure all completions are valid:
-		USTDEX_LET_COMPLETIONS(auto(_tmp) = (completion_signatures{}, ..., _cs)) // NB: uses overloaded comma operator
-		{
-			std::ignore = _tmp;                                    // silence unused variable warning
-			auto _non_value_completions = concat_completion_signatures(
-				completion_signatures<set_stopped_t()>(),
-				transform_completion_signatures(_cs, _swallow_transform(), _decay_transform<set_error_t>())...);
-
-			if constexpr (((0 == _cs.count(set_value)) || ...))
-			{
-				// at least one child sender has no value completions at all, so the
-				// when_all will never complete with set_value. return just the error and
-				// stopped completions.
-				return _non_value_completions;
-			}
-			else
-			{
-				// All child senders have exactly one value completion signature, each of
-				// which may have multiple arguments. Concatenate all the arguments into a
-				// single set_value_t completion signature.
-				auto _values = concat_completion_signatures(_cs.select(ustdex::set_value)...);
-				//auto mm = std::make_tuple(_cs.select<set_value_t>(ustdex::set_value)...);
-				// Add the value completion to the error and stopped completions.
-				auto _local = _non_value_completions + _values;
-				// Check if any of the values or errors are not nothrow decay-copyable.
-				constexpr bool _all_nothrow_decay_copyable =
-					(_value_types<Completions, _nothrow_decay_copyable_t, _identity_t>::value && ...);
-				return _local + _eptr_completion_if<!_all_nothrow_decay_copyable>();
-			}
-		}
-	}
-
 	USTDEX_PRAGMA_POP()
 
 		// The sender for when_all
@@ -389,7 +333,14 @@ namespace ustdex
 		template <class Self, class... Env>
 		USTDEX_API static constexpr auto get_completion_signatures()
 		{
-			return _merge_completions(_child_completions<_copy_cvref_t<Self, Sndrs>, Env...>()...);
+
+			auto cs = concat_completion_signatures(
+				_child_completions<Self, Sndrs, Env...>()..., completion_signatures<set_stopped_t()>{});
+
+			using Completions = decltype(cs);
+
+			constexpr bool _all_nothrow_decay_copyable = _value_types<Completions, _nothrow_decay_copyable_t, std::conjunction>::value;
+			return cs + _eptr_completion_if<!_all_nothrow_decay_copyable>();
 		}
 
 		template <class Rcvr>

From e6347705b3fc979a84374f27428389832bad7c44 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Tue, 29 Jul 2025 21:25:13 +0800
Subject: [PATCH 04/12] =?UTF-8?q?=E4=BF=AE=E5=A4=8Denv=E7=9A=84=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/scratch.cpp                   | 46 ++++++++++++++++++++------
 include/ustdex/detail/conditional.hpp  |  2 +-
 include/ustdex/detail/continues_on.hpp |  2 +-
 include/ustdex/detail/let_value.hpp    |  2 +-
 include/ustdex/detail/rcvr_ref.hpp     |  4 +--
 include/ustdex/detail/sequence.hpp     |  2 +-
 include/ustdex/detail/starts_on.hpp    |  2 +-
 include/ustdex/detail/stop_when.hpp    |  2 +-
 include/ustdex/detail/stop_with.hpp    |  6 ++--
 include/ustdex/detail/then.hpp         |  2 +-
 10 files changed, 49 insertions(+), 21 deletions(-)

diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index daacee9..c77e3b3 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -47,25 +47,51 @@ struct sink
 	void set_error(std::exception_ptr) noexcept {}
 
 	void set_stopped() noexcept {}
+
+	[[nodiscard]]
+	prop<get_stop_token_t, inplace_stop_token> get_env() const noexcept
+	{
+		static inplace_stop_source _stop_source_;
+		return prop{ get_stop_token, _stop_source_.get_token() };
+	}
 };
 
 template <class>
 [[deprecated]] void print()
 {}
 
-static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
+static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
 int main()
 {
-	/*{
-		using CS = completion_signatures<set_value_t(int, double), set_value_t(float, char)>;
-		CS cs{};
-		auto c = cs.select(set_value);
+#if 0
+	auto task = read_env(get_stop_token)
+		| then([](auto stop_token)
+			{
+				std::cout << "Stop token: " << stop_token.stop_requested() << '\n';
+				return 42;
+			})
+		| then([](int i)
+			{
+				std::cout << "Value: " << i << '\n';
+				return i + 1;
+			});
 
-		_whatis<decltype(c)>();
-	}*/
+	auto task2 = when_all(task);
 
+	//using TT = completion_signatures_of_t<decltype(task)>;
+
+	//_whatis<TT>();
+
+	auto op = connect(task2, sink{});
+
+	start(op);
+
+	//auto [sch2] = sync_wait(read_env(get_scheduler)).value();
+#endif
+
+#if 1
 	thread_context ctx;
 	auto sch = ctx.get_scheduler();
 
@@ -167,7 +193,7 @@ int main()
 						std::cout << "Error: " << ex.what() << '\n';
 					}
 				});
-		
+
 		auto op = connect(std::move(task), sink{});
 		start(op);
 		//sync_wait(std::move(task));
@@ -175,7 +201,7 @@ int main()
 	}
 
 	{
-		auto task = when_any(just(5), just('a'), just(3.14)) | 
+		auto task = when_any(just(5), just('a'), just(3.14)) |
 			then([](std::any v)
 				{
 					int aa = 0;
@@ -192,5 +218,5 @@ int main()
 	}
 
 
-
+#endif
 }
diff --git a/include/ustdex/detail/conditional.hpp b/include/ustdex/detail/conditional.hpp
index a530afc..c7ece94 100644
--- a/include/ustdex/detail/conditional.hpp
+++ b/include/ustdex/detail/conditional.hpp
@@ -165,7 +165,7 @@ struct _cond_t
 
     Rcvr _rcvr_;
     _data_t _data_;
-    connect_result_t<Sndr, _rcvr_ref<_opstate>> _op_;
+    connect_result_t<Sndr, _rcvr_ref<_opstate, _env_t>> _op_;
     _next_ops_variant_t _ops_;
   };
 
diff --git a/include/ustdex/detail/continues_on.hpp b/include/ustdex/detail/continues_on.hpp
index 65c4871..87a5bcb 100644
--- a/include/ustdex/detail/continues_on.hpp
+++ b/include/ustdex/detail/continues_on.hpp
@@ -155,7 +155,7 @@ struct USTDEX_TYPE_VISIBILITY_DEFAULT continue_on_t
     }
 
     _rcvr_t<Rcvr, _result_t> _rcvr_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate1_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
     connect_result_t<schedule_result_t<Sch>, _rcvr_ref<_rcvr_t<Rcvr, _result_t>>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/let_value.hpp b/include/ustdex/detail/let_value.hpp
index 647295f..4dbfb8b 100644
--- a/include/ustdex/detail/let_value.hpp
+++ b/include/ustdex/detail/let_value.hpp
@@ -167,7 +167,7 @@ struct _let
     Rcvr _rcvr_;
     Fn _fn_;
     _results<CvSndr, _env_t> _result_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate1_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
     _opstate_variant_t _opstate2_;
   };
 
diff --git a/include/ustdex/detail/rcvr_ref.hpp b/include/ustdex/detail/rcvr_ref.hpp
index bbbc7bd..6ec59e5 100644
--- a/include/ustdex/detail/rcvr_ref.hpp
+++ b/include/ustdex/detail/rcvr_ref.hpp
@@ -25,7 +25,7 @@
 
 namespace ustdex
 {
-template <class _Rcvr>
+template <class _Rcvr, class _Env = env_of_t<_Rcvr>>
 struct _rcvr_ref
 {
   using receiver_concept = receiver_t;
@@ -48,7 +48,7 @@ struct _rcvr_ref
     static_cast<_Rcvr&&>(_rcvr_).set_stopped();
   }
 
-  USTDEX_API auto get_env() const noexcept
+  USTDEX_API auto get_env() const noexcept -> _Env
   {
     return ustdex::get_env(_rcvr_);
   }
diff --git a/include/ustdex/detail/sequence.hpp b/include/ustdex/detail/sequence.hpp
index 767700e..11c036b 100644
--- a/include/ustdex/detail/sequence.hpp
+++ b/include/ustdex/detail/sequence.hpp
@@ -82,7 +82,7 @@ struct _seq
     }
 
     _rcvr_t _rcvr_;
-    connect_result_t<_sndr1_t, _rcvr_ref<_opstate>> _opstate1_;
+    connect_result_t<_sndr1_t, _rcvr_ref<_opstate, _env_t>> _opstate1_;
     connect_result_t<_sndr2_t, _rcvr_ref<_rcvr_t>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/starts_on.hpp b/include/ustdex/detail/starts_on.hpp
index ecc4c84..953108e 100644
--- a/include/ustdex/detail/starts_on.hpp
+++ b/include/ustdex/detail/starts_on.hpp
@@ -72,7 +72,7 @@ inline constexpr struct start_on_t
       return ustdex::get_env(this->base());
     }
 
-    connect_result_t<schedule_result_t<Sch&>, _rcvr_ref<_opstate_t>> _opstate1_;
+    connect_result_t<schedule_result_t<Sch&>, _rcvr_ref<_opstate_t, _env_t>> _opstate1_;
     connect_result_t<CvSndr, _rcvr_ref<_rcvr_with_sch_t>> _opstate2_;
   };
 
diff --git a/include/ustdex/detail/stop_when.hpp b/include/ustdex/detail/stop_when.hpp
index 697c3d6..75f1428 100644
--- a/include/ustdex/detail/stop_when.hpp
+++ b/include/ustdex/detail/stop_when.hpp
@@ -81,7 +81,7 @@ namespace ustdex
 			inplace_stop_source _stop_source_;
             _lazy<_stop_callback_t1> _on_stop1_;
             _lazy<_stop_callback_t2> _on_stop2_;
-            connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
+            connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate_;
         };
 
         template <class Sndr, class Token>
diff --git a/include/ustdex/detail/stop_with.hpp b/include/ustdex/detail/stop_with.hpp
index e502b96..96c23aa 100644
--- a/include/ustdex/detail/stop_with.hpp
+++ b/include/ustdex/detail/stop_with.hpp
@@ -45,6 +45,8 @@ namespace ustdex
         {
             using operation_state_concept = operation_state_t;
 
+			using _env_t = env_of_t<Rcvr>;
+
             USTDEX_API _opstate_t(CvSndr&& _sndr, Rcvr _rcvr, Fn _fn)
                 : _rcvr_{ static_cast<Rcvr&&>(_rcvr) }
                 , _fn_{ static_cast<Fn&&>(_fn) }
@@ -97,14 +99,14 @@ namespace ustdex
                 ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr_));
             }
 
-            USTDEX_API auto get_env() const noexcept -> env_of_t<Rcvr>
+            USTDEX_API auto get_env() const noexcept -> _env_t
             {
                 return  ustdex::get_env(_rcvr_);
             }
 
             Rcvr _rcvr_;
             Fn _fn_;
-            connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
+            connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate_;
         };
 
         template <class Fn>
diff --git a/include/ustdex/detail/then.hpp b/include/ustdex/detail/then.hpp
index 4b4b576..16da99e 100644
--- a/include/ustdex/detail/then.hpp
+++ b/include/ustdex/detail/then.hpp
@@ -176,7 +176,7 @@ struct _upon_t
 
     Rcvr _rcvr_;
     Fn _fn_;
-    connect_result_t<CvSndr, _rcvr_ref<_opstate_t>> _opstate_;
+    connect_result_t<CvSndr, _rcvr_ref<_opstate_t, _env_t>> _opstate_;
   };
 
   template <class Fn>

From 480d0bc1287f30c6b2474285896ff2311a9fcea8 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Fri, 1 Aug 2025 23:58:02 +0800
Subject: [PATCH 05/12] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E5=B9=B6=E5=8F=91sort?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/scratch.cpp                         | 102 ++++++++++++++++++-
 include/ustdex/detail/conditional.hpp        |   2 +-
 include/ustdex/detail/static_thread_pool.hpp |  56 ++++++++++
 include/ustdex/ustdex.hpp                    |   3 +-
 4 files changed, 160 insertions(+), 3 deletions(-)
 create mode 100644 include/ustdex/detail/static_thread_pool.hpp

diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index c77e3b3..7fbba88 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -21,6 +21,7 @@
 #include "ustdex/ustdex.hpp"
 #include <variant>
 #include <any>
+#include <random>
 
 using namespace ustdex;
 
@@ -63,8 +64,107 @@ template <class>
 
 static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
+struct parallel_sort_t
+{
+private:
+
+	template<class Rcvr, class Sch, class RandomAccessIterator, typename SortFun>
+	struct _opstate_t
+	{
+		using operation_state_concept = operation_state_t;
+		using _env_t = env_of_t<Rcvr>;
+
+		USTDEX_API _opstate_t(Rcvr&& rcvr, Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun)
+			: _rcvr_{ std::move(rcvr) }, _sch_{ sch }, _begin_{ begin }, _end_{ end }, _sort_fun_{ sort_fun }
+			, _opstate_(ustdex::connect(ustdex::schedule(_sch_), ustdex::_rcvr_ref{ *this }))
+		{}
+		USTDEX_API void start() noexcept
+		{
+			ustdex::start(_opstate_);
+		}
+		USTDEX_API void set_value() noexcept;
+
+		USTDEX_API void set_error(std::exception_ptr) noexcept
+		{
+			ustdex::set_error(std::move(_rcvr_), std::current_exception());
+		}
+		USTDEX_API void set_stopped() noexcept
+		{
+			ustdex::set_stopped(std::move(_rcvr_));
+		}
+		USTDEX_API auto get_env() const noexcept -> _env_t
+		{
+			return ustdex::get_env(_rcvr_);
+		}
+
+		Rcvr _rcvr_;
+		Sch _sch_;
+		RandomAccessIterator _begin_;
+		RandomAccessIterator _end_;
+		SortFun _sort_fun_;
+		ustdex::connect_result_t<ustdex::schedule_result_t<Sch>, ustdex::_rcvr_ref<_opstate_t, _env_t>> _opstate_;
+	};
+
+	template <class Sch, class RandomAccessIterator, typename SortFun>
+	struct _sndr_t
+	{
+		using sender_concept = sender_t;
+
+		template <class Self, class... Env>
+		static constexpr auto get_completion_signatures() noexcept
+		{
+			return completion_signatures<set_value_t(RandomAccessIterator, RandomAccessIterator), set_error_t(::std::exception_ptr)>();
+		}
+		template <class Rcvr>
+		auto connect(Rcvr&& rcvr) && noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
+			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
+		{
+			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
+				std::move(rcvr), std::move(_sch_), _begin_, _end_, std::move(_sort_fun_));
+		}
+
+		template <class Rcvr>
+		auto connect(Rcvr&& rcvr) const& noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
+			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
+		{
+			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
+				std::move(rcvr), _sch_, _begin_, _end_, _sort_fun_);
+		}
+
+		Sch _sch_;
+		RandomAccessIterator _begin_;
+		RandomAccessIterator _end_;
+		SortFun _sort_fun_;
+	};
+
+	template <class Sch, class RandomAccessIterator, typename SortFun>
+	auto operator()(Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun) const noexcept -> _sndr_t<Sch, RandomAccessIterator, SortFun>
+	{
+		return _sndr_t<Sch, RandomAccessIterator, SortFun>{std::move(sch), begin, end, std::move(sort_fun)};
+	}
+};
+
+inline constexpr parallel_sort_t parallel_sort{};
+
 int main()
 {
+	ustdex::static_thread_pool thread_pool{};
+	std::vector<int> vec;
+	std::random_device rd;
+	std::mt19937 gen(rd());
+	std::uniform_int_distribution<int> dis(1, 300);
+	std::generate(vec.begin(), vec.end(), [&]()
+		{
+			return dis(gen);
+		});
+
+	auto ps = parallel_sort(thread_pool.get_scheduler(), vec.begin(), vec.end(), [](const int& a, const int& b)
+		{
+			return a < b;
+		});
+	ustdex::sync_wait(std::move(ps));
+	thread_pool.join();
+
 #if 0
 	auto task = read_env(get_stop_token)
 		| then([](auto stop_token)
@@ -91,7 +191,7 @@ int main()
 	//auto [sch2] = sync_wait(read_env(get_scheduler)).value();
 #endif
 
-#if 1
+#if 0
 	thread_context ctx;
 	auto sch = ctx.get_scheduler();
 
diff --git a/include/ustdex/detail/conditional.hpp b/include/ustdex/detail/conditional.hpp
index c7ece94..0603fe3 100644
--- a/include/ustdex/detail/conditional.hpp
+++ b/include/ustdex/detail/conditional.hpp
@@ -236,7 +236,7 @@ struct USTDEX_TYPE_VISIBILITY_DEFAULT _cond_t::_sndr_t
   template <class Rcvr>
   USTDEX_API auto connect(Rcvr _rcvr) const& -> _opstate<Sndr const&, Rcvr, Pred, Then, Else>
   {
-    return {_sndr_, static_cast<Rcvr&&>(_rcvr), static_cast<_data_t&&>(_data_)};
+    return {_sndr_, static_cast<Rcvr&&>(_rcvr), _data_};
   }
 
   USTDEX_API env_of_t<Sndr> get_env() const noexcept
diff --git a/include/ustdex/detail/static_thread_pool.hpp b/include/ustdex/detail/static_thread_pool.hpp
new file mode 100644
index 0000000..a1d6634
--- /dev/null
+++ b/include/ustdex/detail/static_thread_pool.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "thread_context.hpp"
+#include <vector>
+#include <random>
+
+#  include "prologue.hpp"
+
+namespace ustdex
+{
+	struct USTDEX_TYPE_VISIBILITY_DEFAULT static_thread_pool
+	{
+		static_thread_pool(int num = std::thread::hardware_concurrency()) noexcept
+		{
+			_loops_.resize(num);
+			_thrds_.resize(num);
+
+			for (int i = 0; i < num; i++)
+			{
+				_thrds_[i] = std::thread{ [this, i]()
+					{
+						_loops_[i].run();
+					} };
+			}
+		}
+
+		~static_thread_pool() noexcept
+		{
+			join();
+		}
+
+		void join() noexcept
+		{
+			for (auto& it : _thrds_)
+			{
+				if (it.joinable())
+				{
+					it.join();
+				}
+			}
+		}
+
+		auto get_scheduler()
+		{
+			int i = mt() % _loops_.size();
+			return _loops_[i].get_scheduler();
+		}
+
+	private:
+		std::mt19937 mt{ std::default_random_engine{}() };
+		std::vector<std::thread> _thrds_;
+		std::vector<run_loop> _loops_;
+	};
+} // namespace ustdex
+
+#  include "epilogue.hpp"
\ No newline at end of file
diff --git a/include/ustdex/ustdex.hpp b/include/ustdex/ustdex.hpp
index 3133002..6aa3bfe 100644
--- a/include/ustdex/ustdex.hpp
+++ b/include/ustdex/ustdex.hpp
@@ -37,4 +37,5 @@
 #include "detail/when_any.hpp"      // IWYU pragma: export
 #include "detail/write_env.hpp"      // IWYU pragma: export
 #include "detail/stop_when.hpp"      // IWYU pragma: export
-#include "detail/stop_with.hpp"      // IWYU pragma: export
\ No newline at end of file
+#include "detail/stop_with.hpp"      // IWYU pragma: export
+#include "detail/static_thread_pool.hpp"
\ No newline at end of file

From 5415cfad597a2efc1799db03639a5c096c1f632f Mon Sep 17 00:00:00 2001
From: bzh <18635939450@163.com>
Date: Sun, 10 Aug 2025 10:25:46 +0800
Subject: [PATCH 06/12] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=B9=B6=E8=A1=8C?=
 =?UTF-8?q?=E6=8E=92=E5=BA=8F=E7=9A=84=E4=BE=8B=E5=AD=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt                               |  16 +--
 CMakePresets.json                            |   6 +-
 examples/CMakeLists.txt                      |   5 +-
 examples/asio_thread_pool.hpp                | 135 +++++++++++++++++++
 examples/parallel_sort.hpp                   | 120 +++++++++++++++++
 examples/scratch.cpp                         | 119 ++++------------
 include/ustdex/detail/static_thread_pool.hpp |  53 ++++++--
 7 files changed, 339 insertions(+), 115 deletions(-)
 create mode 100644 examples/asio_thread_pool.hpp
 create mode 100644 examples/parallel_sort.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 04c3c8a..a309345 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,20 +66,20 @@ target_include_directories(ustdex INTERFACE
 
 target_link_libraries(ustdex INTERFACE Threads::Threads)
 
-target_compile_features(ustdex INTERFACE cxx_std_17)
+target_compile_features(ustdex INTERFACE cxx_std_20)
 target_include_directories(ustdex INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 target_compile_options(ustdex INTERFACE
                        $<$<COMPILE_LANG_AND_ID:CXX,MSVC>:/Zc:__cplusplus /Zc:hiddenFriend /Zc:preprocessor /Zc:externConstexpr>)
 
 # download CPM.cmake
-file(
-  DOWNLOAD
-  https://github.com/cpm-cmake/CPM.cmake/releases/download/v0.39.0/CPM.cmake
-  ${CMAKE_CURRENT_BINARY_DIR}/cmake/CPM.cmake
-  EXPECTED_HASH SHA256=66639bcac9dd2907b2918de466783554c1334446b9874e90d38e3778d404c2ef
-)
-include(${CMAKE_CURRENT_BINARY_DIR}/cmake/CPM.cmake)
+#file(
+#  DOWNLOAD
+#  https://github.com/cpm-cmake/CPM.cmake/releases/download/v0.39.0/CPM.cmake
+#  ${CMAKE_CURRENT_BINARY_DIR}/cmake/CPM.cmake
+#  EXPECTED_HASH SHA256=66639bcac9dd2907b2918de466783554c1334446b9874e90d38e3778d404c2ef
+#)
+#include(${CMAKE_CURRENT_BINARY_DIR}/cmake/CPM.cmake)
 
 if (USTDEX_ENABLE_CUDA)
   target_compile_features(ustdex INTERFACE cuda_std_17)
diff --git a/CMakePresets.json b/CMakePresets.json
index fc779f1..ccbc819 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -11,7 +11,8 @@
       "binaryDir": "${sourceDir}/build/Debug",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_STANDARD": "17"
+        "CMAKE_CXX_STANDARD": "17",
+        "CMAKE_TOOLCHAIN_FILE": "C:/Users/BiZeHao/vcpkg/scripts/buildsystems/vcpkg.cmake"
       }
     },
     {
@@ -19,7 +20,8 @@
       "binaryDir": "${sourceDir}/build/Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_STANDARD": "17"
+        "CMAKE_CXX_STANDARD": "17",
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG}/scripts/buildsystems/vcpkg.cmake"
       }
     },
     {
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 7ea0d6b..73fab1a 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -12,11 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
+find_package(asio CONFIG REQUIRED)
+
 add_executable(_clangd_helper_file detail/_clangd_helper_file.cpp)
 target_link_libraries(_clangd_helper_file PUBLIC ustdex)
 
 add_executable(scratch scratch.cpp)
-target_link_libraries(scratch PUBLIC ustdex)
+target_link_libraries(scratch PUBLIC ustdex asio::asio)
 
 if (USTDEX_ENABLE_CUDA)
   add_executable(cuscratch scratch.cu)
diff --git a/examples/asio_thread_pool.hpp b/examples/asio_thread_pool.hpp
new file mode 100644
index 0000000..faa8508
--- /dev/null
+++ b/examples/asio_thread_pool.hpp
@@ -0,0 +1,135 @@
+#pragma once
+
+#include <ustdex/ustdex.hpp>
+#include <asio.hpp>
+
+namespace atp
+{
+	template <class Rcvr>
+	struct _operation
+	{
+		asio::any_io_executor _executor_;
+		USTDEX_NO_UNIQUE_ADDRESS Rcvr _rcvr_;
+
+		USTDEX_API static void _execute_impl(_operation* _p) noexcept
+		{
+			auto& _rcvr = _p->_rcvr_;
+			try
+			{
+				if (ustdex::get_stop_token(ustdex::get_env(_rcvr)).stop_requested())
+				{
+					ustdex::set_stopped(static_cast<Rcvr&&>(_rcvr));
+				}
+				else
+				{
+					ustdex::set_value(static_cast<Rcvr&&>(_rcvr));
+				}
+			}
+			catch (...)
+			{
+				ustdex::set_error(static_cast<Rcvr&&>(_rcvr), ::std::current_exception());
+			}
+
+		}
+
+		USTDEX_API _operation(asio::any_io_executor executor, Rcvr _rcvr) :
+			_executor_{ executor }
+			, _rcvr_{ static_cast<Rcvr&&>(_rcvr) }
+		{}
+
+		USTDEX_API void start() & noexcept;
+	};
+
+	class asio_scheduler
+	{
+		struct _schedule_task
+		{
+			using sender_concept = ustdex::sender_t;
+
+			template <class Rcvr>
+			USTDEX_API auto connect(Rcvr _rcvr) const noexcept -> _operation<Rcvr>
+			{
+				return { _executor_, static_cast<Rcvr&&>(_rcvr) };
+			}
+
+			template <class Self>
+			USTDEX_API static constexpr auto get_completion_signatures() noexcept
+			{
+				return ustdex::completion_signatures<ustdex::set_value_t(), ustdex::set_error_t(::std::exception_ptr), ustdex::set_stopped_t()>();
+			}
+
+		private:
+			friend asio_scheduler;
+
+			struct _env
+			{
+				asio::any_io_executor _executor_;
+
+				template <class Tag>
+				USTDEX_API auto query(ustdex::get_completion_scheduler_t<Tag>) const noexcept -> asio_scheduler
+				{
+					return asio_scheduler{ _executor_ };
+				}
+			};
+
+			USTDEX_API auto get_env() const noexcept -> _env
+			{
+				return _env{ _executor_ };
+			}
+
+			USTDEX_API explicit _schedule_task(asio::any_io_executor executor) noexcept
+				: _executor_(executor)
+			{}
+
+			asio::any_io_executor const _executor_;
+		};
+
+		USTDEX_API auto query(ustdex::get_forward_progress_guarantee_t) const noexcept -> ustdex::forward_progress_guarantee
+		{
+			return ustdex::forward_progress_guarantee::parallel;
+		}
+
+		asio::any_io_executor _executor_;
+
+	public:
+		using scheduler_concept = ustdex::scheduler_t;
+
+		USTDEX_API explicit asio_scheduler(asio::any_io_executor executor) noexcept
+			: _executor_(executor)
+		{}
+
+		[[nodiscard]] USTDEX_API auto schedule() const noexcept -> _schedule_task
+		{
+			return _schedule_task{ _executor_ };
+		}
+
+		USTDEX_API friend bool operator==(const asio_scheduler& _a, const asio_scheduler& _b) noexcept
+		{
+			return _a._executor_ == _b._executor_;
+		}
+
+		USTDEX_API friend bool operator!=(const asio_scheduler& _a, const asio_scheduler& _b) noexcept
+		{
+			return _a._executor_ != _b._executor_;
+		}
+	};
+
+	template <class Rcvr>
+	USTDEX_API inline void _operation<Rcvr>::start() & noexcept
+	{
+		try
+		{
+			asio::post(_executor_,
+				[this]()
+				{
+					_execute_impl(this);
+				});
+		}
+		catch(...)
+		{
+			ustdex::set_error(static_cast<Rcvr&&>(_rcvr_), ::std::current_exception());
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/examples/parallel_sort.hpp b/examples/parallel_sort.hpp
new file mode 100644
index 0000000..7300d24
--- /dev/null
+++ b/examples/parallel_sort.hpp
@@ -0,0 +1,120 @@
+#pragma once
+
+#include <ustdex/ustdex.hpp>
+
+struct parallel_sort_t
+{
+private:
+	struct exec_then
+	{
+		template<typename... Args>
+		void operator()(Args&&... args)
+		{
+			_fun_();
+		}
+		std::function<void()> _fun_;
+	};
+
+	template<class Rcvr, class Sch, class RandomAccessIterator, typename SortFun>
+	struct _opstate_t
+	{
+		using operation_state_concept = ustdex::operation_state_t;
+		using _env_t = ustdex::env_of_t<Rcvr>;
+
+		_opstate_t(Rcvr&& rcvr, Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun)
+			: _rcvr_{ std::move(rcvr) }, _sch_{ sch }, _begin_{ begin }, _end_{ end }, _sort_fun_{ sort_fun }
+			, _opstate_(ustdex::connect(ustdex::schedule(_sch_), ustdex::_rcvr_ref{ *this }))
+		{}
+		void start() noexcept
+		{
+			ustdex::start(_opstate_);
+		}
+		void set_value() noexcept;
+
+		void set_error(std::exception_ptr) noexcept
+		{
+			ustdex::set_error(std::move(_rcvr_), std::current_exception());
+		}
+		void set_stopped() noexcept
+		{
+			ustdex::set_stopped(std::move(_rcvr_));
+		}
+		auto get_env() const noexcept -> _env_t
+		{
+			return ustdex::get_env(_rcvr_);
+		}
+
+		Rcvr _rcvr_;
+		Sch _sch_;
+		RandomAccessIterator _begin_;
+		RandomAccessIterator _end_;
+		SortFun _sort_fun_;
+		ustdex::connect_result_t<ustdex::schedule_result_t<Sch>, ustdex::_rcvr_ref<_opstate_t, _env_t>> _opstate_;
+	};
+
+	template <class Sch, class RandomAccessIterator, typename SortFun>
+	struct _sndr_t
+	{
+		using sender_concept = ustdex::sender_t;
+
+		template <class Self, class... Env>
+		static constexpr auto get_completion_signatures() noexcept
+		{
+			return ustdex::completion_signatures<ustdex::set_value_t(RandomAccessIterator, RandomAccessIterator), ustdex::set_error_t(::std::exception_ptr)>();
+		}
+		template <class Rcvr>
+		auto connect(Rcvr&& rcvr) && noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
+			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
+		{
+			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
+				std::move(rcvr), std::move(_sch_), _begin_, _end_, std::move(_sort_fun_));
+		}
+
+		template <class Rcvr>
+		auto connect(Rcvr&& rcvr) const& noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
+			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
+		{
+			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
+				std::move(rcvr), _sch_, _begin_, _end_, _sort_fun_);
+		}
+
+		Sch _sch_;
+		RandomAccessIterator _begin_;
+		RandomAccessIterator _end_;
+		SortFun _sort_fun_;
+	};
+public:
+	template <class Sch, class RandomAccessIterator, typename SortFun>
+	auto operator()(Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun) const noexcept -> _sndr_t<Sch, RandomAccessIterator, SortFun>
+	{
+		return _sndr_t<Sch, RandomAccessIterator, SortFun>{std::move(sch), begin, end, std::move(sort_fun)};
+	}
+};
+
+inline constexpr parallel_sort_t parallel_sort{};
+
+template<class Rcvr, class Sch, class RandomAccessIterator, typename SortFun>
+inline void parallel_sort_t::_opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>::set_value() noexcept
+{
+	auto n = _end_ - _begin_;
+	if (n <= 16384)
+	{
+		std::sort(_begin_, _end_, _sort_fun_);
+		ustdex::set_value(std::move(_rcvr_), std::move(_begin_), std::move(_end_));
+	}
+	else
+	{
+		auto mid = _begin_ + n / 2;
+		auto left = parallel_sort(_sch_, _begin_, mid, _sort_fun_);
+		auto right = parallel_sort(_sch_, mid, _end_, _sort_fun_);
+
+		std::function<void()> fun = [begin = _begin_, mid, end = _end_, rcvr = std::move(_rcvr_)]() mutable
+			{
+				std::inplace_merge(begin, mid, end);
+				ustdex::set_value(std::move(rcvr), begin, end);
+			};
+		auto task = ustdex::when_all(std::move(left), std::move(right)) | ustdex::then(exec_then{ std::move(fun) });
+
+		ustdex::start_detached(std::move(task));
+	}
+}
diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 7fbba88..2df2008 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -22,6 +22,9 @@
 #include <variant>
 #include <any>
 #include <random>
+#include <chrono>
+#include "parallel_sort.hpp"
+#include "asio_thread_pool.hpp"
 
 using namespace ustdex;
 
@@ -64,106 +67,34 @@ template <class>
 
 static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
-struct parallel_sort_t
-{
-private:
-
-	template<class Rcvr, class Sch, class RandomAccessIterator, typename SortFun>
-	struct _opstate_t
-	{
-		using operation_state_concept = operation_state_t;
-		using _env_t = env_of_t<Rcvr>;
-
-		USTDEX_API _opstate_t(Rcvr&& rcvr, Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun)
-			: _rcvr_{ std::move(rcvr) }, _sch_{ sch }, _begin_{ begin }, _end_{ end }, _sort_fun_{ sort_fun }
-			, _opstate_(ustdex::connect(ustdex::schedule(_sch_), ustdex::_rcvr_ref{ *this }))
-		{}
-		USTDEX_API void start() noexcept
-		{
-			ustdex::start(_opstate_);
-		}
-		USTDEX_API void set_value() noexcept;
-
-		USTDEX_API void set_error(std::exception_ptr) noexcept
-		{
-			ustdex::set_error(std::move(_rcvr_), std::current_exception());
-		}
-		USTDEX_API void set_stopped() noexcept
-		{
-			ustdex::set_stopped(std::move(_rcvr_));
-		}
-		USTDEX_API auto get_env() const noexcept -> _env_t
-		{
-			return ustdex::get_env(_rcvr_);
-		}
-
-		Rcvr _rcvr_;
-		Sch _sch_;
-		RandomAccessIterator _begin_;
-		RandomAccessIterator _end_;
-		SortFun _sort_fun_;
-		ustdex::connect_result_t<ustdex::schedule_result_t<Sch>, ustdex::_rcvr_ref<_opstate_t, _env_t>> _opstate_;
-	};
-
-	template <class Sch, class RandomAccessIterator, typename SortFun>
-	struct _sndr_t
-	{
-		using sender_concept = sender_t;
-
-		template <class Self, class... Env>
-		static constexpr auto get_completion_signatures() noexcept
-		{
-			return completion_signatures<set_value_t(RandomAccessIterator, RandomAccessIterator), set_error_t(::std::exception_ptr)>();
-		}
-		template <class Rcvr>
-		auto connect(Rcvr&& rcvr) && noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
-			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
-		{
-			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
-				std::move(rcvr), std::move(_sch_), _begin_, _end_, std::move(_sort_fun_));
-		}
-
-		template <class Rcvr>
-		auto connect(Rcvr&& rcvr) const& noexcept(ustdex::_nothrow_decay_copyable<Sch, RandomAccessIterator, SortFun>)
-			-> _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>
-		{
-			return _opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun>(
-				std::move(rcvr), _sch_, _begin_, _end_, _sort_fun_);
-		}
-
-		Sch _sch_;
-		RandomAccessIterator _begin_;
-		RandomAccessIterator _end_;
-		SortFun _sort_fun_;
-	};
-
-	template <class Sch, class RandomAccessIterator, typename SortFun>
-	auto operator()(Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun) const noexcept -> _sndr_t<Sch, RandomAccessIterator, SortFun>
-	{
-		return _sndr_t<Sch, RandomAccessIterator, SortFun>{std::move(sch), begin, end, std::move(sort_fun)};
-	}
-};
-
-inline constexpr parallel_sort_t parallel_sort{};
-
 int main()
 {
-	ustdex::static_thread_pool thread_pool{};
-	std::vector<int> vec;
-	std::random_device rd;
-	std::mt19937 gen(rd());
-	std::uniform_int_distribution<int> dis(1, 300);
-	std::generate(vec.begin(), vec.end(), [&]()
-		{
-			return dis(gen);
-		});
-
-	auto ps = parallel_sort(thread_pool.get_scheduler(), vec.begin(), vec.end(), [](const int& a, const int& b)
+	asio::static_thread_pool thread_pool_a{};
+	ustdex::static_thread_pool thread_pool_b{};
+	std::vector<int> values(100'000'000);
+	std::random_device random_device;
+	std::mt19937 rng(random_device());
+	std::uniform_int_distribution<int> dist(1, 1'000'000);
+	std::generate(values.begin(), values.end(), [&] { return dist(rng); });
+
+	std::cout << "starting sort\n";
+
+	auto begin = std::chrono::high_resolution_clock::now();
+	//thread_pool_b.get_scheduler()
+	auto ps = parallel_sort(atp::asio_scheduler{thread_pool_a.get_executor()}, values.begin(), values.end(), [](const int& a, const int& b)
 		{
 			return a < b;
 		});
 	ustdex::sync_wait(std::move(ps));
-	thread_pool.join();
+
+	auto end = std::chrono::high_resolution_clock::now();
+
+	auto duration = end - begin;
+	std::cout << "sort took "
+		<< std::chrono::duration_cast<std::chrono::microseconds>(duration).count()
+		<< " microseconds\n";
+
+	return 0;
 
 #if 0
 	auto task = read_env(get_stop_token)
diff --git a/include/ustdex/detail/static_thread_pool.hpp b/include/ustdex/detail/static_thread_pool.hpp
index a1d6634..5056322 100644
--- a/include/ustdex/detail/static_thread_pool.hpp
+++ b/include/ustdex/detail/static_thread_pool.hpp
@@ -10,46 +10,79 @@ namespace ustdex
 {
 	struct USTDEX_TYPE_VISIBILITY_DEFAULT static_thread_pool
 	{
-		static_thread_pool(int num = std::thread::hardware_concurrency()) noexcept
+		class _scheduler
+		{
+		public:
+			USTDEX_API explicit _scheduler(static_thread_pool* _thread_pool) noexcept
+				: _thread_pool_{ _thread_pool }
+			{}
+
+			[[nodiscard]] USTDEX_API auto schedule() const noexcept
+			{
+				int i = _thread_pool_->get_rand_index();
+				return _thread_pool_->_loops_[i]->get_scheduler().schedule();
+			}
+		private:
+			static_thread_pool* _thread_pool_;
+		};
+
+		static_thread_pool(int num = std::thread::hardware_concurrency()*2) noexcept
+			: _ss_{ 0, num - 1 }
 		{
 			_loops_.resize(num);
 			_thrds_.resize(num);
 
 			for (int i = 0; i < num; i++)
 			{
+				_loops_[i] = std::make_unique<run_loop>();
 				_thrds_[i] = std::thread{ [this, i]()
 					{
-						_loops_[i].run();
+						_loops_[i]->run();
 					} };
 			}
 		}
 
 		~static_thread_pool() noexcept
 		{
+			finish();
 			join();
 		}
 
+		void finish() noexcept
+		{
+			for (int i = 0; i < _loops_.size(); i++)
+			{
+				_loops_[i]->finish();
+			}
+		}
+
 		void join() noexcept
 		{
-			for (auto& it : _thrds_)
+			for (int i = 0; i < _thrds_.size(); i++)
 			{
-				if (it.joinable())
+				if (_thrds_[i].joinable())
 				{
-					it.join();
+					_thrds_[i].join();
 				}
 			}
 		}
 
-		auto get_scheduler()
+		int get_rand_index() const noexcept
 		{
-			int i = mt() % _loops_.size();
-			return _loops_[i].get_scheduler();
+			return _ss_(_mt_);
+		}
+
+		_scheduler get_scheduler()
+		{
+			return _scheduler{ this };
 		}
 
 	private:
-		std::mt19937 mt{ std::default_random_engine{}() };
 		std::vector<std::thread> _thrds_;
-		std::vector<run_loop> _loops_;
+		std::vector<std::unique_ptr<run_loop>> _loops_;
+
+		mutable std::mt19937 _mt_{ std::random_device{}() };
+		mutable std::uniform_int_distribution<int> _ss_;
 	};
 } // namespace ustdex
 

From 8767ed6f055d1e882f06f37e33209905a8634dd5 Mon Sep 17 00:00:00 2001
From: bzh <18635939450@163.com>
Date: Tue, 12 Aug 2025 20:43:52 +0800
Subject: [PATCH 07/12] =?UTF-8?q?=E6=B7=BB=E5=8A=A0base=5Fsender?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/scratch.cpp                   |   6 +
 include/ustdex/detail/basic_sender.hpp | 170 +++++++++++++++++++++++++
 2 files changed, 176 insertions(+)
 create mode 100644 include/ustdex/detail/basic_sender.hpp

diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 2df2008..713f7ab 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -25,6 +25,7 @@
 #include <chrono>
 #include "parallel_sort.hpp"
 #include "asio_thread_pool.hpp"
+#include "ustdex/detail/basic_sender.hpp"
 
 using namespace ustdex;
 
@@ -69,6 +70,9 @@ static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
 int main()
 {
+	ustdex::_make_sexpr<int>(3, 4, 5);
+
+#if 0
 	asio::static_thread_pool thread_pool_a{};
 	ustdex::static_thread_pool thread_pool_b{};
 	std::vector<int> values(100'000'000);
@@ -96,6 +100,8 @@ int main()
 
 	return 0;
 
+#endif
+
 #if 0
 	auto task = read_env(get_stop_token)
 		| then([](auto stop_token)
diff --git a/include/ustdex/detail/basic_sender.hpp b/include/ustdex/detail/basic_sender.hpp
new file mode 100644
index 0000000..5c1ff0c
--- /dev/null
+++ b/include/ustdex/detail/basic_sender.hpp
@@ -0,0 +1,170 @@
+#pragma once
+
+#include "completion_signatures.hpp"
+#include "config.hpp"
+#include "cpos.hpp"
+#include "tuple.hpp"
+#include "utility.hpp"
+
+#include "prologue.hpp"
+
+namespace ustdex
+{
+    namespace detail
+    {
+        // A type that describes a sender's metadata
+        template <class _Tag, class _Data, class... _Child>
+        struct __desc
+        {
+            using __tag = _Tag;
+            using __data = _Data;
+            using __children = _m_list<_Child...>;
+
+            template <class _Fn>
+            using call = _m_call<_Fn, _Tag, _Data, _Child...>;
+        };
+    }
+
+    template <
+        class _Descriptor,
+        auto _DescriptorFn =
+        []
+        {
+            return _Descriptor();
+        }
+    >
+    inline constexpr auto __descriptor_fn_v = _DescriptorFn;
+
+    template <class _Tag, class _Data, class... _Child>
+    inline constexpr auto __descriptor_fn()
+    {
+        return __descriptor_fn_v<detail::__desc<_Tag, _Data, _Child...>>;
+    }
+
+    namespace
+    {
+        //! A struct template to aid in creating senders.
+        //! This struct closely resembles P2300's [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24),
+        //! but is not an exact implementation.
+        //! Note: The struct named `__basic_sender` is just a dummy type and is also not _`basic-sender`_.
+        template <auto _DescriptorFn>
+        struct __sexpr
+        {
+            using sender_concept = sender_t;
+
+            // See MAINTAINERS.md#class-template-parameters for `__id` and `__t`.
+            /*using __id = __sexpr;
+            using __t = __sexpr;
+            using __desc_t = decltype(_DescriptorFn());
+            using __tag_t = typename __desc_t::__tag;
+            using __captures_t = __minvoke<__desc_t, __q<__detail::__captures_t>>;
+
+            mutable __captures_t __impl_;*/
+
+            template <class _Tag, class _Data, class... _Child>
+            explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child)
+                /*: __impl_(
+                    __detail::__captures(
+                        _Tag(),
+                        static_cast<_Data&&>(__data),
+                        static_cast<_Child&&>(__child)...))*/
+            {}
+
+            //template <class _Self>
+            //using __impl = __sexpr_impl<__meval<__msecond, _Self, __tag_t>>;
+
+            //template <class _Self = __sexpr>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    auto get_env() const noexcept
+            //    -> __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>>
+            //{
+            //    return __sexpr_apply(*this, __detail::__drop_front(__impl<_Self>::get_attrs));
+            //}
+
+            //template <__decays_to<__sexpr> _Self, class... _Env>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    static auto get_completion_signatures(_Self&&, _Env&&...) noexcept -> __msecond<
+            //    __if_c<__decays_to<_Self, __sexpr>>,
+            //    __result_of<__impl<_Self>::get_completion_signatures, _Self, _Env...>
+            //    >
+            //{
+            //    return {};
+            //}
+
+            //// BUGBUG fix receiver constraint here:
+            //template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    static auto connect(_Self&& __self, _Receiver&& __rcvr)
+            //    noexcept(__noexcept_of<__impl<_Self>::connect, _Self, _Receiver>) -> __msecond<
+            //    __if_c<__decays_to<_Self, __sexpr>>,
+            //    __result_of<__impl<_Self>::connect, _Self, _Receiver>
+            //    >
+            //{
+            //    return __impl<_Self>::connect(
+            //        static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
+            //}
+
+            //template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    static auto submit(_Self&& __self, _Receiver&& __rcvr)
+            //    noexcept(__noexcept_of<__impl<_Self>::submit, _Self, _Receiver>) -> __msecond<
+            //    __if_c<__decays_to<_Self, __sexpr>>,
+            //    __result_of<__impl<_Self>::submit, _Self, _Receiver>
+            //    >
+            //{
+            //    return __impl<_Self>::submit(
+            //        static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
+            //}
+
+            //template <class _Sender, class _ApplyFn>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    static auto apply(_Sender&& __sndr, _ApplyFn&& __fun) noexcept(
+            //        __nothrow_callable<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn>)
+            //    -> __call_result_t<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn>
+            //{
+            //    return static_cast<_Sender&&>(__sndr)
+            //        .__impl_(__copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun));
+            //}
+
+            //template <std::size_t _Idx, __decays_to_derived_from<__sexpr> _Self>
+            //STDEXEC_ATTRIBUTE(always_inline)
+            //    friend auto get(_Self&& __self) noexcept -> decltype(auto)
+            //    requires __detail::__in_range<_Idx, __desc_t>
+            //{
+            //    if constexpr (_Idx == 0)
+            //    {
+            //        return __tag_t();
+            //    }
+            //    else
+            //    {
+            //        return __self.__impl_(__copy_cvref_fn<_Self>(), __nth_pack_element<_Idx>);
+            //    }
+            //}
+        };
+
+        template <class _Tag, class _Data, class... _Child>
+        __sexpr(_Tag, _Data, _Child...)->__sexpr<__descriptor_fn<_Tag, _Data, _Child...>()>;
+    } // namespace
+
+	template <class _Tag, class _Data, class... _Child>
+	using _sexpr_t = __sexpr<__descriptor_fn<_Tag, _Data, _Child...>()>;
+
+	namespace detail
+	{
+		template <class _Tag>
+		struct _make_sexpr_t
+		{
+			template <class _Data = __, class... _Child>
+			constexpr auto operator()(_Data _data = {}, _Child... _child) const
+			{
+				return _sexpr_t<_Tag, _Data, _Child...>{
+					_Tag(), static_cast<_Data&&>(_data), static_cast<_Child&&>(_child)...};
+			}
+		};
+	} // namespace __detail
+
+	template <class _Tag>
+	inline constexpr detail::_make_sexpr_t<_Tag> _make_sexpr{};
+}
+
+#include "epilogue.hpp"
\ No newline at end of file

From 82f8588fd0078937a6ba7bede933d588648f5403 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Tue, 12 Aug 2025 22:48:07 +0800
Subject: [PATCH 08/12] =?UTF-8?q?=E7=BB=A7=E7=BB=AD=E5=AE=8C=E6=88=90base?=
 =?UTF-8?q?=5Fsender?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt                         |  2 +-
 CMakePresets.json                      |  2 +-
 examples/scratch.cpp                   |  6 ++-
 include/ustdex/detail/basic_sender.hpp | 61 ++++++++++++++++----------
 4 files changed, 46 insertions(+), 25 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a309345..d564e3a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -66,7 +66,7 @@ target_include_directories(ustdex INTERFACE
 
 target_link_libraries(ustdex INTERFACE Threads::Threads)
 
-target_compile_features(ustdex INTERFACE cxx_std_20)
+target_compile_features(ustdex INTERFACE cxx_std_17)
 target_include_directories(ustdex INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
 target_compile_options(ustdex INTERFACE
diff --git a/CMakePresets.json b/CMakePresets.json
index ccbc819..a3662f2 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -12,7 +12,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_STANDARD": "17",
-        "CMAKE_TOOLCHAIN_FILE": "C:/Users/BiZeHao/vcpkg/scripts/buildsystems/vcpkg.cmake"
+        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG}/scripts/buildsystems/vcpkg.cmake"
       }
     },
     {
diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 713f7ab..e8a78d9 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -70,7 +70,11 @@ static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
 int main()
 {
-	ustdex::_make_sexpr<int>(3, 4, 5);
+	auto pp1 = ustdex::_make_sexpr<int>(3, 4, 5);
+
+	_whatis<decltype(pp1)::__captures_t>();
+
+	int a = 0;
 
 #if 0
 	asio::static_thread_pool thread_pool_a{};
diff --git a/include/ustdex/detail/basic_sender.hpp b/include/ustdex/detail/basic_sender.hpp
index 5c1ff0c..19a8dc7 100644
--- a/include/ustdex/detail/basic_sender.hpp
+++ b/include/ustdex/detail/basic_sender.hpp
@@ -12,6 +12,7 @@ namespace ustdex
 {
     namespace detail
     {
+        struct __ {};
         // A type that describes a sender's metadata
         template <class _Tag, class _Data, class... _Child>
         struct __desc
@@ -23,43 +24,59 @@ namespace ustdex
             template <class _Fn>
             using call = _m_call<_Fn, _Tag, _Data, _Child...>;
         };
-    }
 
-    template <
-        class _Descriptor,
-        auto _DescriptorFn =
-        []
+        template <class _Tag, class... _Captures>
+        struct __captures_impl
+        {
+            template<class _Cvref, class _Fun>
+            auto operator()(_Cvref, _Fun&& __fun) noexcept(_nothrow_callable<_Fun, _Tag, _m_call<_Cvref, _Captures>...>)
+                -> _call_result_t<_Fun, _Tag, _m_call<_Cvref, _Captures>...>
+            {
+
+                return __captures3_tup.apply([](_Captures&&... __captures3)
+                    {
+                        static_cast<_Fun&&>(__fun)(_Tag(), const_cast<_m_call<_Cvref, _Captures>&&>(__captures3)...);
+                    }, __captures3_tup);
+            }
+
+            _tuple<_Captures...> __captures3_tup;
+        };
+
+        template <class _Tag, class... _Captures>
+        constexpr auto __captures(_Tag, _Captures&&... __captures2)
         {
-            return _Descriptor();
+            return __captures_impl<_Tag, _Captures...>{_tuple<_Captures...>{std::move(__captures2)...}};
         }
-    >
-    inline constexpr auto __descriptor_fn_v = _DescriptorFn;
 
-    template <class _Tag, class _Data, class... _Child>
-    inline constexpr auto __descriptor_fn()
-    {
-        return __descriptor_fn_v<detail::__desc<_Tag, _Data, _Child...>>;
+        /*struct __captures_t
+        {
+            template <class _Tag, class _Data, class... _Child>
+            using call = decltype(__captures(_Tag(), std::declval<_Data>(), std::declval<_Child>()...));
+        };*/
+
+        template <class _Tag, class _Data, class... _Child>
+        using __captures_t = decltype(__captures(_Tag(), std::declval<_Data>(), std::declval<_Child>()...));
     }
 
+    template <class _Tag, class _Data, class... _Child>
+    using __descriptor_fn_t = _fn_t<detail::__desc<_Tag, _Data, _Child...>>*;
+
     namespace
     {
         //! A struct template to aid in creating senders.
         //! This struct closely resembles P2300's [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24),
         //! but is not an exact implementation.
         //! Note: The struct named `__basic_sender` is just a dummy type and is also not _`basic-sender`_.
-        template <auto _DescriptorFn>
+        template <typename _DescriptorFn>
         struct __sexpr
         {
             using sender_concept = sender_t;
 
-            // See MAINTAINERS.md#class-template-parameters for `__id` and `__t`.
-            /*using __id = __sexpr;
-            using __t = __sexpr;
-            using __desc_t = decltype(_DescriptorFn());
-            using __tag_t = typename __desc_t::__tag;
-            using __captures_t = __minvoke<__desc_t, __q<__detail::__captures_t>>;
+            using __desc_t = decltype(std::declval<_DescriptorFn>()());
+            //using __tag_t = typename __desc_t::__tag;
+            using __captures_t = _m_call<__desc_t, _m_indirect_q<detail::__captures_t>>;
 
-            mutable __captures_t __impl_;*/
+            //mutable __captures_t __impl_;
 
             template <class _Tag, class _Data, class... _Child>
             explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child)
@@ -143,11 +160,11 @@ namespace ustdex
         };
 
         template <class _Tag, class _Data, class... _Child>
-        __sexpr(_Tag, _Data, _Child...)->__sexpr<__descriptor_fn<_Tag, _Data, _Child...>()>;
+        __sexpr(_Tag, _Data, _Child...)->__sexpr<__descriptor_fn_t<_Tag, _Data, _Child...>>;
     } // namespace
 
 	template <class _Tag, class _Data, class... _Child>
-	using _sexpr_t = __sexpr<__descriptor_fn<_Tag, _Data, _Child...>()>;
+	using _sexpr_t = __sexpr<__descriptor_fn_t<_Tag, _Data, _Child...>>;
 
 	namespace detail
 	{

From 77178d6002a32c18d86dfd466f34273bfcb9986c Mon Sep 17 00:00:00 2001
From: bzh <18635939450@163.com>
Date: Tue, 19 Aug 2025 21:57:51 +0800
Subject: [PATCH 09/12] =?UTF-8?q?=E5=AE=8C=E6=88=90base=5Fsender,=E8=BF=98?=
 =?UTF-8?q?=E6=9C=AA=E8=AF=A6=E7=BB=86=E6=B5=8B=E8=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/CMakeLists.txt                |   5 +-
 examples/scratch.cpp                   |  79 ++-
 include/ustdex/detail/basic_sender.hpp | 649 +++++++++++++++++++------
 include/ustdex/detail/type_traits.hpp  |   3 +
 4 files changed, 578 insertions(+), 158 deletions(-)

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 73fab1a..5555ff2 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -13,13 +13,14 @@
 # limitations under the License.
 
 
-find_package(asio CONFIG REQUIRED)
+#find_package(asio CONFIG REQUIRED)
 
 add_executable(_clangd_helper_file detail/_clangd_helper_file.cpp)
 target_link_libraries(_clangd_helper_file PUBLIC ustdex)
 
 add_executable(scratch scratch.cpp)
-target_link_libraries(scratch PUBLIC ustdex asio::asio)
+target_link_libraries(scratch PUBLIC ustdex)
+#target_link_libraries(scratch PUBLIC ustdex asio::asio)
 
 if (USTDEX_ENABLE_CUDA)
   add_executable(cuscratch scratch.cu)
diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index e8a78d9..91f710e 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -23,8 +23,8 @@
 #include <any>
 #include <random>
 #include <chrono>
-#include "parallel_sort.hpp"
-#include "asio_thread_pool.hpp"
+//#include "parallel_sort.hpp"
+//#include "asio_thread_pool.hpp"
 #include "ustdex/detail/basic_sender.hpp"
 
 using namespace ustdex;
@@ -68,11 +68,82 @@ template <class>
 
 static_assert(dependent_sender<decltype(read_env(_empty()))>);
 
+namespace __test_sender
+{
+	struct test_sender_t
+	{
+		template <typename... _Ts>
+		auto operator()(_Ts&&... __ts) const noexcept((ustdex::_nothrow_decay_copyable<_Ts> && ...))
+		{
+			return ustdex::_make_sexpr<test_sender_t>(_tuple<_Ts...>{ static_cast<_Ts&&>(__ts)... });
+		}
+	};
+
+	struct __impl : __sexpr_defaults
+	{
+		static constexpr struct
+		{
+			template<typename _Sender, typename... Env>
+			auto operator()(_Sender&&, Env&&...) const noexcept
+			{
+				return completion_signatures<set_value_t()>{};
+			};
+		} get_completion_signatures;
+
+
+		static constexpr struct
+		{
+			template<class _State, class _Receiver>
+			void operator()(_State& __state, _Receiver& __rcvr) const noexcept
+			{
+				__state.apply([&__rcvr](auto&... ts)
+					{
+						ustdex::set_value(__rcvr, std::move(ts)...);
+					}, __state);
+			};
+		} start;
+	};
+}
+
+template <>
+struct __sexpr_impl<__test_sender::test_sender_t> : __test_sender::__impl {};
+
+template<typename T>
+auto test_aa(T t)
+{
+	return t;
+}
+
+template <class _Tag>
+using AA_get_attrs_fn = decltype(test_aa(_Tag {}));
+
 int main()
 {
-	auto pp1 = ustdex::_make_sexpr<int>(3, 4, 5);
+	AA_get_attrs_fn<int> vv;
+
+	__test_sender::test_sender_t test_sender;
+
+	//auto ts11 = test_sender(1, 2, 3);
+
+	//ts11.get_completion_signatures<int>();
+
+	//using T1 = ustdex::completion_signatures_of_t<decltype(ts11)>;
+
+	//_whatis<T1>();
+
+	auto v1 = test_sender(1, 2, 3);
+
+	/*using T_v1 = tag_of_t<decltype(v1)>;
+
+	_whatis<T_v1>();*/
+
+	auto op = ustdex::connect(v1, sink{});
+
+	ustdex::start(op);
+
 
-	_whatis<decltype(pp1)::__captures_t>();
+	/*auto pp1 = ustdex::_make_sexpr<int>(3, 4, 5);
+	_whatis<decltype(pp1)::__captures_t>();*/
 
 	int a = 0;
 
diff --git a/include/ustdex/detail/basic_sender.hpp b/include/ustdex/detail/basic_sender.hpp
index 19a8dc7..9f2abb7 100644
--- a/include/ustdex/detail/basic_sender.hpp
+++ b/include/ustdex/detail/basic_sender.hpp
@@ -10,158 +10,503 @@
 
 namespace ustdex
 {
-    namespace detail
-    {
-        struct __ {};
-        // A type that describes a sender's metadata
-        template <class _Tag, class _Data, class... _Child>
-        struct __desc
-        {
-            using __tag = _Tag;
-            using __data = _Data;
-            using __children = _m_list<_Child...>;
-
-            template <class _Fn>
-            using call = _m_call<_Fn, _Tag, _Data, _Child...>;
-        };
-
-        template <class _Tag, class... _Captures>
-        struct __captures_impl
-        {
-            template<class _Cvref, class _Fun>
-            auto operator()(_Cvref, _Fun&& __fun) noexcept(_nothrow_callable<_Fun, _Tag, _m_call<_Cvref, _Captures>...>)
-                -> _call_result_t<_Fun, _Tag, _m_call<_Cvref, _Captures>...>
-            {
-
-                return __captures3_tup.apply([](_Captures&&... __captures3)
-                    {
-                        static_cast<_Fun&&>(__fun)(_Tag(), const_cast<_m_call<_Cvref, _Captures>&&>(__captures3)...);
-                    }, __captures3_tup);
-            }
-
-            _tuple<_Captures...> __captures3_tup;
-        };
-
-        template <class _Tag, class... _Captures>
-        constexpr auto __captures(_Tag, _Captures&&... __captures2)
-        {
-            return __captures_impl<_Tag, _Captures...>{_tuple<_Captures...>{std::move(__captures2)...}};
-        }
-
-        /*struct __captures_t
-        {
-            template <class _Tag, class _Data, class... _Child>
-            using call = decltype(__captures(_Tag(), std::declval<_Data>(), std::declval<_Child>()...));
-        };*/
-
-        template <class _Tag, class _Data, class... _Child>
-        using __captures_t = decltype(__captures(_Tag(), std::declval<_Data>(), std::declval<_Child>()...));
-    }
-
-    template <class _Tag, class _Data, class... _Child>
-    using __descriptor_fn_t = _fn_t<detail::__desc<_Tag, _Data, _Child...>>*;
-
-    namespace
-    {
-        //! A struct template to aid in creating senders.
-        //! This struct closely resembles P2300's [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24),
-        //! but is not an exact implementation.
-        //! Note: The struct named `__basic_sender` is just a dummy type and is also not _`basic-sender`_.
-        template <typename _DescriptorFn>
-        struct __sexpr
-        {
-            using sender_concept = sender_t;
-
-            using __desc_t = decltype(std::declval<_DescriptorFn>()());
-            //using __tag_t = typename __desc_t::__tag;
-            using __captures_t = _m_call<__desc_t, _m_indirect_q<detail::__captures_t>>;
-
-            //mutable __captures_t __impl_;
-
-            template <class _Tag, class _Data, class... _Child>
-            explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child)
-                /*: __impl_(
-                    __detail::__captures(
-                        _Tag(),
-                        static_cast<_Data&&>(__data),
-                        static_cast<_Child&&>(__child)...))*/
-            {}
-
-            //template <class _Self>
-            //using __impl = __sexpr_impl<__meval<__msecond, _Self, __tag_t>>;
-
-            //template <class _Self = __sexpr>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    auto get_env() const noexcept
-            //    -> __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>>
-            //{
-            //    return __sexpr_apply(*this, __detail::__drop_front(__impl<_Self>::get_attrs));
-            //}
-
-            //template <__decays_to<__sexpr> _Self, class... _Env>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    static auto get_completion_signatures(_Self&&, _Env&&...) noexcept -> __msecond<
-            //    __if_c<__decays_to<_Self, __sexpr>>,
-            //    __result_of<__impl<_Self>::get_completion_signatures, _Self, _Env...>
-            //    >
-            //{
-            //    return {};
-            //}
-
-            //// BUGBUG fix receiver constraint here:
-            //template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    static auto connect(_Self&& __self, _Receiver&& __rcvr)
-            //    noexcept(__noexcept_of<__impl<_Self>::connect, _Self, _Receiver>) -> __msecond<
-            //    __if_c<__decays_to<_Self, __sexpr>>,
-            //    __result_of<__impl<_Self>::connect, _Self, _Receiver>
-            //    >
-            //{
-            //    return __impl<_Self>::connect(
-            //        static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
-            //}
-
-            //template <__decays_to<__sexpr> _Self, /*receiver*/ class _Receiver>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    static auto submit(_Self&& __self, _Receiver&& __rcvr)
-            //    noexcept(__noexcept_of<__impl<_Self>::submit, _Self, _Receiver>) -> __msecond<
-            //    __if_c<__decays_to<_Self, __sexpr>>,
-            //    __result_of<__impl<_Self>::submit, _Self, _Receiver>
-            //    >
-            //{
-            //    return __impl<_Self>::submit(
-            //        static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
-            //}
-
-            //template <class _Sender, class _ApplyFn>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    static auto apply(_Sender&& __sndr, _ApplyFn&& __fun) noexcept(
-            //        __nothrow_callable<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn>)
-            //    -> __call_result_t<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn>
-            //{
-            //    return static_cast<_Sender&&>(__sndr)
-            //        .__impl_(__copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun));
-            //}
-
-            //template <std::size_t _Idx, __decays_to_derived_from<__sexpr> _Self>
-            //STDEXEC_ATTRIBUTE(always_inline)
-            //    friend auto get(_Self&& __self) noexcept -> decltype(auto)
-            //    requires __detail::__in_range<_Idx, __desc_t>
-            //{
-            //    if constexpr (_Idx == 0)
-            //    {
-            //        return __tag_t();
-            //    }
-            //    else
-            //    {
-            //        return __self.__impl_(__copy_cvref_fn<_Self>(), __nth_pack_element<_Idx>);
-            //    }
-            //}
-        };
-
-        template <class _Tag, class _Data, class... _Child>
-        __sexpr(_Tag, _Data, _Child...)->__sexpr<__descriptor_fn_t<_Tag, _Data, _Child...>>;
-    } // namespace
+	template <class _Tag>
+	struct __sexpr_impl;
+
+	template <class _Sexpr, class _Receiver>
+	struct __op_state;
+
+	template <class _Receiver, class _Sexpr, std::size_t _Idx>
+	struct __rcvr;
+
+	namespace detail
+	{
+		struct __ {};
+
+		template <class _Tp>
+		using __t = typename _Tp::__t;
+
+		template <class...>
+		inline constexpr bool __mnever = false;
+
+		//! Metafunction selects the first of two type arguments.
+		template <class _Tp, class _Up>
+		using __mfirst = _Tp;
+
+		//! Metafunction selects the second of two type arguments.
+		template <class _Tp, class _Up>
+		using __msecond = _Up;
+
+		// A type that describes a sender's metadata
+		template <class _Tag, class _Data, class... _Child>
+		struct __desc
+		{
+			using __tag = _Tag;
+			using __data = _Data;
+			using __children = _m_list<_Child...>;
+
+			template <class _Fn>
+			using call = _m_call<_Fn, _Tag, _Data, _Child...>;
+		};
+
+		template <class _Sender>
+		using __impl_of = decltype((std::declval<_Sender>().__impl_));
+
+		// Accessor for the "data" field of a sender
+		struct __get_data
+		{
+			template <class _Data, typename... _Child>
+			USTDEX_ATTR_ALWAYS_INLINE
+				auto operator()(_ignore, _Data&& __data, _Child&&...) const noexcept -> _Data&&
+			{
+				return static_cast<_Data&&>(__data);
+			}
+		};
+
+		// A function object that is to senders what std::apply is to tuples:
+		struct __sexpr_apply_t
+		{
+			template <class _Sender, class _ApplyFn>
+			USTDEX_ATTR_ALWAYS_INLINE
+				auto operator()(_Sender&& __sndr, _ApplyFn&& __fun) const
+				noexcept(noexcept(__sndr
+					.apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun))))
+				-> decltype(__sndr
+					.apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun)))
+			{
+				return __sndr.apply(static_cast<_Sender&&>(__sndr), static_cast<_ApplyFn&&>(__fun));
+			}
+		};
+
+		template <class _Fn>
+		struct __sexpr_uncurry_fn
+		{
+			template <class _Tag, class _Data, class... _Child>
+			constexpr auto operator()(_Tag, _Data&&, _Child&&...) const noexcept
+				-> _m_call<_Fn, _Tag, _Data, _Child...>;
+		};
+
+		template <class _CvrefSender, class _Fn>
+		using __sexpr_uncurry = _call_result_t<__sexpr_apply_t, _CvrefSender, __sexpr_uncurry_fn<_Fn>>;
+
+		template <class _Sender>
+		using __desc_of = __sexpr_uncurry<_Sender, _m_quote<__desc>>;
+
+		template <class _Sexpr, class _Receiver>
+		struct __connect_fn
+		{
+			template <std::size_t _Idx>
+			using __receiver_t = __t<__rcvr<_Receiver, _Sexpr, _Idx>>;
+
+			__op_state<_Sexpr, _Receiver>* __op_;
+
+			struct __impl
+			{
+				__op_state<_Sexpr, _Receiver>* __op_;
+
+				template <std::size_t... _Is, class... _Child>
+				auto operator()(std::index_sequence<_Is...>, _Child&&... __child) const
+					noexcept((_nothrow_callable<connect_t, _Child, __receiver_t<_Is>> && ...))
+					-> _tuple<connect_result_t<_Child, __receiver_t<_Is>>...>
+				{
+					return _tuple{ ustdex::connect(static_cast<_Child&&>(__child), __receiver_t<_Is>{__op_})... };
+				}
+			};
+
+			template <class... _Child>
+			auto operator()(_ignore, _ignore, _Child&&... __child) const
+				noexcept(_nothrow_callable<__impl, std::index_sequence_for<_Child...>, _Child...>)
+				-> _call_result_t<__impl, std::index_sequence_for<_Child...>, _Child...>
+			{
+				return __impl{ __op_ }(std::index_sequence_for<_Child...>(), static_cast<_Child&&>(__child)...);
+			}
+
+			auto operator()(_ignore, _ignore) const noexcept -> _tuple<>
+			{
+				return {};
+			}
+		};
+
+		template <class _Tag, class _Sexpr, class _Receiver>
+		using __state_type_t =
+			std::decay_t<decltype(__sexpr_impl<_Tag>::get_state(std::declval<_Sexpr>(), std::declval<_Receiver&>()))>;
+
+		template <class _Self, class _Tag, class _Index, class _Sexpr, class _Receiver>
+		using __env_type_t = decltype(
+			__sexpr_impl<_Tag>::get_env(std::declval<_Index>(), std::declval<__state_type_t<_Tag, _Sexpr, _Receiver>&>(), std::declval<_Receiver&>())
+			);
+
+		template <class _Fn>
+		struct __drop_front_impl
+		{
+			template <class... _Rest>
+			auto operator()(_ignore, _Rest&&... __rest) const noexcept(
+				_nothrow_callable<const _Fn&, _Rest...>) -> _call_result_t<const _Fn&, _Rest...>
+			{
+				return __fn(static_cast<_Rest&&>(__rest)...);
+			};
+
+			_Fn __fn;
+		};
+
+		template <class _Fn>
+		inline constexpr __drop_front_impl<_Fn> __drop_front(_Fn __fn) noexcept
+		{
+			return __drop_front_impl<_Fn>{std::move(__fn)};
+		};
+
+		template <class _Tag, class... _Captures>
+		struct __captures_impl
+		{
+			template<class _Cvref, class _Fun>
+			auto operator()(_Cvref, _Fun&& __fun) noexcept(_nothrow_callable<_Fun, _Tag, _m_call<_Cvref, _Captures>...>)
+				-> _call_result_t<_Fun, _Tag, _m_call<_Cvref, _Captures>...>
+			{
+				return __captures3_tup.apply([__fun = std::move(__fun)](_Captures&... __captures3) mutable
+					{
+						return static_cast<_Fun&&>(__fun)(_Tag(), const_cast<_m_call<_Cvref, _Captures>&&>(__captures3)...);
+					}, __captures3_tup);
+			}
+			_tuple<_Captures...> __captures3_tup;
+		};
+
+		template <class _Tag, class... _Captures>
+		constexpr auto __captures(_Tag, _Captures&&... __captures2)
+		{
+			return __captures_impl<_Tag, _Captures...>{_tuple<_Captures...>{std::move(__captures2)...}};
+		}
+
+		template <class _Tag, class _Data, class... _Child>
+		using __captures_t = decltype(__captures(_Tag(), std::declval<_Data>(), std::declval<_Child>()...));
+
+		template <class _Sexpr, class _Receiver>
+		struct __op_base : _immovable
+		{
+			using __tag_t = typename std::decay_t<_Sexpr>::__tag_t;
+			using __state_t = __state_type_t<__tag_t, _Sexpr, _Receiver>;
+
+			USTDEX_NO_UNIQUE_ADDRESS
+				_Receiver __rcvr_;
+			USTDEX_NO_UNIQUE_ADDRESS
+				__state_t __state_;
+
+			__op_base(_Sexpr&& __sndr, _Receiver&& __rcvr) noexcept(
+				_nothrow_decay_copyable<_Receiver>
+				&& _nothrow_callable<decltype(__sexpr_impl<__tag_t>::get_state), _Sexpr, _Receiver&>)
+				: __rcvr_(static_cast<_Receiver&&>(__rcvr))
+				, __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_))
+			{}
+
+			USTDEX_ATTR_ALWAYS_INLINE auto __state() & noexcept -> __state_t&
+			{
+				return __state_;
+			}
+
+			USTDEX_ATTR_ALWAYS_INLINE auto __state() const& noexcept -> const __state_t&
+			{
+				return __state_;
+			}
+
+			USTDEX_ATTR_ALWAYS_INLINE auto __rcvr() & noexcept -> _Receiver&
+			{
+				return __rcvr_;
+			}
+
+			USTDEX_ATTR_ALWAYS_INLINE auto __rcvr() const& noexcept -> const _Receiver&
+			{
+				return __rcvr_;
+			}
+		};
+
+		struct __defaults
+		{
+			static constexpr struct
+			{
+				template <class... _Child>
+				auto operator()(_ignore, const _Child&... __child) const noexcept -> decltype(auto)
+				{
+					if constexpr (sizeof...(__child) == 1)
+					{
+						return ustdex::get_env(__child...);
+					}
+					else
+					{
+						return env<>();
+					}
+				}
+			} get_attrs;
+
+			static constexpr struct
+			{
+				template <class _Receiver>
+				auto operator()(_ignore, _ignore, const _Receiver& __rcvr) const noexcept
+					-> env_of_t<const _Receiver&>
+				{
+					return ustdex::get_env(__rcvr);
+				};
+
+			} get_env;
+
+			static constexpr struct
+			{
+				template <class _Sender>
+				auto operator()(_Sender&& __sndr, _ignore) const noexcept -> decltype(auto)
+				{
+					return __sndr.apply(static_cast<_Sender&&>(__sndr), __get_data());
+				};
+
+			} get_state;
+
+			static constexpr struct
+			{
+				//requires __connectable<_Sender, _Receiver>
+				template <class _Sender, class _Receiver>
+				auto operator()(_Sender&& __sndr, _Receiver __rcvr) const noexcept(
+					_nothrow_constructible<__op_state<_Sender, _Receiver>, _Sender, _Receiver>)
+					-> __op_state<_Sender, _Receiver>
+				{
+					return __op_state<_Sender, _Receiver>{
+						static_cast<_Sender&&>(__sndr), static_cast<_Receiver&&>(__rcvr)};
+				};
+			} connect;
+
+			static constexpr struct
+			{
+				template <class _StartTag = start_t, class... _ChildOps>
+				auto operator()(
+					_ignore,
+					_ignore,
+					_ChildOps&... __ops) const noexcept
+				{
+					(_StartTag()(__ops), ...);
+				};
+			} start;
+
+			static constexpr struct
+			{
+				template <class _Index, class _Receiver, class _SetTag, class... _Args>
+				auto operator()(
+					_Index,
+					_ignore,
+					_Receiver& __rcvr,
+					_SetTag,
+					_Args&&... __args) const noexcept
+				{
+					static_assert(_Index::value == 0, "I don't know how to complete this operation.");
+					_SetTag()(std::move(__rcvr), static_cast<_Args&&>(__args)...);
+				};
+			} complete;
+
+			static constexpr struct
+			{
+				template <class _Sender, typename... _Args>
+				void operator()(_Sender&&, _Args&&...) const noexcept
+				{
+					static_assert(
+						__mnever < tag_of_t<_Sender>>
+						"No customization of get_completion_signatures for this sender tag type.");
+				};
+			} get_completion_signatures;
+		};
+	}
+
+	using detail::__sexpr_apply_t;
+	inline constexpr __sexpr_apply_t __sexpr_apply{};
+
+	template <class _Sexpr, class _Receiver>
+	struct __op_state : detail::__op_base<_Sexpr, _Receiver>
+	{
+		using __desc_t = typename std::decay_t<_Sexpr>::__desc_t;
+		using __tag_t = typename __desc_t::__tag;
+		using __data_t = typename __desc_t::__data;
+		using __state_t = typename __op_state::__state_t;
+		using __inner_ops_t =
+			_call_result_t<detail::__sexpr_apply_t, _Sexpr, detail::__connect_fn<_Sexpr, _Receiver>>;
+
+		__inner_ops_t __inner_ops_;
+
+		__op_state(_Sexpr&& __sexpr, _Receiver __rcvr) noexcept(
+			_nothrow_constructible<detail::__op_base<_Sexpr, _Receiver>, _Sexpr, _Receiver>
+			&& _nothrow_callable<detail::__sexpr_apply_t, _Sexpr, detail::__connect_fn<_Sexpr, _Receiver>>)
+			: __op_state::__op_base{ static_cast<_Sexpr&&>(__sexpr), static_cast<_Receiver&&>(__rcvr) }
+			, __inner_ops_(__sexpr_apply(
+				static_cast<_Sexpr&&>(__sexpr),
+				detail::__connect_fn<_Sexpr, _Receiver>{this}))
+		{}
+
+		USTDEX_ATTR_ALWAYS_INLINE void start() & noexcept
+		{
+			using __tag_t = typename __op_state::__tag_t;
+			auto&& __rcvr = this->__rcvr();
+			__inner_ops_.apply(
+				[&](auto&... __ops) noexcept
+				{
+					__sexpr_impl<__tag_t>::start(this->__state(), __rcvr, __ops...);
+				},
+				__inner_ops_);
+		}
+
+		template <class _Index, class _Tag2, class... _Args>
+		USTDEX_ATTR_ALWAYS_INLINE
+			void __complete(_Index, _Tag2, _Args&&... __args) noexcept
+		{
+			using __tag_t = typename __op_state::__tag_t;
+			auto&& __rcvr = this->__rcvr();
+			using _CompleteFn = __mtypeof<__sexpr_impl<__tag_t>::complete>;
+			if constexpr (__callable<_CompleteFn, _Index, __op_state&, _Tag2, _Args...>)
+			{
+				__sexpr_impl<__tag_t>::complete(_Index(), *this, _Tag2(), static_cast<_Args&&>(__args)...);
+			}
+			else
+			{
+				__sexpr_impl<__tag_t>::complete(
+					_Index(), this->__state(), __rcvr, _Tag2(), static_cast<_Args&&>(__args)...);
+			}
+		}
+
+		template <class _Index>
+		USTDEX_ATTR_ALWAYS_INLINE
+			auto __get_env(_Index) const noexcept
+			-> detail::__env_type_t<_Index, __tag_t, _Index, _Sexpr, _Receiver>
+		{
+			const auto& __rcvr = this->__rcvr();
+			return __sexpr_impl<__tag_t>::get_env(_Index(), this->__state(), __rcvr);
+		}
+	};
+
+	template <class _Sender>
+	using tag_of_t = typename detail::__desc_of<_Sender>::__tag;
+
+	template <class _Tag, class _Data, class... _Child>
+	using __descriptor_fn_t = _fn_t<detail::__desc<_Tag, _Data, _Child...>>*;
+
+	using __sexpr_defaults = detail::__defaults;
+
+	template <class _Receiver, class _Sexpr, std::size_t _Idx>
+	struct __rcvr
+	{
+		struct __t
+		{
+			using receiver_concept = receiver_t;
+			using __id = __rcvr;
+
+			using __index = _m_size_t<_Idx>;
+			using __parent_op_t = __op_state<_Sexpr, _Receiver>;
+			using __tag_t = tag_of_t<_Sexpr>;
+
+			// A pointer to the parent operation state, which contains the one created with
+			// this receiver.
+			__parent_op_t* __op_;
+
+			template <class... _Args>
+			USTDEX_ATTR_ALWAYS_INLINE
+				void set_value(_Args&&... __args) noexcept
+			{
+				__op_->__complete(__index(), ustdex::set_value, static_cast<_Args&&>(__args)...);
+			}
+
+			template <class _Error>
+			USTDEX_ATTR_ALWAYS_INLINE
+				void set_error(_Error&& __err) noexcept
+			{
+				__op_->__complete(__index(), ustdex::set_error, static_cast<_Error&&>(__err));
+			}
+
+			USTDEX_ATTR_ALWAYS_INLINE void set_stopped() noexcept
+			{
+				__op_->__complete(__index(), ustdex::set_stopped);
+			}
+
+			template <typename _Self = __t, typename = std::enable_if_t<std::is_same_v<_Self, __t>>>
+			USTDEX_ATTR_ALWAYS_INLINE
+				auto get_env() const noexcept
+				-> detail::__env_type_t<_Self, __tag_t, __index, _Sexpr, _Receiver>
+			{
+				return __op_->__get_env(__index());
+			}
+		};
+	};
+
+	template <class _Tag>
+	struct __sexpr_impl : detail::__defaults
+	{
+		using not_specialized = void;
+	};
+
+	template <class _Tag>
+	using __get_attrs_fn =
+		decltype(detail::__drop_front(__sexpr_impl<_Tag>::get_attrs));
+
+	namespace
+	{
+		//! A struct template to aid in creating senders.
+		//! This struct closely resembles P2300's [_`basic-sender`_](https://eel.is/c++draft/exec#snd.expos-24),
+		//! but is not an exact implementation.
+		//! Note: The struct named `__basic_sender` is just a dummy type and is also not _`basic-sender`_.
+		template <typename _DescriptorFn>
+		struct __sexpr
+		{
+			using sender_concept = sender_t;
+
+			using __desc_t = decltype(std::declval<_DescriptorFn>()());
+			using __tag_t = typename __desc_t::__tag;
+			using __captures_t = _m_call<__desc_t, _m_indirect_q<detail::__captures_t>>;
+
+			mutable __captures_t __impl_;
+
+			template <class _Tag, class _Data, class... _Child>
+			explicit __sexpr(_Tag, _Data&& __data, _Child&&... __child)
+				: __impl_(
+					detail::__captures(
+						_Tag(),
+						static_cast<_Data&&>(__data),
+						static_cast<_Child&&>(__child)...))
+			{}
+
+			using __impl = __sexpr_impl<__tag_t>;
+			using _Self_t = __sexpr;
+
+			template <class _Self = _Self_t>
+			USTDEX_ATTR_ALWAYS_INLINE
+				auto get_env() const noexcept
+				-> __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>>
+			{
+				return __sexpr_apply(*this, detail::__drop_front(__impl::get_attrs));
+			}
+
+			template <class _Self, class... _Env>
+			USTDEX_ATTR_ALWAYS_INLINE
+				static auto get_completion_signatures() noexcept ->
+				__result_of<__impl::get_completion_signatures, _Self, _Env...>
+			{
+				return {};
+			}
+
+			// BUGBUG fix receiver constraint here:
+			template <class _Receiver>
+			USTDEX_ATTR_ALWAYS_INLINE
+				auto connect(_Receiver&& __rcvr)
+				noexcept(_nothrow_callable<decltype(__impl::connect), _Self_t, _Receiver>) ->
+				__result_of<__impl::connect, _Self_t, _Receiver>
+			{
+				return __impl::connect(
+					static_cast<_Self_t&&>(*this), static_cast<_Receiver&&>(__rcvr));
+			}
+
+			template <class _Sender, class _ApplyFn>
+			USTDEX_ATTR_ALWAYS_INLINE
+				static auto apply(_Sender&& __sndr, _ApplyFn&& __fun) noexcept(
+					_nothrow_callable<detail::__impl_of<_Sender>, _copy_cvref_fn<_Sender>, _ApplyFn>)
+				-> _call_result_t<detail::__impl_of<_Sender>, _copy_cvref_fn<_Sender>, _ApplyFn>
+			{
+				return static_cast<_Sender&&>(__sndr)
+					.__impl_(_copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun));
+			}
+		};
+
+		template <class _Tag, class _Data, class... _Child>
+		__sexpr(_Tag, _Data, _Child...) -> __sexpr<__descriptor_fn_t<_Tag, _Data, _Child...>>;
+	} // namespace
 
 	template <class _Tag, class _Data, class... _Child>
 	using _sexpr_t = __sexpr<__descriptor_fn_t<_Tag, _Data, _Child...>>;
diff --git a/include/ustdex/detail/type_traits.hpp b/include/ustdex/detail/type_traits.hpp
index a21f5d2..ad4b58e 100644
--- a/include/ustdex/detail/type_traits.hpp
+++ b/include/ustdex/detail/type_traits.hpp
@@ -86,6 +86,9 @@ using _copy_cvref_t = typename _copy_cvref_fn<From>::template call<To>;
 template <class Fn, class... As>
 using _call_result_t = decltype(declval<Fn>()(declval<As>()...));
 
+template <const auto& _Fun, class... _As>
+using __result_of = _call_result_t<decltype(_Fun), _As...>;
+
 template <class Fn, class... As>
 inline constexpr bool _callable = _m_callable_q<_call_result_t, Fn, As...>;
 

From 8bb765fc93b247f783d06d12da4896d7d4e36b24 Mon Sep 17 00:00:00 2001
From: bzh <18635939450@163.com>
Date: Fri, 22 Aug 2025 18:41:59 +0800
Subject: [PATCH 10/12] =?UTF-8?q?=E5=AE=8C=E6=88=90basic=5Fsender?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/parallel_sort.hpp             | 100 ++++++++++++++++++++++++
 examples/scratch.cpp                   | 102 ++++++-------------------
 include/ustdex/detail/basic_sender.hpp |  49 ++++++------
 include/ustdex/detail/tuple.hpp        |  12 +++
 include/ustdex/detail/type_traits.hpp  |   2 +-
 include/ustdex/ustdex.hpp              |   3 +-
 6 files changed, 162 insertions(+), 106 deletions(-)

diff --git a/examples/parallel_sort.hpp b/examples/parallel_sort.hpp
index 7300d24..784469d 100644
--- a/examples/parallel_sort.hpp
+++ b/examples/parallel_sort.hpp
@@ -2,6 +2,105 @@
 
 #include <ustdex/ustdex.hpp>
 
+#define use_basic_sender
+
+#ifdef use_basic_sender
+namespace {
+
+struct parallel_sort_t
+{
+	template <class Sch, class RandomAccessIterator, typename SortFun>
+	auto operator()(Sch sch, RandomAccessIterator begin, RandomAccessIterator end, SortFun sort_fun) const noexcept
+	{
+		return ustdex::_make_sexpr<parallel_sort_t>(ustdex::_mk_tuple(begin, end, sort_fun, sch), ustdex::schedule(sch));
+	}
+};
+
+struct __impl : ustdex::__sexpr_defaults
+{
+private:
+	//Ïû³ýÄ£°åµÝ¹é
+	struct exec_then
+	{
+		template<typename... Args>
+		void operator()(Args&&... args)
+		{
+			_fun_();
+		}
+		std::function<void()> _fun_;
+	};
+
+public:
+	static constexpr struct
+	{
+		template<typename _Sender, typename... Env>
+		auto operator()(_Sender&&, Env&&...) const noexcept
+		{
+			using RAI = typename ustdex::data_of<_Sender>::template at<0>;
+			return ustdex::completion_signatures<ustdex::set_value_t(RAI, RAI), ustdex::set_error_t(::std::exception_ptr)>();
+		};
+	} get_completion_signatures;
+
+	static constexpr struct
+	{
+		template <class _State, class _Receiver, class _SetTag, class... _Args>
+		auto operator()(
+			ustdex::_ignore,
+			_State _state,
+			_Receiver& _rcvr,
+			_SetTag,
+			_Args&&... _args) const noexcept
+		{
+			auto _begin_ = ustdex::_cget<0>(_state);
+			auto _end_ = ustdex::_cget<1>(_state);
+			auto _sort_fun_ = ustdex::_cget<2>(_state);
+
+			if constexpr (std::is_same_v<_SetTag, ustdex::set_value_t>)
+			{
+				auto _begin_ = ustdex::_cget<0>(_state);
+				auto _end_ = ustdex::_cget<1>(_state);
+				auto _sort_fun_ = ustdex::_cget<2>(_state);
+				auto _sch_ = ustdex::_cget<3>(_state);
+				auto n = std::distance(_begin_, _end_);
+				if (n <= 16384)
+				{
+					std::sort(_begin_, _end_, _sort_fun_);
+					ustdex::set_value(std::move(_rcvr), std::move(_begin_), std::move(_end_));
+				}
+				else
+				{
+					auto mid = _begin_ + n / 2;
+					auto left = parallel_sort_t{}(_sch_, _begin_, mid, _sort_fun_);
+					auto right = parallel_sort_t{}(_sch_, mid, _end_, _sort_fun_);
+
+					std::function<void()> fun = [begin = _begin_, mid, end = _end_, rcvr = std::move(_rcvr)]() mutable
+						{
+							std::inplace_merge(begin, mid, end);
+							ustdex::set_value(std::move(rcvr), begin, end);
+						};
+					auto task = ustdex::when_all(std::move(left), std::move(right)) | ustdex::then(exec_then{ std::move(fun) });
+
+					ustdex::start_detached(std::move(task));
+				}
+			}
+			else
+			{
+				_SetTag()(static_cast<_Receiver&&>(_rcvr), static_cast<_Args&&>(_args)...);
+			}
+		};
+	} complete;
+};
+
+}
+
+namespace ustdex
+{
+	template <>
+	struct __sexpr_impl<parallel_sort_t> : __impl {};
+}
+
+inline constexpr parallel_sort_t parallel_sort;
+#else
 struct parallel_sort_t
 {
 private:
@@ -118,3 +217,4 @@ inline void parallel_sort_t::_opstate_t<Rcvr, Sch, RandomAccessIterator, SortFun
 		ustdex::start_detached(std::move(task));
 	}
 }
+#endif // use_basic_sender
diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 91f710e..330846c 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -23,18 +23,16 @@
 #include <any>
 #include <random>
 #include <chrono>
-//#include "parallel_sort.hpp"
-//#include "asio_thread_pool.hpp"
+ #include "parallel_sort.hpp"
+ //#include "asio_thread_pool.hpp"
 #include "ustdex/detail/basic_sender.hpp"
 
-using namespace ustdex;
-
 template<typename... Args>
 void _whatis();
 
 struct sink
 {
-	using receiver_concept = receiver_t;
+	using receiver_concept = ustdex::receiver_t;
 
 	void set_value() noexcept {}
 
@@ -54,10 +52,10 @@ struct sink
 	void set_stopped() noexcept {}
 
 	[[nodiscard]]
-	prop<get_stop_token_t, inplace_stop_token> get_env() const noexcept
+	ustdex::prop<ustdex::get_stop_token_t, ustdex::inplace_stop_token> get_env() const noexcept
 	{
-		static inplace_stop_source _stop_source_;
-		return prop{ get_stop_token, _stop_source_.get_token() };
+		static ustdex::inplace_stop_source _stop_source_;
+		return ustdex::prop{ ustdex::get_stop_token, _stop_source_.get_token() };
 	}
 };
 
@@ -65,92 +63,31 @@ template <class>
 [[deprecated]] void print()
 {}
 
-
-static_assert(dependent_sender<decltype(read_env(_empty()))>);
-
-namespace __test_sender
-{
-	struct test_sender_t
-	{
-		template <typename... _Ts>
-		auto operator()(_Ts&&... __ts) const noexcept((ustdex::_nothrow_decay_copyable<_Ts> && ...))
-		{
-			return ustdex::_make_sexpr<test_sender_t>(_tuple<_Ts...>{ static_cast<_Ts&&>(__ts)... });
-		}
-	};
-
-	struct __impl : __sexpr_defaults
-	{
-		static constexpr struct
-		{
-			template<typename _Sender, typename... Env>
-			auto operator()(_Sender&&, Env&&...) const noexcept
-			{
-				return completion_signatures<set_value_t()>{};
-			};
-		} get_completion_signatures;
-
-
-		static constexpr struct
-		{
-			template<class _State, class _Receiver>
-			void operator()(_State& __state, _Receiver& __rcvr) const noexcept
-			{
-				__state.apply([&__rcvr](auto&... ts)
-					{
-						ustdex::set_value(__rcvr, std::move(ts)...);
-					}, __state);
-			};
-		} start;
-	};
-}
-
-template <>
-struct __sexpr_impl<__test_sender::test_sender_t> : __test_sender::__impl {};
-
-template<typename T>
-auto test_aa(T t)
-{
-	return t;
-}
-
-template <class _Tag>
-using AA_get_attrs_fn = decltype(test_aa(_Tag {}));
-
 int main()
 {
-	AA_get_attrs_fn<int> vv;
-
-	__test_sender::test_sender_t test_sender;
-
-	//auto ts11 = test_sender(1, 2, 3);
-
-	//ts11.get_completion_signatures<int>();
-
-	//using T1 = ustdex::completion_signatures_of_t<decltype(ts11)>;
-
-	//_whatis<T1>();
-
-	auto v1 = test_sender(1, 2, 3);
+#if 0
+	std::cout << "main: " << std::this_thread::get_id() << std::endl;
 
-	/*using T_v1 = tag_of_t<decltype(v1)>;
 
-	_whatis<T_v1>();*/
+	ustdex::static_thread_pool thread_pool_b{};
+	auto v1 = test_sender(thread_pool_b.get_scheduler(), 2, 3, 4);
 
 	auto op = ustdex::connect(v1, sink{});
 
 	ustdex::start(op);
 
+	while (true);
 
+#endif
 	/*auto pp1 = ustdex::_make_sexpr<int>(3, 4, 5);
 	_whatis<decltype(pp1)::__captures_t>();*/
 
 	int a = 0;
 
-#if 0
-	asio::static_thread_pool thread_pool_a{};
+#if 1
+	//asio::static_thread_pool thread_pool_a{};
 	ustdex::static_thread_pool thread_pool_b{};
-	std::vector<int> values(100'000'000);
+	std::vector<int> values(100'000'000);//
 	std::random_device random_device;
 	std::mt19937 rng(random_device());
 	std::uniform_int_distribution<int> dist(1, 1'000'000);
@@ -160,12 +97,19 @@ int main()
 
 	auto begin = std::chrono::high_resolution_clock::now();
 	//thread_pool_b.get_scheduler()
-	auto ps = parallel_sort(atp::asio_scheduler{thread_pool_a.get_executor()}, values.begin(), values.end(), [](const int& a, const int& b)
+	/*auto ps = parallel_sort(atp::asio_scheduler{thread_pool_a.get_executor()}, values.begin(), values.end(), [](const int& a, const int& b)
+		{
+			return a < b;
+		});*/
+
+	auto ps = parallel_sort(thread_pool_b.get_scheduler(), values.begin(), values.end(), [](const int& a, const int& b)
 		{
 			return a < b;
 		});
+	auto op = ustdex::connect(ps, sink{});
 	ustdex::sync_wait(std::move(ps));
 
+
 	auto end = std::chrono::high_resolution_clock::now();
 
 	auto duration = end - begin;
diff --git a/include/ustdex/detail/basic_sender.hpp b/include/ustdex/detail/basic_sender.hpp
index 9f2abb7..ff37fcc 100644
--- a/include/ustdex/detail/basic_sender.hpp
+++ b/include/ustdex/detail/basic_sender.hpp
@@ -56,7 +56,7 @@ namespace ustdex
 		struct __get_data
 		{
 			template <class _Data, typename... _Child>
-			USTDEX_ATTR_ALWAYS_INLINE
+			//USTDEX_ATTR_ALWAYS_INLINE
 				auto operator()(_ignore, _Data&& __data, _Child&&...) const noexcept -> _Data&&
 			{
 				return static_cast<_Data&&>(__data);
@@ -107,9 +107,9 @@ namespace ustdex
 				template <std::size_t... _Is, class... _Child>
 				auto operator()(std::index_sequence<_Is...>, _Child&&... __child) const
 					noexcept((_nothrow_callable<connect_t, _Child, __receiver_t<_Is>> && ...))
-					-> _tuple<connect_result_t<_Child, __receiver_t<_Is>>...>
+					-> _tupl_for<connect_result_t<_Child, __receiver_t<_Is>>...>
 				{
-					return _tuple{ ustdex::connect(static_cast<_Child&&>(__child), __receiver_t<_Is>{__op_})... };
+					return _tupl{ ustdex::connect(static_cast<_Child&&>(__child), __receiver_t<_Is>{__op_})... };
 				}
 			};
 
@@ -159,10 +159,11 @@ namespace ustdex
 		struct __captures_impl
 		{
 			template<class _Cvref, class _Fun>
-			auto operator()(_Cvref, _Fun&& __fun) noexcept(_nothrow_callable<_Fun, _Tag, _m_call<_Cvref, _Captures>...>)
+			auto operator()(_Cvref a, _Fun&& __fun) noexcept(_nothrow_callable<_Fun, _Tag, _m_call<_Cvref, _Captures>...>)
 				-> _call_result_t<_Fun, _Tag, _m_call<_Cvref, _Captures>...>
 			{
 				return __captures3_tup.apply([__fun = std::move(__fun)](_Captures&... __captures3) mutable
+					-> _call_result_t<_Fun, _Tag, _m_call<_Cvref, _Captures>...>
 					{
 						return static_cast<_Fun&&>(__fun)(_Tag(), const_cast<_m_call<_Cvref, _Captures>&&>(__captures3)...);
 					}, __captures3_tup);
@@ -195,7 +196,8 @@ namespace ustdex
 				&& _nothrow_callable<decltype(__sexpr_impl<__tag_t>::get_state), _Sexpr, _Receiver&>)
 				: __rcvr_(static_cast<_Receiver&&>(__rcvr))
 				, __state_(__sexpr_impl<__tag_t>::get_state(static_cast<_Sexpr&&>(__sndr), __rcvr_))
-			{}
+			{
+			}
 
 			USTDEX_ATTR_ALWAYS_INLINE auto __state() & noexcept -> __state_t&
 			{
@@ -313,6 +315,20 @@ namespace ustdex
 	using detail::__sexpr_apply_t;
 	inline constexpr __sexpr_apply_t __sexpr_apply{};
 
+	template <class _Sender>
+	using tag_of_t = typename detail::__desc_of<_Sender>::__tag;
+
+	template <class _Sender>
+	using data_of = typename detail::__desc_of<_Sender>::__data;
+
+	template <class _Sender, class _Continuation = _m_quote<_m_list>>
+	using children_of = _m_apply<_Continuation, typename detail::__desc_of<_Sender>::__children>;
+
+	template <class _Tag, class _Data, class... _Child>
+	using __descriptor_fn_t = _fn_t<detail::__desc<_Tag, _Data, _Child...>>*;
+
+	using __sexpr_defaults = detail::__defaults;
+
 	template <class _Sexpr, class _Receiver>
 	struct __op_state : detail::__op_base<_Sexpr, _Receiver>
 	{
@@ -336,7 +352,6 @@ namespace ustdex
 
 		USTDEX_ATTR_ALWAYS_INLINE void start() & noexcept
 		{
-			using __tag_t = typename __op_state::__tag_t;
 			auto&& __rcvr = this->__rcvr();
 			__inner_ops_.apply(
 				[&](auto&... __ops) noexcept
@@ -352,16 +367,8 @@ namespace ustdex
 		{
 			using __tag_t = typename __op_state::__tag_t;
 			auto&& __rcvr = this->__rcvr();
-			using _CompleteFn = __mtypeof<__sexpr_impl<__tag_t>::complete>;
-			if constexpr (__callable<_CompleteFn, _Index, __op_state&, _Tag2, _Args...>)
-			{
-				__sexpr_impl<__tag_t>::complete(_Index(), *this, _Tag2(), static_cast<_Args&&>(__args)...);
-			}
-			else
-			{
-				__sexpr_impl<__tag_t>::complete(
-					_Index(), this->__state(), __rcvr, _Tag2(), static_cast<_Args&&>(__args)...);
-			}
+			__sexpr_impl<__tag_t>::complete(
+				_Index(), this->__state(), __rcvr, _Tag2(), static_cast<_Args&&>(__args)...);
 		}
 
 		template <class _Index>
@@ -374,14 +381,6 @@ namespace ustdex
 		}
 	};
 
-	template <class _Sender>
-	using tag_of_t = typename detail::__desc_of<_Sender>::__tag;
-
-	template <class _Tag, class _Data, class... _Child>
-	using __descriptor_fn_t = _fn_t<detail::__desc<_Tag, _Data, _Child...>>*;
-
-	using __sexpr_defaults = detail::__defaults;
-
 	template <class _Receiver, class _Sexpr, std::size_t _Idx>
 	struct __rcvr
 	{
@@ -476,7 +475,7 @@ namespace ustdex
 
 			template <class _Self, class... _Env>
 			USTDEX_ATTR_ALWAYS_INLINE
-				static auto get_completion_signatures() noexcept ->
+				static constexpr auto get_completion_signatures() noexcept ->
 				__result_of<__impl::get_completion_signatures, _Self, _Env...>
 			{
 				return {};
diff --git a/include/ustdex/detail/tuple.hpp b/include/ustdex/detail/tuple.hpp
index 3037bf0..ed6c266 100644
--- a/include/ustdex/detail/tuple.hpp
+++ b/include/ustdex/detail/tuple.hpp
@@ -47,6 +47,9 @@ struct _tupl;
 template <std::size_t... Idx, class... Ts>
 struct _tupl<std::index_sequence<Idx...>, Ts...> : _box<Idx, Ts>...
 {
+  template<std::size_t idx_at>
+  using at = _m_index<idx_at, Ts...>;
+
   template <class Fn, class Self, class... Us>
   USTDEX_TRIVIAL_API static auto apply(Fn&& _fn, Self&& _self, Us&&... _us) //
     noexcept(_nothrow_callable<Fn, Us..., _copy_cvref_t<Self, Ts>...>)
@@ -82,6 +85,15 @@ namespace detail
 template <class... Ts>
 using _tuple = detail::_tuple<Ts...>;
 
+template <class... _Ts>
+using _tupl_for = _tuple<_Ts...>;
+
+template <typename... Ts>
+_tuple<Ts...> _mk_tuple(Ts... ts)
+{
+    return _tuple<Ts...>{std::move(ts)...};
+}
+
 template <class... Ts>
 using _decayed_tuple = _tuple<USTDEX_DECAY(Ts)...>;
 
diff --git a/include/ustdex/detail/type_traits.hpp b/include/ustdex/detail/type_traits.hpp
index ad4b58e..f2add77 100644
--- a/include/ustdex/detail/type_traits.hpp
+++ b/include/ustdex/detail/type_traits.hpp
@@ -84,7 +84,7 @@ template <class From, class To>
 using _copy_cvref_t = typename _copy_cvref_fn<From>::template call<To>;
 
 template <class Fn, class... As>
-using _call_result_t = decltype(declval<Fn>()(declval<As>()...));
+using _call_result_t = decltype(std::declval<Fn>()(std::declval<As>()...));
 
 template <const auto& _Fun, class... _As>
 using __result_of = _call_result_t<decltype(_Fun), _As...>;
diff --git a/include/ustdex/ustdex.hpp b/include/ustdex/ustdex.hpp
index 6aa3bfe..04138ca 100644
--- a/include/ustdex/ustdex.hpp
+++ b/include/ustdex/ustdex.hpp
@@ -38,4 +38,5 @@
 #include "detail/write_env.hpp"      // IWYU pragma: export
 #include "detail/stop_when.hpp"      // IWYU pragma: export
 #include "detail/stop_with.hpp"      // IWYU pragma: export
-#include "detail/static_thread_pool.hpp"
\ No newline at end of file
+#include "detail/static_thread_pool.hpp"
+#include "detail/basic_sender.hpp"

From 8466d0dd2c9282977d49fd8e3d1cc22c2e49f859 Mon Sep 17 00:00:00 2001
From: bizehao <18635939450@163.com>
Date: Tue, 9 Sep 2025 22:46:01 +0800
Subject: [PATCH 11/12] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9Bbug,?=
 =?UTF-8?q?=20=E4=BC=98=E5=8C=96=5Fm=5Fquote?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 include/ustdex/detail/basic_sender.hpp |  2 +-
 include/ustdex/detail/conditional.hpp  |  2 ++
 include/ustdex/detail/meta.hpp         | 28 +++++++++++++-------------
 include/ustdex/detail/when_all.hpp     |  2 +-
 4 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/include/ustdex/detail/basic_sender.hpp b/include/ustdex/detail/basic_sender.hpp
index ff37fcc..61212fd 100644
--- a/include/ustdex/detail/basic_sender.hpp
+++ b/include/ustdex/detail/basic_sender.hpp
@@ -449,7 +449,7 @@ namespace ustdex
 
 			using __desc_t = decltype(std::declval<_DescriptorFn>()());
 			using __tag_t = typename __desc_t::__tag;
-			using __captures_t = _m_call<__desc_t, _m_indirect_q<detail::__captures_t>>;
+			using __captures_t = _m_call<__desc_t, _m_quote<detail::__captures_t>>;
 
 			mutable __captures_t __impl_;
 
diff --git a/include/ustdex/detail/conditional.hpp b/include/ustdex/detail/conditional.hpp
index 0603fe3..7d878a8 100644
--- a/include/ustdex/detail/conditional.hpp
+++ b/include/ustdex/detail/conditional.hpp
@@ -211,6 +211,8 @@ struct _cond_t
 template <class Sndr, class Pred, class Then, class Else>
 struct USTDEX_TYPE_VISIBILITY_DEFAULT _cond_t::_sndr_t
 {
+  using sender_concept = sender_t;
+
   using _data_t = _cond_t::_data<Pred, Then, Else>;
   _cond_t _tag_;
   _data_t _data_;
diff --git a/include/ustdex/detail/meta.hpp b/include/ustdex/detail/meta.hpp
index 86798ab..35b704f 100644
--- a/include/ustdex/detail/meta.hpp
+++ b/include/ustdex/detail/meta.hpp
@@ -68,20 +68,6 @@ struct _m_size
   using call USTDEX_ATTR_NODEBUG_ALIAS = _m_size_t<sizeof...(Ts)>;
 };
 
-template <template <class...> class Fn>
-struct _m_quote
-{
-  template <class... Ts>
-  using call USTDEX_ATTR_NODEBUG_ALIAS = Fn<Ts...>;
-};
-
-template <template <class> class Fn>
-struct _m_quote1
-{
-  template <class Ty>
-  using call USTDEX_ATTR_NODEBUG_ALIAS = Fn<Ty>;
-};
-
 template <class Fn, class... Ts>
 using _m_call USTDEX_ATTR_NODEBUG_ALIAS = typename Fn::template call<Ts...>;
 
@@ -144,6 +130,20 @@ struct _m_indirect_q
     typename detail::_m_call_indirect_fn<sizeof(_m_list<_Ts...>*)>::template call<_Fn, _Ts...>;
 };
 
+template <template <class...> class Fn>
+struct _m_quote
+{
+    template <class... Ts>
+    using call USTDEX_ATTR_NODEBUG_ALIAS = _m_call<_m_indirect_q<Fn>, Ts...>;
+};
+
+template <template <class> class Fn>
+struct _m_quote1
+{
+    template <class Ty>
+    using call USTDEX_ATTR_NODEBUG_ALIAS = Fn<Ty>;
+};
+
 template <bool>
 struct _m_if_
 {
diff --git a/include/ustdex/detail/when_all.hpp b/include/ustdex/detail/when_all.hpp
index 12410e6..5380c8f 100644
--- a/include/ustdex/detail/when_all.hpp
+++ b/include/ustdex/detail/when_all.hpp
@@ -400,7 +400,7 @@ USTDEX_API constexpr auto when_all_t::_merge_completions(Completions... _cs)
     }
     else
     {
-      using _m_list_size_fn                                    = _m_bind_front<_m_indirect_q<_m_apply>, _m_size>;
+      using _m_list_size_fn                                    = _m_bind_front<_m_quote<_m_apply>, _m_size>;
       std::array<std::size_t, sizeof...(Completions)> _offsets = {
         _value_types<Completions, _m_list, _m_list_size_fn::call>::value...};
       (void) ustdex::exclusive_scan(_offsets.begin(), _offsets.end(), _offsets.begin(), 0ul);

From b9f2c1270f328154ed805d54e29d6048c68e6f23 Mon Sep 17 00:00:00 2001
From: bzh <18635939450@163.com>
Date: Thu, 5 Feb 2026 23:20:56 +0800
Subject: [PATCH 12/12] =?UTF-8?q?=E4=BF=AE=E5=A4=8Dlet=5F=E7=9A=84env?=
 =?UTF-8?q?=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/scratch.cpp                | 19 +++++++++++++---
 include/ustdex/detail/config.hpp    |  3 +++
 include/ustdex/detail/let_value.hpp |  8 ++++---
 include/ustdex/detail/read_env.hpp  |  5 +++--
 include/ustdex/detail/run_loop.hpp  | 35 ++++++++++++++++-------------
 include/ustdex/detail/when_all.hpp  |  7 +++++-
 6 files changed, 53 insertions(+), 24 deletions(-)

diff --git a/examples/scratch.cpp b/examples/scratch.cpp
index 330846c..1aecb34 100644
--- a/examples/scratch.cpp
+++ b/examples/scratch.cpp
@@ -27,8 +27,6 @@
  //#include "asio_thread_pool.hpp"
 #include "ustdex/detail/basic_sender.hpp"
 
-template<typename... Args>
-void _whatis();
 
 struct sink
 {
@@ -63,8 +61,23 @@ template <class>
 [[deprecated]] void print()
 {}
 
+using namespace ustdex;
+
 int main()
 {
+  ustdex::thread_context tp;
+  using MT = decltype(tp.get_scheduler());
+  auto task = schedule(tp.get_scheduler()) | let_value([] {
+      /*return read_env(get_scheduler) | then([](auto&& sched) {
+                         static_assert(std::is_same_v < std::decay_t<decltype(sched)>, std::decay_t<MT>>);
+             });*/
+
+	  auto sched_sender = read_env(get_scheduler);
+      auto value_sender = just(42);
+      return when_all(std::move(sched_sender), std::move(value_sender)) // <-- use a when_all here
+          | then([](auto&& sched, int value) { /*io_uring_socket.async_send(value, on=sched)...*/ });
+    });
+
 #if 0
 	std::cout << "main: " << std::this_thread::get_id() << std::endl;
 
@@ -84,7 +97,7 @@ int main()
 
 	int a = 0;
 
-#if 1
+#if 0
 	//asio::static_thread_pool thread_pool_a{};
 	ustdex::static_thread_pool thread_pool_b{};
 	std::vector<int> values(100'000'000);//
diff --git a/include/ustdex/detail/config.hpp b/include/ustdex/detail/config.hpp
index 65c060f..c7ccfe2 100644
--- a/include/ustdex/detail/config.hpp
+++ b/include/ustdex/detail/config.hpp
@@ -366,3 +366,6 @@ using _remove_reference_t = __remove_reference_t(Ty);
 namespace ustdex
 {
 }
+
+template <typename... Args>
+struct _whatis;
diff --git a/include/ustdex/detail/let_value.hpp b/include/ustdex/detail/let_value.hpp
index 4dbfb8b..8d7d9c0 100644
--- a/include/ustdex/detail/let_value.hpp
+++ b/include/ustdex/detail/let_value.hpp
@@ -230,19 +230,21 @@ struct _let
     template <class Self, class... Env>
     USTDEX_API static constexpr auto get_completion_signatures()
     {
+      using SndrEnv = env_of_t<Sndr>;
+      using Env_t = env<SndrEnv, Env...>;
       USTDEX_LET_COMPLETIONS(auto(_child_completions) = get_child_completion_signatures<Self, Sndr, Env...>())
       {
         if constexpr (Disposition == _disposition_t::_value)
         {
-          return transform_completion_signatures(_child_completions, _transform_args_fn<Fn>{});
+          return transform_completion_signatures(_child_completions, _transform_args_fn<Fn, Env_t>{});
         }
         else if constexpr (Disposition == _disposition_t::_error)
         {
-          return transform_completion_signatures(_child_completions, {}, _transform_args_fn<Fn>{});
+          return transform_completion_signatures(_child_completions, {}, _transform_args_fn<Fn, Env_t>{});
         }
         else
         {
-          return transform_completion_signatures(_child_completions, {}, {}, _transform_args_fn<Fn>{});
+          return transform_completion_signatures(_child_completions, {}, {}, _transform_args_fn<Fn, Env_t>{});
         }
       }
     }
diff --git a/include/ustdex/detail/read_env.hpp b/include/ustdex/detail/read_env.hpp
index f89fa01..fc78a82 100644
--- a/include/ustdex/detail/read_env.hpp
+++ b/include/ustdex/detail/read_env.hpp
@@ -98,10 +98,11 @@ struct USTDEX_TYPE_VISIBILITY_DEFAULT read_env_t::_sndr_t
   {
     if constexpr (!_callable<Query, Env>)
     {
-      return invalid_completion_signature<WHERE(IN_ALGORITHM, read_env_t),
+      /*return invalid_completion_signature<WHERE(IN_ALGORITHM, read_env_t),
                                           WHAT(THE_CURRENT_ENVIRONMENT_LACKS_THIS_QUERY),
                                           WITH_QUERY(Query),
-                                          WITH_ENVIRONMENT(Env)>();
+                                          WITH_ENVIRONMENT(Env)>();*/
+      return _dependent_sender<Self>();
     }
     else if constexpr (std::is_void_v<_call_result_t<Query, Env>>)
     {
diff --git a/include/ustdex/detail/run_loop.hpp b/include/ustdex/detail/run_loop.hpp
index 8e1289a..1d3c714 100644
--- a/include/ustdex/detail/run_loop.hpp
+++ b/include/ustdex/detail/run_loop.hpp
@@ -130,21 +130,6 @@ class run_loop
       using _id            = _schedule_task;
       using sender_concept = sender_t;
 
-      template <class Rcvr>
-      USTDEX_API auto connect(Rcvr _rcvr) const noexcept -> _operation<Rcvr>
-      {
-        return {&_loop_->_head, _loop_, static_cast<Rcvr&&>(_rcvr)};
-      }
-
-      template <class Self>
-      USTDEX_API static constexpr auto get_completion_signatures() noexcept
-      {
-        return completion_signatures<set_value_t(), set_error_t(::std::exception_ptr), set_stopped_t()>();
-      }
-
-    private:
-      friend _scheduler;
-
       struct _env
       {
         run_loop* _loop_;
@@ -154,6 +139,11 @@ class run_loop
         {
           return _loop_->get_scheduler();
         }
+
+        USTDEX_API auto query(get_scheduler_t) const noexcept -> _scheduler
+        {
+          return _loop_->get_scheduler();
+        }
       };
 
       USTDEX_API auto get_env() const noexcept -> _env
@@ -161,6 +151,21 @@ class run_loop
         return _env{_loop_};
       }
 
+      template <class Rcvr>
+      USTDEX_API auto connect(Rcvr _rcvr) const noexcept -> _operation<Rcvr>
+      {
+        return {&_loop_->_head, _loop_, static_cast<Rcvr&&>(_rcvr)};
+      }
+
+      template <class Self>
+      USTDEX_API static constexpr auto get_completion_signatures() noexcept
+      {
+        return completion_signatures<set_value_t(), set_error_t(::std::exception_ptr), set_stopped_t()>();
+      }
+
+    private:
+      friend _scheduler;
+
       USTDEX_API explicit _schedule_task(run_loop* _loop) noexcept
           : _loop_(_loop)
       {}
diff --git a/include/ustdex/detail/when_all.hpp b/include/ustdex/detail/when_all.hpp
index 5380c8f..9aab5c0 100644
--- a/include/ustdex/detail/when_all.hpp
+++ b/include/ustdex/detail/when_all.hpp
@@ -384,7 +384,12 @@ template <class... Completions>
 USTDEX_API constexpr auto when_all_t::_merge_completions(Completions... _cs)
 {
   // Use USTDEX_LET_COMPLETIONS to ensure all completions are valid:
-  USTDEX_LET_COMPLETIONS(auto(_tmp) = (completion_signatures{}, ..., _cs)) // NB: uses overloaded comma operator
+  if constexpr (auto _tmp = (completion_signatures{}, ..., _cs);
+                !::ustdex::_valid_completion_signatures<decltype(_tmp)>)
+  {
+    return _pair{_tmp, _nil{}};
+  }
+  else                                                                     // NB: uses overloaded comma operator
   {
     std::ignore                 = _tmp;                                    // silence unused variable warning
     auto _non_value_completions = concat_completion_signatures(