use __tuple to implement __sexpr instead of a lambda

include/exec/__detail/__basic_sequence.hpp

@@ -31,76 +31,53 @@ namespace exec {
     using __t = __basic_sequence_sender;
   };
 
-  template <auto _DescriptorFn, class = STDEXEC::__anon>
-  struct __seqexpr {
-    using sender_concept = sequence_sender_t;
-    using __t = __seqexpr;
-    using __id = __seqexpr;
-    using __desc_t = decltype(_DescriptorFn());
-    using __tag_t = __desc_t::__tag;
-    using __captures_t =
-      STDEXEC::__minvoke<__desc_t, STDEXEC::__q<STDEXEC::__detail::__captures_t>>;
-
-    static constexpr auto __tag() noexcept -> __tag_t {
-      return {};
-    }
-
-    mutable __captures_t __impl_;
+  namespace {
+    template <auto _DescriptorFn>
+    struct __seqexpr
+      : STDEXEC::__minvoke<decltype(_DescriptorFn()), STDEXEC::__qq<STDEXEC::__tuple>> {
+      using sender_concept = sequence_sender_t;
+      using __t = __seqexpr;
+      using __id = __seqexpr;
+      using __desc_t = decltype(_DescriptorFn());
+      using __tag_t = __desc_t::__tag;
+
+      static constexpr auto __tag() noexcept -> __tag_t {
+        return {};
+      }
+
+      template <class _Self = __seqexpr>
+      auto get_env() const noexcept -> decltype(_Self::__tag().get_env(*this)) {
+        static_assert(noexcept(_Self::__tag().get_env(*this)));
+        return _Self::__tag().get_env(*this);
+      }
+
+      template <class _Self, class... _Env>
+      static consteval auto get_completion_signatures() {
+        static_assert(STDEXEC::__decays_to_derived_from<_Self, __seqexpr>);
+        return __tag_t::template get_completion_signatures<_Self, _Env...>();
+      }
+
+      template <class _Self, class... _Env>
+      static consteval auto get_item_types() {
+        static_assert(STDEXEC::__decays_to_derived_from<_Self, __seqexpr>);
+        return __tag_t::template get_item_types<_Self, _Env...>();
+      }
+
+      template <class _Self, STDEXEC::receiver _Receiver>
+      static auto subscribe(_Self&& __self, _Receiver&& __rcvr) noexcept(noexcept(
+        __self.__tag().subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr))))
+        -> decltype(__self.__tag()
+                      .subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr))) {
+        static_assert(STDEXEC::__decays_to_derived_from<_Self, __seqexpr>);
+        return __tag_t::subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
+      }
+    };
 
     template <class _Tag, class _Data, class... _Child>
     STDEXEC_ATTRIBUTE(host, device)
-    explicit __seqexpr(_Tag, _Data&& __data, _Child&&... __child)
-      : __impl_(
-          STDEXEC::__detail::__captures(
-            _Tag(),
-            static_cast<_Data&&>(__data),
-            static_cast<_Child&&>(__child)...)) {
-    }
-
-    template <STDEXEC::__std::same_as<__seqexpr> _Self = __seqexpr>
-    auto get_env() const noexcept -> decltype(_Self::__tag().get_env(*this)) {
-      static_assert(noexcept(_Self::__tag().get_env(*this)));
-      return _Self::__tag().get_env(*this);
-    }
-
-    template <STDEXEC::__decays_to_derived_from<__seqexpr> _Self, class... _Env>
-    static consteval auto get_completion_signatures() {
-      return __tag_t::template get_completion_signatures<_Self, _Env...>();
-    }
-
-    template <STDEXEC::__decays_to_derived_from<__seqexpr> _Self, class... _Env>
-    static consteval auto get_item_types() {
-      return __tag_t::template get_item_types<_Self, _Env...>();
-    }
-
-    template <STDEXEC::__decays_to_derived_from<__seqexpr> _Self, STDEXEC::receiver _Receiver>
-    static auto subscribe(_Self&& __self, _Receiver&& __rcvr) noexcept(noexcept(
-      __self.__tag().subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr))))
-      -> decltype(__self.__tag()
-                    .subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr))) {
-      return __tag_t::subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr));
-    }
-
-    template <class _Sequence, class _ApplyFn>
-    static auto apply(_Sequence&& __sequence, _ApplyFn&& __fun)
-      noexcept(STDEXEC::__nothrow_callable<
-               STDEXEC::__detail::__impl_of<_Sequence>,
-               STDEXEC::__copy_cvref_fn<_Sequence>,
-               _ApplyFn
-      >)
-        -> STDEXEC::__call_result_t<
-          STDEXEC::__detail::__impl_of<_Sequence>,
-          STDEXEC::__copy_cvref_fn<_Sequence>,
-          _ApplyFn
-        > {
-      return static_cast<_Sequence&&>(__sequence)
-        .__impl_(STDEXEC::__copy_cvref_fn<_Sequence>(), static_cast<_ApplyFn&&>(__fun));
-    }
-  };
-
-  template <class _Tag, class _Data, class... _Child>
-  STDEXEC_ATTRIBUTE(host, device)
-  __seqexpr(_Tag, _Data, _Child...) -> __seqexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
+    __seqexpr(_Tag, _Data, _Child...)
+      -> __seqexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;
+  } // namespace
 
   template <class _Tag, class _Data, class... _Child>
   using __seqexpr_t = __seqexpr<STDEXEC_SEXPR_DESCRIPTOR(_Tag, _Data, _Child...)>;

