Namespaces
namespace	detail

Classes
struct	adapter_chain

struct	borrow_prev_mut_t
	Describes a parameter that borrows the direct parent output as `T&`. More...

struct	borrow_prev_t
	Describes a parameter that borrows the direct parent output as `const T&`. More...

struct	bound_forward_prev_task

struct	bound_member_forward_prev_task

struct	bound_member_output_task
	Bound direct-output task composed of a member function, receiver spec, and non-output parameter specs. More...

struct	bound_member_task
	Bound executable task composed of a member function, receiver spec, and per-parameter specs. More...

struct	bound_output_task
	Bound direct-output task that writes its payload into a provided slot. More...

struct	bound_task
	Bound executable task composed of a callable and per-parameter specs. More...

struct	catch_as_failure_adapter_desc

struct	catch_as_failure_with_policy_adapter_desc

struct	catch_failure_task
	Exception-catching adapter for tasks that rely on the default failure mapping. More...

struct	catch_failure_with_policy_task
	Exception-catching adapter for tasks with a user-supplied fallback policy. More...

struct	compiled_plan
	Static plan compiled from a `task_tree_builder`. More...

struct	compiled_plan_from

struct	compiled_plan_from< task_tree_builder< Nodes... > >
	Maps a `task_tree_builder` type to its corresponding compiled plan type. More...

struct	consume_prev_t
	Describes a parameter that consumes the direct parent output. More...

struct	context
	Statically typed context container with a compile-time schema. More...

struct	copy_prev_t
	Describes a parameter that copies the direct parent output as `T`. More...

struct	direct_out
	Output sink passed to direct-output tasks. More...

struct	exec_context
	Lightweight borrowed view used during execution. More...

struct	exec_context< Ctx, no_prev >

struct	exec_context< void, no_prev >
	Indicates that the current execution path carries no context. More...

struct	exec_context< void, Prev >

struct	exec_serial_dfs_explicit_heap_stack_policy

struct	exec_serial_dfs_recursive_policy

struct	fanout_auto_policy
	Default fanout policy. More...

struct	fanout_consume_with_copies_policy
	Mixed fanout policy that allows one consumer plus any number of copies. More...

struct	fanout_shared_readonly_policy
	Explicit readonly fanout policy. More...

struct	from_ctx_t
	Describes a parameter sourced from the execution context by type. More...

struct	is_task_result
	Type trait that detects `task_result<T>`. More...

struct	is_task_result< task_result< T > >

struct	no_prev
	Sentinel view indicating that the current execution has no direct parent output. More...

struct	plan_exec_slots
	Public per-run plan payload storage entry point. More...

struct	prev_slot_view
	Lightweight borrowed view over a direct parent output slot. More...

struct	retry_adapter_desc

struct	retry_fixed_passthrough_policy
	Retry policy that allows a fixed number of retries and then preserves the final `retry` result unchanged. More...

struct	retry_fixed_policy
	Retry policy that allows a fixed number of additional retries. More...

struct	retry_forever_policy
	Retry policy that keeps retrying for as long as the task requests it. More...

struct	retry_task
	Retry adapter that re-invokes a task when it returns `retry`. More...

struct	slot_layout_one_to_one_policy

struct	slot_layout_serial_dfs_compact_policy

struct	step_result
	Represents the basic outcome of a task step. More...

struct	task_binder

struct	task_forward_prev_binder

struct	task_forward_prev_member_receiver_binder

struct	task_into_binder

struct	task_into_member_receiver_binder

struct	task_member_receiver_binder

struct	task_result
	Represents a step result that may carry a produced value. More...

struct	task_result_value
	Extracts the payload type from a supported `task_result<T>`. More...

struct	task_result_value< task_result< T > >

struct	task_tree_builder

struct	value_t
	Stores a concrete value inside a spec. More...

Concepts
concept	executable_task
	Describes the main execution protocol accepted by `run_task(...)`.

concept	executable_direct_output_task

concept	bindable_from_lvalue

concept	resolvable_mutable_value

concept	resolvable_const_value

concept	adapter_wrappable_task
	Reports whether a task object exposes the raw execution protocol for a concrete `exec_context`.

concept	direct_output_task

concept	default_catchable_task
	Reports whether `catch_as_failure(task)` can wrap `Task` for a concrete execution context without a custom policy.

concept	catch_policy_compatible_task
	Reports whether `catch_as_failure(task, policy)` can wrap `Task` using the provided fallback `Policy`.

concept	catch_policy_compatible_direct_output_task

concept	retry_policy
	Reports whether a retry policy exposes the minimal protocol required by `with_retry(...)`.

Typedefs
template<typename Tree >
using	compiled_plan_t = typename compiled_plan_from< std::remove_cvref_t< Tree > >::type
	Convenience alias for the compiled plan type produced from a tree type.

template<typename T >
using	task_result_value_t = typename task_result_value< std::remove_cvref_t< T > >::type

template<typename Plan , typename LayoutPolicy = slot_layout_one_to_one_policy>
using	plan_slots = plan_exec_slots< Plan, LayoutPolicy >

Enumerations
enum class	step_status : unsigned char { success , failure , retry , abort_branch , abort_execution }
	Describes the execution status of a single step. More...

Functions
template<typename Policy > requires retry_policy<std::decay_t<Policy>>
constexpr auto	adapt_retry (Policy &&policy)

constexpr auto	adapt_catch_as_failure () noexcept

template<typename Policy > requires detail::catch_policy_like<std::remove_cvref_t<Policy>>
constexpr auto	adapt_catch_as_failure (Policy &&policy)

template<typename... Descs> requires (detail::adapter_descriptor<Descs> && ...)
constexpr auto	adapters (Descs &&... descs)

template<typename Task >
constexpr auto	apply_adapters (Task &&task, const adapter_chain<> &)

template<typename Task , typename... Descs>
constexpr auto	apply_adapters (Task &&task, const adapter_chain< Descs... > &chain)

template<typename Task , typename... Descs>
constexpr auto	apply_adapters (Task &&task, adapter_chain< Descs... > &&chain)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (retry_adapter_desc< Policy > &desc, Task &&task)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (const retry_adapter_desc< Policy > &desc, Task &&task)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (retry_adapter_desc< Policy > &&desc, Task &&task)

template<typename Task >
constexpr auto	apply_adapter (catch_as_failure_adapter_desc, Task &&task)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (catch_as_failure_with_policy_adapter_desc< Policy > &desc, Task &&task)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (const catch_as_failure_with_policy_adapter_desc< Policy > &desc, Task &&task)

template<typename Task , typename Policy >
constexpr auto	apply_adapter (catch_as_failure_with_policy_adapter_desc< Policy > &&desc, Task &&task)

template<typename F > requires detail::ordinary_bind_callable<F>
constexpr auto	task (F &&f)

template<typename F , typename AdapterChain > requires detail::ordinary_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr auto	task (F &&f, AdapterChain &&adapter_specs)

template<typename F , typename ReceiverSpec > requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)
constexpr auto	task_member (F &&f, ReceiverSpec &&receiver_spec)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>
constexpr auto	task_member (F &&f, ReceiverSpec &&receiver_spec, AdapterChain &&adapter_specs)

