move sender_expr[_for] concepts out of the STDEXEC namespace

Author: ericniebler

include/exec/detail/shared.hpp

@@ -496,7 +496,7 @@ namespace experimental::execution::__shared
     template <class _CvSender>
     static consteval auto __get_completion_signatures()
     {
-      static_assert(sender_expr_for<_CvSender, _Tag>);
+      static_assert(STDEXEC::__sender_for<_CvSender, _Tag>);
       return __get_completion_signatures_impl<__child_of<_CvSender>,
                                               __decay_t<__data_of<_CvSender>>>();
     };

include/exec/ensure_started.hpp

@@ -23,6 +23,7 @@
 #include "../stdexec/__detail/__senders.hpp"
 #include "../stdexec/__detail/__transform_sender.hpp"
 #include "detail/shared.hpp"
+#include "sender_for.hpp"
 
 namespace experimental::execution
 {
@@ -68,7 +69,7 @@ namespace experimental::execution
     static constexpr auto
     transform_sender(STDEXEC::set_value_t, _CvSender&& __sndr, STDEXEC::__ignore)
     {
-      static_assert(STDEXEC::sender_expr_for<_CvSender, ensure_started_t>);
+      static_assert(sender_for<_CvSender, ensure_started_t>);
       auto __result = __shared::__sndr{ensure_started_t(),
                                        STDEXEC::__get<2>(static_cast<_CvSender&&>(__sndr)),
                                        STDEXEC::__get<1>(static_cast<_CvSender&&>(__sndr))};

include/exec/libdispatch_queue.hpp

@@ -28,6 +28,9 @@
 #  endif
 
 #  include "../stdexec/execution.hpp"
+
+#  include "sender_for.hpp"
+
 #  include <dispatch/dispatch.h>
 
 namespace experimental::execution
@@ -91,9 +94,10 @@ namespace experimental::execution
     struct domain
     {
       // transform the generic bulk sender into a parallel libdispatch bulk sender
-      template <STDEXEC::sender_expr_for<STDEXEC::bulk_t> Sender, class Env>
+      template <class Sender, class Env>
       auto transform_sender(STDEXEC::set_value_t, Sender &&sndr, Env const &env) const noexcept
       {
+        static_assert(sender_for<Sender, STDEXEC::bulk_t>);
         if constexpr (STDEXEC::__completes_on<Sender, libdispatch_scheduler, Env>)
         {
           auto sched =

include/exec/sender_for.hpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2022 NVIDIA Corporation
+ *
+ * Licensed under the Apache License Version 2.0 with LLVM Exceptions
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *   https://llvm.org/LICENSE.txt
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "../stdexec/__detail/__sender_introspection.hpp"
+
+namespace experimental::execution
+{
+  template <class _Sender, class... _Tag>
+  concept sender_for = STDEXEC::__sender_for<_Sender, _Tag...>;
+}  // namespace experimental::execution
+
+namespace exec = experimental::execution;

include/exec/sequence/ignore_all_values.hpp

@@ -21,6 +21,7 @@
 // include these after execution.hpp
 #include "../../stdexec/__detail/__tuple.hpp"
 #include "../../stdexec/__detail/__variant.hpp"
+#include "../sender_for.hpp"
 #include "../sequence_senders.hpp"
 
 #include "../../stdexec/__detail/__atomic.hpp"
@@ -316,7 +317,7 @@ namespace experimental::execution
       template <class _Sender, class... _Env>
       static consteval auto __get_completion_signatures()
       {
-        static_assert(sender_expr_for<_Sender, ignore_all_values_t>);
+        static_assert(sender_for<_Sender, ignore_all_values_t>);
         return __sequence_completion_signatures_of<__child_of<_Sender>, _Env...>();
       }
 
@@ -325,7 +326,7 @@ namespace experimental::execution
           __nothrow_applicable<__connect_fn, _Sender, _Receiver&>)
         -> __apply_result_t<__connect_fn, _Sender, _Receiver&>
       {
-        static_assert(sender_expr_for<_Sender, ignore_all_values_t>);
+        static_assert(sender_for<_Sender, ignore_all_values_t>);
         return __apply(__connect_fn(), static_cast<_Sender&&>(__sndr), __rcvr);
       };
     };

include/exec/sequence/iterate.hpp

@@ -24,6 +24,7 @@
 #  include "../../stdexec/execution.hpp"
 
 #  include "../detail/basic_sequence.hpp"
+#  include "../sender_for.hpp"
 #  include "../sequence.hpp"
 #  include "../sequence_senders.hpp"
 #  include "../trampoline_scheduler.hpp"
@@ -203,13 +204,14 @@ namespace experimental::execution
       template <class _Sequence, class _Receiver>
       using _NextSender = next_sender_of_t<_Receiver, __item_sender_t<_Sequence>>;
 
-      template <sender_expr_for<iterate_t>                                  _SeqExpr,
+      template <class _SeqExpr,
                 sequence_receiver_of<item_types<__item_sender_t<_SeqExpr>>> _Receiver>
         requires sender_to<_NextSender<_SeqExpr, _Receiver>, _NextReceiver<_SeqExpr, _Receiver>>
       static constexpr auto subscribe(_SeqExpr&& __seq, _Receiver __rcvr)
         noexcept(__nothrow_applicable<__subscribe_fn<_Receiver>, _SeqExpr>)
           -> __apply_result_t<__subscribe_fn<_Receiver>, _SeqExpr>
       {
+        static_assert(sender_for<_SeqExpr, iterate_t>);
         return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_SeqExpr&&>(__seq));
       }
 
@@ -221,9 +223,10 @@ namespace experimental::execution
                                      set_stopped_t()>();
       }
 
-      template <sender_expr_for<iterate_t> _Sequence, class... _Env>
+      template <class _Sequence, class... _Env>
       static consteval auto get_item_types() noexcept
       {
+        static_assert(sender_for<_Sequence, iterate_t>);
         return item_types<__item_sender_t<_Sequence>>();
       }
 

include/exec/sequence/merge.hpp

@@ -19,6 +19,7 @@
 #include "../../stdexec/execution.hpp"
 
 #include "../detail/basic_sequence.hpp"
+#include "../sender_for.hpp"
 #include "../sequence_senders.hpp"
 #include "ignore_all_values.hpp"
 #include "transform_each.hpp"
@@ -175,7 +176,7 @@ namespace experimental::execution
       template <class _Self, class... _Env>
       static consteval auto get_completion_signatures() noexcept
       {
-        static_assert(STDEXEC::sender_expr_for<_Self, merge_t>);
+        static_assert(sender_for<_Self, merge_t>);
         auto __items = STDEXEC::__children_of<_Self, STDEXEC::__qq<item_types>>();
         return exec::concat_completion_signatures(
           completion_signatures<set_stopped_t()>(),
@@ -185,7 +186,7 @@ namespace experimental::execution
       template <class _Self, class... _Env>
       static consteval auto get_item_types()
       {
-        static_assert(sender_expr_for<_Self, merge_t>);
+        static_assert(sender_for<_Self, merge_t>);
         auto __items = STDEXEC::__children_of<_Self, STDEXEC::__qq<item_types>>();
         return __items.__transform(__mk_get_item_types<_Env...>(), __mk_unique_concat_items());
       }
@@ -195,7 +196,7 @@ namespace experimental::execution
         noexcept(__nothrow_applicable<__subscribe_fn, _Self, _Receiver&>)
           -> __apply_result_t<__subscribe_fn, _Self, _Receiver&>
       {
-        static_assert(sender_expr_for<_Self, merge_t>);
+        static_assert(sender_for<_Self, merge_t>);
         return STDEXEC::__apply(__subscribe_fn{}, static_cast<_Self&&>(__self), __rcvr);
       }
     };

include/exec/sequence/merge_each.hpp

@@ -33,6 +33,7 @@
 #include "../../stdexec/__detail/__transform_completion_signatures.hpp"
 #include "../../stdexec/__detail/__variant.hpp"
 #include "../detail/basic_sequence.hpp"
+#include "../sender_for.hpp"
 
 #include <atomic>
 
@@ -1277,9 +1278,10 @@ namespace experimental::execution
         return make_sequence_expr<merge_each_t>(__(), static_cast<_Sequence&&>(__sequence));
       }
 
-      template <sender_expr_for<merge_each_t> _Self, class... _Env>
+      template <class _Self, class... _Env>
       static consteval auto get_item_types()
       {
+        static_assert(sender_for<_Self, merge_each_t>);
         using __result_t =
           __compute::__nested_values_t<__child_of<_Self>,
                                        __env_with_inplace_stop_token_result_t<_Env>...>;
@@ -1310,7 +1312,7 @@ namespace experimental::execution
       template <class _Self, class... _Env>
       static consteval auto get_completion_signatures()
       {
-        static_assert(sender_expr_for<_Self, merge_each_t>);
+        static_assert(sender_for<_Self, merge_each_t>);
         // TODO: update this to use constant evaluation:
         using __result_t = __minvoke<__mtry_q<__completions_t>,
                                      _Self,
@@ -1331,7 +1333,7 @@ namespace experimental::execution
           __nothrow_applicable<__subscribe_fn<_Receiver>, _Sequence>)
         -> __apply_result_t<__subscribe_fn<_Receiver>, _Sequence>
       {
-        static_assert(sender_expr_for<_Sequence, merge_each_t>);
+        static_assert(sender_for<_Sequence, merge_each_t>);
         return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_Sequence&&>(__sndr));
       };
     };

