a simpler implementation for stdexec::__tuple

ericniebler · ericniebler · commit 5f6839ed7599 · 2025-12-16T16:36:48.000-08:00
diff --git a/include/exec/fork_join.hpp b/include/exec/fork_join.hpp
@@ -39,7 +39,7 @@ namespace exec {
       template <class Rcvr, class Tuple>
       STDEXEC_ATTRIBUTE(always_inline, host, device)
       void operator()(Rcvr& rcvr, const Tuple& tupl) const noexcept {
-        tupl.apply(_impl_fn{}, tupl, rcvr);
+        stdexec::__apply(_impl_fn{}, tupl, rcvr);
       }
     };
 
@@ -122,7 +122,7 @@ namespace exec {
     };
 
     template <class Completions, class Closures, class Domain>
-    using _when_all_sndr_t = stdexec::__tup::__apply_result_t<
+    using _when_all_sndr_t = stdexec::__apply_result_t<
       _mk_when_all_fn,
       Closures,
       _cache_sndr_t<_variant_t<Completions>, Domain>
@@ -147,7 +147,7 @@ namespace exec {
         : _rcvr_(static_cast<Rcvr&&>(rcvr))
         , _fork_opstate_(
             stdexec::connect(
-              closures.apply(
+              stdexec::__apply(
                 _mk_when_all_fn{},
                 static_cast<Closures&&>(closures),
                 _cache_sndr_t{&_cache_}),
diff --git a/include/exec/sequence.hpp b/include/exec/sequence.hpp
@@ -66,6 +66,14 @@ namespace exec {
       }
     };
 
+    template <class _Tuple>
+    struct __convert_tuple_fn {
+      template <class... _Ts>
+      STDEXEC_ATTRIBUTE(host, device, always_inline)
+      constexpr auto
+        operator()(_Ts&&... __ts) const STDEXEC_AUTO_RETURN(_Tuple{static_cast<_Ts&&>(__ts)...});
+    };
+
     template <class Rcvr, class... Sndrs>
     struct _opstate;
 
@@ -99,16 +107,15 @@ namespace exec {
       STDEXEC_ATTRIBUTE(host, device)
       explicit _opstate(Rcvr&& rcvr, CvrefSndrs&& sndrs)
         : _rcvr{static_cast<Rcvr&&>(rcvr)}
-        , _sndrs{_senders_tuple_t::__convert_from(static_cast<CvrefSndrs&&>(sndrs))}
-      // move all but the first sender into the opstate.
+        , _sndrs{stdexec::__apply(
+            __convert_tuple_fn<_senders_tuple_t>{},
+            static_cast<CvrefSndrs&&>(sndrs))} // move all but the first sender into the opstate.
       {
         // Below, it looks like we are using `sndrs` after it has been moved from. This is not the
         // case. `sndrs` is moved into a tuple type that has `__ignore` for the first element. The
         // result is that the first sender in `sndrs` is not moved from, but the rest are.
         _ops.template emplace_from_at<0>(
-          stdexec::connect,
-          sndrs.template __get<0>(static_cast<CvrefSndrs&&>(sndrs)),
-          _rcvr_t<0>{this});
+          stdexec::connect, stdexec::__get<0>(static_cast<CvrefSndrs&&>(sndrs)), _rcvr_t<0>{this});
       }
 
       template <class Index, class... Args>
@@ -119,7 +126,7 @@ namespace exec {
           if constexpr (Idx == sizeof...(Sndrs) + 1) {
             stdexec::set_value(static_cast<Rcvr&&>(_rcvr), static_cast<Args&&>(args)...);
           } else {
-            auto& sndr = _sndrs.template __get<Idx>(_sndrs);
+            auto& sndr = stdexec::__get<Idx>(_sndrs);
             auto& op = _ops.template emplace_from_at<Idx>(
               stdexec::connect, std::move(sndr), _rcvr_t<Idx>{this});
             stdexec::start(op);
diff --git a/include/exec/start_now.hpp b/include/exec/start_now.hpp
@@ -182,7 +182,7 @@ namespace exec {
             __scope.nest(static_cast<stdexec::__cvref_t<_SenderIds>&&>(__sndr)),
             __receiver_t{this})...} {
         // Start all of the child operations
-        __op_state_.for_each(stdexec::start, __op_state_);
+        stdexec::__apply(stdexec::__for_each{stdexec::start}, __op_state_);
       }
 
       auto request_stop() noexcept -> bool {
@@ -249,7 +249,7 @@ namespace exec {
         return __storage_t<stdexec::__root_env, _AsyncScope, _Sender...>{
           stdexec::__root_env{}, __scope, static_cast<_Sender&&>(__sndr)...};
       }
-    };
+      };
   } // namespace __start_now_
 
   using __start_now_::start_now_t;
diff --git a/include/exec/when_any.hpp b/include/exec/when_any.hpp
@@ -80,7 +80,7 @@ namespace exec {
     template <class _Receiver>
     auto __make_visitor_fn(_Receiver& __rcvr) noexcept {
       return [&__rcvr]<class _Tuple>(_Tuple&& __result) noexcept {
-        __result.apply(
+        stdexec::__apply(
           [&__rcvr]<class... _As>(auto __tag, _As&... __args) noexcept {
             __tag(static_cast<_Receiver&&>(__rcvr), static_cast<_As&&>(__args)...);
           },
@@ -200,7 +200,7 @@ namespace exec {
         template <class _SenderTuple>
         __t(_SenderTuple&& __senders, _Receiver&& __rcvr) noexcept(__nothrow_construct)
           : __op_base_t{static_cast<_Receiver&&>(__rcvr), sizeof...(_CvrefSenderIds)}
-          , __ops_{__senders.apply(
+          , __ops_{stdexec::__apply(
               [this]<class... _Senders>(_Senders&&... __sndrs) noexcept(
                 __nothrow_construct) -> __opstate_tuple {
                 return __opstate_tuple{
@@ -215,7 +215,7 @@ namespace exec {
           if (this->__stop_source_.stop_requested()) {
             stdexec::set_stopped(static_cast<_Receiver&&>(this->__rcvr_));
           } else {
-            __ops_.for_each(stdexec::start, __ops_);
+            stdexec::__apply(stdexec::__for_each{stdexec::start}, __ops_);
           }
         }
 
diff --git a/include/nvexec/stream/when_all.cuh b/include/nvexec/stream/when_all.cuh
@@ -252,7 +252,7 @@ namespace nvexec::_strm {
           -> __tuple_for<child_op_state_t<SenderIds, Is>...> {
 
           using __child_ops_t = __tuple_for<child_op_state_t<SenderIds, Is>...>;
-          return when_all.sndrs_.apply(
+          return stdexec::__apply(
             [parent_op]<class... Children>(Children&&... children) -> __child_ops_t {
               return __child_ops_t{_strm::exit_op_state(
                 static_cast<Children&&>(children),
@@ -299,7 +299,7 @@ namespace nvexec::_strm {
               }
             } else {
               // Synchronize the streams of all the child operations
-              child_states_.for_each(_when_all::_sync_op, child_states_);
+              stdexec::__apply(stdexec::__for_each{_when_all::_sync_op}, child_states_);
             }
           }
 
@@ -309,9 +309,9 @@ namespace nvexec::_strm {
             case _when_all::started:
               if constexpr (__v<sends_values<Completions>>) {
                 // All child operations completed successfully:
-                values_->apply(
+                stdexec::__apply(
                   [this]<class... Tuples>(Tuples&&... value_tupls) noexcept -> void {
-                    __tup::__cat_apply(
+                    stdexec::__cat_apply(
                       __mk_completion_fn(stdexec::set_value, rcvr_),
                       static_cast<Tuples&&>(value_tupls)...);
                   },
@@ -336,13 +336,14 @@ namespace nvexec::_strm {
         using stream_providers_t = std::array<stream_provider_t, sizeof...(SenderIds)>;
 
         static auto get_stream_providers(WhenAll& when_all, Receiver& rcvr) -> stream_providers_t {
-          return when_all.sndrs_.apply(
-            [&rcvr](auto&... sndrs) -> stream_providers_t {
+          return stdexec::__apply(
+            [](auto& rcvr, auto&... sndrs) -> stream_providers_t {
               return stream_providers_t{stdexec::get_completion_scheduler<set_value_t>(
                                           stdexec::get_env(sndrs), stdexec::get_env(rcvr))
                                           .context_state_...};
             },
-            when_all.sndrs_);
+            when_all.sndrs_,
+            rcvr);
         }
 
         operation_t(WhenAll&& when_all, Receiver rcvr)
@@ -368,7 +369,7 @@ namespace nvexec::_strm {
             // the child operations.
             stdexec::set_stopped(static_cast<Receiver&&>(rcvr_));
           } else {
-            child_states_.for_each(stdexec::start, child_states_);
+            stdexec::__apply(stdexec::__for_each{stdexec::start}, child_states_);
             if constexpr (sizeof...(SenderIds) == 0) {
               complete();
             }
@@ -401,10 +402,10 @@ namespace nvexec::_strm {
             // We only need to bother recording the completion values
             // if we're not already in the "error" or "stopped" state.
             if (state_.load() == _when_all::started) {
-              cudaStream_t stream = child_states_.template __get<Index>(child_states_).get_stream();
+              cudaStream_t stream = stdexec::__get<Index>(child_states_).get_stream();
               if constexpr (sizeof...(Args)) {
                 _when_all::copy_kernel<Args&&...><<<1, 1, 0, stream>>>(
-                  &(values_->template __get<Index>(*values_)), static_cast<Args&&>(args)...);
+                  &stdexec::__get<Index>(*values_), static_cast<Args&&>(args)...);
                 statuses_[Index] = cudaGetLastError();
               }
 
diff --git a/include/stdexec/__detail/__basic_sender.hpp b/include/stdexec/__detail/__basic_sender.hpp
@@ -429,7 +429,7 @@ namespace stdexec {
     STDEXEC_ATTRIBUTE(always_inline) void start() & noexcept {
       using __tag_t = __op_state::__tag_t;
       auto&& __rcvr = this->__rcvr();
-      __inner_ops_.apply(
+      stdexec::__apply(
         [&](auto&... __ops) noexcept {
           __sexpr_impl<__tag_t>::start(this->__state(), __rcvr, __ops...);
         },
diff --git a/include/stdexec/__detail/__config.hpp b/include/stdexec/__detail/__config.hpp
@@ -112,6 +112,13 @@
 #  define STDEXEC_INTELLISENSE() 0
 #endif
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+#if STDEXEC_MSVC()
+#  define STDEXEC_PRAGMA(_ARG) __pragma(_ARG)
+#else
+#  define STDEXEC_PRAGMA(_ARG) _Pragma(STDEXEC_STRINGIZE(_ARG))
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 #if defined(__CUDACC__) || defined(_NVHPC_CUDA)
 #  define STDEXEC_CUDA_COMPILATION() 1
@@ -133,6 +140,13 @@
 #  define STDEXEC_HOST_DEVICE_DEDUCTION_GUIDE
 #endif
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+#if STDEXEC_NVCC()
+#  define STDEXEC_EXEC_CHECK_DISABLE STDEXEC_PRAGMA(nv_exec_check_disable)
+#else
+#  define STDEXEC_EXEC_CHECK_DISABLE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 #if __cpp_impl_coroutine >= 2019'02 && __cpp_lib_coroutine >= 2019'02
 #  include <coroutine> // IWYU pragma: keep
@@ -241,32 +255,39 @@ namespace __coro = std::experimental;
 #define STDEXEC_ATTR_launch_bounds(...)               STDEXEC_PROBE(~, 7)
 #define STDEXEC_ATTR___launch_bounds__(...)           STDEXEC_PROBE(~, 7)
 
+#if STDEXEC_MSVC() && !STDEXEC_CLANG_CL()
+#  define STDEXEC_ATTR_WHICH_8(_ATTR) __declspec(_ATTR)
+#else
+#  define STDEXEC_ATTR_WHICH_8(_ATTR) /*nothing*/
+#endif
+#define STDEXEC_ATTR_empty_bases STDEXEC_PROBE(~, 8)
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // warning push/pop portability macros
 #if STDEXEC_NVCC()
-#  define STDEXEC_PRAGMA_PUSH()          _Pragma("nv_diagnostic push")
-#  define STDEXEC_PRAGMA_POP()           _Pragma("nv_diagnostic pop")
-#  define STDEXEC_PRAGMA_IGNORE_EDG(...) _Pragma(STDEXEC_STRINGIZE(nv_diag_suppress __VA_ARGS__))
+#  define STDEXEC_PRAGMA_PUSH()          STDEXEC_PRAGMA(nv_diagnostic push)
+#  define STDEXEC_PRAGMA_POP()           STDEXEC_PRAGMA(nv_diagnostic pop)
+#  define STDEXEC_PRAGMA_IGNORE_EDG(...) STDEXEC_PRAGMA(nv_diag_suppress __VA_ARGS__)
 #elif STDEXEC_EDG()
 #  define STDEXEC_PRAGMA_PUSH()                                                                    \
-    _Pragma("diagnostic push") STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_number)                     \
-      STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_tag)
-#  define STDEXEC_PRAGMA_POP()           _Pragma("diagnostic pop")
-#  define STDEXEC_PRAGMA_IGNORE_EDG(...) _Pragma(STDEXEC_STRINGIZE(diag_suppress __VA_ARGS__))
+    STDEXEC_PRAGMA(diagnostic push)                                                                \
+    STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_number) STDEXEC_PRAGMA_IGNORE_EDG(invalid_error_tag)
+#  define STDEXEC_PRAGMA_POP()           STDEXEC_PRAGMA(diagnostic pop)
+#  define STDEXEC_PRAGMA_IGNORE_EDG(...) STDEXEC_PRAGMA(diag_suppress __VA_ARGS__)
 #elif STDEXEC_CLANG() || STDEXEC_GCC()
 #  define STDEXEC_PRAGMA_PUSH()                                                                    \
-    _Pragma("GCC diagnostic push") STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas")                          \
-      STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-pragmas")                                               \
-        STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-warning-option")                                      \
-          STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-attributes")                                        \
-            STDEXEC_PRAGMA_IGNORE_GNU("-Wattributes")
-#  define STDEXEC_PRAGMA_POP() _Pragma("GCC diagnostic pop")
-#  define STDEXEC_PRAGMA_IGNORE_GNU(...)                                                           \
-    _Pragma(STDEXEC_STRINGIZE(GCC diagnostic ignored __VA_ARGS__))
+    STDEXEC_PRAGMA(GCC diagnostic push)                                                            \
+    STDEXEC_PRAGMA_IGNORE_GNU("-Wpragmas")                                                         \
+    STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-pragmas")                                                 \
+    STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-warning-option")                                          \
+    STDEXEC_PRAGMA_IGNORE_GNU("-Wunknown-attributes")                                              \
+    STDEXEC_PRAGMA_IGNORE_GNU("-Wattributes")
+#  define STDEXEC_PRAGMA_POP()           STDEXEC_PRAGMA(GCC diagnostic pop)
+#  define STDEXEC_PRAGMA_IGNORE_GNU(...) STDEXEC_PRAGMA(GCC diagnostic ignored __VA_ARGS__)
 #elif STDEXEC_MSVC()
-#  define STDEXEC_PRAGMA_PUSH()           __pragma(warning(push))
-#  define STDEXEC_PRAGMA_POP()            __pragma(warning(pop))
-#  define STDEXEC_PRAGMA_IGNORE_MSVC(...) __pragma(warning(disable : __VA_ARGS__))
+#  define STDEXEC_PRAGMA_PUSH()           STDEXEC_PRAGMA(warning(push))
+#  define STDEXEC_PRAGMA_POP()            STDEXEC_PRAGMA(warning(pop))
+#  define STDEXEC_PRAGMA_IGNORE_MSVC(...) STDEXEC_PRAGMA(warning(disable : __VA_ARGS__))
 #else
 #  define STDEXEC_PRAGMA_PUSH()
 #  define STDEXEC_PRAGMA_POP()
diff --git a/include/stdexec/__detail/__continues_on.hpp b/include/stdexec/__detail/__continues_on.hpp
@@ -87,7 +87,7 @@ namespace stdexec {
     STDEXEC_ATTRIBUTE(always_inline)
     auto __make_visitor_fn(_State* __state) noexcept {
       return [__state]<class _Tup>(_Tup& __tupl) noexcept -> void {
-        __tupl.apply(
+        stdexec::__apply(
           [&]<class... _Args>(auto __tag, _Args&... __args) noexcept -> void {
             __tag(std::move(__state->__receiver()), static_cast<_Args&&>(__args)...);
           },
@@ -356,11 +356,11 @@ namespace stdexec {
           _Args&&... __args) noexcept -> void {
         // Write the tag and the args into the operation state so that we can forward the completion
         // from within the scheduler's execution context.
-        if constexpr (__nothrow_callable<__tup::__mktuple_t, _Tag, _Args...>) {
-          __state.__data_.emplace_from(__tup::__mktuple, __tag, static_cast<_Args&&>(__args)...);
+        if constexpr (__nothrow_callable<__mktuple_t, _Tag, _Args...>) {
+          __state.__data_.emplace_from(__mktuple, __tag, static_cast<_Args&&>(__args)...);
         } else {
           STDEXEC_TRY {
-            __state.__data_.emplace_from(__tup::__mktuple, __tag, static_cast<_Args&&>(__args)...);
+            __state.__data_.emplace_from(__mktuple, __tag, static_cast<_Args&&>(__args)...);
           }
           STDEXEC_CATCH_ALL {
             stdexec::set_error(static_cast<_Receiver&&>(__rcvr), std::current_exception());
diff --git a/include/stdexec/__detail/__just.hpp b/include/stdexec/__detail/__just.hpp
@@ -48,14 +48,15 @@ namespace stdexec {
 
       static constexpr auto start =
         []<class _State, class _Receiver>(_State& __state, _Receiver& __rcvr) noexcept -> void {
-        __state.apply(__tag_t(), static_cast<_State&&>(__state), static_cast<_Receiver&&>(__rcvr));
+        stdexec::__apply(
+          __tag_t(), static_cast<_State&&>(__state), static_cast<_Receiver&&>(__rcvr));
       };
 
       static constexpr auto submit =
         []<class _Sender, class _Receiver>(_Sender&& __sndr, _Receiver __rcvr) noexcept -> void {
         static_assert(sender_expr_for<_Sender, _JustTag>);
         auto&& __state = get_state(static_cast<_Sender&&>(__sndr), __rcvr);
-        __state.apply(
+        stdexec::__apply(
           __tag_t(), static_cast<decltype(__state)>(__state), static_cast<_Receiver&&>(__rcvr));
       };
     };
diff --git a/include/stdexec/__detail/__let.hpp b/include/stdexec/__detail/__let.hpp
@@ -579,9 +579,9 @@ namespace stdexec {
       template <class _State, class _OpState, class... _As>
       static void __bind_(_State& __state, _OpState& __op_state, _As&&... __as) {
         // Store the passed-in (received) args:
-        auto& __args = __state.__args_.emplace_from(__tup::__mktuple, static_cast<_As&&>(__as)...);
+        auto& __args = __state.__args_.emplace_from(__mktuple, static_cast<_As&&>(__as)...);
         // Apply the function to the args to get the sender:
-        auto __sndr2 = __args.apply(std::move(__state.__fun_), __args);
+        auto __sndr2 = stdexec::__apply(std::move(__state.__fun_), __args);
         // Create a receiver based on the state, the computed sender, and the operation state:
         auto __rcvr2 = __state.__get_result_receiver(__sndr2, __op_state);
         // Connect the sender to the receiver and start it:
diff --git a/include/stdexec/__detail/__sender_adaptor_closure.hpp b/include/stdexec/__detail/__sender_adaptor_closure.hpp
@@ -121,9 +121,9 @@ namespace stdexec {
       auto operator()(_Sender&& __sndr) && noexcept(__nothrow_callable<_Fun, _Sender, _As...>)
         -> __call_result_t<_Fun, _Sender, _As...> {
 #if STDEXEC_INTELLISENSE()
-        return this->apply(__lambda_rvalue<_Sender>{*this, __sndr}, *this);
+        return stdexec::__apply(__lambda_rvalue<_Sender>{*this, __sndr}, *this);
 #else
-        return this->apply(
+        return stdexec::__apply(
           [&__sndr, this](_As&... __as) noexcept(
             __nothrow_callable<_Fun, _Sender, _As...>) -> __call_result_t<_Fun, _Sender, _As...> {
             return static_cast<_Fun&&>(
@@ -140,9 +140,9 @@ namespace stdexec {
         __nothrow_callable<const _Fun&, _Sender, const _As&...>)
         -> __call_result_t<const _Fun&, _Sender, const _As&...> {
 #if STDEXEC_INTELLISENSE()
-        return this->apply(__lambda_lvalue<_Sender>{*this, __sndr}, *this);
+        return stdexec::__apply(__lambda_lvalue<_Sender>{*this, __sndr}, *this);
 #else
-        return this->apply(
+        return stdexec::__apply(
           [&__sndr, this](const _As&... __as) noexcept(
             __nothrow_callable<const _Fun&, _Sender, const _As&...>)
             -> __call_result_t<const _Fun&, _Sender, const _As&...> {
diff --git a/include/stdexec/__detail/__shared.hpp b/include/stdexec/__detail/__shared.hpp
@@ -76,7 +76,7 @@ namespace stdexec::__shared {
   template <class _Receiver>
   auto __make_notify_visitor(_Receiver& __rcvr) noexcept {
     return [&]<class _Tuple>(_Tuple&& __tupl) noexcept -> void {
-      __tupl.apply(__notify_fn<_Receiver>{__rcvr}, static_cast<_Tuple&&>(__tupl));
+      stdexec::__apply(__notify_fn<_Receiver>{__rcvr}, static_cast<_Tuple&&>(__tupl));
     };
   }
 
diff --git a/include/stdexec/__detail/__transfer_just.hpp b/include/stdexec/__detail/__transfer_just.hpp
@@ -43,7 +43,7 @@ namespace stdexec {
 
     inline auto __transform_sender_fn() {
       return [&]<class _Data>(__ignore, _Data&& __data) {
-        return __data.apply(__make_transform_fn(), static_cast<_Data&&>(__data));
+        return stdexec::__apply(__make_transform_fn(), static_cast<_Data&&>(__data));
       };
     }
 
@@ -70,7 +70,7 @@ namespace stdexec {
 
     struct __transfer_just_impl : __sexpr_defaults {
       static constexpr auto get_attrs = []<class _Data>(const _Data& __data) noexcept {
-        return __data.apply(__make_attrs_fn(), __data);
+        return stdexec::__apply(__make_attrs_fn(), __data);
       };
 
       static constexpr auto get_completion_signatures =
diff --git a/include/stdexec/__detail/__tuple.hpp b/include/stdexec/__detail/__tuple.hpp
diff --git a/include/stdexec/__detail/__when_all.hpp b/include/stdexec/__detail/__when_all.hpp
diff --git a/include/stdexec/functional.hpp b/include/stdexec/functional.hpp
