• Log in

namespace std{// execution policy type traittemplate<class T>struct is_execution_policy;// freestandingtemplate<class T>constexprbool is_execution_policy_v= is_execution_policy<T>::value;// freestanding} namespace std::execution{// sequenced execution policyclass sequenced_policy; // parallel execution policyclass parallel_policy; // parallel and unsequenced execution policyclass parallel_unsequenced_policy; // unsequenced execution policyclass unsequenced_policy; // execution policy objectsinlineconstexpr sequenced_policy seq{/* unspecified */};inlineconstexpr parallel_policy par{/* unspecified */};inlineconstexpr parallel_unsequenced_policy par_unseq{/* unspecified */};inlineconstexpr unsequenced_policy unseq{/* unspecified */};} namespace std{// helper conceptstemplate<class T>  concept/*movable-value*/=/* see description */;// 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*/=/* see description */;// exposition only // queriesstruct forwarding_query_t{/* unspecified */};struct get_allocator_t{/* unspecified */};struct get_stop_token_t{/* unspecified */}; 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*/= forwarding_query(T{});// exposition only} namespace std::execution{// queriesstruct get_domain_t{/* unspecified */};struct get_scheduler_t{/* unspecified */};struct get_delegation_scheduler_t{/* unspecified */};struct get_forward_progress_guarantee_t{/* unspecified */};template<class CPO>struct get_completion_scheduler_t{/* unspecified */}; inlineconstexpr get_domain_t get_domain{};inlineconstexpr get_scheduler_t get_scheduler{};inlineconstexpr get_delegation_scheduler_t get_delegation_scheduler{};enumclass forward_progress_guarantee;inlineconstexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{};template<class CPO>constexpr get_completion_scheduler_t<CPO> get_completion_scheduler{}; struct get_env_t{/* unspecified */};inlineconstexpr get_env_t get_env{}; template<class T>using env_of_t= decltype(get_env(declval<T>())); template<class QueryTag,class ValueType>struct prop; template</*queryable*/...Envs>struct env; // execution domainsstruct default_domain; // schedulersstruct scheduler_t{}; template<class Sch>  concept scheduler=/* see description */; // receiversstruct receiver_t{}; template<class Rcvr>  concept receiver=/* see description */; template<class Rcvr,class Completions>  concept receiver_of=/* see description */; struct set_value_t{/* unspecified */};struct set_error_t{/* unspecified */};struct set_stopped_t{/* unspecified */}; inlineconstexpr set_value_t set_value{};inlineconstexpr set_error_t set_error{};inlineconstexpr set_stopped_t set_stopped{}; // operation statesstruct operation_state_t{}; template<class O>  concept operation_state=/* see description */; struct start_t;inlineconstexpr start_t start{}; // sendersstruct sender_t{}; template<class Sndr>  concept sender=/* see description */; template<class Sndr,class Env= env<>>  concept sender_in=/* see description */; template<class Sndr,class Rcvr>  concept sender_to=/* see description */; template<class...Ts>struct/*type-list*/;// exposition only // completion signaturesstruct get_completion_signatures_t;inlineconstexpr get_completion_signatures_t get_completion_signatures{}; template<class Sndr,class Env= env<>>    requires sender_in<Sndr, Env>using completion_signatures_of_t=/*call-result-t*/<get_completion_signatures_t, Sndr, Env>; 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 Sndr,class Env= env<>,template<class...>class Tuple=/*decayed-tuple*/,template<class...>class Variant=/*variant-or-empty*/>    requires sender_in<Sndr, Env>using value_types_of_t=/* see description */; template<class Sndr,class Env= env<>,template<class...>class Variant=/*variant-or-empty*/>    requires sender_in<Sndr, Env>using error_types_of_t=/* see description */; template<class Sndr,class Env= env<>>    requires sender_in<Sndr, Env>constexprbool sends_stopped=/* see description */; template<class Sndr,class Env>using/*single-sender-value-type*/=/* see description */;// exposition only template<class Sndr,class Env>  concept/*single-sender*/=/* see description */;// exposition only template<sender Sndr>using tag_of_t=/* see description */; // sender transformationstemplate<class Domain, sender Sndr,/*queryable*/...Env>    requires(sizeof...(Env)<=1)constexpr sender decltype(auto) transform_sender(    Domain dom,    Sndr&& sndr,const Env&...env)noexcept(/* see description */); // environment transformationstemplate<class Domain, sender Sndr,/*queryable*/ Env>constexpr/*queryable*/ decltype(auto) transform_env(Domain dom,                                                       Sndr&& sndr,                                                       Env&& env)noexcept; // sender algorithm applicationtemplate<class Domain,class Tag, sender Sndr,class...Args>constexpr decltype(auto) apply_sender(Domain dom,                                        Tag,                                        Sndr&& sndr,                                        Args&&...args)noexcept(/* see description */); // the connect sender algorithmstruct connect_t;inlineconstexpr connect_t connect{}; template<class Sndr,class Rcvr>using connect_result_t= decltype(connect(declval<Sndr>(), declval<Rcvr>())); // sender factoriesstruct just_t{/* unspecified */};struct just_error_t{/* unspecified */};struct just_stopped_t{/* unspecified */};struct schedule_t{/* unspecified */}; inlineconstexpr just_t just{};inlineconstexpr just_error_t just_error{};inlineconstexpr just_stopped_t just_stopped{};inlineconstexpr schedule_t schedule{};inlineconstexpr/* unspecified */ read_env{}; template<scheduler Sndr>using schedule_result_t= decltype(schedule(declval<Sndr>())); // sender adaptorstemplate</*class-type*/ D>struct sender_adaptor_closure{}; struct starts_on_t{/* unspecified */};struct continues_on_t{/* unspecified */};struct on_t{/* unspecified */};struct schedule_from_t{/* unspecified */};struct then_t{/* unspecified */};struct upon_error_t{/* unspecified */};struct upon_stopped_t{/* unspecified */};struct let_value_t{/* unspecified */};struct let_error_t{/* unspecified */};struct let_stopped_t{/* unspecified */};struct bulk_t{/* unspecified */};struct split_t{/* unspecified */};struct when_all_t{/* unspecified */};struct when_all_with_variant_t{/* unspecified */};struct into_variant_t{/* unspecified */};struct stopped_as_optional_t{/* unspecified */};struct stopped_as_error_t{/* unspecified */}; inlineconstexpr starts_on_t starts_on{};inlineconstexpr continues_on_t continues_on{};inlineconstexpr on_t on{};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 into_variant_t into_variant{};inlineconstexpr stopped_as_optional_t stopped_as_optional{};inlineconstexpr stopped_as_error_t stopped_as_error{}; // sender and receiver utilities template<class Fn>  concept/*completion-signature*/=/* see description */;// exposition only template</*completion-signature*/...Fns>struct completion_signatures{}; template<class Sigs>  concept/*valid-completion-signatures*/=/* see description */;// exposition only template</*valid-completion-signatures*/ InputSignatures,/*valid-completion-signatures*/ AdditionalSignatures= completion_signatures<>,template<class...>class SetValue=/* see description */,template<class>class SetError=/* see description */,/*valid-completion-signatures*/ SetStopped=             completion_signatures<set_stopped_t()>>using transform_completion_signatures= completion_signatures</* see description */>; template<sender Sndr,class Env= env<>,/*valid-completion-signatures*/ AdditionalSignatures= 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 transform_completion_signatures_of=    transform_completion_signatures<completion_signatures_of_t<Sndr, Env>,                                    AdditionalSignatures,                                    SetValue,                                    SetError,                                    SetStopped>; // run_loopclass run_loop;} namespace std::this_thread{// consumersstruct sync_wait_t{/* unspecified */};struct sync_wait_with_variant_t{/* unspecified */}; inlineconstexpr sync_wait_t sync_wait{};inlineconstexpr sync_wait_with_variant_t sync_wait_with_variant{};} namespace std::execution{struct as_awaitable_t{/* unspecified */};inlineconstexpr as_awaitable_t as_awaitable{}; template</*class-type*/ Promise>struct with_awaitable_senders;}

namespace std{template<class T>  concept/*movable-value*/=// exposition only    move_constructible<decay_t<T>>&& constructible_from<decay_t<T>, T>&&(!is_array_v<remove_reference_t<T>>);} namespace std{template<class T>  concept/*queryable*/= destructible<T>;// exposition only} namespace std::execution{template<class Sndr,class Env>  concept/*single-sender*/= sender_in<Sndr, Env>&& requires{typename/*single-sender-value-type*/<Sndr, Env>;};}

namespace std::execution{struct/*empty-variant*/{// exposition only/*empty-variant*/()= delete;};}

namespace std::execution{enumclass forward_progress_guarantee{    concurrent,    parallel,    weakly_parallel};}

namespace std::execution{template<class Sch>  concept scheduler=    derived_from<typename remove_cvref_t<Sch>::scheduler_concept, scheduler_t>&&/*queryable*/<Sch>&&    requires(Sch&& sch){{        schedule(std::forward<Sch>(sch))}-> sender;{auto(get_completion_scheduler<set_value_t>(          get_env(schedule(std::forward<Sch>(sch)))))}-> same_as<remove_cvref_t<Sch>>;}&& equality_comparable<remove_cvref_t<Sch>>&&    copy_constructible<remove_cvref_t<Sch>>;}

namespace std::execution{template<class Rcvr>  concept receiver=    derived_from<typename remove_cvref_t<Rcvr>::receiver_concept, receiver_t>&&    requires(const remove_cvref_t<Rcvr>& rcvr){{        get_env(rcvr)}->/*queryable*/;}&& move_constructible<remove_cvref_t<Rcvr>>&&// rvalues are movable, and    constructible_from<remove_cvref_t<Rcvr>, Rcvr>;// lvalues are copyable template<class Signature,class Rcvr>  concept/*valid-completion-for*/= requires(Signature* sig){[]<class Tag,class...Args>(Tag(*)(Args...))      requires/*callable*/<Tag, remove_cvref_t<Rcvr>, Args...>{}(sig);}; template<class Rcvr,class Completions>  concept/*has-completions*/= requires(Completions* completions){[]</*valid-completion-for*/<Rcvr>...Sigs>(completion_signatures<Sigs...>*){}(completions);}; template<class Rcvr,class Completions>  concept receiver_of= receiver<Rcvr>&&/*has-completions*/<Rcvr, Completions>;}

namespace std::execution{template<class O>  concept operation_state=    derived_from<typename O::operation_state_concept, operation_state_t>&&    is_object_v<O>&& requires(O& o){{        start(o)}noexcept;};}