remove needless hops through tag_invoke

Author: ericniebler

docs/source/conf.py

@@ -36,6 +36,7 @@
     "sphinx.ext.autodoc",
     "sphinx.ext.autosummary",
     "sphinx.ext.intersphinx",
+    "sphinx.ext.graphviz",
     "sphinx.ext.mathjax",
     "sphinx.ext.napoleon",
     "sphinx_copybutton",

include/exec/any_sender_of.hpp

@@ -17,6 +17,7 @@
 
 #include "../stdexec/execution.hpp"
 #include "../stdexec/__detail/__any_receiver_ref.hpp"
+#include "../stdexec/__detail/__transform_completion_signatures.hpp"
 
 #include "sequence_senders.hpp"
 
@@ -250,7 +251,8 @@ 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,7 +261,8 @@ 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*));
@@ -377,7 +380,8 @@ 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(
@@ -396,7 +400,8 @@ 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* {
@@ -407,7 +412,8 @@ namespace exec {
             _Vtable,
             __with_delete,
             __with_move,
-            __with_copy>;
+            __with_copy
+          >;
         } else {
           return &__storage_vtbl<__t, __decay_t<_Tp>, _Vtable, __with_delete, __with_move>;
         }
@@ -584,7 +590,8 @@ 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>>;
 
@@ -594,7 +601,8 @@ 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>
@@ -747,7 +755,8 @@ 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_;
@@ -850,7 +859,8 @@ 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_{};
     };
 
@@ -1060,7 +1070,8 @@ 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)};
         }
 
@@ -1211,19 +1222,15 @@ 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>
-        requires stdexec::tag_invocable<_Tag, stdexec::__copy_cvref_t<Self, __sender_base>, _As...>
-      friend auto tag_invoke(_Tag, Self&& __self, _As&&... __as) noexcept(
-        stdexec::nothrow_tag_invocable<_Tag, stdexec::__copy_cvref_t<Self, __sender_base>, _As...>) {
-        return stdexec::tag_invoke(
-          _Tag{}, static_cast<Self&&>(__self).__sender_, static_cast<_As&&>(__as)...);
-      }
      public:
       using sender_concept = stdexec::sender_t;
       using completion_signatures = typename __sender_base::completion_signatures;
+      using __t = any_sender;
+      using __id = any_sender;
 
       template <stdexec::__not_decays_to<any_sender> _Sender>
         requires stdexec::sender_to<_Sender, __receiver_base>
@@ -1237,12 +1244,17 @@ namespace exec {
         return static_cast<__sender_base&&>(__sender_).connect(static_cast<_Receiver&&>(__rcvr));
       }
 