include/exec/finally.hpp

@@ -313,15 +313,15 @@ namespace exec {
 
       template <class _Sender>
       static auto transform_sender(STDEXEC::set_value_t, _Sender&& __sndr, __ignore) {
-        return __sexpr_apply(
-          static_cast<_Sender&&>(__sndr),
+        return __apply(
           []<class _Initial, class _Final>(
             __ignore, __ignore, _Initial&& __initial, _Final&& __final) {
             using __result_sndr_t =
               __t<__sender<__id<__decay_t<_Initial>>, __id<__decay_t<_Final>>>>;
             return __result_sndr_t{
               static_cast<_Initial&&>(__initial), static_cast<_Final&&>(__final)};
-          });
+          },
+          static_cast<_Sender&&>(__sndr));
       }
     };
   } // namespace __final

include/exec/libdispatch_queue.hpp

@@ -120,8 +120,8 @@ namespace exec {
           auto sched =
             STDEXEC::get_completion_scheduler<STDEXEC::set_value_t>(STDEXEC::get_env(sndr), env);
           static_assert(std::is_same_v<decltype(sched), libdispatch_scheduler>);
-          return STDEXEC::__sexpr_apply(
-            std::forward<Sender>(sndr), __libdispatch_bulk::transform_bulk{*sched.queue_});
+          return STDEXEC::__apply(
+            __libdispatch_bulk::transform_bulk{*sched.queue_}, std::forward<Sender>(sndr));
         } else {
           return STDEXEC::__not_a_sender<
             STDEXEC::_WHAT_<>(CANNOT_DISPATCH_THE_BULK_ALGORITHM_TO_THE_LIBDISPATCH_SCHEDULER),

include/exec/repeat_effect_until.hpp

@@ -89,8 +89,7 @@ namespace exec {
       trampoline_scheduler __sched_;
 
       __repeat_effect_state(_Sender &&__sndr, _Receiver &)
-        : __child_(
-            __sexpr_apply(static_cast<_Sender &&>(__sndr), STDEXEC::__detail::__get_data())) {
+        : __child_(STDEXEC::__get<1>(static_cast<_Sender &&>(__sndr))) {
         __connect();
       }
 
@@ -227,10 +226,11 @@ namespace exec {
 
       template <class _Sender>
       auto transform_sender(STDEXEC::set_value_t, _Sender &&__sndr, __ignore) {
-        return __sexpr_apply(
-          static_cast<_Sender &&>(__sndr), []<class _Child>(__ignore, __ignore, _Child __child) {
+        return STDEXEC::__apply(
+          []<class _Child>(__ignore, __ignore, _Child __child) {
             return __make_sexpr<__repeat_effect_until_tag>(std::move(__child));
-          });
+          },
+          static_cast<_Sender &&>(__sndr));
       }
     };
 
@@ -255,9 +255,9 @@ namespace exec {
 
       template <class _Sender>
       auto transform_sender(STDEXEC::set_value_t, _Sender &&__sndr, __ignore) {
-        return __sexpr_apply(static_cast<_Sender &&>(__sndr), [](__ignore, __ignore, auto __child) {
+        return STDEXEC::__apply([](__ignore, __ignore, auto __child) {
           return repeat_effect_until_t{}(STDEXEC::then(std::move(__child), _never{}));
-        });
+        }, static_cast<_Sender &&>(__sndr));
       }
     };
   } // namespace __repeat_effect

include/exec/repeat_n.hpp

@@ -92,7 +92,7 @@ namespace exec {
       using __child_op_t = STDEXEC::connect_result_t<__child_on_sched_sender_t, __receiver_t>;
 
       __repeat_n_state(_Sender &&__sndr, _Receiver &)
-        : __pair_(__sexpr_apply(static_cast<_Sender &&>(__sndr), STDEXEC::__detail::__get_data())) {
+        : __pair_(STDEXEC::__get<1>(static_cast<_Sender &&>(__sndr))) {
         // Q: should we skip __connect() if __count_ == 0?
         __connect();
       }
@@ -208,11 +208,11 @@ namespace exec {
 
       template <class _Sender, bool _NoThrow = __nothrow_decay_copyable<_Sender>>
       auto transform_sender(set_value_t, _Sender &&__sndr, __ignore) noexcept(_NoThrow) {
-        return __sexpr_apply(
-          static_cast<_Sender &&>(__sndr),
+        return __apply(
           []<class _Child>(__ignore, std::size_t __count, _Child __child) noexcept(_NoThrow) {
             return __make_sexpr<__repeat_n_tag>(__child_count_pair{std::move(__child), __count});
-          });
+          },
+          static_cast<_Sender &&>(__sndr));
       }
     };
   } // namespace __repeat_n

include/exec/sequence/ignore_all_values.hpp

@@ -330,24 +330,12 @@ namespace exec {
       template <class _Child, class _Receiver>
       using __receiver_t = __t<__receiver<__id<_Receiver>, _ResultVariant<_Child, _Receiver>>>;
 
-      // static constexpr auto get_state =
-      //   []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver& __rcvr) noexcept(
-      //     __nothrow_callable<__sexpr_apply_t, _Sender, __connect_fn<__rcvr_ref_t<_Receiver>>>)
-      //   -> __call_result_t<__sexpr_apply_t, _Sender, __connect_fn<__rcvr_ref_t<_Receiver>>> {
-      //   static_assert(sender_expr_for<_Sender, ignore_all_values_t>);
-      //   return __sexpr_apply(static_cast<_Sender&&>(__sndr), __connect_fn{__ref_rcvr(__rcvr)});
-      // };
-
-      // static constexpr auto start = [](auto& __state, __ignore, __ignore) noexcept -> void {
-      //   STDEXEC::start(__state);
-      // };
-
       static constexpr auto connect =
         []<class _Sender, receiver _Receiver>(_Sender&& __sndr, _Receiver __rcvr) noexcept(
-          __nothrow_callable<__sexpr_apply_t, _Sender, __connect_fn<_Receiver>>)
-        -> __call_result_t<__sexpr_apply_t, _Sender, __connect_fn<_Receiver>> {
+          __nothrow_applicable<__connect_fn<_Receiver>, _Sender>)
+        -> __apply_result_t<__connect_fn<_Receiver>, _Sender> {
         static_assert(sender_expr_for<_Sender, ignore_all_values_t>);
-        return __sexpr_apply(static_cast<_Sender&&>(__sndr), __connect_fn<_Receiver>{__rcvr});
+        return __apply(__connect_fn<_Receiver>{__rcvr}, static_cast<_Sender&&>(__sndr));
       };
     };
   } // namespace __ignore_all_values

include/exec/sequence/iterate.hpp

@@ -190,9 +190,9 @@ namespace exec {
       >
         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>>)
-          -> __call_result_t<__sexpr_apply_t, _SeqExpr, __subscribe_fn<_Receiver>> {
-        return __sexpr_apply(static_cast<_SeqExpr&&>(__seq), __subscribe_fn<_Receiver>{__rcvr});
+        noexcept(__nothrow_applicable<__subscribe_fn<_Receiver>, _SeqExpr>)
+          -> __apply_result_t<__subscribe_fn<_Receiver>, _SeqExpr> {
+        return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_SeqExpr&&>(__seq));
       }
 
       template <class, class...>

include/exec/sequence/merge.hpp

@@ -214,9 +214,9 @@ namespace exec {
 
       template <sender_expr_for<merge_t> _Self, receiver _Receiver>
       static auto subscribe(_Self&& __self, _Receiver __rcvr)
-        noexcept(__nothrow_callable<__sexpr_apply_t, _Self, __subscribe_fn<_Receiver>>)
-          -> __sexpr_apply_result_t<_Self, __subscribe_fn<_Receiver>> {
-        return __sexpr_apply(static_cast<_Self&&>(__self), __subscribe_fn<_Receiver>{__rcvr});
+        noexcept(__nothrow_applicable<__subscribe_fn<_Receiver>, _Self>)
+          -> __apply_result_t<__subscribe_fn<_Receiver>, _Self> {
+        return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_Self&&>(__self));
       }
     };
   } // namespace __merge

