exec::repeat_effect: No set_value Completion Signature

exec::repeat_effect_until provides the asynchronous analogue of an until
loop (i.e. a while not loop). The algorithm repeatedly:

1. Connects the wrapped sender, and then
2. Starts the resulting operation state and allows it to run

Until the result is true (or converts to true) at which point the
asynchronous loop ends and the overall asynchronous operation ends with
a nullary set_value completion signal.

exec::repeat_effect on the other hand provides the asynchronous analogue
of an infinite loop. Notably unlike until loops infinite loops never
complete successfully. Despite this exec::repeat_effect(snd) was
previously implemented as being equivalent to:

  exec::repeat_effect_until(snd | stdexec::then([] noexcept {
    return false;
  }))

Note that this means that the resulting sender advertised stdexec::
set_value_t() as a completion signature, but never actually sent it
(because the sender wrapped by exec::repeat_effect_until always
connected to form an asynchronous operation which sends false).

Addressed the above by updating exec::repeat_effect_until such that when
its child operation completes it examines sent type T:

- If std::remove_cvref_t<T>::value is a constant expression which
  evaluates to true, unconditionally completes the operation with a
  nullary set_value completion signature (i.e. the runtime branch is
  eliminated without relying on the optimizer), otherwise
- If T satisfies the conditions laid out above except that the constant
  expression evaluates to false, unconditionally starts the next loop
  (i.e. the call to stdexec::set_value is not emitted and therefore the
  operation's receiver need not support receipt thereof), otherwise
- Proceeds as before this change

Moreover updated the computation of exec::repeat_effect_until's
completion signatures to reflect the above: That is, if all set_value
completions of the child sender send a type which falls under the second
bullet above, no set_value completion signature will be advertised from
exec::repeat_effect_until.

Lastly updated the sender synthesized by exec::repeat_effect such that
it sends std::false_type rather than bool, thereby causing it to no
longer advertise set_value completion signatures (or require handling
thereof from its receiver).

Author: RobertLeahy

include/exec/repeat_effect_until.hpp

@@ -64,6 +64,9 @@ namespace exec {
       };
     };
 
+    template <typename _T, bool _B>
+    concept __compile_time_bool_of = std::remove_cvref_t<_T>::value == _B;
+
     STDEXEC_PRAGMA_PUSH()
     STDEXEC_PRAGMA_IGNORE_GNU("-Wtsan")
 
@@ -120,10 +123,15 @@ namespace exec {
         if constexpr (same_as<_Tag, set_value_t>) {
           // If the sender completed with true, we're done
           STDEXEC_TRY {
-            const bool __done = (static_cast<bool>(static_cast<_Args &&>(__args)) && ...);
-            if (__done) {
+            if constexpr ((__compile_time_bool_of<_Args, true> && ...)) {
               stdexec::set_value(static_cast<_Receiver &&>(this->__receiver()));
               return;
+            } else if constexpr (!(__compile_time_bool_of<_Args, false> && ...)) {
+              const bool __done = (static_cast<bool>(static_cast<_Args &&>(__args)) && ...);
+              if (__done) {
+                stdexec::set_value(static_cast<_Receiver &&>(this->__receiver()));
+                return;
+              }
             }
             __destroy();
             STDEXEC_TRY {
@@ -163,16 +171,23 @@ namespace exec {
       // There's something funny going on with __if_c here. Use std::conditional_t instead. :-(
       std::conditional_t<
         ((sizeof...(_Args) == 1) && (convertible_to<_Args, bool> && ...)),
-        completion_signatures<>,
+        std::conditional_t<
+          (__compile_time_bool_of<_Args, false> && ...),
+          completion_signatures<>,
+          completion_signatures<set_value_t()>>,
         __mexception<_INVALID_ARGUMENT_TO_REPEAT_EFFECT_UNTIL_<>, _WITH_SENDER_<_Sender>>
       >;
 
+    template <class...>
+    using __delete_set_value_t = completion_signatures<>;
+
     template <class _Sender, class... _Env>
     using __completions_t = stdexec::transform_completion_signatures<
       __completion_signatures_of_t<__decay_t<_Sender> &, _Env...>,
       stdexec::transform_completion_signatures<
         __completion_signatures_of_t<stdexec::schedule_result_t<exec::trampoline_scheduler>, _Env...>,
-        __eptr_completion
+        __eptr_completion,
+        __delete_set_value_t
       >,
       __mbind_front_q<__values_t, _Sender>::template __f
     >;
@@ -222,8 +237,8 @@ namespace exec {
       struct _never {
         template <class... _Args>
         STDEXEC_ATTRIBUTE(host, device, always_inline)
-        constexpr auto operator()(_Args &&...) const noexcept -> bool {
-          return false;
+        constexpr std::false_type operator()(_Args &&...) const noexcept {
+          return {};
         }
       };
 

test/exec/test_repeat_effect_until.cpp

@@ -189,11 +189,23 @@ namespace {
     REQUIRE(called);
   }
 
+  template <typename Receiver>
+  struct no_set_value_receiver : Receiver {
+    explicit no_set_value_receiver(Receiver r) noexcept
+      : Receiver(std::move(r)) {
+    }
+    void set_value() && noexcept = delete;
+  };
+
   TEST_CASE("repeat_effect repeats until an error is encountered", "[adaptors][repeat_effect]") {
     int counter = 0;
     ex::sender auto snd = exec::repeat_effect(
       succeed_n_sender(10, ex::set_error, std::string("error")) | ex::then([&] { ++counter; }));
-    auto op = ex::connect(std::move(snd), expect_error_receiver{std::string("error")});
+    static_assert(!all_contained_in<
+                  ex::completion_signatures<ex::set_value_t()>,
+                  ex::completion_signatures_of_t<decltype(snd), ex::env<>>>);
+    auto op = ex::connect(
+      std::move(snd), no_set_value_receiver(expect_error_receiver{std::string("error")}));
     ex::start(op);
     REQUIRE(counter == 10);
   }
@@ -202,7 +214,7 @@ namespace {
     int counter = 0;
     ex::sender auto snd = exec::repeat_effect(
       succeed_n_sender(10, ex::set_stopped) | ex::then([&] { ++counter; }));
-    auto op = ex::connect(std::move(snd), expect_stopped_receiver{});
+    auto op = ex::connect(std::move(snd), no_set_value_receiver(expect_stopped_receiver{}));
     ex::start(op);
     REQUIRE(counter == 10);
   }