template<typename F > requires detail::inferable_direct_output_callable<F>
constexpr auto	task_into (F &&f)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr auto	task_into (F &&f, AdapterChain &&adapter_specs)

template<typename F > requires detail::inferable_forward_prev_callable<F>
constexpr auto	task_forward_prev (F &&f)

template<typename F , typename AdapterChain > requires detail::inferable_forward_prev_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr auto	task_forward_prev (F &&f, AdapterChain &&adapter_specs)

template<typename F , typename ReceiverSpec > requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)
constexpr auto	task_forward_prev_member (F &&f, ReceiverSpec &&receiver_spec)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>
constexpr auto	task_forward_prev_member (F &&f, ReceiverSpec &&receiver_spec, AdapterChain &&adapter_specs)

template<typename F , typename ReceiverSpec > requires detail::inferable_direct_output_member_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)
constexpr auto	task_into_member (F &&f, ReceiverSpec &&receiver_spec)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>
constexpr auto	task_into_member (F &&f, ReceiverSpec &&receiver_spec, AdapterChain &&adapter_specs)

template<typename F > requires detail::inferable_direct_output_callable<F>
constexpr void	task (F &&)

template<typename F > requires detail::member_bind_callable<F>
constexpr void	task (F &&)

template<typename Task > requires detail::bind_task_object<Task> && detail::task_uses_direct_output_protocol_v<Task>
constexpr void	task (Task &&)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task (F &&, AdapterChain &&)

template<typename F , typename AdapterChain > requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task (F &&, AdapterChain &&)

template<typename Task > requires detail::bind_task_object<Task>
constexpr void	task_into (Task &&)

template<typename Task , typename AdapterChain > requires detail::bind_task_object<Task> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into (Task &&, AdapterChain &&)

template<typename F > requires detail::ordinary_bind_callable<F>
constexpr void	task_into (F &&)

template<typename Task > requires detail::bind_task_object<Task>
constexpr void	task_forward_prev (Task &&)

template<typename Task , typename AdapterChain > requires detail::bind_task_object<Task> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev (Task &&, AdapterChain &&)

template<typename F > requires detail::inferable_direct_output_callable<F>
constexpr void	task_forward_prev (F &&)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev (F &&, AdapterChain &&)

template<typename F > requires detail::member_bind_callable<F>
constexpr void	task_forward_prev (F &&)

template<typename F , typename AdapterChain > requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev (F &&, AdapterChain &&)

template<typename F > requires detail::ordinary_member_bind_callable<F>
constexpr void	task_member (F &&)

template<typename F , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_member (F &&, AdapterChain &&)

template<typename F > requires detail::inferable_direct_output_member_callable<F>
constexpr void	task_member (F &&)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_member (F &&, AdapterChain &&)

template<typename F , typename ReceiverSpec > requires detail::inferable_direct_output_member_callable<F>
constexpr void	task_member (F &&, ReceiverSpec &&)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_member (F &&, ReceiverSpec &&, AdapterChain &&)

template<typename F > requires detail::ordinary_member_bind_callable<F>
constexpr void	task_forward_prev_member (F &&)

template<typename F , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev_member (F &&, AdapterChain &&)

template<typename F > requires detail::inferable_direct_output_member_callable<F>
constexpr void	task_forward_prev_member (F &&)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev_member (F &&, AdapterChain &&)

template<typename F , typename ReceiverSpec > requires detail::inferable_direct_output_member_callable<F>
constexpr void	task_forward_prev_member (F &&, ReceiverSpec &&)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_forward_prev_member (F &&, ReceiverSpec &&, AdapterChain &&)

template<typename F > requires detail::inferable_direct_output_member_callable<F>
constexpr void	task_into_member (F &&)

template<typename F , typename AdapterChain > requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into_member (F &&, AdapterChain &&)

template<typename F > requires detail::ordinary_member_bind_callable<F>
constexpr void	task_into_member (F &&)

template<typename F , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into_member (F &&, AdapterChain &&)

template<typename F , typename ReceiverSpec > requires detail::ordinary_member_bind_callable<F>
constexpr void	task_into_member (F &&, ReceiverSpec &&)

template<typename F , typename ReceiverSpec , typename AdapterChain > requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into_member (F &&, ReceiverSpec &&, AdapterChain &&)

template<typename F > requires detail::member_bind_callable<F>
constexpr void	task_into (F &&)

template<typename F , typename AdapterChain > requires detail::ordinary_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into (F &&, AdapterChain &&)

template<typename F , typename AdapterChain > requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>
constexpr void	task_into (F &&, AdapterChain &&)

template<typename F , typename... Specs>
constexpr auto	bind (F &&f, Specs &&... specs)
	Creates a `bound_task` from a callable and matching argument specs.

template<typename T , typename F , typename... Specs>
constexpr auto	bind_into (F &&f, Specs &&... specs)
	Creates a direct-output task from a callable and matching input specs.

template<typename T , typename F , typename... Specs>
constexpr auto	bind_forward_prev (F &&f, Specs &&... specs)

template<typename T , typename F >
constexpr void	bind_forward_prev_member (F &&)

template<typename T , typename F , typename ReceiverSpec , typename... Specs>
constexpr auto	bind_forward_prev_member (F &&f, ReceiverSpec &&receiver_spec, Specs &&... specs)

template<typename F >
constexpr void	bind_member (F &&)

template<typename F , typename ReceiverSpec , typename... Specs>
constexpr auto	bind_member (F &&f, ReceiverSpec &&receiver_spec, Specs &&... specs)

template<typename T , typename F >
constexpr void	bind_into_member (F &&)

template<typename T , typename F , typename ReceiverSpec , typename... Specs>
constexpr auto	bind_into_member (F &&f, ReceiverSpec &&receiver_spec, Specs &&... specs)

template<typename T >
constexpr auto	prev_slot (T &value) noexcept -> prev_slot_view< T >
	Creates a borrowed view over a direct parent payload object.

template<typename LayoutPolicy = slot_layout_one_to_one_policy, typename ExecPolicy = exec_serial_dfs_recursive_policy, typename Plan > requires detail::slot_layout_policy<LayoutPolicy> && detail::exec_policy<ExecPolicy> && (Plan::node_count > 0) && detail::plan_valid_v<Plan> && detail::plan_prev_source_valid_v<Plan> && detail::plan_prev_access_valid_v<Plan> && detail::plan_forward_prev_source_valid_v<Plan> && detail::plan_fanout_policy_valid_v<Plan>
constexpr step_result	run_plan (Plan &plan)
	Executes a compiled plan using the selected serial depth-first policy.

template<typename LayoutPolicy = slot_layout_one_to_one_policy, typename ExecPolicy = exec_serial_dfs_recursive_policy, typename Plan , typename Ctx > requires detail::slot_layout_policy<LayoutPolicy> && detail::exec_policy<ExecPolicy> && (Plan::node_count > 0) && detail::plan_valid_v<Plan> && detail::plan_prev_source_valid_v<Plan> && detail::plan_prev_access_valid_v<Plan> && detail::plan_forward_prev_source_valid_v<Plan> && detail::plan_fanout_policy_valid_v<Plan>
constexpr step_result	run_plan (Plan &plan, Ctx &ctx)
	Executes a compiled plan using serial depth-first traversal with an external typed execution context.