include/exec/sequence/merge_each.hpp

@@ -1288,10 +1288,10 @@ namespace exec {
 
       static constexpr auto subscribe =
         []<class _Sequence, receiver _Receiver>(_Sequence&& __sndr, _Receiver __rcvr) noexcept(
-          __nothrow_callable<__sexpr_apply_t, _Sequence, __subscribe_fn<_Receiver>>)
-        -> __sexpr_apply_result_t<_Sequence, __subscribe_fn<_Receiver>> {
+          __nothrow_applicable<__subscribe_fn<_Receiver>, _Sequence>)
+        -> __apply_result_t<__subscribe_fn<_Receiver>, _Sequence> {
         static_assert(sender_expr_for<_Sequence, merge_each_t>);
-        return __sexpr_apply(static_cast<_Sequence&&>(__sndr), __subscribe_fn<_Receiver>{__rcvr});
+        return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_Sequence&&>(__sndr));
       };
     };
   } // namespace __merge_each

include/exec/sequence/transform_each.hpp

@@ -259,16 +259,16 @@ namespace exec {
 
       template <sender_expr_for<transform_each_t> _Self, receiver _Receiver>
       static auto subscribe(_Self&& __self, _Receiver __rcvr)
-        noexcept(__nothrow_callable<__sexpr_apply_t, _Self, __subscribe_fn<_Receiver>>)
-          -> __call_result_t<__sexpr_apply_t, _Self, __subscribe_fn<_Receiver>> {
-        return __sexpr_apply(static_cast<_Self&&>(__self), __subscribe_fn<_Receiver>{__rcvr});
+        noexcept(__nothrow_applicable<__subscribe_fn<_Receiver>, _Self>)
+          -> __apply_result_t<__subscribe_fn<_Receiver>, _Self> {
+        return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_Self&&>(__self));
       }
 
       template <sender_expr_for<transform_each_t> _Sexpr>
       static auto get_env(const _Sexpr& __sexpr) noexcept -> env_of_t<__child_of<_Sexpr>> {
-        return __sexpr_apply(__sexpr, []<class _Child>(__ignore, __ignore, const _Child& __child) {
+        return __apply([]<class _Child>(__ignore, __ignore, const _Child& __child) {
           return STDEXEC::get_env(__child);
-        });
+        }, __sexpr);
       }
     };
   } // namespace __transform_each

