the let_* algorithms have a dependent domain, which causes a recursiv…

…e tree transformation

include/exec/static_thread_pool.hpp

@@ -37,6 +37,11 @@ namespace exec {
     void (*__execute)(task_base*, std::uint32_t tid) noexcept;
   };
 
+  template <class>
+  struct not_a_sender {
+    using is_sender = void;
+  };
+
   class static_thread_pool {
     template <class ReceiverId>
     class operation;
@@ -100,21 +105,44 @@ namespace exec {
       static_thread_pool& pool_;
     };
 
+   public:
     struct domain {
       // For eager customization
       template <stdexec::sender_expr_for<stdexec::bulk_t> Sender>
       auto transform_sender(Sender&& sndr) const noexcept {
-        auto sched = stdexec::get_completion_scheduler<stdexec::set_value_t>(
-          stdexec::get_env(sndr));
-        return stdexec::apply_sender((Sender&&) sndr, transform_bulk{*sched.pool_});
+        if constexpr (stdexec::__completes_on<Sender, static_thread_pool>) {
+          auto sched = stdexec::get_completion_scheduler<stdexec::set_value_t>(
+            stdexec::get_env(sndr));
+          return stdexec::apply_sender((Sender&&) sndr, transform_bulk{*sched.pool_});
+        } else {
+          static_assert(
+            stdexec::__completes_on<Sender, static_thread_pool>,
+            "No static_thread_pool instance can be found in the sender's environment "
+            "on which to schedule bulk work.");
+          return not_a_sender<stdexec::__name_of<Sender>>();
+        }
+        STDEXEC_UNREACHABLE();
       }
 
       // transform the generic bulk sender into a parallel thread-pool bulk sender
       template <stdexec::sender_expr_for<stdexec::bulk_t> Sender, class Env>
-        requires stdexec::__callable<stdexec::get_scheduler_t, Env>
       auto transform_sender(Sender&& sndr, const Env& env) const noexcept {
-        auto sched = stdexec::get_scheduler(env);
-        return stdexec::apply_sender((Sender&&) sndr, transform_bulk{*sched.pool_});
+        if constexpr (stdexec::__completes_on<Sender, static_thread_pool>) {
+          auto sched = stdexec::get_completion_scheduler<stdexec::set_value_t>(
+            stdexec::get_env(sndr));
+          return stdexec::apply_sender((Sender&&) sndr, transform_bulk{*sched.pool_});
+        } else if constexpr (stdexec::__starts_on<Sender, static_thread_pool, Env>) {
+          auto sched = stdexec::get_scheduler(env);
+          return stdexec::apply_sender((Sender&&) sndr, transform_bulk{*sched.pool_});
+        } else {
+          static_assert( //
+            stdexec::__starts_on<Sender, static_thread_pool, Env>
+            || stdexec::__completes_on<Sender, static_thread_pool>,
+            "No static_thread_pool instance can be found in the sender's or receiver's "
+            "environment on which to schedule bulk work.");
+          return not_a_sender<stdexec::__name_of<Sender>>();
+        }
+        STDEXEC_UNREACHABLE();
       }
     };
 

include/stdexec/__detail/__execution_fwd.hpp

@@ -175,6 +175,14 @@ namespace stdexec {
   using __transfer_just::transfer_just_t;
   extern const transfer_just_t transfer_just;
 
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  namespace __bulk {
+    struct bulk_t;
+  }
+
+  using __bulk::bulk_t;
+  extern const bulk_t bulk;
+
   //////////////////////////////////////////////////////////////////////////////////////////////////
   namespace __on_v2 {
     struct on_t;

include/stdexec/concepts.hpp

@@ -234,6 +234,9 @@ namespace stdexec {
   template <class _Ty>
   concept __nothrow_decay_copyable = __nothrow_constructible_from<__decay_t<_Ty>, _Ty>;
 
+  template <class _Ty, class _Up>
+  concept __decays_to_derived_from = derived_from<__decay_t<_Ty>, _Up>;
+
 } // namespace stdexec
 
 // #if !STDEXEC_HAS_STD_CONCEPTS_HEADER()