template<typename Task , typename Ctx , typename Prev = no_prev> requires executable_task<Task, Ctx, Prev>
constexpr step_result	run_task (Task &&task, exec_context< Ctx, Prev > &ec) noexcept(noexcept(std::forward< Task >(task).invoke_raw(ec)) &&(std::is_void_v< detail::raw_task_result_t< Task &&, Ctx, Prev > >\|\|noexcept(detail::normalize_task_result(std::forward< Task >(task).invoke_raw(ec)))))
	Executes a ready-to-run task against the provided execution context.

template<typename Task , typename Ctx , typename Prev = no_prev> requires executable_direct_output_task<Task, Ctx, Prev>
constexpr step_result	run_task_into (Task &&task, exec_context< Ctx, Prev > &ec, direct_out< detail::declared_task_output_t< Task > > out) noexcept(noexcept(std::forward< Task >(task).invoke_into(ec, out)))
	Executes a direct-output task against the provided execution context.

template<typename... Nodes> requires (sizeof...(Nodes) > 0) && detail::plannable_plan_nodes<Nodes...>
constexpr auto	compile_plan (task_tree_builder< Nodes... > &&tree)
	Compiles a populated `task_tree_builder` into a static plan.

template<typename... Nodes> requires (sizeof...(Nodes) > 0) && detail::plannable_plan_nodes<Nodes...>
constexpr auto	compile_plan (const task_tree_builder< Nodes... > &tree)

template<typename Arg , typename Source > requires bindable_from_lvalue<Arg, Source>
constexpr decltype(auto)	bind_from_lvalue (Source &src) noexcept(detail::bind_from_lvalue_nothrow_v< Arg, Source >)
	Binds an existing lvalue source object to the requested argument type.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (from_ctx_t< T >, exec_context< Ctx, Prev > &ec) noexcept(detail::resolve_from_ctx_nothrow_v< Arg, T, Ctx >)
	Resolves a `from_ctx(...)` spec by fetching the requested object from the execution context and binding it as `Arg`.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (borrow_prev_t< T >, exec_context< Ctx, Prev > &ec) noexcept(detail::resolve_borrow_prev_nothrow_v< Arg, T, Prev >)
	Resolves a `borrow_prev(...)` spec by fetching the direct parent output payload as a readonly borrow.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (borrow_prev_mut_t< T >, exec_context< Ctx, Prev > &ec) noexcept(detail::resolve_borrow_prev_mut_nothrow_v< Arg, T, Prev >)
	Resolves a `borrow_prev_mut(...)` spec by fetching the direct parent output payload as an exclusive mutable borrow.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (copy_prev_t< T >, exec_context< Ctx, Prev > &ec) noexcept(detail::resolve_copy_prev_nothrow_v< T, Prev >)
	Resolves a `copy_prev(...)` spec by copying the direct parent output payload into a new value.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (consume_prev_t< T >, exec_context< Ctx, Prev > &ec) noexcept(detail::resolve_consume_prev_nothrow_v< Arg, T, Prev >)
	Resolves a `consume_prev(...)` spec by moving from the direct parent output payload exactly once.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (value_t< std::reference_wrapper< T > > &spec, exec_context< Ctx, Prev > &) noexcept(std::is_reference_v< Arg >)
	Resolves a mutable `value(...)` spec into the requested argument type.

template<typename Arg , typename T , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (const value_t< std::reference_wrapper< T > > &spec, exec_context< Ctx, Prev > &) noexcept(std::is_reference_v< Arg >)

template<typename Arg , typename T , typename Ctx , typename Prev > requires resolvable_mutable_value<Arg, T>
constexpr decltype(auto)	resolve_as (value_t< T > &spec, exec_context< Ctx, Prev > &) noexcept(detail::resolve_value_nothrow_v< Arg, T >)

template<typename Arg , typename T , typename Ctx , typename Prev > requires resolvable_const_value<Arg, T>
constexpr decltype(auto)	resolve_as (const value_t< T > &spec, exec_context< Ctx, Prev > &) noexcept(detail::resolve_const_value_nothrow_v< Arg, T >)
	Resolves a const `value(...)` spec into the requested argument type.

template<typename Arg , typename Spec , typename Ctx , typename Prev >
constexpr decltype(auto)	resolve_as (Spec &&, exec_context< Ctx, Prev > &)
	Fallback overload for unsupported spec categories.

template<typename T >
constexpr auto	from_ctx () noexcept -> from_ctx_t< std::remove_cvref_t< T > >
	Creates a spec that asks execution to fetch `T` from the context.

template<typename T >
constexpr auto	borrow_prev () noexcept -> borrow_prev_t< std::remove_cvref_t< T > >
	Creates a spec that borrows `T` from the direct parent output slot as `const T&`.

template<typename T >
constexpr auto	borrow_prev_mut () noexcept -> borrow_prev_mut_t< std::remove_cvref_t< T > >
	Creates a spec that borrows `T` from the direct parent output slot as `T&`.

template<typename T >
constexpr auto	copy_prev () noexcept -> copy_prev_t< std::remove_cvref_t< T > >
	Creates a spec that copies `T` from the direct parent output slot as a new value.

template<typename T >
constexpr auto	consume_prev () noexcept -> consume_prev_t< std::remove_cvref_t< T > >
	Creates a spec that consumes `T` from the direct parent output slot.

template<typename T >
constexpr auto	value (T &&v) -> value_t< std::remove_cvref_t< T > >
	Wraps a value as an owning spec.

template<typename Task >
constexpr auto	catch_as_failure (Task &&task)
	Wraps a task so thrown exceptions become default failure results.

template<typename Task , typename Policy >
constexpr auto	catch_as_failure (Task &&task, Policy &&policy)
	Wraps a task so thrown exceptions are routed to a user fallback policy.

template<typename Task , typename Policy > requires retry_policy<std::decay_t<Policy>>
constexpr auto	with_retry (Task &&task, Policy &&policy)
	Wraps a task so `retry` results are handled by a user retry policy.

Variables
template<typename T >
constexpr bool	is_task_result_v

constexpr task_tree_builder	task_tree {}

Typedef Documentation

◆ compiled_plan_t

template<typename Tree >

using yorch::compiled_plan_t = typedef typename compiled_plan_from<std::remove_cvref_t<Tree> >::type

Convenience alias for the compiled plan type produced from a tree type.

compiled_plan_t<Tree> removes cv/ref qualifiers from Tree before mapping it to compiled_plan<...>.

Template Parameters

Tree	Task tree builder type.

Definition at line 133 of file compiled_plan.hpp.

◆ plan_slots

template<typename Plan , typename LayoutPolicy = slot_layout_one_to_one_policy>

using yorch::plan_slots = typedef plan_exec_slots<Plan, LayoutPolicy>

Definition at line 512 of file plan_exec_slots.hpp.

◆ task_result_value_t

template<typename T >

using yorch::task_result_value_t = typedef typename task_result_value<std::remove_cvref_t<T> >::type

Definition at line 207 of file result.hpp.

Enumeration Type Documentation

◆ step_status

enum class yorch::step_status : unsigned char

strong

