namespace std{// helper conceptstemplate<class T> concept/*movable-value*/=/*see-below*/;// exposition only template<class From,class To> concept/*decays-to*/= same_as<decay_t<From>, To>;// exposition only template<class T> concept/*class-type*/=/*decays-to*/<T, T>&& is_class_v<T>;// exposition only // queryable objectstemplate<class T> concept queryable= destructible; // queriesnamespace queries{// exposition onlystruct forwarding_query_t;struct get_allocator_t;struct get_stop_token_t;}using queries::forwarding_query_t;using queries::get_allocator_t;using queries::get_stop_token_t;inlineconstexpr forwarding_query_t forwarding_query{};inlineconstexpr get_allocator_t get_allocator{};inlineconstexpr get_stop_token_t get_stop_token{}; template<class T>using stop_token_of_t= remove_cvref_t<decltype(get_stop_token(declval<T>()))>; template<class T> concept/*forwarding-query*/=// exposition only forwarding_query(T{}); namespace/*exec-envs*/{// exposition onlystruct empty_env{};struct get_env_t;}using/*exec-envs*/::empty_env;using/*exec-envs*/::get_env_t;inlineconstexpr get_env_t get_env{}; template<class T>using env_of_t= decltype(get_env(declval<T>()));} namespace std::execution{// queriesenumclass forward_progress_guarantee;namespace queries{// exposition onlystruct get_scheduler_t;struct get_delegatee_scheduler_t;struct get_forward_progress_guarantee_t;template<class CPO>struct get_completion_scheduler_t;}using queries::get_scheduler_t;using queries::get_delegatee_scheduler_t;using queries::get_forward_progress_guarantee_t;using queries::get_completion_scheduler_t;inlineconstexpr get_scheduler_t get_scheduler{};inlineconstexpr get_delegatee_scheduler_t get_delegatee_scheduler{};inlineconstexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{};template<class CPO>inlineconstexpr get_completion_scheduler_t<CPO> get_completion_scheduler{}; // schedulerstemplate<class S> concept scheduler=/*see-below*/; // receiverstemplate<class R>inlineconstexprbool enable_receiver=/*see-below*/; template<class R> concept receiver=/*see-below*/; template<class R,class Completions> concept receiver_of=/*see-below*/; namespace receivers{// exposition onlystruct set_value_t;struct set_error_t;struct set_stopped_t;}using receivers::set_value_t;using receivers::set_error_t;using receivers::set_stopped_t;inlineconstexpr set_value_t set_value{};inlineconstexpr set_error_t set_error{};inlineconstexpr set_stopped_t set_stopped{}; // operation statestemplate<class O> concept operation_state=/*see-below*/; namespace/*op-state*/{// exposition onlystruct start_t;}using/*op-state*/::start_t;inlineconstexpr start_t start{}; // senderstemplate<class S>inlineconstexprbool enable_sender=/* see description */; template<class S> concept sender=/*see-below*/; template<class S,class E= empty_env> concept sender_in=/*see-below*/; template<class S,class R> concept sender_to=/*see-below*/; template<class S,class Sig,class E= empty_env> concept sender_of=/* see description */; template<class...Ts>struct/*type-list*/;// exposition only template<class S,class E= empty_env>using/*single-sender-value-type*/=/* see description */;// exposition only template<class S,class E= empty_env> concept/*single-sender*/=/* see description */;// exposition only // completion signaturesnamespace/*completion-signatures*/{// exposition onlystruct get_completion_signatures_t;}using/*completion-signatures*/::get_completion_signatures_t;inlineconstexpr get_completion_signatures_t get_completion_signatures{}; template<class S,class E= empty_env> requires sender_in<S, E>using completion_signatures_of_t=/*call-result-t*/<get_completion_signatures_t, S, E>; template<class...Ts>using/*decayed-tuple*/= tuple<decay_t<Ts>...>;// exposition only template<class...Ts>using/*variant-or-empty*/=/* see description */;// exposition only template<class S,class E= empty_env,template<class...>class Tuple=/*decayed-tuple*/,template<class...>class Variant=/*variant-or-empty*/> requires sender_in<S, E>using value_types_of_t=/* see description */; template<class S,class Env= empty_env,template<class...>class Variant=/*variant-or-empty*/> requires sender_in<S, E>using error_types_of_t=/* see description */; template<class S,class E= empty_env> requires sender_in<S, E>inlineconstexprbool sends_stopped=/* see description */; // the connect sender algorithmnamespace/*senders-connect*/{// exposition onlystruct connect_t;}using/*senders-connect*/::connect_t;inlineconstexpr connect_t connect{}; template<class S,class R>using connect_result_t= decltype(connect(declval<S>(), declval<R>())); // sender factoriesnamespace/*senders-factories*/{// exposition onlystruct schedule_t;struct transfer_just_t;}inlineconstexpr/* unspecified */ just{};inlineconstexpr/* unspecified */ just_error{};inlineconstexpr/* unspecified */ just_stopped{};using/*senders-factories*/::schedule_t;using/*senders-factories*/::transfer_just_t;inlineconstexpr schedule_t schedule{};inlineconstexpr transfer_just_t transfer_just{};inlineconstexpr/* unspecified */ read{}; template<scheduler S>using schedule_result_t= decltype(schedule(declval<S>())); // sender adaptorsnamespace/*sender-adaptor-closure*/{// exposition onlytemplate</*class-type*/ D>struct sender_adaptor_closure{};}using/*sender-adaptor-closure*/::sender_adaptor_closure; namespace/*sender-adaptors*/{// exposition onlystruct on_t;struct transfer_t;struct schedule_from_t;struct then_t;struct upon_error_t;struct upon_stopped_t;struct let_value_t;struct let_error_t;struct let_stopped_t;struct bulk_t;struct split_t;struct when_all_t;struct when_all_with_variant_t;struct transfer_when_all_t;struct transfer_when_all_with_variant_t;struct into_variant_t;struct stopped_as_optional_t;struct stopped_as_error_t;struct ensure_started_t;}using/*sender-adaptors*/::on_t;using/*sender-adaptors*/::transfer_t;using/*sender-adaptors*/::schedule_from_t;using/*sender-adaptors*/::then_t;using/*sender-adaptors*/::upon_error_t;using/*sender-adaptors*/::upon_stopped_t;using/*sender-adaptors*/::let_value_t;using/*sender-adaptors*/::let_error_t;using/*sender-adaptors*/::let_stopped_t;using/*sender-adaptors*/::bulk_t;using/*sender-adaptors*/::split_t;using/*sender-adaptors*/::when_all_t;using/*sender-adaptors*/::when_all_with_variant_t;using/*sender-adaptors*/::transfer_when_all_t;using/*sender-adaptors*/::transfer_when_all_with_variant_t;using/*sender-adaptors*/::into_variant_t;using/*sender-adaptors*/::stopped_as_optional_t;using/*sender-adaptors*/::stopped_as_error_t;using/*sender-adaptors*/::ensure_started_t; inlineconstexpr on_t on{};inlineconstexpr transfer_t transfer{};inlineconstexpr schedule_from_t schedule_from{}; inlineconstexpr then_t then{};inlineconstexpr upon_error_t upon_error{};inlineconstexpr upon_stopped_t upon_stopped{}; inlineconstexpr let_value_t let_value{};inlineconstexpr let_error_t let_error{};inlineconstexpr let_stopped_t let_stopped{}; inlineconstexpr bulk_t bulk{}; inlineconstexpr split_t split{};inlineconstexpr when_all_t when_all{};inlineconstexpr when_all_with_variant_t when_all_with_variant{};inlineconstexpr transfer_when_all_t transfer_when_all{};inlineconstexpr transfer_when_all_with_variant_t transfer_when_all_with_variant{}; inlineconstexpr into_variant_t into_variant{}; inlineconstexpr stopped_as_optional_t stopped_as_optional; inlineconstexpr stopped_as_error_t stopped_as_error; inlineconstexpr ensure_started_t ensure_started{}; // sender consumersnamespace/*sender-consumers*/{// exposition onlystruct start_detached_t;}using/*sender-consumers*/::start_detached_t;inlineconstexpr start_detached_t start_detached{}; // sender and receiver utilities// [exec.utils.rcvr.adptr]template</*class-type*/ Derived, receiver Base=/* unspecified */>// arguments are not associated entitiesclass receiver_adaptor; template<class Fn> concept/*completion-signature*/=// exposition only/* see description */; // [exec.utils.cmplsigs]template</*completion-signature*/...Fns>struct completion_signatures{}; template<class...Args>// exposition onlyusing/*default-set-value*/= completion_signatures<set_value_t(Args...)>; template<class Err>// exposition onlyusing/*default-set-error*/= completion_signatures<set_error_t(Err)>; template<class Sigs>// exposition only concept/*valid-completion-signatures*/=/* see description */; // [exec.utils.mkcmplsigs]template< sender Sndr,class Env= empty_env,/*valid-completion-signatures*/ AddlSigs= completion_signatures<>,template<class...>class SetValue=/* see description */,template<class>class SetError=/* see description */,/*valid-completion-signatures*/ SetStopped= completion_signatures<set_stopped_t()>> requires sender_in<Sndr, Env>using make_completion_signatures= completion_signatures</* see description */>; // execution resourcesclass run_loop;} namespace std::this_thread{// queriesnamespace queries{// exposition onlystruct execute_may_block_caller_t;}using queries::execute_may_block_caller_t;inlineconstexpr execute_may_block_caller_t execute_may_block_caller{}; namespace/*this-thread*/{// exposition onlystruct/*sync-wait-env*/;// exposition onlytemplate<class S> requires sender_in<S,/*sync-wait-env*/>using/*sync-wait-type*/=/*see-below*/;// exposition onlytemplate<class S>using/*sync-wait-with-variant-type*/=/*see-below*/;// exposition only struct sync_wait_t;struct sync_wait_with_variant_t;}using/*this-thread*/::sync_wait_t;using/*this-thread*/::sync_wait_with_variant_t;inlineconstexpr sync_wait_t sync_wait{};inlineconstexpr sync_wait_with_variant_t sync_wait_with_variant{};} namespace std::execution{// one-way executionnamespace execute{// exposition onlystruct execute_t;}using execute::execute_t;inlineconstexpr execute_t execute{}; // [exec.as.awaitable]namespace/*coro-utils*/{// exposition onlystruct as_awaitable_t;}using/*coro-utils*/::as_awaitable_t;inlineconstexpr as_awaitable_t as_awaitable; // [exec.with.awaitable.senders]template</*class-type*/ Promise>struct with_awaitable_senders;}
