rewrite any_sender_of in terms of __any

ericniebler · ericniebler · commit 12b667a259d9 · 2026-04-01T19:34:27.000-07:00
diff --git a/include/exec/any_sender_of.hpp b/include/exec/any_sender_of.hpp
diff --git a/include/exec/at_coroutine_exit.hpp b/include/exec/at_coroutine_exit.hpp
@@ -31,7 +31,8 @@ namespace experimental::execution
     using namespace STDEXEC;
 
     using __any_scheduler_t =
-      any_receiver_ref<completion_signatures<set_error_t(std::exception_ptr),
+      any_receiver_ref<completion_signatures<set_value_t(),
+                                             set_error_t(std::exception_ptr),
                                              set_stopped_t()>>::any_sender<>::any_scheduler<>;
 
     struct __die_on_stop_t
diff --git a/include/exec/on_coro_disposition.hpp b/include/exec/on_coro_disposition.hpp
@@ -33,7 +33,8 @@ namespace experimental::execution
     using namespace STDEXEC;
 
     using __any_scheduler =
-      any_receiver_ref<completion_signatures<set_error_t(std::exception_ptr),
+      any_receiver_ref<completion_signatures<set_value_t(),
+                                             set_error_t(std::exception_ptr),
                                              set_stopped_t()>>::any_sender<>::any_scheduler<>;
 
     template <class _Promise>
diff --git a/include/exec/sequence/any_sequence_of.hpp b/include/exec/sequence/any_sequence_of.hpp
diff --git a/include/exec/sequence_senders.hpp b/include/exec/sequence_senders.hpp
@@ -140,6 +140,9 @@ namespace experimental::execution
         noexcept(noexcept(__rcvr.set_next(static_cast<_Item&&>(__item))))
           -> decltype(__rcvr.set_next(static_cast<_Item&&>(__item)))
       {
+        static_assert(next_sender<decltype(__rcvr.set_next(static_cast<_Item&&>(__item)))>,
+                      "The sender returned from set_next is required to complete with "
+                      "set_value_t() or set_stopped_t()");
         return __rcvr.set_next(static_cast<_Item&&>(__item));
       }
 
@@ -153,8 +156,7 @@ namespace experimental::execution
       {
         static_assert(next_sender<__tag_invoke_result_t<set_next_t, _Receiver&, _Item>>,
                       "The sender returned from set_next is required to complete with "
-                      "set_value_t() or "
-                      "set_stopped_t()");
+                      "set_value_t() or set_stopped_t()");
         return __tag_invoke(*this, __rcvr, static_cast<_Item&&>(__item));
       }
     };
@@ -819,8 +821,9 @@ namespace experimental::execution
         }
         else
         {
-          static_assert(__subscribable_with_static_member<__tfx_seq_t, _Receiver>,
-                        STDEXEC_ERROR_CANNOT_SUBSCRIBE_SEQUENCE_TO_RECEIVER);
+          using __result_t [[maybe_unused]] = decltype(__declval<__tfx_seq_t>().subscribe(__declval<_Receiver>()));
+          // static_assert(__subscribable_with_static_member<__tfx_seq_t, _Receiver>,
+          //               STDEXEC_ERROR_CANNOT_SUBSCRIBE_SEQUENCE_TO_RECEIVER);
           return _NO_USABLE_SUBSCRIBE_CUSTOMIZATION_FOUND_();
         }
       }
diff --git a/include/exec/task.hpp b/include/exec/task.hpp
@@ -43,7 +43,7 @@ namespace experimental::execution
     // The required set_value_t() scheduler-sender completion signature is added in
     // any_receiver_ref::any_sender::any_scheduler.
     using __any_scheduler_completions =
-      completion_signatures<set_error_t(std::exception_ptr), set_stopped_t()>;
+      completion_signatures<set_value_t(), set_error_t(std::exception_ptr), set_stopped_t()>;
 
     using __any_scheduler =
       any_receiver_ref<__any_scheduler_completions>::any_sender<>::any_scheduler<>;
diff --git a/include/stdexec/__detail/__any.hpp b/include/stdexec/__detail/__any.hpp
@@ -667,6 +667,9 @@ namespace STDEXEC::__any
     : _Interface<__mcall1<__bases_of<_Interface>, __value_proxy_root<_Interface>>>
   {};
 