Describes the execution status of a single step.

This enum only represents control-flow state and does not carry a task value. The statuses express both outcome and scheduler intent:

success: the step completed normally; child traversal or later execution may continue as usual
failure: the step failed; the status propagates upward as an error and stops later execution
retry: the step requests a retry; the status propagates upward unchanged so an outer scheduler can decide how to handle it
abort_branch: the step intentionally stops only the current subtree; this is a local control-flow signal rather than an error
abort_execution: the step intentionally cancels the whole execution; this is treated as a normal cancellation signal rather than a failure

Enumerator
success
failure
retry
abort_branch
abort_execution

Definition at line 27 of file result.hpp.

Function Documentation

◆ adapt_catch_as_failure() [1/2]

constexpr auto yorch::adapt_catch_as_failure ( )

constexprnoexcept

Definition at line 36 of file adapters.hpp.

◆ adapt_catch_as_failure() [2/2]

template<typename Policy >
requires detail::catch_policy_like<std::remove_cvref_t<Policy>>

constexpr auto yorch::adapt_catch_as_failure ( Policy && policy )

constexpr

Definition at line 41 of file adapters.hpp.

◆ adapt_retry()

template<typename Policy >
requires retry_policy<std::decay_t<Policy>>

constexpr auto yorch::adapt_retry ( Policy && policy )

constexpr

Definition at line 29 of file adapters.hpp.

◆ adapters()

template<typename... Descs>
requires (detail::adapter_descriptor<Descs> && ...)

constexpr auto yorch::adapters ( Descs &&... descs )

constexpr

Definition at line 112 of file adapters.hpp.

◆ apply_adapter() [1/7]

template<typename Task >

constexpr auto yorch::apply_adapter	(	catch_as_failure_adapter_desc	,
		Task &&	task
	)

constexpr

Definition at line 155 of file adapters.hpp.

◆ apply_adapter() [2/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	catch_as_failure_with_policy_adapter_desc< Policy > &&	desc,
		Task &&	task
	)

constexpr

Definition at line 174 of file adapters.hpp.

◆ apply_adapter() [3/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	catch_as_failure_with_policy_adapter_desc< Policy > &	desc,
		Task &&	task
	)

constexpr

Definition at line 162 of file adapters.hpp.

◆ apply_adapter() [4/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	const catch_as_failure_with_policy_adapter_desc< Policy > &	desc,
		Task &&	task
	)

constexpr

Definition at line 167 of file adapters.hpp.

◆ apply_adapter() [5/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	const retry_adapter_desc< Policy > &	desc,
		Task &&	task
	)

constexpr

Definition at line 145 of file adapters.hpp.

◆ apply_adapter() [6/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	retry_adapter_desc< Policy > &&	desc,
		Task &&	task
	)

constexpr

Definition at line 150 of file adapters.hpp.

◆ apply_adapter() [7/7]

template<typename Task , typename Policy >

constexpr auto yorch::apply_adapter	(	retry_adapter_desc< Policy > &	desc,
		Task &&	task
	)

constexpr

Definition at line 140 of file adapters.hpp.

◆ apply_adapters() [1/3]

template<typename Task , typename... Descs>

constexpr auto yorch::apply_adapters	(	Task &&	task,
		adapter_chain< Descs... > &&	chain
	)

constexpr

Definition at line 133 of file adapters.hpp.

◆ apply_adapters() [2/3]

template<typename Task , typename... Descs>

constexpr auto yorch::apply_adapters	(	Task &&	task,
		const adapter_chain< Descs... > &	chain
	)

constexpr

Definition at line 126 of file adapters.hpp.

◆ apply_adapters() [3/3]

template<typename Task >

constexpr auto yorch::apply_adapters	(	Task &&	task,
		const adapter_chain<> &
	)

constexpr

Definition at line 121 of file adapters.hpp.

◆ bind()

template<typename F , typename... Specs>

constexpr auto yorch::bind	(	F &&	f,
		Specs &&...	specs
	)

constexpr

Creates a bound_task from a callable and matching argument specs.

The callable and specs are stored by decayed value. The number of specs must exactly match the callable arity so each parameter can be resolved with the corresponding target type.

Current boundary: bind(...) still requires a callable with one unambiguous signature. Overloaded function names, generic lambdas, and callables with overloaded operator() are intentionally not deduced automatically in this phase. For example, bind(foo, ...) is ambiguous if foo is overloaded, bind([](auto&& x) { ... }, ...) is unsupported because the lambda is generic, and a type such as struct X { void operator()(int) const; void operator()(double) const; }; is also out of scope for this phase.

Template Parameters

F	Callable type.
Specs	Spec types.

Parameters

f	Callable to execute later.
specs	Parameter binding specs in call order.

Returns: A bound_task that can be run with an exec_context.

Definition at line 34 of file factories.hpp.

◆ bind_forward_prev()

template<typename T , typename F , typename... Specs>

constexpr auto yorch::bind_forward_prev	(	F &&	f,
		Specs &&...	specs
	)

constexpr

Definition at line 74 of file factories.hpp.

◆ bind_forward_prev_member() [1/2]

template<typename T , typename F >

constexpr void yorch::bind_forward_prev_member ( F && )

constexpr

Definition at line 89 of file factories.hpp.

◆ bind_forward_prev_member() [2/2]

template<typename T , typename F , typename ReceiverSpec , typename... Specs>

constexpr auto yorch::bind_forward_prev_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		Specs &&...	specs
	)

constexpr

Definition at line 96 of file factories.hpp.

◆ bind_from_lvalue()

template<typename Arg , typename Source >
requires bindable_from_lvalue<Arg, Source>

constexpr decltype(auto) yorch::bind_from_lvalue ( Source & src )

constexprnoexcept

Binds an existing lvalue source object to the requested argument type.

This is the final adaptation step in resolution: it does not locate the source object, it only turns an already available lvalue into Arg. The function supports binding to T&, const T&, and value parameters, while rejecting rvalue-reference arguments.

Rejecting T&& is intentional: this helper is used for stable lvalue sources such as context entries, parent payloads, and stored value(...) objects. Treating those sources as rvalues would let callees move from shared or reusable state, which would make later retries or repeated invocations observe moved-from objects.

Template Parameters

Arg	Target function parameter type.
Source	Concrete source object type.

Parameters

src	Source object to bind from.

Returns: A reference or value matching Arg.

Definition at line 151 of file resolve.hpp.

◆ bind_into()

template<typename T , typename F , typename... Specs>

constexpr auto yorch::bind_into	(	F &&	f,
		Specs &&...	specs
	)

constexpr

Creates a direct-output task from a callable and matching input specs.

The callable's last parameter must be a direct_out<T>-compatible output sink. All earlier parameters are resolved exactly like bind(...).

Template Parameters

T	Payload type produced into the destination slot.
F	Callable type.
Specs	Input spec types.

Parameters

f	Callable to execute later.
specs	Input binding specs, one for each non-output parameter.

Returns: A bound_output_task that can be executed through invoke_into(...).

Definition at line 60 of file factories.hpp.

◆ bind_into_member() [1/2]

template<typename T , typename F >

constexpr void yorch::bind_into_member ( F && )

constexpr

Definition at line 136 of file factories.hpp.

