a simpler implementation for stdexec::__tuple

Author: ericniebler

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);
       }
     };
 
@@ -55,7 +55,7 @@ namespace exec {
     using _maybe_eptr_completion_t = stdexec::__if_c<
       stdexec::__nothrow_decay_copyable_results_t<Completions>::value,
       stdexec::__mset_nil,
-      stdexec::__tuple_for<stdexec::set_error_t, ::std::exception_ptr>
+      stdexec::__tuple<stdexec::set_error_t, ::std::exception_ptr>
     >;
 
     template <class Completions>
@@ -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_}),
@@ -178,7 +178,7 @@ namespace exec {
         }
         STDEXEC_CATCH_ALL {
           if constexpr (!stdexec::__nothrow_decay_copyable<Args...>) {
-            using _tuple_t = stdexec::__tuple_for<stdexec::set_error_t, ::std::exception_ptr>;
+            using _tuple_t = stdexec::__tuple<stdexec::set_error_t, ::std::exception_ptr>;
             _cache_._results_
               .template emplace<_tuple_t>(stdexec::set_error, ::std::current_exception());
           }
@@ -216,7 +216,7 @@ namespace exec {
 
     template <class... Closures>
     struct _closure_t {
-      using _closures_t = stdexec::__tuple_for<Closures...>;
+      using _closures_t = stdexec::__tuple<Closures...>;
 
       template <class Sndr>
       STDEXEC_ATTRIBUTE(host, device)
@@ -250,7 +250,7 @@ namespace exec {
   template <class Sndr, class... Closures>
   struct fork_join_t::_sndr_t {
     using sender_concept = stdexec::sender_t;
-    using _closures_t = stdexec::__tuple_for<Closures...>;
+    using _closures_t = stdexec::__tuple<Closures...>;
 
     template <class Self, class... Env>
     STDEXEC_ATTRIBUTE(host, device)
@@ -297,7 +297,7 @@ namespace exec {
     }
 
     STDEXEC_ATTRIBUTE(no_unique_address) fork_join_t _tag_;
-    stdexec::__tuple_for<Closures...> _closures_;
+    stdexec::__tuple<Closures...> _closures_;
     Sndr sndr_;
   };
 

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;
 
@@ -76,7 +84,7 @@ namespace exec {
       // We will be connecting the first sender in the opstate constructor, so we don't need to
       // store it in the opstate. The use of `stdexec::__ignore` causes the first sender to not
       // be stored.
-      using _senders_tuple_t = stdexec::__tuple_for<stdexec::__ignore, Sndrs...>;
+      using _senders_tuple_t = stdexec::__tuple<stdexec::__ignore, Sndrs...>;
 
       template <size_t Idx>
       using _rcvr_t = _seq::_rcvr<Rcvr, stdexec::__id<_opstate>, stdexec::__msize_t<Idx>>;
@@ -91,24 +99,23 @@ namespace exec {
 
       using _ops_variant_t = stdexec::__minvoke<
         _mk_child_ops_variant_fn,
-        stdexec::__tuple_for<Sndr0, Sndrs...>,
+        stdexec::__tuple<Sndr0, Sndrs...>,
         stdexec::__make_indices<sizeof...(Sndrs) + 1>
       >;
 
       template <class CvrefSndrs>
       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);
@@ -206,7 +213,7 @@ namespace exec {
 
       STDEXEC_ATTRIBUTE(no_unique_address, maybe_unused) sequence_t _tag;
       STDEXEC_ATTRIBUTE(no_unique_address, maybe_unused) stdexec::__ignore _ignore;
-      stdexec::__tuple_for<Sndrs...> _sndrs;
+      stdexec::__tuple<Sndrs...> _sndrs;
     };
 
     template <class Sndr>

include/exec/start_now.hpp

@@ -170,7 +170,7 @@ namespace exec {
       template <class _Sender>
       using __nested_t = nest_result_t<_AsyncScope, _Sender>;
 
-      stdexec::__tuple_for<
+      stdexec::__tuple<
         stdexec::connect_result_t<__nested_t<stdexec::__cvref_t<_SenderIds>>, __receiver_t>...
       >
         __op_state_;
@@ -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;

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)...);
           },
@@ -123,7 +123,7 @@ namespace exec {
               __result_.template emplace<__result_t>(_Tag{}, static_cast<_Args&&>(__args)...);
             }
             STDEXEC_CATCH_ALL {
-              using __error_t = __tuple_for<set_error_t, std::exception_ptr>;
+              using __error_t = __tuple<set_error_t, std::exception_ptr>;
               __result_.template emplace<__error_t>(set_error_t{}, std::current_exception());
             }
           }
@@ -195,12 +195,12 @@ namespace exec {
 
       class __t : __op_base_t {
         using __opstate_tuple =
-          __tuple_for<connect_result_t<stdexec::__cvref_t<_CvrefSenderIds>, __receiver_t>...>;
+          __tuple<connect_result_t<stdexec::__cvref_t<_CvrefSenderIds>, __receiver_t>...>;
        public:
         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_);
           }
         }
 
@@ -246,7 +246,7 @@ namespace exec {
        public:
         using __id = __sender;
         using sender_concept = stdexec::sender_t;
-        using __senders_tuple = __tuple_for<stdexec::__t<_SenderIds>...>;
+        using __senders_tuple = __tuple<stdexec::__t<_SenderIds>...>;
 
         template <__not_decays_to<__t>... _Senders>
         explicit(sizeof...(_Senders) == 1) __t(_Senders&&... __senders)

include/nvexec/stream/when_all.cuh

@@ -249,10 +249,10 @@ namespace nvexec::_strm {
 
         template <size_t... Is>
         static auto connect_children_(operation_t* parent_op, WhenAll&& when_all, __indices<Is...>)
-          -> __tuple_for<child_op_state_t<SenderIds, Is>...> {
+          -> __tuple<child_op_state_t<SenderIds, Is>...> {
 
-          using __child_ops_t = __tuple_for<child_op_state_t<SenderIds, Is>...>;
-          return when_all.sndrs_.apply(
+          using __child_ops_t = __tuple<child_op_state_t<SenderIds, Is>...>;
+          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();
               }
 
@@ -439,7 +440,7 @@ namespace nvexec::_strm {
         using child_values_tuple_t = __if<
           sends_values<Completions>,
           __minvoke<
-            __qq<__tuple_for>,
+            __qq<__tuple>,
             __value_types_of_t<
               stdexec::__t<SenderIds>,
               _when_all::env_t<Env>,
@@ -495,7 +496,7 @@ namespace nvexec::_strm {
       }
 
      private:
-      __tuple_for<stdexec::__t<SenderIds>...> sndrs_;
+      __tuple<stdexec::__t<SenderIds>...> sndrs_;
     };
   };
 

include/stdexec/__detail/__basic_sender.hpp

@@ -308,7 +308,7 @@ namespace stdexec {
           requires(sender_to<_Child, __receiver_archetype<__env_t<_Is>>> && ...)
         auto operator()(__indices<_Is...>, _Child&&... __child) const
           noexcept((__nothrow_connectable<_Child, __receiver_t<_Is>> && ...))
-            -> __tuple_for<connect_result_t<_Child, __receiver_t<_Is>>...> {
+            -> __tuple<connect_result_t<_Child, __receiver_t<_Is>>...> {
           return __tuple{connect(static_cast<_Child&&>(__child), __receiver_t<_Is>{__op_})...};
         }
       };
@@ -320,7 +320,7 @@ namespace stdexec {
         return __impl{__op_}(__indices_for<_Child...>(), static_cast<_Child&&>(__child)...);
       }
 
-      auto operator()(__ignore, __ignore) const noexcept -> __tuple_for<> {
+      auto operator()(__ignore, __ignore) const noexcept -> __tuple<> {
         return {};
       }
     };
@@ -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...);
         },