[exec.envs]

33.11.1 Class template prop [exec.prop]

namespace std::execution { template<class QueryTag, class ValueType> struct prop { QueryTag query_; // exposition only ValueType value_; // exposition only constexpr const ValueType& query(QueryTag) const noexcept { return value_; } }; template<class QueryTag, class ValueType> prop(QueryTag, ValueType) -> prop<QueryTag, unwrap_reference_t<ValueType>>; }

Class template prop is for building a queryable object from a query object and a value.

Mandates: callable<QueryTag, prop-like<ValueType>> is modeled, where prop-like is the following exposition-only class template: template<class ValueType> struct prop-like { // exposition only const ValueType& query(auto) const noexcept; };

[Example 1: template<sender Sndr> sender auto parameterize_work(Sndr sndr) { // Make an environment such that get_allocator(env) returns a reference to a copy of my_alloc{}. auto e = prop(get_allocator, my_alloc{}); // Parameterize the input sender so that it will use our custom execution environment. return write_env(sndr, e); } — end example]

Specializations of prop are not assignable.

33.11.2 Class template env [exec.env]

namespace std::execution { template<queryable... Envs> struct env { Envs

_{0}

{envs}_{0}

; // exposition only Envs

_{1}

{envs}_{1}

; // exposition only ⋮ Envs

_{n - 1}

{envs}_{n - 1}

; // exposition only template<class QueryTag> constexpr decltype(auto) query(QueryTag q) const noexcept(see below); }; template<class... Envs> env(Envs...) -> env<unwrap_reference_t<Envs>...>; }

The class template env is used to construct a queryable object from several queryable objects.

Query invocations on the resulting object are resolved by attempting to query each subobject in lexical order.

Specializations of env are not assignable.

It is unspecified whether env supports initialization using a parenthesized expression-list ([dcl.init]), unless the expression-list consist of a single element of type (possibly const) env.

[Example 1: template<sender Sndr> sender auto parameterize_work(Sndr sndr) { // Make an environment such that: // get_allocator(env) returns a reference to a copy of my_alloc{} // get_scheduler(env) returns a reference to a copy of my_sched{} auto e = env{prop(get_allocator, my_alloc{}), prop(get_scheduler, my_sched{})}; // Parameterize the input sender so that it will use our custom execution environment. return write_env(sndr, e); } — end example]

🔗

template<class QueryTag>
constexpr decltype(auto) query(QueryTag q) const noexcept(see below);

Let has-query be the following exposition-only concept: template<class Env, class QueryTag> concept has-query = // exposition only requires (const Env& env) { env.query(QueryTag()); };

Let fe be the first element of

{envs}_{0}

{envs}_{1}

, …,

{envs}_{n - 1}

such that the expression fe.query(q) is well-formed.

Constraints: (has-query<Envs, QueryTag> || ...) is true.

Effects: Equivalent to: return fe.query(q);

Remarks: The expression in the noexcept clause is equivalent to noexcept(fe.query(q)).

33 Execution control library [exec]

33.11 Queryable utilities [exec.envs]

33.11.1 Class template prop [exec.prop]

33.11.2 Class template env [exec.env]