◆ bind_into_member() [2/2]

template<typename T , typename F , typename ReceiverSpec , typename... Specs>

constexpr auto yorch::bind_into_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		Specs &&...	specs
	)

constexpr

Definition at line 143 of file factories.hpp.

◆ bind_member() [1/2]

template<typename F >

constexpr void yorch::bind_member ( F && )

constexpr

Definition at line 113 of file factories.hpp.

◆ bind_member() [2/2]

template<typename F , typename ReceiverSpec , typename... Specs>

constexpr auto yorch::bind_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		Specs &&...	specs
	)

constexpr

Definition at line 120 of file factories.hpp.

◆ borrow_prev()

template<typename T >

constexpr auto yorch::borrow_prev ( ) -> borrow_prev_t<std::remove_cvref_t<T>>

constexprnoexcept

Creates a spec that borrows T from the direct parent output slot as const T&.

The returned object only records the requested payload type. Actual access happens later during resolution against the current execution's parent slot view.

Template Parameters

T	Parent payload type to request.

Returns: A borrow_prev_t carrying the normalized lookup type.

Definition at line 121 of file specs.hpp.

◆ borrow_prev_mut()

template<typename T >

constexpr auto yorch::borrow_prev_mut ( ) -> borrow_prev_mut_t<std::remove_cvref_t<T>>

constexprnoexcept

Creates a spec that borrows T from the direct parent output slot as T&.

Template Parameters

T	Parent payload type to request.

Returns: A borrow_prev_mut_t carrying the normalized lookup type.

Definition at line 134 of file specs.hpp.

◆ catch_as_failure() [1/2]

template<typename Task >

constexpr auto yorch::catch_as_failure ( Task && task )

constexpr

Wraps a task so thrown exceptions become default failure results.

This overload is intentionally narrow: it only supports raw return categories for which the library can synthesize a failure result without a user-provided payload.

Note that the exception source is not limited to the final callable body. For bound tasks, argument resolution, implicit conversions, and temporary argument construction all happen inside invoke_raw(...) and therefore also participate in the task's effective noexcept surface. If any of those steps may throw, the resulting task is no longer noexcept and may need to be adapted through catch_as_failure(...) before it can re-enter the main executor path.

Template Parameters

Task	Task type to wrap.

Parameters

task	Task object exposing `invoke_raw(...)`.

Returns: A catch_failure_task wrapper.

Definition at line 175 of file catch_as_failure.hpp.

◆ catch_as_failure() [2/2]

template<typename Task , typename Policy >

constexpr auto yorch::catch_as_failure	(	Task &&	task,
		Policy &&	policy
	)

constexpr

Wraps a task so thrown exceptions are routed to a user fallback policy.

The policy contract is a noexcept call accepting the captured exception either by value (std::exception_ptr) or by const lvalue reference (const std::exception_ptr&). Its return type must be compatible with the wrapped task's raw return category.

As with the default overload, exceptions may originate anywhere inside the wrapped task's invoke_raw(...) path, including parameter resolution and conversion work performed before the final callable body is entered. This overload is therefore suitable both for callables that throw directly and for bound tasks whose argument construction path can fail.

Template Parameters

Task	Task type to wrap.
Policy	Fallback policy type.

Parameters

task	Task object exposing `invoke_raw(...)`.
policy	Exception fallback policy.

Returns: A catch_failure_with_policy_task wrapper.

Definition at line 203 of file catch_as_failure.hpp.

◆ compile_plan() [1/2]

template<typename... Nodes>
requires (sizeof...(Nodes) > 0) && detail::plannable_plan_nodes<Nodes...>

constexpr auto yorch::compile_plan ( const task_tree_builder< Nodes... > & tree )

constexpr

Definition at line 159 of file compiled_plan.hpp.

◆ compile_plan() [2/2]

template<typename... Nodes>
requires (sizeof...(Nodes) > 0) && detail::plannable_plan_nodes<Nodes...>

constexpr auto yorch::compile_plan ( task_tree_builder< Nodes... > && tree )

constexpr

Compiles a populated task_tree_builder into a static plan.

This recovers direct-parent relations, direct-child adjacency, and per-node output slot metadata while preserving the stored task objects.

Template Parameters

Nodes Recorded builder node types.

Parameters

tree	Source task tree builder.

Returns: A compiled_plan carrying the same node tuple and static metadata.

Definition at line 148 of file compiled_plan.hpp.

◆ consume_prev()

template<typename T >

constexpr auto yorch::consume_prev ( ) -> consume_prev_t<std::remove_cvref_t<T>>

constexprnoexcept

Creates a spec that consumes T from the direct parent output slot.

Template Parameters

T	Parent payload type to request.

Returns: A consume_prev_t carrying the normalized lookup type.

Definition at line 163 of file specs.hpp.

◆ copy_prev()

template<typename T >

constexpr auto yorch::copy_prev ( ) -> copy_prev_t<std::remove_cvref_t<T>>

constexprnoexcept

Creates a spec that copies T from the direct parent output slot as a new value.

The returned object only records the requested payload type. Actual access happens later during resolution against the current execution's parent slot view.

Template Parameters

T	Parent payload type to request.

Returns: A copy_prev_t carrying the normalized lookup type.

Definition at line 151 of file specs.hpp.

◆ from_ctx()

template<typename T >

constexpr auto yorch::from_ctx ( ) -> from_ctx_t<std::remove_cvref_t<T>>

constexprnoexcept

Creates a spec that asks execution to fetch T from the context.

The returned object only records the requested type. It is typically used in binding expressions such as from_ctx<Scene>().

Template Parameters

T	Context type to request.

Returns: A from_ctx_t carrying the normalized lookup type.

Definition at line 104 of file specs.hpp.

◆ prev_slot()

template<typename T >

constexpr auto yorch::prev_slot ( T & value ) -> prev_slot_view<T>

constexprnoexcept

Creates a borrowed view over a direct parent payload object.

Template Parameters

T	Payload expression type.

Parameters

value Payload object stored in the current direct parent slot.

Returns: A prev_slot_view borrowing value.

Definition at line 91 of file context.hpp.