+  template <class _Interface, __root_kind _RootKind>
+  concept __has_root_kind = std::remove_reference_t<_Interface>::__root_kind == _RootKind;
+
   //////////////////////////////////////////////////////////////////////////////////////////
   //! __interface_base
   template <template <class> class _Interface,
@@ -693,15 +696,20 @@ namespace STDEXEC::__any
                                                  ? _BufferAlignment
                                                  : _Base::__buffer_alignment;
 
+    static constexpr bool __can_slice = __extension_of<_Base, __imovable>
+                                     && (__has_root_kind<_Base, __root_kind::__value>
+                                         || __extension_of<_Base, __icopyable>);
+
     static constexpr bool __nothrow_slice =
       STDEXEC::__any::__nothrow_slice<__this_interface_type, _Base, __buffer_size>;
 
     //! @pre !empty(*this)
-    constexpr virtual void
-    __slice_to_(__value_proxy_root<_Interface> &__result) noexcept(__nothrow_slice)
+    constexpr virtual void __slice_to_(__value_proxy_root<_Interface> &__result)  //
+      noexcept(__nothrow_slice)
     {
       STDEXEC_ASSERT(!__empty(*this));
-      if constexpr (_Base::__box_kind != __box_kind::__abstract)
+      STDEXEC_ASSERT(__can_slice);
+      if constexpr (_Base::__box_kind != __box_kind::__abstract && __can_slice)
       {
         using __root_interface_t = _Base::__interface_type;
         constexpr bool __is_root_interface =
@@ -714,12 +722,15 @@ namespace STDEXEC::__any
             __value(*this).__slice_to_(__result);
             __reset(*this);
           }
-          else  // if constexpr (_Base::__box_kind == __box_kind::__object)
+          else if constexpr (_Base::__root_kind == __root_kind::__value)
           {
             // Move from type-erased values, but not from type-erased references
-            constexpr bool __is_value = (_Base::__root_kind == __root_kind::__value);
             // potentially throwing:
-            __result.emplace(STDEXEC_DECAY_COPY(STDEXEC::__move_if<__is_value>(__value(*this))));
+            __result.emplace(std::move(__value(*this)));
+          }
+          else
+          {
+            __result.emplace(__value(*this));
           }
         }
       }
diff --git a/include/stdexec/__detail/__connect.hpp b/include/stdexec/__detail/__connect.hpp
@@ -232,7 +232,7 @@ namespace STDEXEC
     constexpr auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const
       noexcept(__nothrow_callable<_DeclFn>) -> __call_result_t<_DeclFn>
     {
-      auto&& __new_sndr  = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));
+      decltype(auto) __new_sndr  = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));
       using __new_sndr_t = decltype(__new_sndr);
 
       if constexpr (__connect::__with_static_member<__new_sndr_t, _Receiver>)
