Merge pull request #1733 from ericniebler/deprecate-tag-invoke

deprecate the use of `tag_invoke` in all the CPOs

Author: ericniebler

MAINTAINERS.md

@@ -3,30 +3,12 @@
 This is a place to put design rationale and code idioms that maintainers of
 stdexec should follow.
 
-## ADL isolation
+## Historical reason for all the nested `__t` structs
 
-Stdexec makes use of the [`tag_invoke`](http://wg21.link/p1895) mechanism to
-support end-user customization of algorithms. For the sake of compile-time
-performance, this mechanism requires care to ensure that overload sets stay
-small.
-
-### Hidden friend functions
-
-Define `tag_invoke` overloads for class types _in-situ_ as hidden friend
-functions. Keep in mind that when calling a customizable funtion that
-all the associated entities (classes and namespaces) of all the function's
-arguments are searched for `tag_invoke` overloads. That means that for
-a function call like:
-
-```c++
-connect(sender, receiver);
-```
-
-... the hidden friend functions of the _receiver_ will be considered in
-addition to those of the sender. This can sometimes lead to surprising and
-confusing compiler errors.
-
-### Class template parameters
+At one point all the CPOs used `tag_invoke`, which meant they all did
+argument-dependent lookup (ADL) under the covers. ADL searches all of
+a type's associated namespaces and classes when looking for the best
+overload.
 
 For a class template instantiation such as `N::S<A,B,C>`, the associated
 entities include the associated entities of `A`, `B`, and `C`. This is
@@ -46,27 +28,27 @@ than defining a sender adaptor as:
 
 ```c++
 template <class Sender, class Arg>
-  struct my_sender {
-    Sender sndr_;
-    Arg arg_;
-    // ... rest of sender implementation
-  };
+struct my_sender {
+  Sender sndr_;
+  Arg arg_;
+  // ... rest of sender implementation
+};
 ```
 
 we define it as follows:
 
 ```c++
 template <class SenderId, class Arg>
-  struct my_sender_id {
-    using Sender = stdexec::__t<SenderId>;
-
-    struct __t {
-      using __id = my_sender_id;
-      Sender sndr_;
-      Arg arg_;
-      // ... rest of sender implementation
-    };
+struct my_sender_id {
+  using Sender = stdexec::__t<SenderId>;
+
+  struct __t {
+    using __id = my_sender_id;
+    Sender sndr_;
+    Arg arg_;
+    // ... rest of sender implementation
   };
+};
 
 template <class Sender, class Arg>
   using my_sender =
@@ -82,7 +64,7 @@ to get back the original type from the identifier.
 > We only really need to encode the type of the template arguments that
 > are likely to have `tag_invoke` overloads that we want to exclude when
 > looking for overloads for _this_ type. Hence, the `Sender` type is
-> encoded but the `Arg` type is left alone. 
+> encoded but the `Arg` type is left alone.
 
 Additionally, we move the implementation of the type into a (non-template)
 nested class type called `__t`. This nested class type must have a nested
@@ -92,16 +74,20 @@ When these guidelines are followed, we can ensure that the minimum number
 of class templates are instantiated, and the types of composite senders
 remains short, uncluttered, and readable.
 
+But as the use of `tag_invoke` in stdexec has been deprecated, we can
+stop worrying about this issue in the future, when support for it has
+been dropped completely.
+
 ## Assorted tips and tricks
 
 * Data, including downstream receivers, are best stored in the operation
   state. Receivers themselves should, in general, store nothing but a
   pointer back to the operation state.
 * Assume that schedulers and receivers contain nothing but a pointer and
   are cheap to copy. Take them by value.
-* All `tag_invoke` overloads _must_ be constrained.
+* Do not use `tag_invoke` anywhere. It's deprecated.
 * In a sender adaptor, a reasonable way to constrain
-  `tag_invoke(connect_t, ThisSender<InnerSender>, OuterReceiver)` is by
+  `ThisSender<InnerSender>::connect(OuterReceiver)` is by
   requiring `sender_to<InnerSender, ThisReceiver<OuterReceiver>>`.
 * Place concept checks on public interfaces. Only place concept checks
   on implementation details if needed for correctness; otherwise, leave

examples/algorithms/retry.hpp

@@ -131,8 +131,8 @@ struct _retry_sender {
   }
 
   template <stdexec::receiver R>
-  friend auto tag_invoke(stdexec::connect_t, _retry_sender&& self, R r) -> _op<S, R> {
-    return {static_cast<S&&>(self.s_), static_cast<R&&>(r)};
+  auto connect(R r) && -> _op<S, R> {
+    return {static_cast<S&&>(s_), static_cast<R&&>(r)};
   }
 
   auto get_env() const noexcept -> stdexec::env_of_t<S> {

examples/benchmark/fibonacci.cpp

@@ -67,8 +67,9 @@ struct fib_s {
   };
 
   template <stdexec::receiver_of<completion_signatures> Receiver>
-  friend auto tag_invoke(stdexec::connect_t, fib_s self, Receiver rcvr) -> operation<Receiver> {
-    return {static_cast<Receiver&&>(rcvr), self.cutoff, self.n, self.sched};
+  [[nodiscard]]
+  auto connect(Receiver rcvr) const -> operation<Receiver> {
+    return {static_cast<Receiver&&>(rcvr), cutoff, n, sched};
   }
 };
 

examples/benchmark/static_thread_pool_old.hpp

@@ -169,18 +169,12 @@ namespace exec_old {
         using completion_signatures =
           stdexec::completion_signatures<stdexec::set_value_t(), stdexec::set_stopped_t()>;
 
-       private:
-        template <typename Receiver>
-        auto make_operation_(Receiver r) const -> operation<stdexec::__id<Receiver>> {
-          return operation<stdexec::__id<Receiver>>{pool_, static_cast<Receiver&&>(r)};
-        }
-
         template <stdexec::receiver Receiver>
-        friend auto tag_invoke(stdexec::connect_t, sender s, Receiver r)
-          -> operation<stdexec::__id<Receiver>> {
-          return s.make_operation_(static_cast<Receiver&&>(r));
+        auto connect(Receiver r) const -> operation<stdexec::__id<Receiver>> {
+          return operation<stdexec::__id<Receiver>>{pool_, static_cast<Receiver&&>(r)};
         }
 
+       private:
         struct env {
           static_thread_pool& pool_;
 
@@ -481,7 +475,7 @@ namespace exec_old {
         Receiver,
         completion_signatures<Self, stdexec::env_of_t<Receiver>>
       >
-    friend auto tag_invoke(stdexec::connect_t, Self&& self, Receiver rcvr)
+    STDEXEC_EXPLICIT_THIS_BEGIN(auto connect)(this Self&& self, Receiver rcvr)
       noexcept(stdexec::__nothrow_constructible_from<
                bulk_op_state_t<Self, Receiver>,
                static_thread_pool&,
@@ -497,6 +491,7 @@ namespace exec_old {
         static_cast<Self&&>(self).sndr_,
         static_cast<Receiver&&>(rcvr)};
     }
+    STDEXEC_EXPLICIT_THIS_END(connect)
 
     template <stdexec::__decays_to<bulk_sender> Self, class Env>
     STDEXEC_EXPLICIT_THIS_BEGIN(auto get_completion_signatures)(this Self&&, Env&&)

examples/retry.cpp

@@ -46,7 +46,7 @@ struct fail_some {
   };
 
   template <class R>
-  friend auto tag_invoke(stdexec::connect_t, fail_some, R r) -> op<R> {
+  auto connect(R r) const -> op<R> {
     return {std::move(r)};
   }
 };

include/exec/sequence_senders.hpp

@@ -134,8 +134,9 @@ namespace exec {
       }
 
       template <receiver _Receiver, sender _Item>
-        requires(!__has_set_next_member<_Receiver, _Item>)
-             && tag_invocable<set_next_t, _Receiver&, _Item>
+        requires __has_set_next_member<_Receiver, _Item>
+              || tag_invocable<set_next_t, _Receiver&, _Item>
+      [[deprecated("the use of tag_invoke for set_next is deprecated")]]
       auto operator()(_Receiver& __rcvr, _Item&& __item) const
         noexcept(nothrow_tag_invocable<set_next_t, _Receiver&, _Item>)
           -> tag_invoke_result_t<set_next_t, _Receiver&, _Item> {
@@ -298,8 +299,8 @@ namespace exec {
         } else if constexpr (__is_debug_env<_Env>) {
           using __tag_invoke::tag_invoke;
           // This ought to cause a hard error that indicates where the problem is.
-          using __item_types_t [[maybe_unused]] =
-            decltype(__declval<__tfx_sequence_t>().get_item_types(__declval<_Env>()));
+          using __item_types_t [[maybe_unused]] = decltype(__declval<__tfx_sequence_t>()
+                                                             .get_item_types(__declval<_Env>()));
           return static_cast<__debug::__item_types (*)()>(nullptr);
         } else {
           using __result_t = __unrecognized_sequence_error_t<_Sequence, _Env>;
@@ -560,6 +561,7 @@ namespace exec {
     concept __subscribable_with_tag_invoke = tag_invocable<subscribe_t, _Sequence, _Receiver>;
 
     struct subscribe_t {
+     private:
       template <class _Sequence, class _Receiver>
       STDEXEC_ATTRIBUTE(always_inline)
       static constexpr auto __type_check_arguments() -> bool {
@@ -588,10 +590,8 @@ namespace exec {
 
       template <class _Sequence, class _Receiver>
       static constexpr auto __get_declfn() noexcept {
-        using __domain_t =
-          stdexec::__detail::__completing_domain_t<set_value_t, _Sequence, env_of_t<_Receiver&>>;
         constexpr bool __nothrow_tfx_sequence =
-          __nothrow_callable<transform_sender_t, __domain_t, _Sequence, env_of_t<_Receiver>>;
+          __nothrow_callable<transform_sender_t, _Sequence, env_of_t<_Receiver>>;
         using __tfx_sequence_t = __transform_sender_result_t<_Sequence, _Receiver>;
 
         static_assert(
@@ -631,13 +631,6 @@ namespace exec {
                                      && noexcept(__declval<__tfx_sequence_t>()
                                                    .subscribe(__declval<_Receiver>()));
           return __declfn<__result_t, __is_nothrow>();
-        } else if constexpr (__subscribable_with_tag_invoke<__tfx_sequence_t, _Receiver>) {
-          using __result_t = tag_invoke_result_t<subscribe_t, __tfx_sequence_t, _Receiver>;
-          __check_operation_state<__result_t>();
-          constexpr bool __is_nothrow =
-            __nothrow_tfx_sequence
-            && nothrow_tag_invocable<subscribe_t, __tfx_sequence_t, _Receiver>;
-          return __declfn<__result_t, __is_nothrow>();
         } else if constexpr (__is_debug_env<env_of_t<_Receiver>>) {
           using __result_t = __debug::__debug_operation;
           return __declfn<__result_t, __nothrow_tfx_sequence>();
@@ -649,9 +642,13 @@ namespace exec {
         }
       }
 
-      template <sender _Sequence,
-                receiver _Receiver,
-                auto _DeclFn = __get_declfn<_Sequence, _Receiver>()>
+     public:
+      template <
+        sender _Sequence,
+        receiver _Receiver,
+        auto _DeclFn = __get_declfn<_Sequence, _Receiver>()
+      >
+        requires stdexec::__callable<decltype(_DeclFn)>
       auto operator()(_Sequence&& __sequence, _Receiver&& __rcvr) const
         noexcept(noexcept(_DeclFn())) -> decltype(_DeclFn()) {
         using __tfx_sequence_t = __transform_sender_result_t<_Sequence, _Receiver>;
@@ -661,9 +658,8 @@ namespace exec {
 
         if constexpr (__next_connectable<__tfx_sequence_t, _Receiver>) {
           // sender as sequence of one
-          next_sender_of_t<_Receiver, __tfx_sequence_t> __next = set_next(
-            __rcvr,
-            static_cast<__tfx_sequence_t&&>(__tfx_sequence));
+          next_sender_of_t<_Receiver, __tfx_sequence_t> __next =
+            set_next(__rcvr, static_cast<__tfx_sequence_t&&>(__tfx_sequence));
           return stdexec::connect(
             static_cast<next_sender_of_t<_Receiver, __tfx_sequence_t>&&>(__next),
             __stopped_means_break_t<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
@@ -674,11 +670,6 @@ namespace exec {
         } else if constexpr (__subscribable_with_member<__tfx_sequence_t, _Receiver>) {
           return static_cast<__tfx_sequence_t&&>(__tfx_sequence)
             .subscribe(static_cast<_Receiver&&>(__rcvr));
-        } else if constexpr (__subscribable_with_tag_invoke<__tfx_sequence_t, _Receiver>) {
-          return stdexec::tag_invoke(
-            subscribe_t{},
-            static_cast<__tfx_sequence_t&&>(__tfx_sequence),
-            static_cast<_Receiver&&>(__rcvr));
         } else if constexpr (enable_sequence_sender<stdexec::__decay_t<__tfx_sequence_t>>) {
           // sequence sender fallback
 
@@ -691,15 +682,50 @@ namespace exec {
 
           // This should generate an instantiate backtrace that contains useful
           // debugging information.
-          next_sender_of_t<_Receiver, __tfx_sequence_t> __next = set_next(
-            __rcvr,
-            static_cast<__tfx_sequence_t&&>(__tfx_sequence));
+          next_sender_of_t<_Receiver, __tfx_sequence_t> __next =
+            set_next(__rcvr, static_cast<__tfx_sequence_t&&>(__tfx_sequence));
           return stdexec::connect(
             static_cast<next_sender_of_t<_Receiver, __tfx_sequence_t>&&>(__next),
             __stopped_means_break_t<_Receiver>{static_cast<_Receiver&&>(__rcvr)});
         }
       }
 
+      template <
+        sender _Sequence,
+        receiver _Receiver,
+        auto _DeclFn = __get_declfn<_Sequence, _Receiver>()
+      >
+        requires stdexec::__callable<decltype(_DeclFn)>
+              || stdexec::tag_invocable<
+                   subscribe_t,
+                   __transform_sender_result_t<_Sequence, _Receiver>,
+                   _Receiver
+              >
+      [[deprecated("the use of tag_invoke for subscribe is deprecated")]]
+      auto operator()(_Sequence&& __sequence, _Receiver&& __rcvr) const noexcept(
+        __nothrow_callable<transform_sender_t, _Sequence, env_of_t<_Receiver>>
+        && stdexec::nothrow_tag_invocable<
+          subscribe_t,
+          __transform_sender_result_t<_Sequence, _Receiver>,
+          _Receiver
+        >)
+        -> stdexec::tag_invoke_result_t<
+          subscribe_t,
+          __transform_sender_result_t<_Sequence, _Receiver>,
+          _Receiver
+        > {
+        using __tfx_sequence_t = __transform_sender_result_t<_Sequence, _Receiver>;
+        using __result_t = tag_invoke_result_t<subscribe_t, __tfx_sequence_t, _Receiver>;
+        __check_operation_state<__result_t>();
+        auto&& __env = stdexec::get_env(__rcvr);
+        auto&& __tfx_sequence =
+          stdexec::transform_sender(static_cast<_Sequence&&>(__sequence), __env);
+        return stdexec::tag_invoke(
+          subscribe_t{},
+          static_cast<__tfx_sequence_t&&>(__tfx_sequence),
+          static_cast<_Receiver&&>(__rcvr));
+      }
+
       static constexpr auto query(stdexec::forwarding_query_t) noexcept -> bool {
         return false;
       }

include/stdexec/__detail/__as_awaitable.hpp

@@ -210,10 +210,6 @@ namespace stdexec {
           using _Result = decltype(__declval<_Tp>().as_awaitable(__declval<_Promise&>()));
           constexpr bool _Nothrow = noexcept(__declval<_Tp>().as_awaitable(__declval<_Promise&>()));
           return __declfn<_Result, _Nothrow>();
-        } else if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>) {
-          using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
-          constexpr bool _Nothrow = nothrow_tag_invocable<as_awaitable_t, _Tp, _Promise&>;
-          return __declfn<_Result, _Nothrow>();
           // NOLINTNEXTLINE(bugprone-branch-clone)
         } else if constexpr (__awaitable<_Tp, __unspecified>) { // NOT __awaitable<_Tp, _Promise> !!
           return __declfn<_Tp&&>();
@@ -228,16 +224,13 @@ namespace stdexec {
       }
 
       template <class _Tp, class _Promise, auto _DeclFn = __get_declfn<_Tp, _Promise>()>
+        requires __callable<__mtypeof<_DeclFn>>
       auto operator()(_Tp&& __t, _Promise& __promise) const noexcept(noexcept(_DeclFn()))
         -> decltype(_DeclFn()) {
         if constexpr (__has_as_awaitable_member<_Tp, _Promise>) {
           using _Result = decltype(static_cast<_Tp&&>(__t).as_awaitable(__promise));
           static_assert(__awaitable<_Result, _Promise>);
           return static_cast<_Tp&&>(__t).as_awaitable(__promise);
-        } else if constexpr (tag_invocable<as_awaitable_t, _Tp, _Promise&>) {
-          using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
-          static_assert(__awaitable<_Result, _Promise>);
-          return tag_invoke(*this, static_cast<_Tp&&>(__t), __promise);
           // NOLINTNEXTLINE(bugprone-branch-clone)
         } else if constexpr (__awaitable<_Tp, __unspecified>) { // NOT __awaitable<_Tp, _Promise> !!
           return static_cast<_Tp&&>(__t);
@@ -248,6 +241,17 @@ namespace stdexec {
           return static_cast<_Tp&&>(__t);
         }
       }
+
+      template <class _Tp, class _Promise, auto _DeclFn = __get_declfn<_Tp, _Promise>()>
+        requires __callable<__mtypeof<_DeclFn>> || tag_invocable<as_awaitable_t, _Tp, _Promise&>
+      [[deprecated("the use of tag_invoke for as_awaitable is deprecated")]]
+      auto operator()(_Tp&& __t, _Promise& __promise) const
+        noexcept(nothrow_tag_invocable<as_awaitable_t, _Tp, _Promise&>)
+          -> tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&> {
+        using _Result = tag_invoke_result_t<as_awaitable_t, _Tp, _Promise&>;
+        static_assert(__awaitable<_Result, _Promise>);
+        return tag_invoke(*this, static_cast<_Tp&&>(__t), __promise);
+      }
     };
   } // namespace __as_awaitable