◆ resolve_as() [1/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	borrow_prev_mut_t< T >	,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Resolves a borrow_prev_mut(...) spec by fetching the direct parent output payload as an exclusive mutable borrow.

This access mode is intentionally strict: the target argument must be the exact type T&.

Definition at line 242 of file resolve.hpp.

◆ resolve_as() [2/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	borrow_prev_t< T >	,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Resolves a borrow_prev(...) spec by fetching the direct parent output payload as a readonly borrow.

This access mode is intentionally strict: the target argument must be the exact type const T&.

Template Parameters

Arg	Target function parameter type.
T	Requested parent payload type encoded by the spec.
Ctx	Context type carried by the current execution.
Prev	Direct-parent slot view type carried by the execution.

Parameters

ec	Execution context that provides the direct parent payload.

Returns: A reference or value matching Arg.

Definition at line 220 of file resolve.hpp.

◆ resolve_as() [3/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	const value_t< std::reference_wrapper< T > > &	spec,
		exec_context< Ctx, Prev > &
	)

constexprnoexcept

Definition at line 353 of file resolve.hpp.

◆ resolve_as() [4/10]

template<typename Arg , typename T , typename Ctx , typename Prev >
requires resolvable_const_value<Arg, T>

constexpr decltype(auto) yorch::resolve_as	(	const value_t< T > &	spec,
		exec_context< Ctx, Prev > &
	)

constexprnoexcept

Resolves a const value(...) spec into the requested argument type.

This overload preserves the constness of the stored source expression. As a result, reference binding is limited to const T&, and value construction must be valid from const T&. As with the mutable overload, T&& is intentionally unsupported because value(...) models reusable stored state, not a one-shot forwarding source.

Template Parameters

Arg	Target function parameter type.
T	Stored value type.
Ctx	Context type, unused for this spec category.
Prev	Parent slot view type carried by the current execution.

Parameters

spec	Const spec that owns the stored value.

Returns: A const reference or value matching Arg.

Definition at line 412 of file resolve.hpp.

◆ resolve_as() [5/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	consume_prev_t< T >	,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Resolves a consume_prev(...) spec by moving from the direct parent output payload exactly once.

This access mode only supports owned-value or rvalue-reference targets: T and T&&.

Definition at line 291 of file resolve.hpp.

◆ resolve_as() [6/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	copy_prev_t< T >	,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Resolves a copy_prev(...) spec by copying the direct parent output payload into a new value.

This access mode is intentionally strict: the target argument must be the exact type T.

Definition at line 267 of file resolve.hpp.

◆ resolve_as() [7/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	from_ctx_t< T >	,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Resolves a from_ctx(...) spec by fetching the requested object from the execution context and binding it as Arg.

The lookup type is normalized by from_ctx_t<T>::type, then validated against the context schema before the retrieved object is passed to bind_from_lvalue.

Template Parameters

Arg	Target function parameter type.
T	Requested context type encoded by the spec.
Ctx	Context type carried by the current execution.
Prev	Parent slot view type carried by the current execution.

Parameters

ec	Execution context that provides the source object.

Returns: A reference or value matching Arg.

Definition at line 191 of file resolve.hpp.

◆ resolve_as() [8/10]

template<typename Arg , typename Spec , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	Spec &&	,
		exec_context< Ctx, Prev > &
	)

constexpr

Fallback overload for unsupported spec categories.

This function exists only to produce a focused compile-time diagnostic when no dedicated resolve_as(...) overload matches the provided spec.

Template Parameters

Arg	Target function parameter type.
Spec	Unsupported spec type.
Ctx	Context type carried by the current execution.
Prev	Parent slot view type carried by the current execution.

Definition at line 445 of file resolve.hpp.

◆ resolve_as() [9/10]

template<typename Arg , typename T , typename Ctx , typename Prev >

constexpr decltype(auto) yorch::resolve_as	(	value_t< std::reference_wrapper< T > > &	spec,
		exec_context< Ctx, Prev > &
	)

constexprnoexcept

Resolves a mutable value(...) spec into the requested argument type.

The stored object is taken from spec.v and adapted under the stricter value(...) rules: value parameters are copied or converted from the stored lvalue, and reference parameters must be const T&.

T&& is rejected here for the same reason as in bind_from_lvalue: a value(...) spec owns a reusable object, so resolving it must not silently consume that stored state and leave retries or subsequent invocations observing a moved-from payload.

Template Parameters

Arg	Target function parameter type.
T	Stored value type.
Ctx	Context type, unused for this spec category.
Prev	Parent slot view type carried by the current execution.

Parameters

spec	Spec that owns the stored value.

Returns: A const reference or value matching Arg.

Definition at line 333 of file resolve.hpp.

◆ resolve_as() [10/10]

template<typename Arg , typename T , typename Ctx , typename Prev >
requires resolvable_mutable_value<Arg, T>

constexpr decltype(auto) yorch::resolve_as	(	value_t< T > &	spec,
		exec_context< Ctx, Prev > &
	)

constexprnoexcept

Definition at line 374 of file resolve.hpp.

◆ run_plan() [1/2]

template<typename LayoutPolicy = slot_layout_one_to_one_policy, typename ExecPolicy = exec_serial_dfs_recursive_policy, typename Plan >
requires detail::slot_layout_policy<LayoutPolicy> && detail::exec_policy<ExecPolicy> && (Plan::node_count > 0) && detail::plan_valid_v<Plan> && detail::plan_prev_source_valid_v<Plan> && detail::plan_prev_access_valid_v<Plan> && detail::plan_forward_prev_source_valid_v<Plan> && detail::plan_fanout_policy_valid_v<Plan>

constexpr step_result yorch::run_plan ( Plan & plan )

constexpr

Executes a compiled plan using the selected serial depth-first policy.

abort_branch is consumed locally by the parent and only terminates the current child subtree; all other non-success statuses stop the remaining DFS and bubble to the caller.

The recursive policy keeps the call stack shape:

run_plan(...) creates per-run slot storage and enters the root
run_node<I>(...) prepares node I's direct-parent view and exec_context
enter_node<I>(...) executes node I and materializes its payload if any
run_children<I, Ord>(...) enumerates node I's children and descends into each child via run_node<child>(...)

The explicit-heap-stack policy preserves the same DFS semantics, but stores traversal frames on the heap instead of recursing through the C++ call stack.

Template Parameters

Plan	Compiled plan type.

Parameters

plan	Mutable plan whose stored task objects are executed in DFS order.

Returns: Final step_result of the whole execution.

Definition at line 50 of file plan.hpp.

◆ run_plan() [2/2]

template<typename LayoutPolicy = slot_layout_one_to_one_policy, typename ExecPolicy = exec_serial_dfs_recursive_policy, typename Plan , typename Ctx >
requires detail::slot_layout_policy<LayoutPolicy> && detail::exec_policy<ExecPolicy> && (Plan::node_count > 0) && detail::plan_valid_v<Plan> && detail::plan_prev_source_valid_v<Plan> && detail::plan_prev_access_valid_v<Plan> && detail::plan_forward_prev_source_valid_v<Plan> && detail::plan_fanout_policy_valid_v<Plan>

constexpr step_result yorch::run_plan	(	Plan &	plan,
		Ctx &	ctx
	)

constexpr

Executes a compiled plan using serial depth-first traversal with an external typed execution context.

Template Parameters

Plan	Compiled plan type.
Ctx	Borrowed context type.

Parameters

plan	Mutable plan whose stored task objects are executed in DFS order.
ctx	Borrowed context exposed to each node through `from_ctx(...)`.

Returns: Final step_result of the whole execution.

Definition at line 84 of file plan.hpp.

◆ run_task()

template<typename Task , typename Ctx , typename Prev = no_prev>
requires executable_task<Task, Ctx, Prev>

constexpr step_result yorch::run_task	(	Task &&	task,
		exec_context< Ctx, Prev > &	ec
	)

constexprnoexcept

Executes a ready-to-run task against the provided execution context.

In the current design, run_task(...) remains thin: it resolves no arguments by itself and only normalizes the raw return emitted by the task's invoke_raw(...) protocol. Direct-output tasks that write into a slot-like sink should instead use run_task_into(...).

The function intentionally accepts only the no-throw execution surface modeled by executable_task; potentially throwing tasks must first be wrapped into a no-throw adapter such as catch_as_failure(...).

Template Parameters

Task	Executable task type, typically `bound_task`.
Ctx	Borrowed execution-context schema.

Parameters

task	Task object to execute.
ec	Borrowed execution context.

Returns: The normalized step_result derived from the raw task return.

Definition at line 33 of file task.hpp.

◆ run_task_into()

template<typename Task , typename Ctx , typename Prev = no_prev>
requires executable_direct_output_task<Task, Ctx, Prev>

constexpr step_result yorch::run_task_into	(	Task &&	task,
		exec_context< Ctx, Prev > &	ec,
		direct_out< detail::declared_task_output_t< Task > >	out
	)

constexprnoexcept

Executes a direct-output task against the provided execution context.

Unlike run_task(...), this overload is for tasks whose payload is written into a caller-provided output sink instead of returned through invoke_raw(...). The caller owns the destination slot lifetime; this helper only enforces the direct-output success/non-success contract on top of that sink.

Template Parameters

Task	Direct-output task type exposing `invoke_into(...)`.
Ctx	Borrowed execution-context schema.
Prev	Direct-parent slot view type.

Parameters

task	Task object to execute.
ec	Borrowed execution context.
out	Output sink receiving the task payload on success.

Returns: The resulting step_result from the direct-output execution.

Definition at line 73 of file task.hpp.

◆ task() [1/7]

template<typename F >
requires detail::inferable_direct_output_callable<F>

constexpr void yorch::task ( F && )

constexpr

Definition at line 10 of file diagnostics.hpp.

◆ task() [2/7]

template<typename F >
requires detail::member_bind_callable<F>

constexpr void yorch::task ( F && )

constexpr

Definition at line 19 of file diagnostics.hpp.

◆ task() [3/7]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 38 of file diagnostics.hpp.

◆ task() [4/7]

template<typename F , typename AdapterChain >
requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 48 of file diagnostics.hpp.

◆ task() [5/7]

template<typename F >
requires detail::ordinary_bind_callable<F>

constexpr auto yorch::task ( F && f )

constexpr

Definition at line 207 of file core.hpp.

◆ task() [6/7]

template<typename F , typename AdapterChain >
requires detail::ordinary_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task	(	F &&	f,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 216 of file core.hpp.

◆ task() [7/7]

template<typename Task >
requires detail::bind_task_object<Task> && detail::task_uses_direct_output_protocol_v<Task>

constexpr void yorch::task ( Task && )

constexpr

Definition at line 28 of file diagnostics.hpp.

◆ task_forward_prev() [1/8]

template<typename F >
requires detail::inferable_direct_output_callable<F>

constexpr void yorch::task_forward_prev ( F && )

constexpr

Definition at line 105 of file diagnostics.hpp.

◆ task_forward_prev() [2/8]

template<typename F >
requires detail::member_bind_callable<F>

constexpr void yorch::task_forward_prev ( F && )

constexpr

Definition at line 124 of file diagnostics.hpp.

◆ task_forward_prev() [3/8]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 114 of file diagnostics.hpp.

◆ task_forward_prev() [4/8]

template<typename F , typename AdapterChain >
requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 133 of file diagnostics.hpp.

◆ task_forward_prev() [5/8]

template<typename F >
requires detail::inferable_forward_prev_callable<F>

constexpr auto yorch::task_forward_prev ( F && f )

constexpr

Definition at line 284 of file core.hpp.

◆ task_forward_prev() [6/8]

template<typename F , typename AdapterChain >
requires detail::inferable_forward_prev_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task_forward_prev	(	F &&	f,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 293 of file core.hpp.

◆ task_forward_prev() [7/8]

template<typename Task >
requires detail::bind_task_object<Task>

constexpr void yorch::task_forward_prev ( Task && )

constexpr

Definition at line 86 of file diagnostics.hpp.

◆ task_forward_prev() [8/8]

template<typename Task , typename AdapterChain >
requires detail::bind_task_object<Task> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev	(	Task &&	,
		AdapterChain &&
	)

constexpr

Definition at line 95 of file diagnostics.hpp.

◆ task_forward_prev_member() [1/8]

template<typename F >
requires detail::ordinary_member_bind_callable<F>

constexpr void yorch::task_forward_prev_member ( F && )

constexpr

Definition at line 200 of file diagnostics.hpp.

◆ task_forward_prev_member() [2/8]

template<typename F >
requires detail::inferable_direct_output_member_callable<F>

constexpr void yorch::task_forward_prev_member ( F && )

constexpr

Definition at line 219 of file diagnostics.hpp.

◆ task_forward_prev_member() [3/8]

template<typename F , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 209 of file diagnostics.hpp.

◆ task_forward_prev_member() [4/8]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 228 of file diagnostics.hpp.

◆ task_forward_prev_member() [5/8]

template<typename F , typename ReceiverSpec >
requires detail::inferable_direct_output_member_callable<F>

constexpr void yorch::task_forward_prev_member	(	F &&	,
		ReceiverSpec &&
	)

constexpr

Definition at line 238 of file diagnostics.hpp.

◆ task_forward_prev_member() [6/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_forward_prev_member	(	F &&	,
		ReceiverSpec &&	,
		AdapterChain &&
	)

constexpr

Definition at line 247 of file diagnostics.hpp.

◆ task_forward_prev_member() [7/8]

template<typename F , typename ReceiverSpec >
requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)

constexpr auto yorch::task_forward_prev_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec
	)

constexpr

Definition at line 306 of file core.hpp.

◆ task_forward_prev_member() [8/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task_forward_prev_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 322 of file core.hpp.

◆ task_into() [1/8]

template<typename F >
requires detail::ordinary_bind_callable<F>

constexpr void yorch::task_into ( F && )

constexpr

Definition at line 77 of file diagnostics.hpp.

◆ task_into() [2/8]

template<typename F >
requires detail::member_bind_callable<F>

constexpr void yorch::task_into ( F && )

constexpr

Definition at line 314 of file diagnostics.hpp.

◆ task_into() [3/8]

template<typename F , typename AdapterChain >
requires detail::ordinary_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 323 of file diagnostics.hpp.

◆ task_into() [4/8]

template<typename F , typename AdapterChain >
requires detail::member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 333 of file diagnostics.hpp.

◆ task_into() [5/8]

template<typename F >
requires detail::inferable_direct_output_callable<F>

constexpr auto yorch::task_into ( F && f )

constexpr

Definition at line 262 of file core.hpp.

◆ task_into() [6/8]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task_into	(	F &&	f,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 271 of file core.hpp.

◆ task_into() [7/8]

template<typename Task >
requires detail::bind_task_object<Task>

constexpr void yorch::task_into ( Task && )

constexpr

Definition at line 58 of file diagnostics.hpp.

◆ task_into() [8/8]

template<typename Task , typename AdapterChain >
requires detail::bind_task_object<Task> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into	(	Task &&	,
		AdapterChain &&
	)

constexpr

Definition at line 67 of file diagnostics.hpp.

◆ task_into_member() [1/8]

template<typename F >
requires detail::inferable_direct_output_member_callable<F>

constexpr void yorch::task_into_member ( F && )

constexpr

Definition at line 257 of file diagnostics.hpp.

◆ task_into_member() [2/8]

template<typename F >
requires detail::ordinary_member_bind_callable<F>

constexpr void yorch::task_into_member ( F && )

constexpr

Definition at line 276 of file diagnostics.hpp.

◆ task_into_member() [3/8]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 266 of file diagnostics.hpp.

◆ task_into_member() [4/8]

template<typename F , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 285 of file diagnostics.hpp.

◆ task_into_member() [5/8]

template<typename F , typename ReceiverSpec >
requires detail::ordinary_member_bind_callable<F>

constexpr void yorch::task_into_member	(	F &&	,
		ReceiverSpec &&
	)

constexpr

Definition at line 295 of file diagnostics.hpp.

◆ task_into_member() [6/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_into_member	(	F &&	,
		ReceiverSpec &&	,
		AdapterChain &&
	)

constexpr

Definition at line 304 of file diagnostics.hpp.

◆ task_into_member() [7/8]

template<typename F , typename ReceiverSpec >
requires detail::inferable_direct_output_member_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)

constexpr auto yorch::task_into_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec
	)

constexpr

Definition at line 339 of file core.hpp.

◆ task_into_member() [8/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task_into_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 355 of file core.hpp.

◆ task_member() [1/8]

template<typename F >
requires detail::ordinary_member_bind_callable<F>

constexpr void yorch::task_member ( F && )

constexpr

Definition at line 143 of file diagnostics.hpp.

◆ task_member() [2/8]

template<typename F >
requires detail::inferable_direct_output_member_callable<F>

constexpr void yorch::task_member ( F && )

constexpr

Definition at line 162 of file diagnostics.hpp.

◆ task_member() [3/8]

template<typename F , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 152 of file diagnostics.hpp.

◆ task_member() [4/8]

template<typename F , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_member	(	F &&	,
		AdapterChain &&
	)

constexpr

Definition at line 171 of file diagnostics.hpp.

◆ task_member() [5/8]

template<typename F , typename ReceiverSpec >
requires detail::inferable_direct_output_member_callable<F>

constexpr void yorch::task_member	(	F &&	,
		ReceiverSpec &&
	)

constexpr

Definition at line 181 of file diagnostics.hpp.

◆ task_member() [6/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::inferable_direct_output_member_callable<F> && detail::adapter_chain_like<AdapterChain>

constexpr void yorch::task_member	(	F &&	,
		ReceiverSpec &&	,
		AdapterChain &&
	)

constexpr

Definition at line 190 of file diagnostics.hpp.

◆ task_member() [7/8]

template<typename F , typename ReceiverSpec >
requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>)

constexpr auto yorch::task_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec
	)

constexpr

Definition at line 229 of file core.hpp.

◆ task_member() [8/8]

template<typename F , typename ReceiverSpec , typename AdapterChain >
requires detail::ordinary_member_bind_callable<F> && detail::member_receiver_bindable<F, ReceiverSpec> && (!detail::adapter_chain_like<ReceiverSpec>) && detail::adapter_chain_like<AdapterChain>

constexpr auto yorch::task_member	(	F &&	f,
		ReceiverSpec &&	receiver_spec,
		AdapterChain &&	adapter_specs
	)

constexpr

Definition at line 245 of file core.hpp.

◆ value()

template<typename T >

constexpr auto yorch::value ( T && v ) -> value_t<std::remove_cvref_t<T>>

constexpr

Wraps a value as an owning spec.

The argument is copied or moved into the returned value_t, which keeps a decayed version of the original type.

Template Parameters

T	Source expression type.

Parameters

v	Value to capture.

Returns: A value_t that owns the forwarded value.

Definition at line 179 of file specs.hpp.

◆ with_retry()

template<typename Task , typename Policy >
requires retry_policy<std::decay_t<Policy>>

constexpr auto yorch::with_retry	(	Task &&	task,
		Policy &&	policy
	)

constexpr

Wraps a task so retry results are handled by a user retry policy.

The wrapped task keeps its original raw result type. The adapter simply re-invokes it while the raw result requests retry and the policy approves another attempt.

Template Parameters

Task	Task type to wrap.
Policy	Retry policy type.

Parameters

task	Task object exposing `invoke_raw(...)`.
policy	Retry policy object.

Returns: A retry_task wrapper.

Definition at line 186 of file retry.hpp.

Variable Documentation

◆ is_task_result_v

template<typename T >

constexpr bool yorch::is_task_result_v

inlineconstexpr

Initial value:

=

is_task_result<std::remove_cvref_t<T>>::value

Definition at line 190 of file result.hpp.

◆ task_tree

constexpr task_tree_builder yorch::task_tree {}

inlineconstexpr

Definition at line 48 of file builder.hpp.

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ compiled_plan_t

◆ plan_slots

◆ task_result_value_t

Enumeration Type Documentation

◆ step_status

Function Documentation

◆ adapt_catch_as_failure() [1/2]

◆ adapt_catch_as_failure() [2/2]

◆ adapt_retry()

◆ adapters()

◆ apply_adapter() [1/7]

◆ apply_adapter() [2/7]

◆ apply_adapter() [3/7]

◆ apply_adapter() [4/7]

◆ apply_adapter() [5/7]

◆ apply_adapter() [6/7]

◆ apply_adapter() [7/7]

◆ apply_adapters() [1/3]

◆ apply_adapters() [2/3]

◆ apply_adapters() [3/3]

◆ bind()

◆ bind_forward_prev()

◆ bind_forward_prev_member() [1/2]

◆ bind_forward_prev_member() [2/2]

◆ bind_from_lvalue()

◆ bind_into()

◆ bind_into_member() [1/2]

◆ bind_into_member() [2/2]

◆ bind_member() [1/2]

◆ bind_member() [2/2]

◆ borrow_prev()

◆ borrow_prev_mut()

◆ catch_as_failure() [1/2]

◆ catch_as_failure() [2/2]

◆ compile_plan() [1/2]

◆ compile_plan() [2/2]

◆ consume_prev()

◆ copy_prev()

◆ from_ctx()

◆ prev_slot()

◆ resolve_as() [1/10]

◆ resolve_as() [2/10]

◆ resolve_as() [3/10]

◆ resolve_as() [4/10]

◆ resolve_as() [5/10]

◆ resolve_as() [6/10]

◆ resolve_as() [7/10]

◆ resolve_as() [8/10]

◆ resolve_as() [9/10]

◆ resolve_as() [10/10]

◆ run_plan() [1/2]

◆ run_plan() [2/2]

◆ run_task()

◆ run_task_into()

◆ task() [1/7]

◆ task() [2/7]

◆ task() [3/7]

◆ task() [4/7]

◆ task() [5/7]

◆ task() [6/7]

◆ task() [7/7]

◆ task_forward_prev() [1/8]

◆ task_forward_prev() [2/8]

◆ task_forward_prev() [3/8]

◆ task_forward_prev() [4/8]

◆ task_forward_prev() [5/8]

◆ task_forward_prev() [6/8]

◆ task_forward_prev() [7/8]

◆ task_forward_prev() [8/8]

◆ task_forward_prev_member() [1/8]

◆ task_forward_prev_member() [2/8]

◆ task_forward_prev_member() [3/8]