include/exec/sequence/transform_each.hpp

@@ -18,6 +18,7 @@
 
 #include "../../stdexec/concepts.hpp"
 #include "../../stdexec/execution.hpp"
+#include "../sender_for.hpp"
 #include "../sequence_senders.hpp"
 
 #include "../detail/basic_sequence.hpp"
@@ -155,7 +156,7 @@ namespace experimental::execution
       template <class _Self, class... _Env>
       static consteval auto get_completion_signatures()
       {
-        static_assert(sender_expr_for<_Self, transform_each_t>);
+        static_assert(sender_for<_Self, transform_each_t>);
         return exec::__sequence_completion_signatures_of<__child_of<_Self>, _Env...>();
       }
 
@@ -170,7 +171,7 @@ namespace experimental::execution
       template <class _Self, class... _Env>
       static consteval auto get_item_types()
       {
-        static_assert(sender_expr_for<_Self, transform_each_t>);
+        static_assert(sender_for<_Self, transform_each_t>);
         using __closure_t  = STDEXEC::__decay_t<__data_of<_Self>>&;
         auto __child_items = exec::get_item_types<__child_of<_Self>, _Env...>();
 
@@ -206,17 +207,19 @@ namespace experimental::execution
       template <class _Self, class _Receiver>
       using __operation_t = __operation<__child_of<_Self>, _Receiver, __data_of<_Self>>;
 
-      template <sender_expr_for<transform_each_t> _Self, receiver _Receiver>
+      template <class _Self, receiver _Receiver>
       static auto subscribe(_Self&& __self, _Receiver __rcvr)
         noexcept(__nothrow_applicable<__subscribe_fn<_Receiver>, _Self>)
           -> __apply_result_t<__subscribe_fn<_Receiver>, _Self>
       {
+        static_assert(sender_for<_Self, transform_each_t>);
         return __apply(__subscribe_fn<_Receiver>{__rcvr}, static_cast<_Self&&>(__self));
       }
 
-      template <sender_expr_for<transform_each_t> _Sexpr>
+      template <class _Sexpr>
       static auto get_env(_Sexpr const & __sexpr) noexcept -> env_of_t<__child_of<_Sexpr>>
       {
+        static_assert(sender_for<_Sexpr, transform_each_t>);
         return __apply([]<class _Child>(__ignore, __ignore, _Child const & __child)
                        { return STDEXEC::get_env(__child); },
                        __sexpr);

include/exec/split.hpp

@@ -23,6 +23,7 @@
 #include "../stdexec/__detail/__senders.hpp"
 #include "../stdexec/__detail/__transform_sender.hpp"
 #include "detail/shared.hpp"
+#include "sender_for.hpp"
 
 namespace experimental::execution
 {
@@ -51,7 +52,7 @@ namespace experimental::execution
     static constexpr auto
     transform_sender(STDEXEC::set_value_t, _CvSender&& __sndr, STDEXEC::__ignore)
     {
-      static_assert(STDEXEC::sender_expr_for<_CvSender, split_t>);
+      static_assert(sender_for<_CvSender, split_t>);
       return __shared::__sndr{split_t(),
                               STDEXEC::__get<2>(static_cast<_CvSender&&>(__sndr)),
                               STDEXEC::__get<1>(static_cast<_CvSender&&>(__sndr))};