From a1347eb6d6718785efa91a42f1b18506e722ab35 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:02:27 +0800
Subject: [PATCH 1/7] simplify parallel sender

---
 include/condy/senders.hpp | 88 +++++++++++++--------------------------
 1 file changed, 30 insertions(+), 58 deletions(-)

diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index c1d4b28..ce76ee1 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -99,81 +99,53 @@ class [[nodiscard]] FlaggedOpSender {
     Sender sender_;
 };
 
-template <typename... Senders> class [[nodiscard]] ParallelAllSender {
+template <typename Return, template <typename...> class OperationState,
+          typename... Senders>
+class [[nodiscard]] ParallelSender {
 public:
-    using ReturnType = std::pair<std::array<size_t, sizeof...(Senders)>,
-                                 std::tuple<typename Senders::ReturnType...>>;
+    using ReturnType = Return;
 
-    ParallelAllSender(Senders... senders) : senders_(std::move(senders)...) {}
+    ParallelSender(Senders... senders) : senders_(std::move(senders)...) {}
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::ParallelAllOperationState<Receiver, Senders...>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::tuple<Senders...> senders_;
-};
-
-template <typename... Senders> class [[nodiscard]] ParallelAnySender {
-public:
-    using ReturnType = std::pair<std::array<size_t, sizeof...(Senders)>,
-                                 std::tuple<typename Senders::ReturnType...>>;
-
-    ParallelAnySender(Senders... senders) : senders_(std::move(senders)...) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::ParallelAnyOperationState<Receiver, Senders...>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::tuple<Senders...> senders_;
-};
-
-template <typename... Senders> class [[nodiscard]] WhenAllSender {
-public:
-    using ReturnType = std::tuple<typename Senders::ReturnType...>;
-
-    WhenAllSender(Senders... senders) : senders_(std::move(senders)...) {}
-
-    template <typename S, typename... Ss>
-    WhenAllSender(WhenAllSender<Ss...> other, S sender)
+    template <typename PrevReturn, typename S, typename... Ss>
+    ParallelSender(ParallelSender<PrevReturn, OperationState, Ss...> &&other,
+                   S sender)
         : senders_(std::tuple_cat(std::move(other.senders_),
                                   std::make_tuple(std::move(sender)))) {}
 
     template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAllOperationState<Receiver, Senders...>(
-            std::move(senders_), std::move(receiver));
+        return OperationState<Receiver, Senders...>(std::move(senders_),
+                                                    std::move(receiver));
     }
 
 private:
     std::tuple<Senders...> senders_;
 
-    template <typename...> friend class WhenAllSender;
+    template <typename, template <typename...> class, typename...>
+    friend class ParallelSender;
 };
 
-template <typename... Senders> class [[nodiscard]] WhenAnySender {
-public:
-    using ReturnType = std::variant<typename Senders::ReturnType...>;
-
-    WhenAnySender(Senders... senders) : senders_(std::move(senders)...) {}
-
-    template <typename S, typename... Ss>
-    WhenAnySender(WhenAnySender<Ss...> other, S sender)
-        : senders_(std::tuple_cat(std::move(other.senders_),
-                                  std::make_tuple(std::move(sender)))) {}
+template <typename... Senders>
+using ParallelAllSender =
+    ParallelSender<std::pair<std::array<size_t, sizeof...(Senders)>,
+                             std::tuple<typename Senders::ReturnType...>>,
+                   detail::ParallelAllOperationState, Senders...>;
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAnyOperationState<Receiver, Senders...>(
-            std::move(senders_), std::move(receiver));
-    }
+template <typename... Senders>
+using ParallelAnySender =
+    ParallelSender<std::pair<std::array<size_t, sizeof...(Senders)>,
+                             std::tuple<typename Senders::ReturnType...>>,
+                   detail::ParallelAnyOperationState, Senders...>;
 
