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/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 c1d4b28..9215726 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>
@@ -17,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 {
@@ -99,104 +71,71 @@ class [[nodiscard]] FlaggedOpSender {
     Sender sender_;
 };
 
-template <typename... Senders> class [[nodiscard]] ParallelAllSender {
-public:
-    using ReturnType = std::pair<std::array<size_t, sizeof...(Senders)>,
-                                 std::tuple<typename Senders::ReturnType...>>;
-
-    ParallelAllSender(Senders... senders) : senders_(std::move(senders)...) {}
+namespace detail {
 
-    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 <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...>;
 };
 
-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_;
-};
+} // namespace detail
 
-template <typename... Senders> class [[nodiscard]] WhenAllSender {
+template <typename Return, template <typename...> class OperationState,
+          typename... Senders>
+class [[nodiscard]] ParallelSenderBase {
 public:
-    using ReturnType = std::tuple<typename Senders::ReturnType...>;
+    using ReturnType = Return;
 
-    WhenAllSender(Senders... senders) : senders_(std::move(senders)...) {}
+    ParallelSenderBase(Senders... senders) : senders_(std::move(senders)...) {}
 
-    template <typename S, typename... Ss>
-    WhenAllSender(WhenAllSender<Ss...> other, S sender)
+    template <typename PrevReturn, typename S, typename... Ss>
+    ParallelSenderBase(
+        ParallelSenderBase<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 ParallelSenderBase;
 };
 
-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 =
+    ParallelSenderBase<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 =
+    ParallelSenderBase<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 =
+    ParallelSenderBase<std::tuple<typename Senders::ReturnType...>,
+                       detail::WhenAllOperationState, Senders...>;
 
-    template <typename...> friend class WhenAnySender;
-};
+template <typename... Senders>
+using WhenAnySender =
+    ParallelSenderBase<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)))) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::LinkOperationState<Receiver, Flags, Senders...>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::tuple<Senders...> senders_;
-
-    template <unsigned int, typename...> friend class LinkSenderBase;
-};
+using LinkSenderBase =
+    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...>;
@@ -204,93 +143,50 @@ 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]] RangedParallelSenderBase {
 public:
-    using ReturnType = std::pair<std::vector<size_t>,
-                                 std::vector<typename Sender::ReturnType>>;
+    using ReturnType = Return;
 
-    RangedParallelAllSender(std::vector<Sender> senders)
+    RangedParallelSenderBase(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));
-    }
-
-private:
-    std::vector<Sender> senders_;
-};
-
-template <typename Sender> class [[nodiscard]] RangedWhenAllSender {
-public:
-    using ReturnType = std::vector<typename Sender::ReturnType>;
-
-    RangedWhenAllSender(std::vector<Sender> senders)
-        : senders_(std::move(senders)) {}
-
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAllRangeOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
-
-private:
-    std::vector<Sender> senders_;
-};
+template <typename Sender>
+using RangedParallelAllSender = RangedParallelSenderBase<
+    std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
+    detail::RangedParallelAllOperationState, 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 Sender>
+using RangedParallelAnySender = RangedParallelSenderBase<
+    std::pair<std::vector<size_t>, std::vector<typename Sender::ReturnType>>,
+    detail::RangedParallelAnyOperationState, Sender>;
 
-    template <typename Receiver> auto connect(Receiver receiver) noexcept {
-        return detail::WhenAnyRangeOperationState<Receiver, Sender>(
-            std::move(senders_), std::move(receiver));
-    }
+template <typename Sender>
+using RangedWhenAllSender =
+    RangedParallelSenderBase<std::vector<typename Sender::ReturnType>,
+                             detail::RangedWhenAllOperationState, Sender>;
 
-private:
-    std::vector<Sender> senders_;
-};
+template <typename Sender>
+using RangedWhenAnySender =
+    RangedParallelSenderBase<std::pair<size_t, typename Sender::ReturnType>,
+                             detail::RangedWhenAnyOperationState, Sender>;
 
 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 = RangedParallelSenderBase<
+    std::vector<typename Sender::ReturnType>,
+    detail::link_sender_helper<detail::RangedLinkOperationState,
+                               Flags>::template apply,
+    Sender>;
 
 template <typename Sender>
 using RangedLinkSender = RangedLinkSenderBase<IOSQE_IO_LINK, Sender>;