refactor sender types definition

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 {

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));
 }