Merge pull request #1571 from ericniebler/un-tag-invoke-sequence-senders

ericniebler · web-flow · commit 2674bebb8389 · 2025-07-11T17:46:33.000-07:00
make it possible to define a sequence sender without using `tag_invoke`
diff --git a/include/exec/__detail/__basic_sequence.hpp b/include/exec/__detail/__basic_sequence.hpp
@@ -71,31 +71,18 @@ namespace exec {
       return {};
     }
 
-    template <
-      stdexec::same_as<get_item_types_t> _Tag,
-      stdexec::__decays_to<__seqexpr> _Self,
-      class _Env
-    >
-    friend auto tag_invoke(_Tag, _Self&& __self, _Env&& __env) -> stdexec::__msecond<
-      stdexec::__if_c<stdexec::same_as<_Tag, get_item_types_t>>,
-      decltype(__self.__tag()
-                 .get_item_types(static_cast<_Self&&>(__self), static_cast<_Env&&>(__env)))
-    > {
+    template <stdexec::__decays_to<__seqexpr> _Self, class _Env>
+    STDEXEC_MEMFN_DECL(auto get_item_types)(this _Self&& __self, _Env&& __env)
+      -> decltype(__self.__tag()
+                    .get_item_types(static_cast<_Self&&>(__self), static_cast<_Env&&>(__env))) {
       return {};
     }
 
-    template <
-      stdexec::same_as<subscribe_t> _Tag,
-      stdexec::__decays_to<__seqexpr> _Self,
-      /*receiver*/ class _Receiver
-    >
-    friend auto tag_invoke(_Tag, _Self&& __self, _Receiver&& __rcvr) noexcept(noexcept(
+    template <stdexec::__decays_to<__seqexpr> _Self, stdexec::receiver _Receiver>
+    STDEXEC_MEMFN_DECL(auto subscribe)(this _Self&& __self, _Receiver&& __rcvr) noexcept(noexcept(
       __self.__tag().subscribe(static_cast<_Self&&>(__self), static_cast<_Receiver&&>(__rcvr))))
-      -> stdexec::__msecond<
-        stdexec::__if_c<stdexec::same_as<_Tag, subscribe_t>>,
-        decltype(__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));
     }
 
@@ -104,13 +91,11 @@ namespace exec {
       apply(_Sender&& __sndr, _ApplyFn&& __fun) noexcept(stdexec::__nothrow_callable<
                                                          stdexec::__detail::__impl_of<_Sender>,
                                                          stdexec::__copy_cvref_fn<_Sender>,
-                                                         _ApplyFn
-      >)
+                                                         _ApplyFn>)
         -> stdexec::__call_result_t<
           stdexec::__detail::__impl_of<_Sender>,
           stdexec::__copy_cvref_fn<_Sender>,
-          _ApplyFn
-        > {
+          _ApplyFn> {
       return static_cast<_Sender&&>(__sndr)
         .__impl_(stdexec::__copy_cvref_fn<_Sender>(), static_cast<_ApplyFn&&>(__fun));
     }
diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp
@@ -249,8 +249,7 @@ namespace exec {
       class _Allocator,
       bool _Copyable = false,
       std::size_t _InlineSize = 3 * sizeof(void*),
-      std::size_t _Alignment = alignof(std::max_align_t)
-    >
+      std::size_t _Alignment = alignof(std::max_align_t)>
     struct __storage {
       class __t;
     };
@@ -259,8 +258,7 @@ namespace exec {
       class _Vtable,
       class _Allocator,
       std::size_t _InlineSize = 3 * sizeof(void*),
-      std::size_t _Alignment = alignof(std::max_align_t)
-    >
+      std::size_t _Alignment = alignof(std::max_align_t)>
     struct __immovable_storage {
       class __t : __immovable {
         static constexpr std::size_t __buffer_size = std::max(_InlineSize, sizeof(void*));
@@ -378,8 +376,7 @@ namespace exec {
       class _Allocator,
       bool _Copyable,
       std::size_t _InlineSize,
-      std::size_t _Alignment
-    >
+      std::size_t _Alignment>
     class __storage<_Vtable, _Allocator, _Copyable, _InlineSize, _Alignment>::__t
       : __if_c<_Copyable, __, __move_only> {
       static_assert(
@@ -398,8 +395,7 @@ namespace exec {
       using __vtable_t = __if_c<
         _Copyable,
         __storage_vtable<_Vtable, __with_delete, __with_move, __with_copy>,
-        __storage_vtable<_Vtable, __with_delete, __with_move>
-      >;
+        __storage_vtable<_Vtable, __with_delete, __with_move>>;
 
       template <class _Tp>
       static constexpr auto __get_vtable_of_type() noexcept -> const __vtable_t* {
@@ -410,8 +406,7 @@ namespace exec {
             _Vtable,
             __with_delete,
             __with_move,
-            __with_copy
-          >;
+            __with_copy>;
         } else {
           return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete, __with_move>;
         }
@@ -446,8 +441,8 @@ namespace exec {
       }
 
       __t(const __t& __other)
-        requires(_Copyable) : __vtable_(__other.__vtable_)
-      {
+        requires(_Copyable)
+        : __vtable_(__other.__vtable_) {
         (*__other.__vtable_)(__copy_construct, this, __other);
       }
 
@@ -461,7 +456,8 @@ namespace exec {
         return *this;
       }
 
-      __t(__t&& __other) noexcept : __vtable_(__other.__vtable_) {
+      __t(__t&& __other) noexcept
+        : __vtable_(__other.__vtable_) {
         (*__other.__vtable_)(__move_construct, this, static_cast<__t&&>(__other));
       }
 
@@ -587,8 +583,7 @@ namespace exec {
       class _VTable = __empty_vtable,
       class _Allocator = std::allocator<std::byte>,
       std::size_t _InlineSize = 3 * sizeof(void*),
-      std::size_t _Alignment = alignof(std::max_align_t)
-    >
+      std::size_t _Alignment = alignof(std::max_align_t)>
     using __immovable_storage_t =
       __t<__immovable_storage<_VTable, _Allocator, _InlineSize, _Alignment>>;
 
@@ -598,8 +593,7 @@ namespace exec {
     template <
       class _VTable,
       std::size_t _InlineSize = 3 * sizeof(void*),
-      class _Allocator = std::allocator<std::byte>
-    >
+      class _Allocator = std::allocator<std::byte>>
     using __copyable_storage_t = __t<__storage<_VTable, _Allocator, true, _InlineSize>>;
 
     template <class _Tag, class... _As>
@@ -743,8 +737,7 @@ namespace exec {
         using _FilteredQueries =
           __minvoke<__mremove_if<__q<__is_never_stop_token_query>>, _Queries...>;
         using __vtable_t = stdexec::__t<
-          __mapply<__mbind_front_q<__vtable, completion_signatures<_Sigs...>>, _FilteredQueries>
-        >;
+          __mapply<__mbind_front_q<__vtable, completion_signatures<_Sigs...>>, _FilteredQueries>>;
 
         struct __env_t {
           const __vtable_t* __vtable_;
@@ -835,8 +828,7 @@ namespace exec {
       STDEXEC_ATTRIBUTE(no_unique_address) _Receiver __rcvr_;
       stdexec::inplace_stop_source __stop_source_{};
       using __stop_callback = typename stdexec::stop_token_of_t<
-        stdexec::env_of_t<_Receiver>
-      >::template callback_type<__on_stop_t>;
+        stdexec::env_of_t<_Receiver>>::template callback_type<__on_stop_t>;
       std::optional<__stop_callback> __on_stop_{};
     };
 
@@ -851,11 +843,12 @@ namespace exec {
         using receiver_concept = stdexec::receiver_t;
         __operation_base<_Receiver>* __op_;
 
-        template <same_as<__t> _Self, class _Item>
+        template <class _Item>
           requires __callable<set_next_t, _Receiver&, _Item>
-        STDEXEC_MEMFN_DECL(auto set_next)(this _Self& __self, _Item&& __item) noexcept
+        [[nodiscard]]
+        auto set_next(_Item&& __item) & noexcept(__nothrow_callable<set_next_t, _Receiver&, _Item>)
           -> __call_result_t<set_next_t, _Receiver&, _Item> {
-          return exec::set_next(__self.__op_->__rcvr_, static_cast<_Item&&>(__item));
+          return exec::set_next(__op_->__rcvr_, static_cast<_Item&&>(__item));
         }
 
         template <class... _Args>
@@ -1045,8 +1038,7 @@ namespace exec {
 
         template <receiver_of<_Sigs> _Rcvr>
         auto connect(_Rcvr __rcvr) && -> stdexec::__t<
-          __operation<stdexec::__id<_Rcvr>, __with_inplace_stop_token>
-        > {
+          __operation<stdexec::__id<_Rcvr>, __with_inplace_stop_token>> {
           return {static_cast<__t&&>(*this), static_cast<_Rcvr&&>(__rcvr)};
         }
 
@@ -1197,8 +1189,7 @@ namespace exec {
     template <auto... _SenderQueries>
     class any_sender {
       using __sender_base = stdexec::__t<
-        __any::__sender<_Completions, queries<_SenderQueries...>, queries<_ReceiverQueries...>>
-      >;
+        __any::__sender<_Completions, queries<_SenderQueries...>, queries<_ReceiverQueries...>>>;
       __sender_base __sender_;
 
       template <class _Tag, stdexec::__decays_to<any_sender> Self, class... _As>
@@ -1229,8 +1220,7 @@ namespace exec {
         // Add the required set_value_t() completions to the schedule-sender.
         using __schedule_completions = stdexec::__concat_completion_signatures<
           _Completions,
-          stdexec::completion_signatures<stdexec::set_value_t()>
-        >;
+          stdexec::completion_signatures<stdexec::set_value_t()>>;
         using __schedule_receiver = any_receiver_ref<__schedule_completions, _ReceiverQueries...>;
 
         template <typename _Tag, typename _Sig>
@@ -1245,10 +1235,8 @@ namespace exec {
 
         using __schedule_sender_queries = stdexec::__minvoke<
           stdexec::__mremove_if<
-            __ret_equals_to<stdexec::get_completion_scheduler_t<stdexec::set_value_t>>
-          >,
-          decltype(_SenderQueries)...
-        >;
+            __ret_equals_to<stdexec::get_completion_scheduler_t<stdexec::set_value_t>>>,
+          decltype(_SenderQueries)...>;
 
 #if STDEXEC_MSVC()
         // MSVCBUG https://developercommunity.visualstudio.com/t/ICE-and-non-ICE-bug-in-NTTP-argument-w/10361081
@@ -1261,8 +1249,7 @@ namespace exec {
 #else
         template <class... _Queries>
         using __schedule_sender_fn = typename __schedule_receiver::template any_sender<
-          stdexec::get_completion_scheduler<stdexec::set_value_t>.template signature<any_scheduler() noexcept>
-        >;
+          stdexec::get_completion_scheduler<stdexec::set_value_t>.template signature<any_scheduler() noexcept>>;
 #endif
         using __schedule_sender =
           stdexec::__mapply<stdexec::__q<__schedule_sender_fn>, __schedule_sender_queries>;
diff --git a/include/exec/sequence/any_sequence_of.hpp b/include/exec/sequence/any_sequence_of.hpp
@@ -300,15 +300,13 @@ namespace exec {
       return stdexec::get_env(__receiver_);
     }
 
-   private:
-    STDEXEC_MEMFN_FRIEND(set_value);
-    STDEXEC_MEMFN_FRIEND(set_error);
-    STDEXEC_MEMFN_FRIEND(set_stopped);
-
-    template <std::same_as<__t> _Self, stdexec::sender _Sender>
-      requires stdexec::__callable<set_next_t, _Self&, _Sender>
-    STDEXEC_MEMFN_DECL(auto set_next)(this _Self& __self, _Sender&& __sender) {
-      return exec::set_next(__self.__receiver_, static_cast<_Sender&&>(__sender));
+    template <stdexec::sender _Item>
+      requires stdexec::__callable<set_next_t, __receiver_base&, _Item>
+    [[nodiscard]]
+    auto set_next(_Item&& __item) & noexcept(
+      stdexec::__nothrow_callable<set_next_t, __receiver_base&, _Item>)
+      -> stdexec::__call_result_t<set_next_t, __receiver_base&, _Item> {
+      return exec::set_next(__receiver_, static_cast<_Item&&>(__item));
     }
 
     void set_value() noexcept
@@ -337,8 +335,7 @@ namespace exec {
     using __sender_base = stdexec::__t<__any::__sequence_sender<
       _Completions,
       queries<_SenderQueries...>,
-      queries<_ReceiverQueries...>
-    >>;
+      queries<_ReceiverQueries...>>>;
     __sender_base __sender_;
 
    public:
diff --git a/include/exec/sequence/ignore_all_values.hpp b/include/exec/sequence/ignore_all_values.hpp
@@ -97,8 +97,7 @@ namespace exec {
                      _ResultVariant,
                      __decayed_std_tuple<set_error_t, _Error>,
                      set_error_t,
-                     _Error
-                   >
+                     _Error>
                 && __callable<stdexec::set_stopped_t, _ItemReceiver>
         void set_error(_Error&& __error) noexcept {
           // store error and signal stop
@@ -110,8 +109,7 @@ namespace exec {
           requires __variant_emplaceable<
                      _ResultVariant,
                      __decayed_std_tuple<set_stopped_t>,
-                     set_stopped_t
-                   >
+                     set_stopped_t>
                 && __callable<set_stopped_t, _ItemReceiver>
         {
           // stop without error
@@ -190,11 +188,11 @@ namespace exec {
         using receiver_concept = stdexec::receiver_t;
         __operation_base<_Receiver, _ResultVariant>* __op_;
 
-        template <same_as<__t> _Self, sender _Item>
-        STDEXEC_MEMFN_DECL(auto set_next)(this _Self& __self, _Item&& __item)
-          noexcept(__nothrow_decay_copyable<_Item>)
-            -> stdexec::__t<__item_sender<__decay_t<_Item>, _ResultVariant>> {
-          return {static_cast<_Item&&>(__item), __self.__op_};
+        template <sender _Item>
+        [[nodiscard]]
+        auto set_next(_Item&& __item) & noexcept(__nothrow_decay_copyable<_Item>)
+          -> stdexec::__t<__item_sender<__decay_t<_Item>, _ResultVariant>> {
+          return {static_cast<_Item&&>(__item), __op_};
         }
 
         void set_value() noexcept {
@@ -227,8 +225,7 @@ namespace exec {
       __mconst<__types<>>::__f,
       __mcompose_q<__types, __mbind_front_q<__decayed_std_tuple, set_error_t>::__f>::__f,
       __types<std::tuple<set_stopped_t>>,
-      __mconcat<__qq<__nullable_std_variant>>::__f
-    >;
+      __mconcat<__qq<__nullable_std_variant>>::__f>;
 
     template <class _Sender, class _Env>
     using __result_variant_t =
@@ -324,8 +321,7 @@ namespace exec {
         requires receiver_of<_Receiver, __completion_sigs<__child_of<_Sender>, env_of_t<_Receiver>>>
               && sequence_sender_to<
                    __child_of<_Sender>,
-                   __receiver_t<__child_of<_Sender>, _Receiver>
-              >
+                   __receiver_t<__child_of<_Sender>, _Receiver>>
       {
         static_assert(sender_expr_for<_Sender, ignore_all_values_t>);
         return __sexpr_apply(static_cast<_Sender&&>(__sndr), __connect_fn<_Receiver>{__rcvr});
diff --git a/include/exec/sequence/iterate.hpp b/include/exec/sequence/iterate.hpp
@@ -25,7 +25,6 @@
 #  include "../sequence_senders.hpp"
 #  include "../__detail/__basic_sequence.hpp"
 
-#  include "../env.hpp"
 #  include "../trampoline_scheduler.hpp"
 
 #  include <exception>
@@ -186,8 +185,7 @@ namespace exec {
 
       template <
         sender_expr_for<iterate_t> _SeqExpr,
-        sequence_receiver_of<item_types<_ItemSender<_SeqExpr>>> _Receiver
-      >
+        sequence_receiver_of<item_types<_ItemSender<_SeqExpr>>> _Receiver>
         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>>)
@@ -201,8 +199,8 @@ namespace exec {
       }
 
       template <sender_expr_for<iterate_t> _Sequence>
-      static auto
-        get_item_types(_Sequence&&, __ignore) noexcept -> item_types<_ItemSender<_Sequence>> {
+      static auto get_item_types(_Sequence&&, __ignore) noexcept //
+        -> item_types<_ItemSender<_Sequence>> {
         return {};
       }
 
diff --git a/include/exec/sequence_senders.hpp b/include/exec/sequence_senders.hpp
diff --git a/test/exec/sequence/test_iterate.cpp b/test/exec/sequence/test_iterate.cpp