-private:
-    std::tuple<Senders...> senders_;
+template <typename... Senders>
+using WhenAllSender =
+    ParallelSender<std::tuple<typename Senders::ReturnType...>,
+                   detail::WhenAllOperationState, Senders...>;
 
-    template <typename...> friend class WhenAnySender;
-};
+template <typename... Senders>
+using WhenAnySender =
+    ParallelSender<std::variant<typename Senders::ReturnType...>,
+                   detail::WhenAnyOperationState, Senders...>;
 
 template <unsigned int Flags, typename... Senders>
 class [[nodiscard]] LinkSenderBase {

From e357fa3975afcc0eb0731563be89d7d94c1a4de7 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:08:57 +0800
Subject: [PATCH 2/7] simplify link sender

---
 include/condy/senders.hpp | 30 +++++++++++-------------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index ce76ee1..961c996 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -147,28 +147,20 @@ using WhenAnySender =
     ParallelSender<std::variant<typename Senders::ReturnType...>,
                    detail::WhenAnyOperationState, Senders...>;
 
-template <unsigned int Flags, typename... Senders>
-class [[nodiscard]] LinkSenderBase {
-public:
-    using ReturnType = std::tuple<typename Senders::ReturnType...>;
-
-    LinkSenderBase(Senders... senders) : senders_(std::move(senders)...) {}
-
-    template <typename S, typename... Ss>
-    LinkSenderBase(LinkSenderBase<Flags, Ss...> other, S sender)
-        : senders_(std::tuple_cat(std::move(other.senders_),
-                                  std::make_tuple(std::move(sender)))) {}
+namespace detail {
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::LinkOperationState<Receiver, Flags, Senders...>(
-            std::move(senders_), std::move(receiver));
-    }
+template <unsigned int Flags> struct link_sender_helper {
+    template <typename Receiver, typename... Senders>
+    using apply = LinkOperationState<Receiver, Flags, Senders...>;
+};
 
-private:
-    std::tuple<Senders...> senders_;
+} // namespace detail
 
-    template <unsigned int, typename...> friend class LinkSenderBase;
-};
+template <unsigned int Flags, typename... Senders>
+using LinkSenderBase =
+    ParallelSender<std::tuple<typename Senders::ReturnType...>,
+                   detail::link_sender_helper<Flags>::template apply,
+                   Senders...>;
 
 template <typename... Senders>
 using LinkSender = LinkSenderBase<IOSQE_IO_LINK, Senders...>;

From c044b7ff991c1a12c573e72a6370ef25649b61c5 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:21:41 +0800
Subject: [PATCH 3/7] simplify ranged senders

---
 include/condy/sender_operations.hpp |  4 ++
 include/condy/senders.hpp           | 98 +++++++++--------------------
 2 files changed, 35 insertions(+), 67 deletions(-)

diff --git a/include/condy/sender_operations.hpp b/include/condy/sender_operations.hpp
index 32f157f..2a516e2 100644
--- a/include/condy/sender_operations.hpp
+++ b/include/condy/sender_operations.hpp
@@ -8,6 +8,7 @@
 #include "condy/concepts.hpp"
 #include "condy/senders.hpp"
 #include <coroutine>
