Standard library header  (C++17) (original) (raw)

This header is part of the execution and algorithm libraries.

[edit] Synopsis

namespace std { // execution policy type trait template struct is_execution_policy; // freestanding template constexpr bool is_execution_policy_v = is_execution_policy::value; // freestanding }   namespace std::execution { // sequenced execution policy class sequenced_policy;   // parallel execution policy class parallel_policy;   // parallel and unsequenced execution policy class parallel_unsequenced_policy;   // unsequenced execution policy class unsequenced_policy;   // execution policy objects inline constexpr sequenced_policy seq{ /* unspecified / }; inline constexpr parallel_policy par{ / unspecified / }; inline constexpr parallel_unsequenced_policy par_unseq{ / unspecified / }; inline constexpr unsequenced_policy unseq{ / unspecified / }; }   namespace std { // helper concepts template concept /movable-value/ = / see description /; // exposition only   template<class From, class To> concept /decays-to/ = same_as<decay_t, To>; // exposition only   template concept /class-type/ = /decays-to/<T, T> && is_class_v; // exposition only   // queryable objects template concept /queryable/ = / see description /; // exposition only   // queries struct forwarding_query_t { / unspecified / }; struct get_allocator_t { / unspecified / }; struct get_stop_token_t { / unspecified / };   inline constexpr forwarding_query_t forwarding_query{}; inline constexpr get_allocator_t get_allocator{}; inline constexpr get_stop_token_t get_stop_token{};   template using stop_token_of_t = remove_cvref_t<decltype(get_stop_token(declval()))>;   template concept /forwarding-query/ = forwarding_query(T{}); // exposition only }   namespace std::execution { // queries struct get_domain_t { / unspecified / }; struct get_scheduler_t { / unspecified / }; struct get_delegation_scheduler_t { / unspecified / }; struct get_forward_progress_guarantee_t { / unspecified / }; template struct get_completion_scheduler_t { / unspecified / };   inline constexpr get_domain_t get_domain{}; inline constexpr get_scheduler_t get_scheduler{}; inline constexpr get_delegation_scheduler_t get_delegation_scheduler{}; enum class forward_progress_guarantee; inline constexpr get_forward_progress_guarantee_t get_forward_progress_guarantee{}; template constexpr get_completion_scheduler_t get_completion_scheduler{};   struct get_env_t { / unspecified / }; inline constexpr get_env_t get_env{};   template using env_of_t = decltype(get_env(declval()));   template<class QueryTag, class ValueType> struct prop;   template</*queryable*/... Envs> struct env;   // execution domains struct default_domain;   // schedulers struct scheduler_t {};   template concept scheduler = / see description /;   // receivers struct receiver_t {};   template 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 / };   inline constexpr set_value_t set_value{}; inline constexpr set_error_t set_error{}; inline constexpr set_stopped_t set_stopped{};   // operation states struct operation_state_t {};   template concept operation_state = / see description /;   struct start_t; inline constexpr start_t start{};   // senders struct sender_t {};   template 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 signatures struct get_completion_signatures_t; inline constexpr 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...>; // 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> constexpr bool 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 using tag_of_t = / see description /;   // sender transformations template<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 transformations template<class Domain, sender Sndr, /*queryable*/ Env> constexpr /queryable/ decltype(auto) transform_env(Domain dom, Sndr&& sndr, Env&& env) noexcept;   // sender algorithm application template<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 algorithm struct connect_t; inline constexpr connect_t connect{};   template<class Sndr, class Rcvr> using connect_result_t = decltype(connect(declval(), declval()));   // sender factories struct just_t { / unspecified / }; struct just_error_t { / unspecified / }; struct just_stopped_t { / unspecified / }; struct schedule_t { / unspecified / };   inline constexpr just_t just{}; inline constexpr just_error_t just_error{}; inline constexpr just_stopped_t just_stopped{}; inline constexpr schedule_t schedule{}; inline constexpr / unspecified / read_env{};   template using schedule_result_t = decltype(schedule(declval()));   // sender adaptors template</*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 / };   inline constexpr starts_on_t starts_on{}; inline constexpr continues_on_t continues_on{}; inline constexpr on_t on{}; inline constexpr schedule_from_t schedule_from{}; inline constexpr then_t then{}; inline constexpr upon_error_t upon_error{}; inline constexpr upon_stopped_t upon_stopped{}; inline constexpr let_value_t let_value{}; inline constexpr let_error_t let_error{}; inline constexpr let_stopped_t let_stopped{}; inline constexpr bulk_t bulk{}; inline constexpr split_t split{}; inline constexpr when_all_t when_all{}; inline constexpr when_all_with_variant_t when_all_with_variant{}; inline constexpr into_variant_t into_variant{}; inline constexpr stopped_as_optional_t stopped_as_optional{}; inline constexpr stopped_as_error_t stopped_as_error{};   // sender and receiver utilities   template concept /completion-signature/ = / see description /; // exposition only   template</*completion-signature*/... Fns> struct completion_signatures {};   template 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 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 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_loop class run_loop; }   namespace std::this_thread { // consumers struct sync_wait_t { / unspecified / }; struct sync_wait_with_variant_t { / unspecified / };   inline constexpr sync_wait_t sync_wait{}; inline constexpr sync_wait_with_variant_t sync_wait_with_variant{}; }   namespace std::execution { struct as_awaitable_t { / unspecified */ }; inline constexpr as_awaitable_t as_awaitable{};   template</*class-type*/ Promise> struct with_awaitable_senders; }

[edit] Helper concepts

namespace std { template concept /movable-value/ = // exposition only move_constructible<decay_t> && constructible_from<decay_t, T> && (!is_array_v<remove_reference_t>); }   namespace std { template concept /queryable/ = destructible; // 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>; }; }

[edit] Helper classes

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

[edit] enum std::forward_progress_guarantee

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

[edit] Concept scheduler

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

[edit] Concept receiver

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

[edit] Concept operation_state

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