include/exec/static_thread_pool.hpp

@@ -298,7 +298,7 @@ namespace exec {
           if constexpr (__completes_on<Sender, _static_thread_pool::scheduler, Env>) {
             auto sched = STDEXEC::get_completion_scheduler<set_value_t>(get_env(sndr), env);
             static_assert(std::is_same_v<decltype(sched), _static_thread_pool::scheduler>);
-            return __sexpr_apply(static_cast<Sender&&>(sndr), _transform_bulk{*sched.pool_});
+            return __apply(_transform_bulk{*sched.pool_}, static_cast<Sender&&>(sndr));
           } else {
             return STDEXEC::__not_a_sender<
               STDEXEC::_WHAT_<>(
@@ -318,7 +318,7 @@ namespace exec {
         auto transform_sender(STDEXEC::set_value_t, Sender&& sndr, const Env& env) const noexcept {
           if constexpr (__completes_on<Sender, _static_thread_pool::scheduler, Env>) {
             auto sched = STDEXEC::get_scheduler(env);
-            return __sexpr_apply(static_cast<Sender&&>(sndr), _transform_iterate{*sched.pool_});
+            return __apply(_transform_iterate{*sched.pool_}, static_cast<Sender&&>(sndr));
           } else {
             return STDEXEC::__not_a_sender<
               STDEXEC::_WHAT_<>(

include/exec/system_context.hpp

@@ -712,8 +712,8 @@ namespace exec {
     const _Env& __env) const noexcept {
     if constexpr (STDEXEC::__completes_on<_Sender, parallel_scheduler, _Env>) {
       auto __sched = STDEXEC::get_scheduler(__env);
-      return STDEXEC::__sexpr_apply(
-        static_cast<_Sender&&>(__sndr), __transform_parallel_bulk_sender{__sched});
+      return STDEXEC::__apply(
+        __transform_parallel_bulk_sender{__sched}, static_cast<_Sender&&>(__sndr));
     } else {
       return STDEXEC::__not_a_sender<
         STDEXEC::_WHAT_<>(CANNOT_DISPATCH_THE_BULK_ALGORITHM_TO_THE_PARALLEL_SCHEDULER),

include/exec/unless_stop_requested.hpp

@@ -46,10 +46,14 @@ namespace exec {
       constexpr connect_result_t<__child_of<_Sender>, _Receiver>
         operator()(_Sender&& __sndr, _Receiver __rcvr) const noexcept(
           noexcept(STDEXEC::connect(__declval<__child_of<_Sender>>(), (_Receiver&&) __rcvr))) {
-        return __sexpr_apply((_Sender&&) __sndr, [&](auto, const auto&, auto&& __child) {
-          return STDEXEC::connect((decltype(__child)&&) __child, (_Receiver&&) __rcvr);
-        });
+        return __apply(
+          [&]<class _Child>(auto, const auto&, _Child&& __child) {
+            return STDEXEC::connect(
+              static_cast<_Child&&>(__child), static_cast<_Receiver&&>(__rcvr));
+          },
+          static_cast<_Sender&&>(__sndr));
       }
+
       template <class _Sender, class _Receiver>
       constexpr __op_state<_Sender, _Receiver> operator()(_Sender&& __sndr, _Receiver __rcvr) const
         noexcept(__nothrow_constructible_from<__op_state<_Sender, _Receiver>, _Sender, _Receiver>) {

include/nvexec/stream/common.cuh

@@ -87,14 +87,10 @@ namespace nvexec {
   // algorithms use the current scheduler's domain to transform senders before starting them.
   struct stream_domain : STDEXEC::default_domain {
     template <STDEXEC::sender_expr Sender, class Tag = STDEXEC::tag_of_t<Sender>, class Env>
-      requires STDEXEC::__callable<
-        STDEXEC::__sexpr_apply_t,
-        Sender,
-        _strm::transform_sender_for<Tag, Env>
-      >
+      requires STDEXEC::__applicable<_strm::transform_sender_for<Tag, Env>, Sender>
     static auto transform_sender(STDEXEC::set_value_t, Sender&& sndr, const Env& env) {
-      return STDEXEC::__sexpr_apply(
-        static_cast<Sender&&>(sndr), _strm::transform_sender_for<Tag, Env>{env});
+      return STDEXEC::__apply(
+        _strm::transform_sender_for<Tag, Env>{env}, static_cast<Sender&&>(sndr));
     }
 
     template <class Tag, STDEXEC::sender Sender, class... Args>

include/nvexec/stream/sync_wait.cuh

@@ -19,6 +19,8 @@
 #pragma once
 
 #include "../../stdexec/execution.hpp"
+#include "common.cuh"
+
 #include <concepts>
 #include <exception>
 #include <new>
@@ -27,8 +29,6 @@
 #include <utility>
 #include <variant>
 
-#include "common.cuh"
-
 namespace nvexec::_strm {
   namespace _sync_wait {
     struct __env {