diff --git a/include/stdexec/__detail/__diagnostics.hpp b/include/stdexec/__detail/__diagnostics.hpp
@@ -218,6 +218,10 @@ namespace STDEXEC
 
   struct dependent_sender_error : __compile_time_error<dependent_sender_error>
   {
+    constexpr dependent_sender_error() noexcept
+      : what_("This sender needs to know its execution environment before it can know how it will complete.")
+    {}
+
     constexpr explicit dependent_sender_error(char const *what) noexcept
       : what_(what)
     {}
diff --git a/include/stdexec/__detail/__meta.hpp b/include/stdexec/__detail/__meta.hpp
@@ -207,11 +207,14 @@ namespace STDEXEC
   template <class... _What>
   extern _ERROR_<_What...> __ok_v<__mexception<_What...>>;
 
+  template <class... _What>
+  extern _ERROR_<_What...> __ok_v<__mexception<_What...> const>;
+
   template <class _Ty>
   using __ok_t = decltype(__ok_v<_Ty>);
 
   template <class... _Ts>
-  using __mfind_error = decltype((__msuccess(), ..., __ok_t<_Ts>()));
+  using __mfind_error = decltype((__ok_t<_Ts>(), ..., __msuccess()));
 
   template <class _Arg>
   concept __ok = STDEXEC_IS_SAME(__ok_t<_Arg>, __msuccess);
diff --git a/include/stdexec/__detail/__query.hpp b/include/stdexec/__detail/__query.hpp
@@ -76,7 +76,7 @@ namespace STDEXEC
   struct __query<_Query, __no_default, _Transform>
   {
     template <class _Sig>
-    inline static constexpr _Query (*signature)(_Sig) = nullptr;
+    [[deprecated]] inline static constexpr _Query (*signature)(_Sig) = nullptr;
 
     // Query with a .query member function:
     template <class _Qy = _Query, class _Env, class... _Args>
diff --git a/include/stdexec/__detail/__receiver_ref.hpp b/include/stdexec/__detail/__receiver_ref.hpp
@@ -20,15 +20,29 @@
 #include "__execution_fwd.hpp"
 #include "__operation_states.hpp"
 #include "__receivers.hpp"
+#include "__sender_concepts.hpp"
 
 #include <memory>
 #include <utility>
 
 namespace STDEXEC
 {
+  namespace __detail
+  {
+    template <class _Rcvr, class _Item>
+    concept __has_set_next = requires(_Rcvr &__rcvr, __declfn_t<_Item&&> __item) {
+      __rcvr.set_next(__item());
+    };
+  } // namespace __detail
+
   template <class _RcvrPtr, class _Env = env_of_t<decltype(*_RcvrPtr())>>
   struct __pointer_receiver
   {
+   private:
+    using __receiver_t = std::remove_reference_t<decltype(*_RcvrPtr())>;
+    _RcvrPtr __rcvr_ptr_;
+
+   public:
     using receiver_concept = receiver_t;
 
     STDEXEC_ATTRIBUTE(host, device)
@@ -37,13 +51,15 @@ namespace STDEXEC
     {}
 
     template <class... _As>
+      requires __callable<set_value_t, __receiver_t, _As...>
     STDEXEC_ATTRIBUTE(host, device)
     constexpr void set_value(_As&&... __as) noexcept
     {
       STDEXEC::set_value(std::move(*__rcvr_ptr_), static_cast<_As&&>(__as)...);
     }
 
     template <class _Error>
+      requires __callable<set_error_t, __receiver_t, _Error>
     STDEXEC_ATTRIBUTE(host, device)
     constexpr void set_error(_Error&& __err) noexcept
     {
@@ -52,6 +68,7 @@ namespace STDEXEC
 
     STDEXEC_ATTRIBUTE(host, device)
     constexpr void set_stopped() noexcept
+      requires __callable<set_stopped_t, __receiver_t>
     {
       STDEXEC::set_stopped(std::move(*__rcvr_ptr_));
     }
@@ -64,8 +81,17 @@ namespace STDEXEC
       return STDEXEC::get_env(*__rcvr_ptr_);
     }
 
-   private:
-    _RcvrPtr __rcvr_ptr_;
+    // clang-format off
+    template <sender _Item>
+      requires __detail::__has_set_next<__receiver_t, _Item>
+    STDEXEC_ATTRIBUTE(host, device)
+    constexpr auto set_next(_Item&& __item) STDEXEC_AUTO_RETURN
+    (
+      // Make the type of __rcvr_ptr_ dependent on _Item to avoid forming an invalid
+      // expression when _Rcvr doesn't have set_next:
+      (__item, __rcvr_ptr_)->set_next(static_cast<_Item&&>(__item))
+    )
+    // clang-format on
   };
 
   template <class _Rcvr, class _Env = env_of_t<_Rcvr>>
diff --git a/include/stdexec/__detail/__utility.hpp b/include/stdexec/__detail/__utility.hpp
@@ -253,18 +253,6 @@ namespace STDEXEC
 #  define STDEXEC_DECAY_COPY(...) (true ? (__VA_ARGS__) : STDEXEC::__decay_copy(__VA_ARGS__))
 #endif
 
-  //////////////////////////////////////////////////////////////////////////////////////////
-  // _move_if
-  template <bool Move, class _Ty>
-  STDEXEC_ATTRIBUTE(nodiscard, always_inline)
-  constexpr auto&& __move_if(_Ty& t) noexcept
-  {
-    if constexpr (Move)
-      return std::move(t);
-    else
-      return t;
-  }
-
   //////////////////////////////////////////////////////////////////////////////////////////
   // __unconst
   template <class T>
diff --git a/test/exec/sequence/test_any_sequence_of.cpp b/test/exec/sequence/test_any_sequence_of.cpp
@@ -25,7 +25,6 @@ STDEXEC_PRAGMA_IGNORE_GNU("-Wunused-function")
 
 namespace
 {
-
   template <class Receiver>
   struct ignore_all_item_rcvr
   {
@@ -94,53 +93,61 @@ namespace
   TEST_CASE("any_sequence_of - works with empty_sequence",
             "[sequence_senders][any_sequence_of][empty_sequence]")
   {
-    using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
-    STATIC_REQUIRE(
-      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
-                              decltype(exec::empty_sequence())>);
-    exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence =
-      exec::empty_sequence();
-    auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
+    using completions_t  = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
+    using any_sequence_t = exec::any_sequence_receiver_ref<completions_t>::any_sender<>;
+    STATIC_REQUIRE(std::constructible_from<any_sequence_t, decltype(exec::empty_sequence())>);
+    STATIC_REQUIRE(exec::sequence_sender<any_sequence_t>);
+
+    any_sequence_t any_sequence = exec::empty_sequence();
+    auto           op           = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
   TEST_CASE("any_sequence_of - works with just(42)", "[sequence_senders][any_sequence_of]")
   {
-    using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
-    STATIC_REQUIRE(
-      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
-                              decltype(STDEXEC::just(42))>);
-    exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just(42);
-    auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
+    using completions_t      = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
+    using any_receiver_ref_t = exec::any_sequence_receiver_ref<completions_t>;
+    using any_sequence_t     = any_receiver_ref_t::any_sender<>;
+
+    STATIC_REQUIRE(exec::sequence_sender_to<decltype(STDEXEC::just(42)), any_receiver_ref_t>);
+    STATIC_REQUIRE(exec::sequence_sender<any_sequence_t>);
+    STATIC_REQUIRE(std::constructible_from<any_sequence_t, decltype(STDEXEC::just(42))>);
+
+    any_sequence_t any_sequence = STDEXEC::just(42);
+    auto           op           = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
   TEST_CASE("any_sequence_of - works with just()", "[sequence_senders][any_sequence_of]")
   {
-    using CompletionsFalse = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
-    using Completions      = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
+    using completions_false_t = STDEXEC::completion_signatures<STDEXEC::set_value_t(int)>;
+    using completions_t       = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
+
     STATIC_REQUIRE_FALSE(
-      std::constructible_from<exec::any_sequence_receiver_ref<CompletionsFalse>::any_sender<>,
+      std::constructible_from<exec::any_sequence_receiver_ref<completions_false_t>::any_sender<>,
                               decltype(STDEXEC::just())>);
     STATIC_REQUIRE(
-      std::constructible_from<exec::any_sequence_receiver_ref<Completions>::any_sender<>,
+      std::constructible_from<exec::any_sequence_receiver_ref<completions_t>::any_sender<>,
                               decltype(STDEXEC::just())>);
-    exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just();
+    exec::any_sequence_receiver_ref<completions_t>::any_sender<> any_sequence = STDEXEC::just();
     auto op = exec::subscribe(std::move(any_sequence), ignore_all_receiver{});
     STDEXEC::start(op);
   }
 
-  TEST_CASE("any_sequence_of - has an environment", "[sequence_senders][any_sequence_of]")
+  TEST_CASE("any_sequence_of - has attributes", "[sequence_senders][any_sequence_of]")
   {
-    using Completions = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
-    exec::any_sequence_receiver_ref<Completions>::any_sender<> any_sequence = STDEXEC::just();
-    auto                                                       env = STDEXEC::get_env(any_sequence);
-    using env_t                                                    = decltype(env);
-    STATIC_REQUIRE(
-      std::same_as<env_t,
-                   exec::__any::__sender_env<Completions, STDEXEC::__mlist<>, STDEXEC::__mlist<>>>);
+    using completions_t = STDEXEC::completion_signatures<STDEXEC::set_value_t()>;
+    using queries_t =
+      exec::queries<STDEXEC::inplace_stop_token(STDEXEC::get_stop_token_t) noexcept>;
+    using any_seq_rcvr_t = exec::any_sequence_receiver<completions_t>;
+    using any_seq_sndr_t = exec::any_sequence_sender<any_seq_rcvr_t, queries_t>;
+    auto           attrs = STDEXEC::prop{STDEXEC::get_stop_token, STDEXEC::inplace_stop_token{}};
+    any_seq_sndr_t any_sequence = exec::write_attrs(STDEXEC::just(), attrs);
+    auto           token        = STDEXEC::get_stop_token(STDEXEC::get_env(any_sequence));
+
+    STATIC_REQUIRE(std::same_as<decltype(token), STDEXEC::inplace_stop_token>);
+    CHECK(token == STDEXEC::inplace_stop_token{});
   }
-
 }  // namespace
 
 STDEXEC_PRAGMA_POP()
diff --git a/test/exec/test_any_sender.cpp b/test/exec/test_any_sender.cpp

Original file line number	Diff line number	Diff line change
`@@ -140,6 +140,9 @@ namespace experimental::execution`
`140`	`140`	`noexcept(noexcept(__rcvr.set_next(static_cast<_Item&&>(__item))))`
`141`	`141`	`-> decltype(__rcvr.set_next(static_cast<_Item&&>(__item)))`
`142`	`142`	`{`
	`143`	`+ static_assert(next_sender<decltype(__rcvr.set_next(static_cast<_Item&&>(__item)))>,`
	`144`	`+ "The sender returned from set_next is required to complete with "`
	`145`	`+ "set_value_t() or set_stopped_t()");`
`143`	`146`	`return __rcvr.set_next(static_cast<_Item&&>(__item));`
`144`	`147`	`}`
`145`	`148`
`@@ -153,8 +156,7 @@ namespace experimental::execution`
`153`	`156`	`{`
`154`	`157`	`static_assert(next_sender<__tag_invoke_result_t<set_next_t, _Receiver&, _Item>>,`
`155`	`158`	`"The sender returned from set_next is required to complete with "`
`156`		`- "set_value_t() or "`
`157`		`- "set_stopped_t()");`
	`159`	`+ "set_value_t() or set_stopped_t()");`
`158`	`160`	`return __tag_invoke(*this, __rcvr, static_cast<_Item&&>(__item));`
`159`	`161`	`}`
`160`	`162`	`};`
`@@ -819,8 +821,9 @@ namespace experimental::execution`
`819`	`821`	`}`
`820`	`822`	`else`
`821`	`823`	`{`
`822`		`- static_assert(__subscribable_with_static_member<__tfx_seq_t, _Receiver>,`
`823`		`- STDEXEC_ERROR_CANNOT_SUBSCRIBE_SEQUENCE_TO_RECEIVER);`
	`824`	`+ using __result_t [[maybe_unused]] = decltype(__declval<__tfx_seq_t>().subscribe(__declval<_Receiver>()));`
	`825`	`+ // static_assert(__subscribable_with_static_member<__tfx_seq_t, _Receiver>,`
	`826`	`+ // STDEXEC_ERROR_CANNOT_SUBSCRIBE_SEQUENCE_TO_RECEIVER);`
`824`	`827`	`return _NO_USABLE_SUBSCRIBE_CUSTOMIZATION_FOUND_();`
`825`	`828`	`}`
`826`	`829`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ namespace STDEXEC`
`232`	`232`	`constexpr auto operator()(_Sender&& __sndr, _Receiver&& __rcvr) const`
`233`	`233`	`noexcept(__nothrow_callable<_DeclFn>) -> __call_result_t<_DeclFn>`
`234`	`234`	`{`
`235`		`- auto&& __new_sndr = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));`
	`235`	`+ decltype(auto) __new_sndr = transform_sender(static_cast<_Sender&&>(__sndr), get_env(__rcvr));`
`236`	`236`	`using __new_sndr_t = decltype(__new_sndr);`
`237`	`237`
`238`	`238`	`if constexpr (__connect::__with_static_member<__new_sndr_t, _Receiver>)`