a simpler implementation for stdexec::__tuple (#1717)

* clean up sender adaptor closures

* stop being so precious with the execution policies

Author: ericniebler

include/exec/finally.hpp

@@ -304,8 +304,8 @@ namespace exec {
 
       template <sender _Final>
       STDEXEC_ATTRIBUTE(always_inline)
-      auto operator()(_Final&& __final) const -> __binder_back<finally_t, __decay_t<_Final>> {
-        return {{static_cast<_Final&&>(__final)}, {}, {}};
+      auto operator()(_Final&& __final) const {
+        return __closure(*this, static_cast<_Final&&>(__final));
       }
 
       template <class _Sender>

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/into_tuple.hpp

@@ -101,8 +101,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      constexpr auto operator()() const noexcept -> __binder_back<into_tuple_t> {
-        return {{}, {}, {}};
+      constexpr auto operator()() const noexcept {
+        return __closure(*this);
       }
     };
   } // namespace __into_tuple

include/exec/materialize.hpp

@@ -123,8 +123,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      auto operator()() const noexcept -> __binder_back<__materialize_t> {
-        return {{}, {}, {}};
+      auto operator()() const noexcept {
+        return __closure(*this);
       }
     };
   } // namespace __materialize
@@ -233,8 +233,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      auto operator()() const noexcept -> __binder_back<__dematerialize_t> {
-        return {{}, {}, {}};
+      auto operator()() const noexcept {
+        return __closure(*this);
       }
     };
   } // namespace __dematerialize

include/exec/repeat_effect_until.hpp

@@ -204,8 +204,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      constexpr auto operator()() const -> __binder_back<repeat_effect_until_t> {
-        return {{}, {}, {}};
+      constexpr auto operator()() const {
+        return __closure(*this);
       }
 
       template <class _Sender>
@@ -232,8 +232,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      constexpr auto operator()() const -> __binder_back<repeat_effect_t> {
-        return {{}, {}, {}};
+      constexpr auto operator()() const {
+        return __closure(*this);
       }
 
       template <class _Sender>

include/exec/repeat_n.hpp

@@ -202,9 +202,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      constexpr auto
-        operator()(std::size_t __count) const -> __binder_back<repeat_n_t, std::size_t> {
-        return {{__count}, {}, {}};
+      constexpr auto operator()(std::size_t __count) const noexcept {
+        return __closure(*this, __count);
       }
 
       template <class _Sender, bool _NoThrow = __nothrow_decay_copyable<_Sender>>

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/sequence/ignore_all_values.hpp

@@ -308,8 +308,8 @@ namespace exec {
       }
 
       STDEXEC_ATTRIBUTE(always_inline)
-      constexpr auto operator()() const noexcept -> __binder_back<ignore_all_values_t> {
-        return {{}, {}, {}};
+      constexpr auto operator()() const noexcept {
+        return __closure(*this);
       }
     };
 

include/exec/sequence/merge.hpp

@@ -82,7 +82,7 @@ namespace exec {
     struct __combine {
       template <class _ReceiverId>
       using merge_each_fn_t =
-        __binder_back<__merge_each_fn<_ReceiverId>, __operation_base<__t<_ReceiverId>>*>;
+        __closure<__merge_each_fn<_ReceiverId>, __operation_base<__t<_ReceiverId>>*>;
 
       template <class _Sequence, class _ReceiverId>
       using transform_sender_t =
@@ -118,7 +118,7 @@ namespace exec {
                 exec::ignore_all_values(
                   exec::transform_each(
                     static_cast<_Sequences&&>(__sequences),
-                    merge_each_fn_t{{this}, {}, {}}))...),
+                    merge_each_fn_t({}, this)))...),
               stdexec::__t<__result_receiver<_ReceiverId>>{this})} {
         }
 
@@ -161,7 +161,6 @@ namespace exec {
 
       template <class... _Env>
       struct __completions_fn_t {
-
         template <class... _Sequences>
         using __f = __meval<
           __concat_completion_signatures,

include/exec/sequence/transform_each.hpp

@@ -161,8 +161,8 @@ namespace exec {
       template <class _Adaptor>
       STDEXEC_ATTRIBUTE(always_inline)
       constexpr auto
-        operator()(_Adaptor __adaptor) const noexcept -> __binder_back<transform_each_t, _Adaptor> {
-        return {{static_cast<_Adaptor&&>(__adaptor)}, {}, {}};
+        operator()(_Adaptor&& __adaptor) const noexcept(__nothrow_decay_copyable<_Adaptor>) {
+        return __closure(*this, static_cast<_Adaptor&&>(__adaptor));
       }
 
       template <class _Self, class... _Env>