Implement P4154

docs/code/tst-basic-timer.cpp

@@ -10,7 +10,7 @@ namespace ex = beman::execution;
 // ----------------------------------------------------------------------------
 
 struct receiver {
-    using receiver_concept = ex::receiver_t;
+    using receiver_concept = ex::receiver_tag;
 
     auto set_value() && noexcept { std::cout << "timer done\n"; }
     auto set_error(const std::exception_ptr&) && noexcept { std::cout << "timer error\n"; }

docs/code/tst-repeat_effect_until.hpp

@@ -24,15 +24,15 @@ struct connector {
 inline constexpr struct repeat_effect_unilt_t {
     template <ex::sender Child, typename Fun>
     struct sender {
-        using sender_concept = ex::sender_t;
+        using sender_concept = ex::sender_tag;
         using completion_signatures =
             ex::completion_signatures<ex::set_value_t(), ex::set_error_t(std::exception_ptr), ex::set_stopped_t()>;
 
         template <ex::receiver Receiver>
         struct state {
-            using operation_state_concept = ex::operation_state_t;
+            using operation_state_concept = ex::operation_state_tag;
             struct own_receiver {
-                using receiver_concept = ex::receiver_t;
+                using receiver_concept = ex::receiver_tag;
                 state* s;
                 auto   set_value() && noexcept -> void {
                     static_assert(ex::receiver<own_receiver>);

docs/code/tst-sync_wait.hpp

@@ -32,7 +32,7 @@ struct add_set_value {
     struct add_signature<tst::ex::completion_signatures<S...>, false> {
         using type = tst::ex::completion_signatures<tst::ex::set_value_t(), S...>;
     };
-    using sender_concept = tst::ex::sender_t;
+    using sender_concept = tst::ex::sender_tag;
     template <typename Env>
     constexpr auto get_completion_signatures(const Env& e) noexcept {
         using orig = decltype(tst::ex::get_completion_signatures(std::declval<Sender>(), e));

docs/code/tst-timer.hpp

@@ -29,14 +29,14 @@ class tst::timer {
   public:
     class when_done_sender {
       public:
-        using sender_concept        = tst::ex::sender_t;
+        using sender_concept        = tst::ex::sender_tag;
         using completion_signatures = tst::ex::completion_signatures<tst::ex::set_value_t(),
                                                                      tst::ex::set_error_t(std::exception_ptr),
                                                                      tst::ex::set_stopped_t()>;
         template <tst::ex::receiver Receiver>
         struct state {
-            using operation_state_concept = tst::ex::operation_state_t;
-            using scheduler_t             = decltype(ex::get_scheduler(ex::get_env(std::declval<Receiver>())));
+            using operation_state_concept = tst::ex::operation_state_tag;
+            using scheduler_tag           = decltype(ex::get_scheduler(ex::get_env(std::declval<Receiver>())));
             struct execute {
                 state* s{};
                 auto   operator()() noexcept -> void { this->s->await_one(); }
@@ -46,7 +46,7 @@ class tst::timer {
                 auto   operator()() noexcept -> bool { return this->s->object->queue.empty(); }
             };
             using inner_sender = decltype(tst::repeat_effect_until(
-                ex::schedule(std::declval<scheduler_t>()) | ex::then(execute()), pred()));
+                ex::schedule(std::declval<scheduler_tag>()) | ex::then(execute()), pred()));
             tst::timer*                            object;
             tst::connector<inner_sender, Receiver> inner_op;
 
@@ -78,11 +78,11 @@ class tst::timer {
         virtual auto complete() noexcept -> void = 0;
     };
     struct resume_after_sender {
-        using sender_concept        = tst::ex::sender_t;
+        using sender_concept        = tst::ex::sender_tag;
         using completion_signatures = tst::ex::completion_signatures<tst::ex::set_value_t()>;
         template <tst::ex::receiver Receiver>
         struct state : base {
-            using operation_state_concept = ex::operation_state_t;
+            using operation_state_concept = ex::operation_state_tag;
             tst::timer*                   object;
             std::chrono::milliseconds     duration;
             std::remove_cvref_t<Receiver> receiver;

docs/dependency.txt

@@ -3,7 +3,7 @@ as_awaitable is_awaitable
 await_result_type get_awaiter
 awaitable_receiver forwarding_query
 awaitable_receiver get_env
-awaitable_receiver receiver_t
+awaitable_receiver receiver_tag
 awaitable_receiver set_error
 awaitable_receiver set_stopped
 awaitable_receiver set_value
@@ -15,15 +15,15 @@ basic_operation connect_all_result
 basic_operation impls_for
 basic_operation indices_for
 basic_operation inner_ops
-basic_operation operation_state_t
+basic_operation operation_state_tag
 basic_operation state_type
 basic_operation tag_of_t
 basic_operation valid_specialization
 basic_receiver basic_state
 basic_receiver callable
 basic_receiver env_type
 basic_receiver impls_for
-basic_receiver receiver_t
+basic_receiver receiver_tag
 basic_receiver set_error
 basic_receiver set_stopped
 basic_receiver set_value
@@ -35,7 +35,7 @@ basic_sender completion_signatures_for
 basic_sender decays_to
 basic_sender impls_for
 basic_sender product_type
-basic_sender sender_t
+basic_sender sender_tag
 basic_state impls_for
 basic_state state_type
 basic_state tag_of_t
@@ -182,7 +182,7 @@ into_variant value_types_of_t
 is_awaitable get_awaiter
 is_awaitable is_awaiter
 is_awaiter await_suspend_result
-is_sender sender_t
+is_sender sender_tag
 join_env queryable
 just decayed_typeof
 just default_impls
@@ -212,7 +212,7 @@ let_error join_env
 let_error make_env
 let_error make_sender
 let_error movable_value
-let_error receiver_t
+let_error receiver_tag
 let_error sched_env
 let_error sender_adaptor_closure
 let_error sender_for
@@ -237,7 +237,7 @@ let_stopped join_env
 let_stopped make_env
 let_stopped make_sender
 let_stopped movable_value
-let_stopped receiver_t
+let_stopped receiver_tag
 let_stopped sched_env
 let_stopped sender_adaptor_closure
 let_stopped sender_for
@@ -262,7 +262,7 @@ let_value join_env
 let_value make_env
 let_value make_sender
 let_value movable_value
-let_value receiver_t
+let_value receiver_tag
 let_value sched_env
 let_value sender_adaptor_closure
 let_value sender_for
@@ -287,15 +287,15 @@ on sender
 on sender_adaptor_closure
 on sender_for
 on sender_in
-on sender_t
+on sender_tag
 on set_value
 on transform_sender
 on write_env
 on_stop_request inplace_stop_source
-operation_state operation_state_t
+operation_state operation_state_tag
 operation_state start
 operation_state_task connect_awaitable_promise
-operation_state_task operation_state_t
+operation_state_task operation_state_tag
 read_env decayed_typeof
 read_env default_impls
 read_env get_env
@@ -305,7 +305,7 @@ read_env query
 read_env try_set_value
 receiver get_env
 receiver queryable
-receiver receiver_t
+receiver receiver_tag
 receiver_of has_completions
 run_loop connect
 run_loop get_completion_scheduler
@@ -338,7 +338,7 @@ schedule_from impls_for
 schedule_from join_env
 schedule_from make_sender
 schedule_from query_with_default
-schedule_from receiver_t
+schedule_from receiver_tag
 schedule_from sched_attrs
 schedule_from schedule
 schedule_from schedule_result_t
@@ -352,7 +352,7 @@ scheduler get_env
 scheduler queryable
 scheduler schedule
 scheduler schedule_result_t
-scheduler scheduler_t
+scheduler scheduler_tag
 scheduler sender_in
 scheduler set_value_t
 sender enable_sender
@@ -394,7 +394,7 @@ split get_domain_early
 split get_stop_token
 split inplace_stop_token
 split make_sender
-split receiver_t
+split receiver_tag
 split sender_in
 split set_error
 split set_stopped
@@ -441,7 +441,7 @@ sync_wait get_delegation_scheduler
 sync_wait get_domain_early
 sync_wait get_scheduler
 sync_wait into_variant
-sync_wait receiver_t
+sync_wait receiver_tag
 sync_wait run_loop
 sync_wait sender_in
 sync_wait sender_to

docs/overview.md

@@ -32,7 +32,7 @@ Operation states represent asynchronous operations ready to be <code><a href=‘
 
 Required members for <code>_State_</code>:
 
-- The type `operation_state_concept` is an alias for `operation_state_t` or a type derived thereof.
+- The type `operation_state_concept` is an alias for `operation_state_tag` or a type derived thereof.
 - <code><i>state</i>.<a href=‘#start’>start</a>() & noexcept</code>
 
 <details>
@@ -44,7 +44,7 @@ This example shows a simple operation state object which immediately completes s
 template <std::execution::receiver Receiver>
 struct example_state
 {
-    using operation_state_concept = std::execution::operation_state_t;
+    using operation_state_concept = std::execution::operation_state_tag;
     std::remove_cvref_t<Receiver> receiver;
 
     auto start() & noexcept {
@@ -67,7 +67,7 @@ Users don’t interact with receivers explicitly except when implementing new se
 
 Required members for <code>_Receiver_</code>:
 
-- The type `receiver_concept` is an alias for `receiver_t` or a type derived thereof`.
+- The type `receiver_concept` is an alias for `receiver_tag` or a type derived thereof`.
 - Rvalues of type <code>_Receiver_</code> are movable.
 - Lvalues of type <code>_Receiver_</code> are copyable.
 - <code><a href=‘#get-env’>std::execution::get_env</a>(_receiver_)</code> returns an object. By default this operation returns <code><a href=‘env’>std::execution::env&lt;&gt;</a></code>.
@@ -88,7 +88,7 @@ The example receiver prints the name of each the received <a href=‘#completion
 template <std::execution::receiver NestedReceiver>
 struct example_receiver
 {
-    using receiver_concept = std::execution::receiver_t;
+    using receiver_concept = std::execution::receiver_tag;
     std::remove_cvref_t<NestedReceiver> nested;
 
     auto get_env() const noexcept {
@@ -128,7 +128,7 @@ The example defines a simple <code><a href=‘#receiver’>receiver</a></code> a
 ```c++
 struct example_receiver
 {
-    using receiver_concept = std::execution::receiver_t;
+    using receiver_concept = std::execution::receiver_tag;
 
     auto set_value(int) && noexcept ->void {}
     auto set_stopped() && noexcept ->void {}
@@ -161,7 +161,7 @@ static_assert(not std::execution::receiver_of<example_receiver,
 Schedulers are used to specify the execution context where the asynchronous work is to be executed. A scheduler is a lightweight handle providing a <code><a href=‘#schedule’>schedule</a></code> operation yielding a <code><a href=‘sender’>sender</a></code> with a value <a href=‘#completion-signal’>completion signal</a> without parameters. The completion is on the respective execution context.
 
 Requirements for <code>_Scheduler_</code>:
-- The type <code>_Scheduler_::scheduler_concept</code> is an alias for `scheduler_t` or a type derived thereof.
+- The type <code>_Scheduler_::scheduler_concept</code> is an alias for `scheduler_tag` or a type derived thereof.
 - <code><a href=‘#schedule’>schedule</a>(_scheduler_) -> <a href=‘sender’>sender</a></code>
 - The <a href=‘#get-completion-scheduler’>value completion scheduler</a> of the <code><a href=‘sender’>sender</a></code>’s <a href=‘#environment’>environment</a> is the <code>_scheduler_</code>:
     _scheduler_ == std::execution::get_completion_scheduler&lt;std::execution::set_value_t&gt;(
@@ -176,7 +176,7 @@ Requirements for <code>_Scheduler_</code>:
 Senders represent asynchronous work. They may get composed from multiple senders to model a workflow. Senders can’t be run directly. Instead, they are passed to a <a href=‘#sender-consumer’</a> which <code><a href=‘#connect’>connect</a></code>s the sender to a <code><a href=‘#receiver’>receiver</a></code> to produce an <code><a href=‘#operation-state’>operation_state</a></code> which may get started. When using senders to represent work the inner workings shouldn’t matter. They do become relevant when creating sender algorithms.
 
 Requirements for <code>_Sender_</code>:
-- The type <code>_Sender_::sender_concept</code> is an alias for `sender_t` or a type derived thereof or <code>_Sender_</code> is a suitable _awaitable_.
+- The type <code>_Sender_::sender_concept</code> is an alias for `sender_tag` or a type derived thereof or <code>_Sender_</code> is a suitable _awaitable_.
 - <code><a href='get_env'>std::execution::get_env</a>(_sender_)</code> is valid. By default this operation returns <code><a href=‘env’>std::execution::env&lt;&gt;</a></code>.
 - Rvalues of type <code>_Sender_</code> can be moved.
 - Lvalues of type <code>_Sender_</code> can be copied.
@@ -197,7 +197,7 @@ struct example_sender
     template <std::execution::receiver Receiver>
     struct state
     {
-        using operation_state_concept = std::execution::operation_state_t;
+        using operation_state_concept = std::execution::operation_state_tag;
         std::remove_cvref_t<Receiver> receiver;
         int                           value;
         auto start() & noexcept {
@@ -207,7 +207,7 @@ struct example_sender
             );
         }
     };
-    using sender_concept = std::execution::sender_t;
+    using sender_concept = std::execution::sender_tag;
     using completion_signatures = std::execution::completion_signatures<
         std::execution::set_value_t(int)
     >;
@@ -296,7 +296,7 @@ struct example_state
             this->state.stop();
         }
     };
-    using operation_state_concept = std::execution::operation_state_t;
+    using operation_state_concept = std::execution::operation_state_tag;
     using env = std::execution::env_of_t<Receiver>;
     using token = std::execution::stop_callback_of_t<env>;
     using callback = std::execution::stop_callback_of_t<token, on_cancel>;
@@ -493,7 +493,7 @@ To determine the result the <code><i>sender</i></code> is first transformed usin
 When a <a href=‘#sender’><code>sender</code></a> doesn’t need to compute the completion signatures based on an <a href=‘#environment’>environment</a> it is easiest to use a the type alias, e.g.:
 ```c++
 struct sender {
-    using sender_concept = std::execution::sender_t;
+    using sender_concept = std::execution::sender_tag;
     using completion_signatures = std::completion_signatures<
         std::execution::set_value_t(int),
         std::execution::set_error_t(std::error_code),
@@ -727,13 +727,13 @@ The expression <code>into_variant(<i>sender</i>)</code> creates a sender which t
 - `env_of_t`
 - `error_types_of_t`
 - `fwd_env`
-- `operation_state_t`
-- `receiver_t`
+- `operation_state_tag`
+- `receiver_tag`
 - `run_loop`
-- `scheduler_t`
+- `scheduler_tag`
 - `schedule_result_t`
 - `sender_adaptor_closure`
-- `sender_t`
+- `sender_tag`
 - `stop_token_of_t`
 - `tag_of_t`
 - `transform_sender`

examples/inspect.cpp

@@ -137,7 +137,7 @@ namespace {
 struct logger_t {
     template <ex::sender Sndr, ex::receiver Rcvr, typename Log>
     struct state {
-        using operation_state_concept = ex::operation_state_t;
+        using operation_state_concept = ex::operation_state_tag;
         using inner_t                 = decltype(ex::connect(std::declval<Sndr>(), std::declval<Rcvr>()));
 
         inner_t                  inner;
@@ -154,7 +154,7 @@ struct logger_t {
 
     template <ex::sender Sndr, typename Log>
     struct sender {
-        using sender_concept = ex::sender_t;
+        using sender_concept = ex::sender_tag;
 
         Sndr sndr;
         Log  log;

examples/intro-5-consumer.cpp

@@ -63,7 +63,7 @@ enum class failure : std::uint8_t { fail_one };
 struct expected_to_channel_t {
     template <typename Receiver>
     struct own_receiver {
-        using receiver_concept = ex::receiver_t;
+        using receiver_concept = ex::receiver_tag;
         Receiver* receiver;
         template <typename Value, typename Error>
         auto set_value(tst::expected<Value, Error>&& exp) noexcept -> void {
@@ -88,7 +88,7 @@ struct expected_to_channel_t {
     };
     template <ex::sender CSender, ex::receiver Receiver>
     struct state {
-        using operation_state_concept = ex::operation_state_t;
+        using operation_state_concept = ex::operation_state_tag;
         using child_state_t = decltype(ex::connect(std::declval<CSender>(), std::declval<own_receiver<Receiver>>()));
         Receiver      parent_receiver;
         child_state_t child_state;
@@ -105,7 +105,7 @@ struct expected_to_channel_t {
 
     template <ex::sender CSender>
     struct sender {
-        using sender_concept = ex::sender_t;
+        using sender_concept = ex::sender_tag;
         // value_types_of<CSender....> -> set_value_t(std::expected<T, E>)
         // -> completion_signatures<set_value_t(T), set_error_t(E)>
         // -> + error_type_of<CSender...>