fix the domain used to find customizations within repeat_n, repeat_effect_until, and iterate (#1581)

Author: ericniebler

include/exec/repeat_effect_until.hpp

@@ -22,6 +22,7 @@
 #include "../stdexec/__detail/__manual_lifetime.hpp"
 
 #include "trampoline_scheduler.hpp"
+#include "sequence.hpp"
 
 #include <atomic>
 #include <exception>
@@ -77,7 +78,7 @@ namespace exec {
       using __child_t = __decay_t<__data_of<_Sender>>;
       using __receiver_t = stdexec::__t<__receiver<__id<_Sender>, __id<_Receiver>>>;
       using __child_on_sched_sender_t =
-        __result_of<stdexec::starts_on, trampoline_scheduler, __child_t &>;
+        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __child_t &>;
       using __child_op_t = stdexec::connect_result_t<__child_on_sched_sender_t, __receiver_t>;
 
       __child_t __child_;
@@ -103,7 +104,8 @@ namespace exec {
 
       void __connect() {
         __child_op_.__construct_from([this] {
-          return stdexec::connect(stdexec::starts_on(__sched_, __child_), __receiver_t{this});
+          return stdexec::connect(
+            exec::sequence(stdexec::schedule(__sched_), __child_), __receiver_t{this});
         });
       }
 
@@ -172,6 +174,7 @@ namespace exec {
     >;
 
     struct __repeat_effect_tag { };
+
     struct __repeat_effect_until_tag { };
 
     struct __repeat_effect_until_impl : __sexpr_defaults {
@@ -218,7 +221,7 @@ namespace exec {
       struct _never {
         template <class... _Args>
         STDEXEC_ATTRIBUTE(host, device, always_inline)
-        constexpr auto operator()(_Args &&...) const noexcept -> bool{
+        constexpr auto operator()(_Args &&...) const noexcept -> bool {
           return false;
         }
       };
@@ -231,6 +234,7 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
+
       constexpr auto operator()() const -> __binder_back<repeat_effect_t> {
         return {{}, {}, {}};
       }

include/exec/repeat_n.hpp

@@ -22,6 +22,7 @@
 #include "../stdexec/__detail/__manual_lifetime.hpp"
 
 #include "trampoline_scheduler.hpp"
+#include "sequence.hpp"
 
 #include <atomic>
 #include <cstddef>
@@ -89,7 +90,7 @@ namespace exec {
       using __child_t = decltype(__child_count_pair_t::__child_);
       using __receiver_t = stdexec::__t<__receiver<__id<_Sender>, __id<_Receiver>>>;
       using __child_on_sched_sender_t =
-        __result_of<stdexec::starts_on, trampoline_scheduler, __child_t &>;
+        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __child_t &>;
       using __child_op_t = stdexec::connect_result_t<__child_on_sched_sender_t, __receiver_t>;
 
       __child_count_pair<__child_t> __pair_;
@@ -116,17 +117,16 @@ namespace exec {
       void __connect() {
         __child_op_.__construct_from([this] {
           return stdexec::connect(
-            stdexec::starts_on(__sched_, __pair_.__child_), __receiver_t{this});
+            exec::sequence(stdexec::schedule(__sched_), __pair_.__child_), __receiver_t{this});
         });
       }
 
       void __start() noexcept {
         if (__pair_.__count_ == 0) {
           stdexec::set_value(static_cast<_Receiver &&>(this->__receiver()));
         } else {
-
-          const bool __already_started [[maybe_unused]]
-          = __started_.test_and_set(std::memory_order_relaxed);
+          [[maybe_unused]]
+          const bool __already_started = __started_.test_and_set(std::memory_order_relaxed);
           STDEXEC_ASSERT(!__already_started);
           stdexec::start(__child_op_.__get());
         }
@@ -157,19 +157,20 @@ namespace exec {
 
     STDEXEC_PRAGMA_POP()
 
-    template <
-      __mstring _Where = "In repeat_n: "_mstr,
-      __mstring _What = "The input sender must be a sender of void"_mstr
-    >
-    struct _INVALID_ARGUMENT_TO_REPEAT_N_ { };
+    struct repeat_n_t;
+    struct _REPEAT_N_EXPECTS_A_SENDER_OF_VOID_;
 
     template <class _Sender, class... _Args>
     using __values_t =
       // There's something funny going on with __if_c here. Use std::conditional_t instead. :-(
       std::conditional_t<
         (sizeof...(_Args) == 0),
         completion_signatures<>,
-        __mexception<_INVALID_ARGUMENT_TO_REPEAT_N_<>, _WITH_SENDER_<_Sender>>
+        __mexception<
+          _REPEAT_N_EXPECTS_A_SENDER_OF_VOID_,
+          _WHERE_(_IN_ALGORITHM_, repeat_n_t),
+          _WITH_SENDER_<_Sender>
+        >
       >;
 
     template <class _Error>

include/exec/sequence/iterate.hpp

@@ -26,6 +26,7 @@
 #  include "../__detail/__basic_sequence.hpp"
 
 #  include "../trampoline_scheduler.hpp"
+#  include "../sequence.hpp"
 
 #  include <exception>
 #  include <ranges>
@@ -110,13 +111,13 @@ namespace exec {
       using _Receiver = stdexec::__t<_ReceiverId>;
       _Receiver __rcvr_;
 
-      using _ItemSender = decltype(stdexec::starts_on(
-        std::declval<trampoline_scheduler&>(),
-        std::declval<__sender_t<_Range>>()));
-
+      using __item_sender_t =
+        __result_of<exec::sequence, schedule_result_t<trampoline_scheduler&>, __sender_t<_Range>>;
       using __next_receiver_t = stdexec::__t<__next_receiver<_Range, _ReceiverId>>;
 
-      std::optional<connect_result_t<next_sender_of_t<_Receiver, _ItemSender>, __next_receiver_t>>
+      std::optional<
+        connect_result_t<next_sender_of_t<_Receiver, __item_sender_t>, __next_receiver_t>
+      >
         __op_{};
       trampoline_scheduler __scheduler_{};
 
@@ -128,7 +129,9 @@ namespace exec {
           STDEXEC_TRY {
             stdexec::start(__op_.emplace(__emplace_from{[&] {
               return stdexec::connect(
-                exec::set_next(__rcvr_, stdexec::starts_on(__scheduler_, __sender_t<_Range>{this})),
+                exec::set_next(
+                  __rcvr_,
+                  exec::sequence(stdexec::schedule(__scheduler_), __sender_t<_Range>{this})),
                 __next_receiver_t{this});
             }}));
           }
@@ -171,21 +174,23 @@ namespace exec {
       using __completion_sigs =
         completion_signatures<set_value_t(), set_error_t(std::exception_ptr), set_stopped_t()>;
 
-
       template <class _Sequence>
-      using _ItemSender = decltype(stdexec::starts_on(
-        __declval<trampoline_scheduler&>(),
-        __declval<__sender_t<__data_of<_Sequence>>>()));
+      using __item_sender_t = __result_of<
+        exec::sequence,
+        schedule_result_t<trampoline_scheduler&>,
+        __sender_t<__data_of<_Sequence>>
+      >;
 
       template <class _Sequence, class _Receiver>
       using _NextReceiver = stdexec::__t<__next_receiver<__data_of<_Sequence>, __id<_Receiver>>>;
 
       template <class _Sequence, class _Receiver>
-      using _NextSender = next_sender_of_t<_Receiver, _ItemSender<_Sequence>>;
+      using _NextSender = next_sender_of_t<_Receiver, __item_sender_t<_Sequence>>;
 
       template <
         sender_expr_for<iterate_t> _SeqExpr,
-        sequence_receiver_of<item_types<_ItemSender<_SeqExpr>>> _Receiver>
+        sequence_receiver_of<item_types<__item_sender_t<_SeqExpr>>> _Receiver
+      >
         requires sender_to<_NextSender<_SeqExpr, _Receiver>, _NextReceiver<_SeqExpr, _Receiver>>
       static auto subscribe(_SeqExpr&& __seq, _Receiver __rcvr)
         noexcept(__nothrow_callable<__sexpr_apply_t, _SeqExpr, __subscribe_fn<_Receiver>>)
@@ -200,7 +205,7 @@ namespace exec {
 
       template <sender_expr_for<iterate_t> _Sequence>
       static auto get_item_types(_Sequence&&, __ignore) noexcept //
-        -> item_types<_ItemSender<_Sequence>> {
+        -> item_types<__item_sender_t<_Sequence>> {
         return {};
       }
 

include/stdexec/__detail/__env.hpp

@@ -740,15 +740,15 @@ namespace stdexec {
     using __id = __sched_env;
 
     using __scheduler_t = __decay_t<_Scheduler>;
+    using __sched_domain_t = __query_result_or_t<get_domain_t, __scheduler_t, default_domain>;
     _Scheduler __sched_;
 
     auto query(get_scheduler_t) const noexcept -> __scheduler_t {
       return __sched_;
     }
 
-    template <class _Sched = _Scheduler>
-    auto query(get_domain_t) const noexcept -> __domain_of_t<_Sched> {
-      return get_domain(__sched_);
+    auto query(get_domain_t) const noexcept -> __sched_domain_t {
+      return {};
     }
   };
 

test/exec/test_repeat_n_fail.cpp

@@ -22,6 +22,6 @@ namespace ex = stdexec;
 
 auto main() -> int {
   ex::sender auto snd = ex::just(42) | exec::repeat_n(10);
-  // build error: _INVALID_ARGUMENT_TO_REPEAT_N_
+  // build error: _REPEAT_N_EXPECTS_A_SENDER_OF_VOID_
   stdexec::sync_wait(std::move(snd));
 }