Merge pull request #482 from bustercopley/main

when_all() should return just()

Author: ericniebler

include/stdexec/execution.hpp

@@ -4763,6 +4763,9 @@ namespace stdexec {
                   apply([](auto&&... __child_ops) noexcept -> void {
                     (execution::start(__child_ops), ...);
                   }, __self.__child_states_);
+                  if constexpr (sizeof...(_SenderIds) == 0) {
+                    __self.__complete();
+                  }
                 }
               }
 
@@ -4812,17 +4815,15 @@ namespace stdexec {
     struct when_all_t {
       template <sender... _Senders>
         requires tag_invocable<when_all_t, _Senders...> &&
-          sender<tag_invoke_result_t<when_all_t, _Senders...>> &&
-          (sizeof...(_Senders) > 0)
+          sender<tag_invoke_result_t<when_all_t, _Senders...>>
       auto operator()(_Senders&&... __sndrs) const
         noexcept(nothrow_tag_invocable<when_all_t, _Senders...>)
         -> tag_invoke_result_t<when_all_t, _Senders...> {
         return tag_invoke(*this, (_Senders&&) __sndrs...);
       }
 
       template <sender... _Senders>
-          requires (!tag_invocable<when_all_t, _Senders...>) &&
-            (sizeof...(_Senders) > 0)
+          requires (!tag_invocable<when_all_t, _Senders...>)
       auto operator()(_Senders&&... __sndrs) const
         -> __impl::__sender<__x<decay_t<_Senders>>...> {
         return __impl::__sender<__x<decay_t<_Senders>>...>{

test/stdexec/algos/adaptors/test_transfer_when_all.cpp

@@ -44,6 +44,11 @@ TEST_CASE("transfer_when_all simple example", "[adaptors][transfer_when_all]") {
   auto op = ex::connect(std::move(snd1), expect_value_receiver<double>{3.1415});
   ex::start(op);
 }
+TEST_CASE("transfer_when_all with no senders", "[adaptors][transfer_when_all]") {
+  auto snd = ex::transfer_when_all(inline_scheduler{});
+  auto op = ex::connect(std::move(snd), expect_void_receiver{});
+  ex::start(op);
+}
 
 TEST_CASE("transfer_when_all transfers the result when the scheduler dictates",
     "[adaptors][transfer_when_all]") {
@@ -57,6 +62,17 @@ TEST_CASE("transfer_when_all transfers the result when the scheduler dictates",
   sched.start_next();
   CHECK(res == 3.1415);
 }
+TEST_CASE("transfer_when_all with no senders transfers the result", "[adaptors][transfer_when_all]") {
+  impulse_scheduler sched;
+  auto snd = ex::transfer_when_all(sched);
+  auto snd1 = std::move(snd) | ex::then([]() { return true; });
+  bool res{false};
+  auto op = ex::connect(std::move(snd1), expect_value_receiver_ex<bool>{&res});
+  ex::start(op);
+  CHECK(!res);
+  sched.start_next();
+  CHECK(res);
+}
 
 TEST_CASE("transfer_when_all_with_variant returns a sender", "[adaptors][transfer_when_all]") {
   auto snd = ex::transfer_when_all_with_variant(inline_scheduler{}, ex::just(3), ex::just(0.1415));

test/stdexec/algos/adaptors/test_when_all.cpp

@@ -68,10 +68,9 @@ TEST_CASE("when_all with just one sender", "[adaptors][when_all]") {
   wait_for_value(std::move(snd), 2);
 }
 
-TEST_CASE("when_all with no senders sender -- should fail", "[adaptors][when_all]") {
-  // Should not compile:
-  // auto snd = ex::when_all();
-  static_assert(!std::invocable<ex::when_all_t>);
+TEST_CASE("when_all with no senders", "[adaptors][when_all]") {
+  ex::sender auto snd = ex::when_all();
+  wait_for_value(std::move(snd));
 }
 
 TEST_CASE("when_all when one sender sends void", "[adaptors][when_all]") {
@@ -100,6 +99,11 @@ TEST_CASE("when_all_with_variant with same type", "[adaptors][when_all]") {
       std::move(snd), std::variant<std::tuple<int>>{2}, std::variant<std::tuple<int>>{3});
 }
 
+TEST_CASE("when_all_with_variant with no senders", "[adaptors][when_all]") {
+  ex::sender auto snd = ex::when_all_with_variant();
+  wait_for_value(std::move(snd));
+}
+
 TEST_CASE("when_all completes when children complete", "[adaptors][when_all]") {
   impulse_scheduler sched;
   bool called{false};