+      auto get_env() const noexcept -> stdexec::env_of_t<__sender_base> {
+        return static_cast<const __sender_base&>(__sender_).get_env();
+      }
+
       template <auto... _SchedulerQueries>
       class any_scheduler {
         // 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>
@@ -1257,8 +1269,10 @@ 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
@@ -1271,7 +1285,8 @@ 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>;
@@ -1282,6 +1297,7 @@ namespace exec {
         __scheduler_base __scheduler_;
 
        public:
+        using scheduler_concept = stdexec::scheduler_t;
         using __t = any_scheduler;
         using __id = any_scheduler;
 
@@ -1296,11 +1312,11 @@ namespace exec {
         }
 
         template <class _Tag, class... _As>
-          requires stdexec::tag_invocable<_Tag, const __scheduler_base&, _As...>
+          requires stdexec::__env::__queryable<const __scheduler_base&, _Tag, _As...>
         auto query(_Tag, _As&&... __as) const
-          noexcept(stdexec::nothrow_tag_invocable<_Tag, const __scheduler_base&, _As...>)
-            -> stdexec::tag_invoke_result_t<_Tag, const __scheduler_base&, _As...> {
-          return stdexec::tag_invoke(_Tag(), __scheduler_, static_cast<_As&&>(__as)...);
+          noexcept(stdexec::__env::__nothrow_queryable<const __scheduler_base&, _Tag, _As...>)
+            -> stdexec::__env::__query_result_t<const __scheduler_base&, _Tag, _As...> {
+          return __scheduler_.query(_Tag{}, static_cast<_As&&>(__as)...);
         }
 
         auto operator==(const any_scheduler&) const noexcept -> bool = default;

include/exec/linux/io_uring_context.hpp

@@ -1079,17 +1079,15 @@ namespace exec {
      public:
       __context* __context_;
 
-      friend auto operator==(const __scheduler& __lhs, const __scheduler& __rhs) -> bool = default;
+      auto operator==(const __scheduler&) const -> bool = default;
 
-      class __schedule_env {
-       public:
-        __context* __context_;
-       private:
-        friend auto tag_invoke(
-          stdexec::get_completion_scheduler_t<stdexec::set_value_t>,
-          const __schedule_env& __env) noexcept -> __scheduler {
-          return __scheduler{__env.__context_};
+      struct __schedule_env {
+        [[nodiscard]] auto
+          query(stdexec::get_completion_scheduler_t<stdexec::set_value_t>) const noexcept -> __scheduler {
+          return __scheduler{__context_};
         }
+
+        __context* __context_;
       };
 
       class __schedule_sender {
@@ -1164,25 +1162,22 @@ namespace exec {
         return __schedule_sender{__schedule_env{__context_}};
       }
 
-      friend auto tag_invoke(exec::now_t, const __scheduler&) noexcept
-        -> std::chrono::time_point<std::chrono::steady_clock> {
+      [[nodiscard]]
+      auto now() const noexcept -> std::chrono::time_point<std::chrono::steady_clock> {
         return std::chrono::steady_clock::now();
       }
 
-      friend auto tag_invoke(
-        exec::schedule_after_t,
-        const __scheduler& __sched,
-        std::chrono::nanoseconds __duration) -> __schedule_after_sender {
-        return __schedule_after_sender{.__env_ = {__sched.__context_}, .__duration_ = __duration};
+      [[nodiscard]]
+      auto schedule_after(std::chrono::nanoseconds __duration) const -> __schedule_after_sender {
+        return __schedule_after_sender{.__env_ = {__context_}, .__duration_ = __duration};
       }
 
       template <class _Clock, class _Duration>
-      friend auto tag_invoke(
-        exec::schedule_at_t,
-        const __scheduler& __sched,
-        const std::chrono::time_point<_Clock, _Duration>& __time_point) -> __schedule_after_sender {
+      [[nodiscard]]
+      auto schedule_at(const std::chrono::time_point<_Clock, _Duration>& __time_point) const
+        -> __schedule_after_sender {
         auto __duration = __time_point - _Clock::now();
-        return __schedule_after_sender{.__env_ = {__sched.__context_}, .__duration_ = __duration};
+        return __schedule_after_sender{.__env_ = {__context_}, .__duration_ = __duration};
       }
     };
 
@@ -1194,6 +1189,9 @@ namespace exec {
   using __io_uring::until;
   using io_uring_context = __io_uring::__context;
   using io_uring_scheduler = __io_uring::__scheduler;
+
+  static_assert(__timed_scheduler<io_uring_scheduler>);
+
 } // namespace exec
 
 #  endif // if __has_include(<linux/verison.h>)

include/exec/on.hpp

@@ -23,5 +23,5 @@ namespace exec {
   using on_t [[deprecated("on_t has been moved to the stdexec:: namespace")]] = stdexec::on_t;
 
   [[deprecated("on has been moved to the stdexec:: namespace")]]
-  inline constexpr on_t const& on = stdexec::on;
+  inline constexpr stdexec::on_t const & on = stdexec::on;
 } // namespace exec

include/exec/sequence/any_sequence_of.hpp

@@ -335,7 +335,8 @@ namespace exec {
     using __sender_base = stdexec::__t<__any::__sequence_sender<
       _Completions,
       queries<_SenderQueries...>,
-      queries<_ReceiverQueries...>>>;
+      queries<_ReceiverQueries...>
+    >>;
     __sender_base __sender_;
 
    public:
@@ -352,11 +353,9 @@ namespace exec {
       : __sender_(static_cast<_Sender&&>(__sender)) {
     }
 
-    template <stdexec::same_as<__t> _Self, sequence_receiver_of<item_types> _Rcvr>
-    friend auto tag_invoke(exec::subscribe_t, _Self&& __self, _Rcvr __rcvr)
-      -> subscribe_result_t<__sender_base, _Rcvr> {
-      return exec::subscribe(
-        static_cast<__sender_base&&>(__self.__sender_), static_cast<_Rcvr&&>(__rcvr));
+    template <sequence_receiver_of<item_types> _Rcvr>
+    auto subscribe(_Rcvr __rcvr) && -> subscribe_result_t<__sender_base, _Rcvr> {
+      return exec::subscribe(static_cast<__sender_base&&>(__sender_), static_cast<_Rcvr&&>(__rcvr));
     }
 
     auto get_env() const noexcept -> stdexec::env_of_t<__sender_base> {

include/exec/sequence/transform_each.hpp

@@ -41,15 +41,15 @@ namespace exec {
         using __id = __receiver;
         __operation_base<_Receiver, _Adaptor>* __op_;
 
-        template <same_as<set_next_t> _SetNext, same_as<__t> _Self, class _Item>
+        template <class _Item>
           requires __callable<_Adaptor&, _Item>
                 && __callable<exec::set_next_t, _Receiver&, __call_result_t<_Adaptor&, _Item>>
-        friend auto tag_invoke(_SetNext, _Self& __self, _Item&& __item) noexcept(
-          __nothrow_callable<_SetNext, _Receiver&, __call_result_t<_Adaptor&, _Item>>
+        auto set_next(_Item&& __item) & noexcept(
+          __nothrow_callable<set_next_t, _Receiver&, __call_result_t<_Adaptor&, _Item>>
           && __nothrow_callable<_Adaptor&, _Item>)
           -> next_sender_of_t<_Receiver, __call_result_t<_Adaptor&, _Item>> {
           return exec::set_next(
-            __self.__op_->__receiver_, __self.__op_->__adaptor_(static_cast<_Item&&>(__item)));
+            __op_->__receiver_, __op_->__adaptor_(static_cast<_Item&&>(__item)));
         }
 
         void set_value() noexcept {