+#include <stdexcept>
 
 namespace condy {
 
@@ -204,6 +205,9 @@ template <typename... Senders> auto when_any(Senders &&...senders) {
  * @param range The range of operations to compose.
  */
 template <std::ranges::range Range> auto when_any(Range &&range) {
+    if (std::ranges::empty(range)) {
+        throw std::invalid_argument("when_any requires at least one sender");
+    }
     return parallel<RangedWhenAnySender>(std::forward<Range>(range));
 }
 
diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index 961c996..5f22191 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -168,93 +168,57 @@ using LinkSender = LinkSenderBase<IOSQE_IO_LINK, Senders...>;
 template <typename... Senders>
 using HardLinkSender = LinkSenderBase<IOSQE_IO_HARDLINK, Senders...>;
 
-template <typename Sender> class [[nodiscard]] RangedParallelAllSender {
+template <typename Return, template <typename...> class OperationState,
+          typename Sender>
+class [[nodiscard]] RangedParallelSender {
 public:
-    using ReturnType = std::pair<std::vector<size_t>,
-                                 std::vector<typename Sender::ReturnType>>;
+    using ReturnType = Return;
 
-    RangedParallelAllSender(std::vector<Sender> senders)
+    RangedParallelSender(std::vector<Sender> senders)
         : senders_(std::move(senders)) {}
 
     template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::RangedParallelAllOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
+        return OperationState<Receiver, Sender>(std::move(senders_),
+                                                std::move(receiver));
     }
 
 private:
     std::vector<Sender> senders_;
 };
 
-template <typename Sender> class [[nodiscard]] RangedParallelAnySender {
-public:
-    using ReturnType = std::pair<std::vector<size_t>,
-                                 std::vector<typename Sender::ReturnType>>;
-
-    RangedParallelAnySender(std::vector<Sender> senders)
-        : senders_(std::move(senders)) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::RangedParallelAnyOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
+template <typename Sender>
+using RangedParallelAllSender = RangedParallelSender<
+    std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
+    detail::RangedParallelAllOperationState, Sender>;
 
-private:
-    std::vector<Sender> senders_;
-};
+template <typename Sender>
+using RangedParallelAnySender = RangedParallelSender<
+    std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
+    detail::RangedParallelAnyOperationState, Sender>;
 
-template <typename Sender> class [[nodiscard]] RangedWhenAllSender {
-public:
-    using ReturnType = std::vector<typename Sender::ReturnType>;
+template <typename Sender>
+using RangedWhenAllSender =
+    RangedParallelSender<std::vector<typename Sender::ReturnType>,
+                         detail::WhenAllRangeOperationState, Sender>;
 
-    RangedWhenAllSender(std::vector<Sender> senders)
-        : senders_(std::move(senders)) {}
+template <typename Sender>
+using RangedWhenAnySender =
+    RangedParallelSender<std::pair<size_t, typename Sender::ReturnType>,
+                         detail::WhenAnyRangeOperationState, Sender>;
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAllRangeOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
+namespace detail {
 
-private:
-    std::vector<Sender> senders_;
+template <unsigned int Flags> struct ranged_link_sender_helper {
+    template <typename Receiver, typename Sender>
+    using apply = RangedLinkOperationState<Receiver, Flags, Sender>;
 };
 
-template <typename Sender> class [[nodiscard]] RangedWhenAnySender {
-public:
-    using ReturnType = std::pair<size_t, typename Sender::ReturnType>;
-
-    RangedWhenAnySender(std::vector<Sender> senders)
-        : senders_(std::move(senders)) {
-        if (senders_.empty()) {
-            throw std::invalid_argument(
-                "when_any requires at least one sender");
-        }
-    }
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAnyRangeOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::vector<Sender> senders_;
-};
+} // namespace detail
 
 template <unsigned int Flags, typename Sender>
-class [[nodiscard]] RangedLinkSenderBase {
-public:
-    using ReturnType = std::vector<typename Sender::ReturnType>;
-
-    RangedLinkSenderBase(std::vector<Sender> senders)
-        : senders_(std::move(senders)) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::RangedLinkOperationState<Receiver, Flags, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::vector<Sender> senders_;
-};
+using RangedLinkSenderBase = RangedParallelSender<
+    std::vector<typename Sender::ReturnType>,
+    detail::ranged_link_sender_helper<Flags>::template apply, Sender>;
 
 template <typename Sender>
 using RangedLinkSender = RangedLinkSenderBase<IOSQE_IO_LINK, Sender>;

From 31cb291940de2c127b12d4ae270c0ce86c2c9656 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:24:26 +0800
Subject: [PATCH 4/7] simplify link_sender_helper

---
 include/condy/senders.hpp | 36 ++++++++++++++++--------------------
 1 file changed, 16 insertions(+), 20 deletions(-)

diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index 5f22191..2eb96d1 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -99,6 +99,17 @@ class [[nodiscard]] FlaggedOpSender {
     Sender sender_;
 };
 
+namespace detail {
+
+template <template <typename, unsigned int, typename...> class OperationState,
+          unsigned int Flags>
+struct link_sender_helper {
+    template <typename Receiver, typename... Senders>
+    using apply = OperationState<Receiver, Flags, Senders...>;
+};
+
+} // namespace detail
+
 template <typename Return, template <typename...> class OperationState,
           typename... Senders>
 class [[nodiscard]] ParallelSender {
@@ -147,19 +158,11 @@ using WhenAnySender =
     ParallelSender<std::variant<typename Senders::ReturnType...>,
                    detail::WhenAnyOperationState, Senders...>;
 
-namespace detail {
-
-template <unsigned int Flags> struct link_sender_helper {
-    template <typename Receiver, typename... Senders>
-    using apply = LinkOperationState<Receiver, Flags, Senders...>;
-};
-
-} // namespace detail
-
 template <unsigned int Flags, typename... Senders>
 using LinkSenderBase =
     ParallelSender<std::tuple<typename Senders::ReturnType...>,
-                   detail::link_sender_helper<Flags>::template apply,
+                   detail::link_sender_helper<detail::LinkOperationState,
+                                              Flags>::template apply,
                    Senders...>;
 
 template <typename... Senders>
@@ -206,19 +209,12 @@ using RangedWhenAnySender =
     RangedParallelSender<std::pair<size_t, typename Sender::ReturnType>,
                          detail::WhenAnyRangeOperationState, Sender>;
 
-namespace detail {
-
-template <unsigned int Flags> struct ranged_link_sender_helper {
-    template <typename Receiver, typename Sender>
-    using apply = RangedLinkOperationState<Receiver, Flags, Sender>;
-};
-
-} // namespace detail
-
 template <unsigned int Flags, typename Sender>
 using RangedLinkSenderBase = RangedParallelSender<
     std::vector<typename Sender::ReturnType>,
-    detail::ranged_link_sender_helper<Flags>::template apply, Sender>;
+    detail::link_sender_helper<detail::RangedLinkOperationState,
+                               Flags>::template apply,
+    Sender>;
 
 template <typename Sender>
 using RangedLinkSender = RangedLinkSenderBase<IOSQE_IO_LINK, Sender>;

From ab84981be086403bdb0f2f0d73bc7dfc6e2715a4 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:27:05 +0800
Subject: [PATCH 5/7] fix ranged op state name

---
 include/condy/op_states.hpp | 8 ++++----
 include/condy/senders.hpp   | 5 ++---
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/include/condy/op_states.hpp b/include/condy/op_states.hpp
index 2688679..c8cc8dd 100644
--- a/include/condy/op_states.hpp
+++ b/include/condy/op_states.hpp
@@ -357,18 +357,18 @@ template <typename Receiver> struct ReceiverRangedAnyWrapper {
 };
 
 template <typename Receiver, typename Sender>
-using WhenAllRangeOperationState =
+using RangedWhenAllOperationState =
     RangedParallelAllOperationState<ReceiverRangedAllWrapper<Receiver>, Sender>;
 
 template <typename Receiver, typename Sender>
-using WhenAnyRangeOperationState =
+using RangedWhenAnyOperationState =
     RangedParallelAnyOperationState<ReceiverRangedAnyWrapper<Receiver>, Sender>;
 
 template <typename Receiver, unsigned int Flags, typename Sender>
 class RangedLinkOperationState
-    : public WhenAllRangeOperationState<Receiver, Sender> {
+    : public RangedWhenAllOperationState<Receiver, Sender> {
 public:
-    using Base = WhenAllRangeOperationState<Receiver, Sender>;
+    using Base = RangedWhenAllOperationState<Receiver, Sender>;
     using Base::Base;
 
     void start(unsigned int flags) noexcept {
diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index 2eb96d1..9e9aa28 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -8,7 +8,6 @@
 #include "condy/concepts.hpp"
 #include "condy/op_states.hpp"
 #include <array>
-#include <stdexcept>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -202,12 +201,12 @@ using RangedParallelAnySender = RangedParallelSender<
 template <typename Sender>
 using RangedWhenAllSender =
     RangedParallelSender<std::vector<typename Sender::ReturnType>,
-                         detail::WhenAllRangeOperationState, Sender>;
+                         detail::RangedWhenAllOperationState, Sender>;
 
 template <typename Sender>
 using RangedWhenAnySender =
     RangedParallelSender<std::pair<size_t, typename Sender::ReturnType>,
-                         detail::WhenAnyRangeOperationState, Sender>;
+                         detail::RangedWhenAnyOperationState, Sender>;
 
 template <unsigned int Flags, typename Sender>
 using RangedLinkSenderBase = RangedParallelSender<

From c7e650ff5616ad4974c12296233ab6ef052d9e13 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:30:37 +0800
Subject: [PATCH 6/7] rename to SenderBase

---
 include/condy/senders.hpp | 56 +++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index 9e9aa28..d9b45c6 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -111,15 +111,15 @@ struct link_sender_helper {
 
 template <typename Return, template <typename...> class OperationState,
           typename... Senders>
-class [[nodiscard]] ParallelSender {
+class [[nodiscard]] ParallelSenderBase {
 public:
     using ReturnType = Return;
 
-    ParallelSender(Senders... senders) : senders_(std::move(senders)...) {}
+    ParallelSenderBase(Senders... senders) : senders_(std::move(senders)...) {}
 
     template <typename PrevReturn, typename S, typename... Ss>
-    ParallelSender(ParallelSender<PrevReturn, OperationState, Ss...> &&other,
-                   S sender)
+    ParallelSenderBase(
+        ParallelSenderBase<PrevReturn, OperationState, Ss...> &&other, S sender)
         : senders_(std::tuple_cat(std::move(other.senders_),
                                   std::make_tuple(std::move(sender)))) {}
 
@@ -132,37 +132,37 @@ class [[nodiscard]] ParallelSender {
     std::tuple<Senders...> senders_;
 
     template <typename, template <typename...> class, typename...>
-    friend class ParallelSender;
+    friend class ParallelSenderBase;
 };
 
 template <typename... Senders>
 using ParallelAllSender =
-    ParallelSender<std::pair<std::array<size_t, sizeof...(Senders)>,
-                             std::tuple<typename Senders::ReturnType...>>,
-                   detail::ParallelAllOperationState, Senders...>;
+    ParallelSenderBase<std::pair<std::array<size_t, sizeof...(Senders)>,
+                                 std::tuple<typename Senders::ReturnType...>>,
+                       detail::ParallelAllOperationState, Senders...>;
 
 template <typename... Senders>
 using ParallelAnySender =
-    ParallelSender<std::pair<std::array<size_t, sizeof...(Senders)>,
-                             std::tuple<typename Senders::ReturnType...>>,
-                   detail::ParallelAnyOperationState, Senders...>;
+    ParallelSenderBase<std::pair<std::array<size_t, sizeof...(Senders)>,
+                                 std::tuple<typename Senders::ReturnType...>>,
+                       detail::ParallelAnyOperationState, Senders...>;
 
 template <typename... Senders>
 using WhenAllSender =
-    ParallelSender<std::tuple<typename Senders::ReturnType...>,
-                   detail::WhenAllOperationState, Senders...>;
+    ParallelSenderBase<std::tuple<typename Senders::ReturnType...>,
+                       detail::WhenAllOperationState, Senders...>;
 
 template <typename... Senders>
 using WhenAnySender =
-    ParallelSender<std::variant<typename Senders::ReturnType...>,
-                   detail::WhenAnyOperationState, Senders...>;
+    ParallelSenderBase<std::variant<typename Senders::ReturnType...>,
+                       detail::WhenAnyOperationState, Senders...>;
 
 template <unsigned int Flags, typename... Senders>
 using LinkSenderBase =
-    ParallelSender<std::tuple<typename Senders::ReturnType...>,
-                   detail::link_sender_helper<detail::LinkOperationState,
-                                              Flags>::template apply,
-                   Senders...>;
+    ParallelSenderBase<std::tuple<typename Senders::ReturnType...>,
+                       detail::link_sender_helper<detail::LinkOperationState,
+                                                  Flags>::template apply,
+                       Senders...>;
 
 template <typename... Senders>
 using LinkSender = LinkSenderBase<IOSQE_IO_LINK, Senders...>;
@@ -172,11 +172,11 @@ using HardLinkSender = LinkSenderBase<IOSQE_IO_HARDLINK, Senders...>;
 
 template <typename Return, template <typename...> class OperationState,
           typename Sender>
-class [[nodiscard]] RangedParallelSender {
+class [[nodiscard]] RangedParallelSenderBase {
 public:
     using ReturnType = Return;
 
-    RangedParallelSender(std::vector<Sender> senders)
+    RangedParallelSenderBase(std::vector<Sender> senders)
         : senders_(std::move(senders)) {}
 
     template <typename Receiver> auto connect(Receiver receiver) noexcept {
@@ -189,27 +189,27 @@ class [[nodiscard]] RangedParallelSender {
 };
 
 template <typename Sender>
-using RangedParallelAllSender = RangedParallelSender<
+using RangedParallelAllSender = RangedParallelSenderBase<
     std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
     detail::RangedParallelAllOperationState, Sender>;
 
 template <typename Sender>
-using RangedParallelAnySender = RangedParallelSender<
+using RangedParallelAnySender = RangedParallelSenderBase<
     std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
     detail::RangedParallelAnyOperationState, Sender>;
 
 template <typename Sender>
 using RangedWhenAllSender =
-    RangedParallelSender<std::vector<typename Sender::ReturnType>,
-                         detail::RangedWhenAllOperationState, Sender>;
+    RangedParallelSenderBase<std::vector<typename Sender::ReturnType>,
+                             detail::RangedWhenAllOperationState, Sender>;
 
 template <typename Sender>
 using RangedWhenAnySender =
-    RangedParallelSender<std::pair<size_t, typename Sender::ReturnType>,
-                         detail::RangedWhenAnyOperationState, Sender>;
+    RangedParallelSenderBase<std::pair<size_t, typename Sender::ReturnType>,
+                             detail::RangedWhenAnyOperationState, Sender>;
 
 template <unsigned int Flags, typename Sender>
-using RangedLinkSenderBase = RangedParallelSender<
+using RangedLinkSenderBase = RangedParallelSenderBase<
     std::vector<typename Sender::ReturnType>,
     detail::link_sender_helper<detail::RangedLinkOperationState,
                                Flags>::template apply,

From 469d0cbe88f6519b719e1e7f81f074bfb5678216 Mon Sep 17 00:00:00 2001
From: wokron <yi1tang.yang@gmail.com>
Date: Fri, 1 May 2026 19:37:31 +0800
Subject: [PATCH 7/7] simplify OpSender

---
 include/condy/senders.hpp | 71 ++++++++++++---------------------------
 1 file changed, 22 insertions(+), 49 deletions(-)

diff --git a/include/condy/senders.hpp b/include/condy/senders.hpp
index d9b45c6..9215726 100644
--- a/include/condy/senders.hpp
+++ b/include/condy/senders.hpp
@@ -16,71 +16,44 @@
 
 namespace condy {
 
-template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler>
-class [[nodiscard]] OpSender {
-public:
-    using ReturnType = std::invoke_result_t<CQEHandler &, io_uring_cqe *>;
-
-    OpSender(PrepFunc func, CQEHandler cqe_handler)
-        : prep_func_(std::move(func)), cqe_handler_(std::move(cqe_handler)) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::OpSenderOperationState<
-            OpFinishHandle<CQEHandler, Receiver>, PrepFunc>(
-            std::move(prep_func_), std::move(cqe_handler_),
-            std::move(receiver));
-    }
-
-private:
-    PrepFunc prep_func_;
-    CQEHandler cqe_handler_;
-};
-
 template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler,
-          typename MultiShotFunc>
-class [[nodiscard]] MultiShotOpSender {
+          template <typename...> class FinishHandle, typename... Args>
+class [[nodiscard]] OpSenderBase {
 public:
     using ReturnType = std::invoke_result_t<CQEHandler &, io_uring_cqe *>;
 
-    MultiShotOpSender(PrepFunc func, CQEHandler cqe_handler,
-                      MultiShotFunc multi_shot_func)
+    OpSenderBase(PrepFunc func, CQEHandler cqe_handler, Args... args)
         : prep_func_(std::move(func)), cqe_handler_(std::move(cqe_handler)),
-          multi_shot_func_(std::move(multi_shot_func)) {}
+          args_(std::make_tuple(std::move(args)...)) {}
 
     template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::OpSenderOperationState<
-            MultiShotOpFinishHandle<CQEHandler, MultiShotFunc, Receiver>,
-            PrepFunc>(std::move(prep_func_), std::move(cqe_handler_),
-                      std::move(receiver), std::move(multi_shot_func_));
+        return std::apply(
+            [&](auto &&...args) {
+                return detail::OpSenderOperationState<
+                    FinishHandle<CQEHandler, Args..., Receiver>, PrepFunc>(
+                    std::move(prep_func_), std::move(cqe_handler_),
+                    std::move(receiver), std::forward<decltype(args)>(args)...);
+            },
+            std::move(args_));
     }
 
 private:
     PrepFunc prep_func_;
     CQEHandler cqe_handler_;
-    MultiShotFunc multi_shot_func_;
+    std::tuple<Args...> args_;
 };
 
-template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler, typename FreeFunc>
-class [[nodiscard]] ZeroCopyOpSender {
-public:
-    using ReturnType = std::invoke_result_t<CQEHandler &, io_uring_cqe *>;
-
-    ZeroCopyOpSender(PrepFunc func, CQEHandler cqe_handler, FreeFunc free_func)
-        : prep_func_(std::move(func)), cqe_handler_(std::move(cqe_handler)),
-          free_func_(std::move(free_func)) {}
+template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler>
+using OpSender = OpSenderBase<PrepFunc, CQEHandler, OpFinishHandle>;
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::OpSenderOperationState<
-            ZeroCopyOpFinishHandle<CQEHandler, FreeFunc, Receiver>, PrepFunc>(
-            std::move(prep_func_), std::move(cqe_handler_), std::move(receiver),
-            std::move(free_func_));
-    }
+template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler,
+          typename MultiShotFunc>
+using MultiShotOpSender =
+    OpSenderBase<PrepFunc, CQEHandler, MultiShotOpFinishHandle, MultiShotFunc>;
 
-private:
-    PrepFunc prep_func_;
-    CQEHandler cqe_handler_;
-    FreeFunc free_func_;
-};
+template <PrepFuncLike PrepFunc, CQEHandlerLike CQEHandler, typename FreeFunc>
+using ZeroCopyOpSender =
+    OpSenderBase<PrepFunc, CQEHandler, ZeroCopyOpFinishHandle, FreeFunc>;
 
 template <unsigned int Flags, typename Sender>
 class [[nodiscard]] FlaggedOpSender {