yorch::detail Namespace Reference

Classes
struct	borrowed_member_receiver
struct	builder_node_core
struct	builder_node_core_forward
struct	builder_node_core_member
struct	builder_node_core_ordinary
struct	builder_node_diagnostics
struct	builder_root_core
struct	builder_root_core_forward
struct	builder_root_core_member
struct	builder_root_core_ordinary
struct	builder_root_diagnostics
struct	builder_storage_base
struct	canonical_output_owner_node_impl
struct	canonical_output_owner_node_impl< Plan, I, true >
struct	catch_failure_task_raw_result_base
struct	catch_failure_task_raw_result_base< Task, std::void_t< declared_task_raw_result_t< Task > > >
struct	catch_failure_with_policy_task_raw_result_base
struct	catch_failure_with_policy_task_raw_result_base< Task, Policy, std::void_t< declared_task_raw_result_t< Task >, policy_result_t< std::remove_cvref_t< Policy > > > >
struct	catch_policy_supported
	Trait that reports whether a fallback policy is compatible with raw task result type R. More...
struct	catch_policy_supported< R, Policy, std::void_t< std::invoke_result_t< Policy &, const std::exception_ptr & > > >
struct	child_layout
	Flat direct-child adjacency storage for a tree-shaped plan. More...
struct	compact_slot_index_layout
	Intermediate index data for the serial-DFS compact slot layout. More...
struct	consumed_member_receiver
struct	copied_member_receiver
struct	declared_task_output
	Detects a task's declared logical output type. More...
struct	declared_task_output< Task, std::void_t< typename std::remove_cvref_t< Task >::output_type > >
struct	declared_task_output_protocol
struct	declared_task_output_protocol< Task, std::void_t< typename std::remove_cvref_t< Task >::output_protocol > >
struct	declared_task_raw_result
struct	declared_task_raw_result< Task, std::void_t< typename std::remove_cvref_t< Task >::raw_result_type > >
struct	declared_task_raw_result_matches_invoke_raw
	Reports whether a task's declared raw_result_type agrees with the concrete return type of invoke_raw(exec_context<Ctx, Prev>&). More...
struct	declared_task_raw_result_matches_invoke_raw< Task, Ctx, Prev, std::void_t< declared_task_raw_result_t< Task > > >
struct	default_catch_adapter_policy_tag
struct	dfs_stack_frame
	Runtime frame used by the explicit-heap-stack DFS executor. More...
struct	direct_out_arg
struct	direct_out_arg< direct_out< T > >
struct	direct_out_payload
struct	direct_out_payload< direct_out< T >, void >
struct	direct_output_protocol_tag
struct	empty_fanout_stage
struct	erased_slot
struct	erased_slot< Size, Align, slot_physical_policy::maybe_payload >
struct	erased_slot< Size, Align, slot_physical_policy::must_payload >
struct	exec_context_traits
struct	exec_context_traits< exec_context< Ctx, Prev > >
struct	explicit_heap_stack_dispatch
struct	explicit_heap_stack_dispatch_with_ctx
struct	fanout_stage_slot
struct	fanout_stage_slot< Plan, Parent, std::enable_if_t< parent_has_staged_copy_children_v< Plan, Parent > > >
struct	forward_prev_output_protocol_tag
struct	forward_prev_unique_prev_payload
struct	forward_prev_unique_prev_payload< Spec, Rest... >
struct	forwarded_task_output_base
struct	forwarded_task_output_base< Task, std::void_t< declared_task_output_t< Task > > >
struct	forwarded_task_output_protocol_base
struct	forwarded_task_output_protocol_base< Task, std::void_t< typename std::remove_cvref_t< Task >::output_protocol > >
struct	function_traits
	Extracts the canonical function signature information of a callable. More...
struct	function_traits< F, std::void_t< decltype(&std::remove_reference_t< F >::operator())> >
struct	function_traits< R(&)(Args...) noexcept >
struct	function_traits< R(&)(Args...)>
struct	function_traits< R(*)(Args...) noexcept >
struct	function_traits< R(*)(Args...)>
struct	function_traits< R(Args...)>
	Core traits specialization for a plain function type. More...
struct	function_traits< R(C::*)(Args...) const >
struct	function_traits< R(C::*)(Args...) const noexcept >
struct	function_traits< R(C::*)(Args...) noexcept >
struct	function_traits< R(C::*)(Args...)>
struct	has_declared_task_output
struct	has_declared_task_output< Task, std::void_t< declared_task_output_t< Task > > >
struct	has_plan_declared_task_output
struct	has_plan_declared_task_output< Task, std::void_t< typename std::remove_cvref_t< Task >::output_type > >
struct	is_adapter_chain
struct	is_adapter_chain< adapter_chain< Descs... > >
struct	is_adapter_descriptor
struct	is_adapter_descriptor< catch_as_failure_adapter_desc >
struct	is_adapter_descriptor< catch_as_failure_with_policy_adapter_desc< Policy > >
struct	is_adapter_descriptor< retry_adapter_desc< Policy > >
struct	is_borrow_prev_mut_spec
struct	is_borrow_prev_spec
struct	is_consume_prev_spec
struct	is_copy_prev_spec
struct	is_member_function_pointer_callable
struct	last_node
struct	last_node< Node >
struct	last_node< Node, Rest... >
struct	max_level
struct	max_level< Node >
struct	max_level< Node, Next, Rest... >
struct	max_level<>
struct	maybe_storage
	Manual-lifetime storage for an optional in-place T. More...
struct	member_function_traits
struct	member_function_traits< R(C::*)(Args...) const >
struct	member_function_traits< R(C::*)(Args...) const noexcept >
struct	member_function_traits< R(C::*)(Args...) noexcept >
struct	member_function_traits< R(C::*)(Args...)>
struct	member_receiver_prev_access_valid
struct	no_declared_output_protocol_tag
struct	no_fanout_policy_tag
struct	node_enter_result
struct	node_fanout_guard
struct	node_slot_guard
struct	passthrough_task_prev_access_traits
struct	plan_declared_task_output
struct	plan_declared_task_output< Task, std::void_t< typename std::remove_cvref_t< Task >::output_type > >
struct	plan_exec_slots_impl
	Implementation backend for layout-driven erased plan payload storage. More...
struct	plan_exec_slots_impl< Plan, slot_layout_one_to_one_policy >
	Per-run plan payload storage for the default one-to-one layout. More...
struct	plan_fanout_state
struct	plan_slot_layout
struct	plan_slot_layout< Plan, yorch::slot_layout_one_to_one_policy >
struct	plan_slot_layout< Plan, yorch::slot_layout_serial_dfs_compact_policy >
struct	policy_result
	Extracts the result type returned by an exception fallback policy. More...
struct	policy_result< Policy, std::void_t< std::invoke_result_t< Policy &, const std::exception_ptr & > > >
struct	prev_access_binding_valid
struct	prev_access_spec_traits
struct	prev_access_spec_traits< borrow_prev_mut_t< T > >
struct	prev_access_spec_traits< borrow_prev_t< T > >
struct	prev_access_spec_traits< consume_prev_t< T > >
struct	prev_access_spec_traits< copy_prev_t< T > >
struct	prev_access_summary
struct	retry_task_raw_result_base
struct	retry_task_raw_result_base< Task, std::void_t< declared_task_raw_result_t< Task > > >
struct	slot_view
	Non-owning typed access view over a slot-like storage object. More...
struct	task_binding_view
struct	task_binding_view< bound_forward_prev_task< F, T, Specs... > >
struct	task_binding_view< bound_member_forward_prev_task< F, ReceiverSpec, T, Specs... > >
struct	task_binding_view< bound_member_output_task< F, ReceiverSpec, T, Specs... > >
struct	task_binding_view< bound_member_task< F, ReceiverSpec, Specs... > >
struct	task_binding_view< bound_output_task< F, T, Specs... > >
struct	task_binding_view< bound_task< F, Specs... > >
struct	task_output_for
struct	task_output_for< Task, std::void_t< typename plan_declared_task_output< Task >::type > >
struct	task_output_storage_mode
struct	task_output_storage_mode< Task, std::void_t< typename plan_declared_task_output< Task >::type > >
struct	task_output_type
struct	task_output_type< void >
struct	task_output_type_impl
struct	task_output_type_impl< step_result >
struct	task_output_type_impl< task_result< T > >
struct	task_prev_access_traits_from_binding_view
struct	task_prev_access_traits_impl
struct	task_prev_access_traits_impl< bound_forward_prev_task< F, T, Specs... > >
struct	task_prev_access_traits_impl< bound_member_forward_prev_task< F, ReceiverSpec, T, Specs... > >
struct	task_prev_access_traits_impl< bound_member_output_task< F, ReceiverSpec, T, Specs... > >
struct	task_prev_access_traits_impl< bound_member_task< F, ReceiverSpec, Specs... > >
struct	task_prev_access_traits_impl< bound_output_task< F, T, Specs... > >
struct	task_prev_access_traits_impl< bound_task< F, Specs... > >
struct	task_prev_access_traits_impl< catch_failure_task< Task > >
struct	task_prev_access_traits_impl< catch_failure_with_policy_task< Task, Policy > >
struct	task_prev_access_traits_impl< retry_task< Task, Policy > >
struct	task_prev_access_valid
struct	task_raw_result
	Compile-time trait that extracts a task's raw return type. More...
struct	task_raw_result< Task, std::void_t< typename std::remove_cvref_t< Task >::raw_result_type > >
	Uses a task's own raw_result_type declaration as the raw return. More...
struct	task_slot_logical_policy
struct	task_slot_logical_policy< Task, std::void_t< typename plan_declared_task_output< Task >::type > >
	Direct-output tasks always use maybe-payload slot semantics. More...
struct	task_tree_node
struct	task_uses_borrow_prev
struct	task_uses_borrow_prev_mut
struct	task_uses_consume_prev
struct	task_uses_copy_prev
struct	task_uses_exclusive_prev_access
struct	task_uses_prev_access
struct	tree_node_binder
struct	tree_node_binder_base
struct	tree_node_forward_prev_binder
struct	tree_node_forward_prev_member_receiver_binder
struct	tree_node_into_binder
struct	tree_node_into_member_receiver_binder
struct	tree_node_member_receiver_binder
struct	typed_slot
struct	typed_slot< T, slot_logical_policy::must_payload >
struct	typed_slot< void, slot_logical_policy::none >

Concepts
concept	adapter_descriptor
concept	adapter_chain_like
concept	catch_policy_like
concept	bind_task_object
concept	direct_out_arg_like
concept	bind_callable
concept	member_bind_callable
concept	inferable_direct_output_callable
concept	ordinary_bind_callable
concept	inferable_forward_prev_callable
concept	inferable_direct_output_member_callable
concept	ordinary_member_bind_callable
concept	bind_signature_matches
concept	member_receiver_bindable
concept	member_bound_signature_matches
concept	bind_into_signature_matches
concept	member_bound_into_signature_matches
concept	inferred_bind_into_signature_matches
concept	inferred_forward_prev_signature_matches
concept	inferred_member_bound_into_signature_matches
concept	fanout_validatable_plan_node
concept	plan_validatable_node
concept	prev_access_validatable_plan_node
	Minimal static-plan protocol required by the prev-access validation path for a specific node index.
concept	payload_node
	True when node I owns physical storage for its output.
concept	retry_exhaustion_policy
concept	task_object_argument
concept	callable_task_argument
concept	direct_output_task_object_argument
concept	ordinary_task_object_argument
concept	ordinary_callable_task_argument
concept	direct_output_callable_task_argument
concept	forward_prev_callable_task_argument
concept	ordinary_member_callable_task_argument
concept	forward_prev_member_callable_task_argument
concept	direct_output_member_callable_task_argument
concept	fanout_policy_or_chain
concept	exec_policy
concept	plannable_task
concept	plannable_plan_node
concept	plannable_plan_nodes
concept	slot_layout_policy
concept	fanout_policy

Typedefs
template<typename... Specs>
using	forward_prev_unique_prev_payload_t = typename forward_prev_unique_prev_payload< Specs... >::type
template<std::size_t I, typename F >
using	nth_arg_t = typename function_traits< std::remove_cvref_t< F > >::template arg< I >
template<typename F >
using	result_t = typename function_traits< std::remove_cvref_t< F > >::result_type
template<typename F >
using	member_result_t = typename member_function_traits< std::remove_cvref_t< F > >::result_type
template<typename F >
using	member_class_t = typename member_function_traits< std::remove_cvref_t< F > >::class_type
template<typename F >
using	member_receiver_arg_t = typename member_function_traits< std::remove_cvref_t< F > >::receiver_arg_type
template<typename F >
using	member_borrowed_receiver_t = std::remove_reference_t< member_receiver_arg_t< F > >
template<std::size_t I, typename F >
using	member_nth_arg_t = typename member_function_traits< std::remove_cvref_t< F > >::template arg< I >
template<typename F >
using	last_arg_t = nth_arg_t< last_arg_index_v< F >, F >
template<typename F >
using	member_last_arg_t = member_nth_arg_t< member_last_arg_index_v< F >, F >
template<typename T >
using	direct_out_payload_t = typename direct_out_payload< T >::type
template<typename Plan >
using	plan_fanout_stage_tuple_t = decltype(make_plan_fanout_stage_tuple< Plan >(std::make_index_sequence< Plan::node_count > {}))
template<typename Plan , typename Slots , std::size_t I>
using	node_prev_view_t = decltype(make_node_prev_view< Plan, I >(std::declval< Slots & >(), std::declval< plan_fanout_state< Plan > & >()))
template<typename Spec >
using	normalized_prev_access_spec_traits = prev_access_spec_traits< std::remove_cvref_t< Spec > >
template<typename Layout >
using	plan_erased_slots_tuple_t = decltype(make_erased_slots_tuple< Layout >(std::make_index_sequence< Layout::physical_slot_count > {}))
	Erased backend storage tuple for compact/layout-driven plan slots.
template<typename Plan >
using	plan_typed_slots_tuple_t = decltype(make_typed_slots_tuple< Plan >(std::make_index_sequence< payload_node_count_v< Plan > > {}))
	Typed backend storage tuple for one-to-one owned payload slots.
template<typename Task >
using	declared_task_output_t = typename declared_task_output< Task >::type
template<typename Task >
using	declared_task_output_protocol_t = typename declared_task_output_protocol< Task >::type
template<typename Task , typename Ctx , typename Prev >
using	raw_task_result_t = decltype(std::declval< Task >().invoke_raw(std::declval< exec_context< Ctx, Prev > & >()))
template<typename Policy >
using	policy_result_t = typename policy_result< Policy >::type
template<typename Task >
using	declared_task_raw_result_t = typename declared_task_raw_result< Task >::type
template<typename... Nodes>
using	last_node_t = typename last_node< Nodes... >::type
template<std::size_t Level, typename Task , typename FanoutPolicy = yorch::fanout_auto_policy>
using	task_tree_node_t = task_tree_node< Level, std::decay_t< Task >, std::remove_cvref_t< FanoutPolicy > >
template<typename Task >
using	task_raw_result_t = typename task_raw_result< Task >::type
	Convenience alias for a task's raw return type.
template<typename R >
using	task_output_t = typename task_output_type< R >::type
template<typename Task >
using	task_output_for_t = typename task_output_for< Task >::type
template<typename T >
using	from_ctx_source_t = typename from_ctx_t< T >::type
template<typename T >
using	borrow_prev_source_t = typename borrow_prev_t< T >::type
template<typename T >
using	borrow_prev_mut_source_t = typename borrow_prev_mut_t< T >::type
template<typename T >
using	copy_prev_source_t = typename copy_prev_t< T >::type
template<typename T >
using	consume_prev_source_t = typename consume_prev_t< T >::type

Enumerations
enum class	bind_forward_prev_error {   ok , invalid_output_type , member_callable_not_supported , direct_output_callable_not_supported ,   callable_shape_invalid , arity_mismatch , invalid_result_type , prev_access_count_invalid ,   payload_type_mismatch , binding_mode_not_supported }
enum class	bind_forward_prev_member_error {   ok , invalid_output_type , callable_not_member , direct_output_member_not_supported ,   arity_mismatch , invalid_result_type , prev_access_count_invalid , payload_type_mismatch ,   binding_mode_not_supported }
enum class	bind_error { ok , member_callable_not_supported , callable_shape_invalid , arity_mismatch }
enum class	bind_into_error {   ok , invalid_output_type , member_callable_not_supported , callable_shape_invalid ,   missing_output_parameter , arity_mismatch , last_parameter_not_direct_out }
enum class	bind_member_error { ok , callable_not_member , direct_output_member_not_supported , arity_mismatch }
enum class	bind_into_member_error {   ok , invalid_output_type , callable_not_member , missing_output_parameter ,   arity_mismatch , last_parameter_not_direct_out }
enum class	plan_validation_error {   ok , prev_access_root_node , prev_access_void_parent , forward_prev_root_node ,   forward_prev_void_parent , forward_prev_parent_type_mismatch , prev_access_mode_invalid , fanout_policy_invalid }
enum class	prev_access_kind {   none , borrow , borrow_mut , copy ,   consume }
enum class	slot_logical_policy : unsigned char { none , maybe_payload , must_payload }
	Node-local slot semantics inferred from a task's result protocol. More...
enum class	slot_physical_policy : unsigned char { none , maybe_payload , must_payload }
	Storage-level policy for a physical slot after layout selection. More...
enum class	output_storage_mode : unsigned char { none , owned , forwarded_prev }
	Describes how a node's logical output is backed at runtime. More...

Functions
template<std::size_t I, typename Task , typename Tuple >
constexpr auto	apply_adapters_from_const (Task &&task, const Tuple &descriptors)
template<std::size_t I, typename Task , typename Tuple >
constexpr auto	apply_adapters_from_mut (Task &&task, Tuple &&descriptors)
template<typename T >
constexpr decltype(auto)	forward_member_receiver (const borrowed_member_receiver< T > &holder) noexcept
template<typename T >
constexpr decltype(auto)	forward_member_receiver (copied_member_receiver< T > &holder) noexcept
template<typename T >
constexpr decltype(auto)	forward_member_receiver (copied_member_receiver< T > &&holder) noexcept
	Keep this rvalue overload so invoke_member_with_receiver(...) can accept a forwarded temporary copied_member_receiver<T>.
template<typename T >
constexpr decltype(auto)	forward_member_receiver (consumed_member_receiver< T > &holder) noexcept
template<typename T >
constexpr decltype(auto)	forward_member_receiver (consumed_member_receiver< T > &&holder) noexcept
template<typename F , typename Receiver , typename... Args>
constexpr decltype(auto)	invoke_member_with_receiver (F &&func, Receiver &&receiver, Args &&... args) noexcept(noexcept(std::invoke(std::forward< F >(func), forward_member_receiver(std::forward< Receiver >(receiver)), std::forward< Args >(args)...)))
template<typename F , typename T , typename Ctx , typename Prev >
constexpr auto	resolve_member_receiver (copy_prev_t< T > spec, exec_context< Ctx, Prev > &ec) noexcept(noexcept(resolve_as< member_class_t< F > >(spec, ec)))
template<typename F , typename T , typename Ctx , typename Prev >
constexpr auto	resolve_member_receiver (consume_prev_t< T > spec, exec_context< Ctx, Prev > &ec) noexcept(noexcept(resolve_as< member_class_t< F > >(spec, ec)))
template<typename F , typename Spec , typename Ctx , typename Prev >
constexpr auto	resolve_member_receiver (Spec &spec, exec_context< Ctx, Prev > &ec) noexcept(noexcept(resolve_as< member_receiver_arg_t< F > >(spec, ec)))
template<typename Self , typename T >
constexpr decltype(auto)	forward_member (T &value) noexcept
template<typename Task , typename PolicyLike >
constexpr auto	apply_catch_adapter (Task &&task, PolicyLike &&policy_like)
template<typename T , typename F , typename... Specs, std::size_t... I>
consteval bool	forward_prev_bindings_supported_impl (std::index_sequence< I... >)
template<typename T , typename F , typename ReceiverSpec , typename... Specs, std::size_t... I>
consteval bool	forward_prev_member_bindings_supported_impl (std::index_sequence< I... >)
template<typename T , typename F , typename... Specs>
consteval bind_forward_prev_error	validate_bind_forward_prev ()
template<typename T , typename F , typename... Specs>
consteval void	emit_bind_forward_prev_diagnostic ()
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
consteval bind_forward_prev_member_error	validate_bind_forward_prev_member ()
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
consteval void	emit_bind_forward_prev_member_diagnostic ()
template<typename F , typename... Specs>
consteval bind_error	validate_bind ()
template<typename F , typename... Specs>
consteval void	emit_bind_diagnostic ()
template<typename T , typename F , typename... Specs>
consteval bind_into_error	validate_bind_into ()
template<typename T , typename F , typename... Specs>
consteval void	emit_bind_into_diagnostic ()
template<typename F , typename ReceiverSpec , typename... Specs>
consteval bind_member_error	validate_bind_member ()
template<typename F , typename ReceiverSpec , typename... Specs>
consteval void	emit_bind_member_diagnostic ()
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
consteval bind_into_member_error	validate_bind_into_member ()
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
consteval void	emit_bind_into_member_diagnostic ()
template<typename Plan , std::size_t Parent, std::size_t... Ord>
consteval std::size_t	parent_exclusive_prev_child_count_impl (std::index_sequence< Ord... >)
template<typename Plan , std::size_t Parent, std::size_t... Ord>
consteval std::size_t	parent_copy_only_prev_child_count_impl (std::index_sequence< Ord... >)
template<typename Plan , std::size_t Parent, std::size_t... Ord>
consteval std::size_t	parent_consume_only_prev_child_count_impl (std::index_sequence< Ord... >)
template<typename Plan , std::size_t Parent, std::size_t... Ord>
consteval bool	parent_has_non_copy_or_consume_prev_child_impl (std::index_sequence< Ord... >)
template<typename Plan , std::size_t Parent> requires fanout_validatable_plan_node<Plan, Parent>
consteval bool	parent_fanout_policy_valid ()
template<typename Plan , std::size_t... I> requires (fanout_validatable_plan_node<Plan, I> && ...)
consteval bool	plan_fanout_policy_valid_impl (std::index_sequence< I... >)
template<typename Plan , std::size_t... I>
consteval auto	make_plan_fanout_stage_tuple (std::index_sequence< I... >) -> std::tuple< typename fanout_stage_slot< Plan, I >::type... >
template<typename Ctx >
constexpr auto	make_exec_context (Ctx &ctx, no_prev) noexcept -> exec_context< Ctx >
template<typename Ctx , typename Prev >
constexpr auto	make_exec_context (Ctx &ctx, Prev prev) noexcept -> exec_context< Ctx, Prev >
constexpr auto	make_exec_context (no_prev) noexcept -> exec_context< void >
template<typename Prev >
constexpr auto	make_exec_context (Prev prev) noexcept -> exec_context< void, Prev >
template<typename Plan , std::size_t I, typename Slots , typename FanoutState >
constexpr auto	make_node_prev_view (Slots &slots, FanoutState &fanout)
template<std::size_t I, typename Plan , typename Slots , typename Ec >
constexpr node_enter_result	enter_node_with_exec_context (Plan &plan, Slots &slots, Ec &ec)
template<std::size_t I, typename Plan , typename Slots >
constexpr node_enter_result	enter_node (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout)
template<std::size_t I, typename Plan , typename Slots , typename Ctx >
constexpr node_enter_result	enter_node (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout, Ctx &ctx)
template<typename Plan , std::size_t I> requires plan_validatable_node<Plan, I>
consteval bool	node_uses_root_prev_access ()
template<typename Plan , std::size_t I> requires plan_validatable_node<Plan, I>
consteval bool	node_uses_void_parent_prev_access ()
template<typename Plan , std::size_t I> requires plan_validatable_node<Plan, I>
consteval bool	node_uses_root_forward_prev ()
template<typename Plan , std::size_t I> requires plan_validatable_node<Plan, I>
consteval bool	node_uses_void_parent_forward_prev ()
template<typename Plan , std::size_t I> requires plan_validatable_node<Plan, I>
consteval bool	node_uses_mismatched_forward_prev_parent_type ()
template<typename Plan , std::size_t... I> requires (plan_validatable_node<Plan, I> && ...)
consteval plan_validation_error	validate_plan_impl (std::index_sequence< I... >)
template<typename Plan >
consteval plan_validation_error	validate_plan ()
template<typename Plan >
consteval void	emit_plan_diagnostic ()
template<typename Plan , std::size_t I> requires prev_access_validatable_plan_node<Plan, I>
consteval bool	node_prev_source_valid ()
	Checks whether node I is structurally allowed to use direct-parent access at all.
template<typename Plan , std::size_t I> requires prev_access_validatable_plan_node<Plan, I>
consteval bool	node_prev_access_valid ()
	Checks whether node I's declared prev-access mode is locally valid.
template<typename Plan , std::size_t I> requires prev_access_validatable_plan_node<Plan, I>
consteval bool	node_forward_prev_source_valid ()
template<typename Plan , std::size_t... I> requires (prev_access_validatable_plan_node<Plan, I> && ...)
consteval bool	plan_prev_source_valid_impl (std::index_sequence< I... >)
template<typename Plan , std::size_t... I> requires (prev_access_validatable_plan_node<Plan, I> && ...)
consteval bool	plan_prev_access_valid_impl (std::index_sequence< I... >)
template<typename Plan , std::size_t... I> requires (prev_access_validatable_plan_node<Plan, I> && ...)
consteval bool	plan_forward_prev_source_valid_impl (std::index_sequence< I... >)
constexpr prev_access_summary	merge_prev_access_summary (prev_access_summary lhs, const prev_access_summary &rhs) noexcept
template<typename Spec >
consteval prev_access_summary	summarize_prev_access_spec ()
constexpr bool	prev_access_summary_is_locally_valid (const prev_access_summary &summary) noexcept
template<typename View , std::size_t... I>
consteval bool	task_binding_prev_access_bindings_valid_impl (std::index_sequence< I... >)
template<typename View , std::size_t... I>
consteval prev_access_summary	summarize_task_binding_impl (std::index_sequence< I... >)
template<typename R >
constexpr step_result	normalize_task_result (R &&r)
	Normalizes a raw task return into scheduler-facing step_result.
template<typename R >
constexpr step_result	extract_step_result (R &&r)
template<std::size_t I, typename Slots , typename Raw >
constexpr bool	store_node_output (Slots &slots, Raw &raw)
	Materializes the payload portion of a node's raw task return into the node's compiled slot, when that return category actually carries a value.
template<std::size_t I, typename Slots >
constexpr step_result	finalize_direct_output_step (Slots &slots, step_result step)
template<std::size_t I, std::size_t Ord = 0, typename Plan , typename Slots >
constexpr step_result	run_children (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout)
template<std::size_t I, std::size_t Ord = 0, typename Plan , typename Slots , typename Ctx >
constexpr step_result	run_children (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout, Ctx &ctx)
template<std::size_t I, typename Plan , typename Slots >
constexpr step_result	run_node (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout)
template<std::size_t I, typename Plan , typename Slots , typename Ctx >
constexpr step_result	run_node (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout, Ctx &ctx)
template<std::size_t I, typename Plan , typename Slots >
constexpr node_enter_result	enter_node_runtime (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout)
	Per-node runtime thunk for entering node I.
template<std::size_t I, typename Plan , typename Slots , typename Ctx >
constexpr node_enter_result	enter_node_runtime (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout, Ctx &ctx)
	Context-threading variant of the per-node enter thunk.
template<std::size_t I, typename Slots >
constexpr void	destroy_node_payload_runtime (Slots &slots) noexcept
	Per-node runtime thunk for destroying node I's payload slot.
template<std::size_t I, typename Plan , typename Slots >
constexpr void	prepare_fanout_runtime (Slots &slots, plan_fanout_state< Plan > &fanout)
template<std::size_t I, typename Plan >
constexpr void	destroy_fanout_runtime (plan_fanout_state< Plan > &fanout) noexcept
template<typename Plan , typename Slots , std::size_t... I>
consteval auto	make_enter_node_dispatch_table (std::index_sequence< I... >)
	Builds the runtime dispatch table for node entry without external context.
template<typename Plan , typename Slots , typename Ctx , std::size_t... I>
consteval auto	make_enter_node_dispatch_table (std::index_sequence< I... >)
	Builds the runtime dispatch table for node entry with external context.
template<typename Plan , typename Slots , std::size_t... I>
consteval auto	make_destroy_node_dispatch_table (std::index_sequence< I... >)
	Builds the runtime dispatch table for payload destruction.
template<typename Plan , typename Slots , std::size_t... I>
consteval auto	make_prepare_fanout_dispatch_table (std::index_sequence< I... >)
template<typename Plan , typename Slots , std::size_t... I>
consteval auto	make_destroy_fanout_dispatch_table (std::index_sequence< I... >)
template<typename Plan , std::size_t... I>
consteval auto	make_requires_fanout_staging_table (std::index_sequence< I... >)
template<typename Plan , typename EnterInvoker , typename DestroyInvoker , typename PrepareFanoutInvoker , typename DestroyFanoutInvoker >
constexpr step_result	run_explicit_heap_stack_loop (const auto &requires_fanout_staging_by_index, EnterInvoker enter_node_by_index, DestroyInvoker destroy_node_payload_by_index, PrepareFanoutInvoker prepare_fanout_by_index, DestroyFanoutInvoker destroy_fanout_by_index)
	Executes serial DFS using a heap-backed explicit stack.
template<typename Plan , typename Slots >
constexpr step_result	run_explicit_heap_stack (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout)
template<typename Plan , typename Slots , typename Ctx >
constexpr step_result	run_explicit_heap_stack (Plan &plan, Slots &slots, plan_fanout_state< Plan > &fanout, Ctx &ctx)
template<typename Plan , std::size_t... I>
consteval auto	make_payload_node_array (std::index_sequence< I... >)
	Builds the compile-time node -> has-payload table for a plan.
template<typename Plan , std::size_t... I>
consteval auto	make_slot_logical_policy_array (std::index_sequence< I... >)
	Builds the compile-time node -> logical slot policy table.
template<typename Plan >
consteval auto	make_one_to_one_physical_slot_indices ()
	Builds the one-to-one node -> physical slot index table.
template<typename Plan >
consteval auto	make_serial_dfs_compact_slot_layout ()
	Builds the serial-DFS compact node -> physical slot layout.
constexpr slot_physical_policy	join_slot_physical_policy (slot_physical_policy left, slot_logical_policy right) noexcept
	Joins one node's logical policy into a physical slot policy.
template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>
consteval auto	make_physical_slot_sizes (const std::array< std::size_t, Plan::node_count > &indices, std::index_sequence< I... >)
	Computes the required raw storage size for each physical slot.
template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>
consteval auto	make_physical_slot_alignments (const std::array< std::size_t, Plan::node_count > &indices, std::index_sequence< I... >)
	Computes the required alignment for each physical slot.
template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>
consteval auto	make_physical_slot_policies (const std::array< std::size_t, Plan::node_count > &indices, std::index_sequence< I... >)
	Computes the storage policy for each physical slot.
template<typename Layout , std::size_t... K>
auto	make_erased_slots_tuple (std::index_sequence< K... >) -> std::tuple< erased_slot< Layout::physical_slot_sizes[K], Layout::physical_slot_alignments[K], Layout::template physical_slot_policy< K > >... >
	Type factory for a layout's erased-slot storage tuple.
template<typename Plan , std::size_t PhysicalSlot>
consteval std::size_t	one_to_one_physical_slot_owner_node ()
	Finds the unique node that owns a one-to-one physical slot.
template<typename Plan , std::size_t... K>
auto	make_typed_slots_tuple (std::index_sequence< K... >) -> std::tuple< typed_slot< typename Plan::template output_type< one_to_one_physical_slot_owner_node< Plan, K >()>, Plan::template slot_logical_policy_for< one_to_one_physical_slot_owner_node< Plan, K >()> >... >
	Type factory for a plan's typed one-to-one slot tuple.
template<typename R >
constexpr auto	default_catch_failure_result () noexcept
	Produces the default failure result used by catch_as_failure(task).
template<typename R , typename Policy >
auto	policy_catch_failure_result (Policy &policy, const std::exception_ptr &ep) noexcept
	Invokes a fallback policy to produce the exception-path raw result.
template<typename PolicyResult >
constexpr auto	void_task_success_result () noexcept
	Produces the success-path raw result for a wrapped void task when a custom fallback policy is installed.
template<typename R >
constexpr bool	raw_result_requests_retry (const R &r) noexcept
template<typename Raw >
constexpr auto	retry_exhausted_as_failure (const Raw &raw) noexcept
template<typename Policy , typename Raw >
constexpr auto	handle_retry_exhausted (const Policy &policy, Raw &&raw) noexcept
template<typename... Nodes>
consteval auto	make_level_array ()
template<std::size_t N>
consteval auto	make_slot_index_array ()
template<std::size_t N>
consteval auto	make_parent_index_array (const std::array< std::size_t, N > &levels)
	Reconstructs each node's direct parent index from the recorded level sequence.
template<std::size_t N>
consteval auto	make_child_layout (const std::array< std::size_t, N > &parents)
	Builds a flat direct-child adjacency layout from per-node parent indices.

Variables
template<typename Desc >
constexpr bool	is_adapter_descriptor_v
template<typename T >
constexpr bool	is_adapter_chain_v
template<typename T , typename... Ts>
constexpr std::size_t	type_count_v = (std::size_t{0} + ... + (std::is_same_v<T, Ts> ? 1 : 0))
template<typename... Ts>
constexpr bool	unique_types_v = ((type_count_v<Ts, Ts...> == 1) && ...)
template<typename >
constexpr bool	no_prev_always_false_v = false
template<typename >
constexpr bool	bind_tasks_always_false_v = false
template<typename... Specs>
constexpr std::size_t	forward_prev_prev_access_count_v
template<typename T , typename Arg , typename Spec >
constexpr bool	forward_prev_spec_matches_binding_v
template<typename T , typename F , typename... Specs>
constexpr bool	bind_forward_prev_payload_matches_v
template<typename T , typename F , typename... Specs>
constexpr bool	bind_forward_prev_bindings_supported_v
template<typename T , typename F , typename ReceiverSpec >
constexpr bool	forward_prev_member_receiver_binding_supported_v
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
constexpr bool	bind_forward_prev_member_payload_matches_v
template<typename T , typename F , typename ReceiverSpec , typename... Specs>
constexpr bool	bind_forward_prev_member_bindings_supported_v
template<typename T >
constexpr bool	is_member_function_pointer_callable_v
template<typename F >
constexpr std::size_t	last_arg_index_v
template<typename F >
constexpr std::size_t	member_last_arg_index_v
template<typename T >
constexpr bool	direct_out_arg_v
template<typename Task >
constexpr bool	task_uses_copy_only_prev_access_v
template<typename Task >
constexpr bool	task_uses_consume_only_prev_access_v
template<typename Plan , std::size_t Child>
constexpr bool	node_uses_copy_only_prev_access_v
template<typename Plan , std::size_t Child>
constexpr bool	node_uses_consume_only_prev_access_v
template<typename Plan >
constexpr bool	plan_fanout_policy_valid_v
template<typename Plan , std::size_t Parent>
constexpr bool	parent_requires_fanout_staging_v
template<typename Plan , std::size_t Parent>
constexpr bool	parent_has_staged_copy_children_v
template<typename Plan , std::size_t Child>
constexpr bool	node_uses_staged_copy_prev_v
template<typename >
constexpr bool	plan_validation_always_false_v = false
template<typename Plan >
constexpr plan_validation_error	plan_validation_error_v
template<typename Plan >
constexpr bool	plan_valid_v
template<typename Plan >
constexpr bool	plan_prev_source_valid_v
template<typename Plan >
constexpr bool	plan_prev_access_valid_v
template<typename Plan >
constexpr bool	plan_forward_prev_source_valid_v
template<typename F >
constexpr bool	member_receiver_is_const_v
template<typename Spec >
constexpr bool	is_borrow_prev_spec_v
template<typename Spec >
constexpr bool	is_borrow_prev_mut_spec_v
template<typename Spec >
constexpr bool	is_copy_prev_spec_v
template<typename Spec >
constexpr bool	is_consume_prev_spec_v
template<typename Spec >
constexpr bool	is_prev_access_spec_v
template<typename Spec >
constexpr bool	is_exclusive_prev_access_spec_v
template<typename Spec , typename Arg >
constexpr bool	prev_access_binding_valid_v
template<typename Spec , typename F >
constexpr bool	member_receiver_prev_access_valid_v
template<typename Task >
constexpr bool	task_prev_access_valid_v
template<typename Task >
constexpr bool	task_uses_prev_access_v
template<typename Task >
constexpr bool	task_uses_exclusive_prev_access_v
template<typename Task >
constexpr bool	task_uses_consume_prev_v
template<typename Task >
constexpr bool	task_uses_borrow_prev_v
template<typename Task >
constexpr bool	task_uses_borrow_prev_mut_v
template<typename Task >
constexpr bool	task_uses_copy_prev_v
template<typename Plan >
constexpr auto	payload_node_array_v
template<typename Plan >
constexpr auto	slot_logical_policy_array_v
template<typename Plan >
constexpr std::size_t	payload_node_count_v
constexpr std::size_t	no_physical_slot = std::numeric_limits<std::size_t>::max()
	Sentinel physical slot index meaning "this node has no storage".
template<typename Task >
constexpr bool	has_declared_task_output_v
template<typename Task >
constexpr bool	task_uses_direct_output_protocol_v
template<typename Task >
constexpr bool	task_uses_forward_prev_output_protocol_v
template<typename R >
constexpr bool	retry_status_capable_result_v
template<typename R >
constexpr bool	default_catch_supported_v
	Reports whether the default catch_as_failure(task) adapter can synthesize a failure result for raw return type R.
template<typename Task , typename Ctx , typename Prev >
constexpr bool	declared_task_raw_result_matches_invoke_raw_v
template<typename R , typename Policy >
constexpr bool	catch_policy_supported_v
template<typename... Nodes>
constexpr std::size_t	max_level_v = max_level<Nodes...>::value
template<std::size_t Level, typename... Nodes>
constexpr bool	append_level_valid_v
template<typename... Nodes>
constexpr auto	compiled_levels_v = make_level_array<Nodes...>()
template<typename... Nodes>
constexpr auto	compiled_parent_indices_v
template<typename... Nodes>
constexpr auto	compiled_child_layout_v
template<typename... Nodes>
constexpr auto	compiled_slot_indices_v
template<typename Task >
constexpr detail::output_storage_mode	task_output_storage_mode_v
template<typename Task >
constexpr slot_logical_policy	task_slot_logical_policy_v
template<typename >
constexpr bool	always_false_v = false
template<typename Arg , typename Source >
constexpr bool	supports_bind_from_lvalue_v
template<typename Arg , typename Source >
constexpr bool	bind_from_lvalue_nothrow_v
template<typename Ctx , typename T >
constexpr bool	ctx_get_nothrow_v
template<typename Prev , typename Source >
constexpr bool	prev_get_source_nothrow_v
template<typename Arg , typename T , typename Ctx >
constexpr bool	resolve_from_ctx_nothrow_v
template<typename Arg , typename T , typename Prev >
constexpr bool	resolve_borrow_prev_nothrow_v
template<typename Arg , typename T , typename Prev >
constexpr bool	resolve_borrow_prev_mut_nothrow_v
template<typename T , typename Prev >
constexpr bool	resolve_copy_prev_nothrow_v
template<typename Arg , typename T >
constexpr bool	consume_bind_nothrow_v
template<typename Arg , typename T , typename Prev >
constexpr bool	resolve_consume_prev_nothrow_v
template<typename Arg , typename T >
constexpr bool	resolve_value_nothrow_v
template<typename Arg , typename T >
constexpr bool	resolve_const_value_nothrow_v
template<typename Plan , std::size_t I>
constexpr std::size_t	canonical_output_owner_node_v

Typedef Documentation

borrow_prev_mut_source_t

template<typename T >

using yorch::detail::borrow_prev_mut_source_t = typedef typename borrow_prev_mut_t<T>::type

Definition at line 36 of file resolve.hpp.

borrow_prev_source_t

template<typename T >

using yorch::detail::borrow_prev_source_t = typedef typename borrow_prev_t<T>::type

Definition at line 33 of file resolve.hpp.

consume_prev_source_t

template<typename T >

using yorch::detail::consume_prev_source_t = typedef typename consume_prev_t<T>::type

Definition at line 42 of file resolve.hpp.

copy_prev_source_t

template<typename T >

using yorch::detail::copy_prev_source_t = typedef typename copy_prev_t<T>::type

Definition at line 39 of file resolve.hpp.

declared_task_output_protocol_t

template<typename Task >

using yorch::detail::declared_task_output_protocol_t = typedef typename declared_task_output_protocol<Task>::type

Definition at line 70 of file traits.hpp.

declared_task_output_t

template<typename Task >

using yorch::detail::declared_task_output_t = typedef typename declared_task_output<Task>::type

Definition at line 41 of file traits.hpp.

declared_task_raw_result_t

template<typename Task >

using yorch::detail::declared_task_raw_result_t = typedef typename declared_task_raw_result<Task>::type

Definition at line 66 of file traits.hpp.

direct_out_payload_t

template<typename T >

using yorch::detail::direct_out_payload_t = typedef typename direct_out_payload<T>::type

Definition at line 182 of file traits.hpp.

forward_prev_unique_prev_payload_t

template<typename... Specs>

using yorch::detail::forward_prev_unique_prev_payload_t = typedef typename forward_prev_unique_prev_payload<Specs...>::type

Definition at line 65 of file forward_prev.hpp.

from_ctx_source_t

template<typename T >

using yorch::detail::from_ctx_source_t = typedef typename from_ctx_t<T>::type

Definition at line 30 of file resolve.hpp.

last_arg_t

template<typename F >

using yorch::detail::last_arg_t = typedef nth_arg_t<last_arg_index_v<F>, F>

Definition at line 148 of file traits.hpp.

last_node_t

template<typename... Nodes>

using yorch::detail::last_node_t = typedef typename last_node<Nodes...>::type

Definition at line 22 of file metadata.hpp.

member_borrowed_receiver_t

template<typename F >

using yorch::detail::member_borrowed_receiver_t = typedef std::remove_reference_t<member_receiver_arg_t<F> >

Definition at line 136 of file traits.hpp.

member_class_t

template<typename F >

using yorch::detail::member_class_t = typedef typename member_function_traits<std::remove_cvref_t<F> >::class_type

Definition at line 128 of file traits.hpp.

member_last_arg_t

template<typename F >

using yorch::detail::member_last_arg_t = typedef member_nth_arg_t<member_last_arg_index_v<F>, F>

Definition at line 156 of file traits.hpp.

member_nth_arg_t

template<std::size_t I, typename F >

using yorch::detail::member_nth_arg_t = typedef typename member_function_traits<std::remove_cvref_t<F> >::template arg<I>

Definition at line 140 of file traits.hpp.

member_receiver_arg_t

template<typename F >

using yorch::detail::member_receiver_arg_t = typedef typename member_function_traits<std::remove_cvref_t<F> >::receiver_arg_type

Definition at line 132 of file traits.hpp.

member_result_t

template<typename F >

using yorch::detail::member_result_t = typedef typename member_function_traits<std::remove_cvref_t<F> >::result_type

Definition at line 124 of file traits.hpp.

node_prev_view_t

template<typename Plan , typename Slots , std::size_t I>

using yorch::detail::node_prev_view_t = typedef decltype(make_node_prev_view<Plan, I>( std::declval<Slots&>(), std::declval<plan_fanout_state<Plan>&>()))

Definition at line 69 of file node_entry.hpp.

normalized_prev_access_spec_traits

template<typename Spec >

using yorch::detail::normalized_prev_access_spec_traits = typedef prev_access_spec_traits<std::remove_cvref_t<Spec> >

Definition at line 108 of file prev_access_specs.hpp.

nth_arg_t

template<std::size_t I, typename F >

using yorch::detail::nth_arg_t = typedef typename function_traits<std::remove_cvref_t<F> >::template arg<I>

Definition at line 118 of file traits.hpp.

plan_erased_slots_tuple_t

template<typename Layout >

using yorch::detail::plan_erased_slots_tuple_t = typedef decltype(make_erased_slots_tuple<Layout>( std::make_index_sequence<Layout::physical_slot_count> {}))

Erased backend storage tuple for compact/layout-driven plan slots.

Definition at line 343 of file layout.hpp.

plan_fanout_stage_tuple_t

template<typename Plan >

using yorch::detail::plan_fanout_stage_tuple_t = typedef decltype(make_plan_fanout_stage_tuple<Plan>(std::make_index_sequence<Plan::node_count> {}))

Definition at line 179 of file fanout.hpp.

plan_typed_slots_tuple_t

template<typename Plan >

using yorch::detail::plan_typed_slots_tuple_t = typedef decltype(make_typed_slots_tuple<Plan>( std::make_index_sequence<payload_node_count_v<Plan> > {}))

Typed backend storage tuple for one-to-one owned payload slots.

Definition at line 390 of file layout.hpp.

policy_result_t

template<typename Policy >

using yorch::detail::policy_result_t = typedef typename policy_result<Policy>::type

Definition at line 52 of file traits.hpp.

raw_task_result_t

template<typename Task , typename Ctx , typename Prev >

using yorch::detail::raw_task_result_t = typedef decltype(std::declval<Task>().invoke_raw(std::declval<exec_context<Ctx, Prev>&>()))

Definition at line 15 of file traits.hpp.

result_t

template<typename F >

using yorch::detail::result_t = typedef typename function_traits<std::remove_cvref_t<F> >::result_type

Definition at line 121 of file traits.hpp.

task_output_for_t

template<typename Task >

using yorch::detail::task_output_for_t = typedef typename task_output_for<Task>::type

Definition at line 126 of file traits.hpp.

task_output_t

template<typename R >

using yorch::detail::task_output_t = typedef typename task_output_type<R>::type

Definition at line 110 of file traits.hpp.

task_raw_result_t

template<typename Task >

using yorch::detail::task_raw_result_t = typedef typename task_raw_result<Task>::type

Convenience alias for a task's raw return type.

This avoids repeatedly spelling typename task_raw_result<T>::type.

Template Parameters

Task	Task type being analyzed.

Definition at line 53 of file traits.hpp.

task_tree_node_t

template<std::size_t Level, typename Task , typename FanoutPolicy = yorch::fanout_auto_policy>

using yorch::detail::task_tree_node_t = typedef task_tree_node<Level, std::decay_t<Task>, std::remove_cvref_t<FanoutPolicy> >

Definition at line 64 of file metadata.hpp.

Enumeration Type Documentation

bind_error

enum class yorch::detail::bind_error

strong

Enumerator
ok
member_callable_not_supported
callable_shape_invalid
arity_mismatch

Definition at line 11 of file validate.hpp.

bind_forward_prev_error

enum class yorch::detail::bind_forward_prev_error

strong

Enumerator
ok
invalid_output_type
member_callable_not_supported
direct_output_callable_not_supported
callable_shape_invalid
arity_mismatch
invalid_result_type
prev_access_count_invalid
payload_type_mismatch
binding_mode_not_supported

Definition at line 18 of file forward_prev.hpp.

bind_forward_prev_member_error

enum class yorch::detail::bind_forward_prev_member_error

strong

Enumerator
ok
invalid_output_type
callable_not_member
direct_output_member_not_supported
arity_mismatch
invalid_result_type
prev_access_count_invalid
payload_type_mismatch
binding_mode_not_supported

Definition at line 31 of file forward_prev.hpp.

bind_into_error

enum class yorch::detail::bind_into_error

strong

Enumerator
ok
invalid_output_type
member_callable_not_supported
callable_shape_invalid
missing_output_parameter
arity_mismatch
last_parameter_not_direct_out

Definition at line 18 of file validate.hpp.

bind_into_member_error

enum class yorch::detail::bind_into_member_error

strong

Enumerator
ok
invalid_output_type
callable_not_member
missing_output_parameter
arity_mismatch
last_parameter_not_direct_out

Definition at line 35 of file validate.hpp.

bind_member_error

enum class yorch::detail::bind_member_error

strong

Enumerator
ok
callable_not_member
direct_output_member_not_supported
arity_mismatch

Definition at line 28 of file validate.hpp.

output_storage_mode

enum class yorch::detail::output_storage_mode : unsigned char

strong

Describes how a node's logical output is backed at runtime.

none means the node has no output payload. owned means the node owns physical slot storage for its output. forwarded_prev means the node has a logical output type, but its value is statically forwarded from the direct parent's canonical owner rather than materialized into a new slot.

Enumerator
none
owned
forwarded_prev

Definition at line 46 of file policy.hpp.

plan_validation_error

enum class yorch::detail::plan_validation_error

strong

Enumerator
ok
prev_access_root_node
prev_access_void_parent
forward_prev_root_node
forward_prev_void_parent
forward_prev_parent_type_mismatch
prev_access_mode_invalid
fanout_policy_invalid

Definition at line 15 of file plan_validation.hpp.

prev_access_kind

enum class yorch::detail::prev_access_kind

strong

Enumerator
none
borrow
borrow_mut
copy
consume

Definition at line 10 of file prev_access_specs.hpp.

slot_logical_policy

enum class yorch::detail::slot_logical_policy : unsigned char

strong

Node-local slot semantics inferred from a task's result protocol.

This policy answers whether a plan node logically owns a payload slot: none is used for void output nodes; maybe_payload is used when a successful-looking task invocation may still skip materializing a payload, such as direct-output tasks; must_payload is used when success always materializes a payload value.

Enumerator
none
maybe_payload
must_payload

Definition at line 17 of file policy.hpp.

slot_physical_policy

enum class yorch::detail::slot_physical_policy : unsigned char

strong

Storage-level policy for a physical slot after layout selection.

This policy is derived from every logical owner mapped to the same physical slot. none is only the empty/default state before any owner contributes; a physical slot is must_payload only when all owners are logically must_payload; if any owner is logically maybe_payload, the physical slot becomes maybe_payload and carries an engagement flag.

Enumerator
none
maybe_payload
must_payload

Definition at line 32 of file policy.hpp.

Function Documentation

apply_adapters_from_const()

template<std::size_t I, typename Task , typename Tuple >

constexpr auto yorch::detail::apply_adapters_from_const ( Task &&  task, const Tuple &  descriptors  )

constexpr

Definition at line 85 of file adapters.hpp.

apply_adapters_from_mut()

template<std::size_t I, typename Task , typename Tuple >

constexpr auto yorch::detail::apply_adapters_from_mut ( Task &&  task, Tuple &&  descriptors  )

constexpr

Definition at line 96 of file adapters.hpp.

apply_catch_adapter()

template<typename Task , typename PolicyLike >

constexpr auto yorch::detail::apply_catch_adapter ( Task &&  task, PolicyLike &&  policy_like  )

constexpr

Definition at line 20 of file adapters.hpp.

default_catch_failure_result()

template<typename R >

constexpr auto yorch::detail::default_catch_failure_result ( )

constexprnoexcept

Produces the default failure result used by catch_as_failure(task).

This helper is valid only for raw result categories accepted by default_catch_supported_v.

Template Parameters

R	Raw task return type.

Returns

A failure result compatible with R.

Definition at line 21 of file result_helpers.hpp.

destroy_fanout_runtime()

template<std::size_t I, typename Plan >

constexpr void yorch::detail::destroy_fanout_runtime ( plan_fanout_state< Plan > &  fanout )

constexprnoexcept

Definition at line 76 of file serial_dfs_explicit_heap_stack.hpp.

destroy_node_payload_runtime()

template<std::size_t I, typename Slots >

constexpr void yorch::detail::destroy_node_payload_runtime ( Slots &  slots )

constexprnoexcept

Per-node runtime thunk for destroying node I's payload slot.

Payload destruction is also a compile-time operation (slots.destroy<I>()), so the explicit-stack executor needs the same "fix `I`, erase the rest" adapter layer as node entry.

Definition at line 66 of file serial_dfs_explicit_heap_stack.hpp.

emit_bind_diagnostic()

template<typename F , typename... Specs>

consteval void yorch::detail::emit_bind_diagnostic

(

)

Definition at line 60 of file validate.hpp.

emit_bind_forward_prev_diagnostic()

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

consteval void yorch::detail::emit_bind_forward_prev_diagnostic

(

)

Definition at line 151 of file forward_prev.hpp.

emit_bind_forward_prev_member_diagnostic()

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

consteval void yorch::detail::emit_bind_forward_prev_member_diagnostic

(

)

Definition at line 225 of file forward_prev.hpp.

emit_bind_into_diagnostic()

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

consteval void yorch::detail::emit_bind_into_diagnostic

(

)

Definition at line 104 of file validate.hpp.

emit_bind_into_member_diagnostic()

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

consteval void yorch::detail::emit_bind_into_member_diagnostic

(

)

Definition at line 193 of file validate.hpp.

emit_bind_member_diagnostic()

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

consteval void yorch::detail::emit_bind_member_diagnostic

(

)

Definition at line 150 of file validate.hpp.

emit_plan_diagnostic()

template<typename Plan >

consteval void yorch::detail::emit_plan_diagnostic

(

)

Definition at line 133 of file plan_validation.hpp.

enter_node() [1/2]

template<std::size_t I, typename Plan , typename Slots >

constexpr node_enter_result yorch::detail::enter_node ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Definition at line 125 of file node_entry.hpp.

enter_node() [2/2]

template<std::size_t I, typename Plan , typename Slots , typename Ctx >

constexpr node_enter_result yorch::detail::enter_node ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout, Ctx &  ctx  )

constexpr

Definition at line 135 of file node_entry.hpp.

enter_node_runtime() [1/2]

template<std::size_t I, typename Plan , typename Slots >

constexpr node_enter_result yorch::detail::enter_node_runtime ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Per-node runtime thunk for entering node I.

The explicit-stack executor discovers the current node only through the runtime frame.node_index, but the real node execution helper is still the compile-time template enter_node<I>(...). This thunk fixes I and exposes a uniform function-pointer shape so later code can dispatch by index.

Definition at line 39 of file serial_dfs_explicit_heap_stack.hpp.

enter_node_runtime() [2/2]

template<std::size_t I, typename Plan , typename Slots , typename Ctx >

constexpr node_enter_result yorch::detail::enter_node_runtime ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout, Ctx &  ctx  )

constexpr

Context-threading variant of the per-node enter thunk.

Definition at line 50 of file serial_dfs_explicit_heap_stack.hpp.

enter_node_with_exec_context()

template<std::size_t I, typename Plan , typename Slots , typename Ec >

constexpr node_enter_result yorch::detail::enter_node_with_exec_context ( Plan &  plan, Slots &  slots, Ec &  ec  )

constexpr

Definition at line 80 of file node_entry.hpp.

extract_step_result()

template<typename R >

constexpr step_result yorch::detail::extract_step_result ( R &&  r )

constexpr

Definition at line 38 of file result.hpp.

finalize_direct_output_step()

template<std::size_t I, typename Slots >

constexpr step_result yorch::detail::finalize_direct_output_step ( Slots &  slots, step_result  step  )

constexpr

Definition at line 117 of file result.hpp.

forward_member()

template<typename Self , typename T >

constexpr decltype(auto) yorch::detail::forward_member ( T &  value )

constexprnoexcept

Definition at line 114 of file member_receiver.hpp.

forward_member_receiver() [1/5]

template<typename T >

constexpr decltype(auto) yorch::detail::forward_member_receiver ( const borrowed_member_receiver< T > &  holder )

constexprnoexcept

Definition at line 28 of file member_receiver.hpp.

forward_member_receiver() [2/5]

template<typename T >

constexpr decltype(auto) yorch::detail::forward_member_receiver ( consumed_member_receiver< T > &&  holder )

constexprnoexcept

Definition at line 58 of file member_receiver.hpp.

forward_member_receiver() [3/5]

template<typename T >

constexpr decltype(auto) yorch::detail::forward_member_receiver ( consumed_member_receiver< T > &  holder )

constexprnoexcept

Definition at line 53 of file member_receiver.hpp.

forward_member_receiver() [4/5]

template<typename T >

constexpr decltype(auto) yorch::detail::forward_member_receiver ( copied_member_receiver< T > &&  holder )

constexprnoexcept

Keep this rvalue overload so invoke_member_with_receiver(...) can accept a forwarded temporary copied_member_receiver<T>.

We still return holder.value as an lvalue on purpose: copy_prev<T>() means "invoke the member function on a local copy", not "move the copied receiver into the member call".

Definition at line 46 of file member_receiver.hpp.

forward_member_receiver() [5/5]

template<typename T >

constexpr decltype(auto) yorch::detail::forward_member_receiver ( copied_member_receiver< T > &  holder )

constexprnoexcept

Definition at line 33 of file member_receiver.hpp.

forward_prev_bindings_supported_impl()

template<typename T , typename F , typename... Specs, std::size_t... I>

consteval bool yorch::detail::forward_prev_bindings_supported_impl

(

std::index_sequence< I... >

)

Definition at line 75 of file forward_prev.hpp.

forward_prev_member_bindings_supported_impl()

template<typename T , typename F , typename ReceiverSpec , typename... Specs, std::size_t... I>

consteval bool yorch::detail::forward_prev_member_bindings_supported_impl

(

std::index_sequence< I... >

)

Definition at line 103 of file forward_prev.hpp.

handle_retry_exhausted()

template<typename Policy , typename Raw >

constexpr auto yorch::detail::handle_retry_exhausted ( const Policy &  policy, Raw &&  raw  )

constexprnoexcept

Definition at line 112 of file result_helpers.hpp.

invoke_member_with_receiver()

template<typename F , typename Receiver , typename... Args>

constexpr decltype(auto) yorch::detail::invoke_member_with_receiver ( F &&  func, Receiver &&  receiver, Args &&...  args  )

constexprnoexcept

Definition at line 63 of file member_receiver.hpp.

join_slot_physical_policy()

constexpr slot_physical_policy yorch::detail::join_slot_physical_policy ( slot_physical_policy  left, slot_logical_policy  right  )

constexprnoexcept

Joins one node's logical policy into a physical slot policy.

left is the physical policy accumulated for a physical slot so far, and right is the next logical owner mapped to that slot. Logical none does not contribute. An empty physical policy adopts the first payload owner, and any maybe_payload owner upgrades the whole physical slot to maybe_payload, because the shared storage must carry an engagement flag if any possible owner may skip materializing a payload. The result stays must_payload only when every contributing owner is logically must_payload.

Definition at line 156 of file layout.hpp.

make_child_layout()

template<std::size_t N>

consteval auto yorch::detail::make_child_layout

(

const std::array< std::size_t, N > &

parents

)

Builds a flat direct-child adjacency layout from per-node parent indices.

The returned layout stores, for each node:

• how many direct children it has (counts)
• where that node's child range begins in the flattened indices array (offsets)
• the concatenated child indices for all nodes (indices)

This relies on the tree invariant: every non-root node has exactly one direct parent, so the full set of child edges can be reconstructed from the parents array alone.

Template Parameters

N	Number of nodes in the plan.

Parameters

parents

Direct parent index for each node. The root is expected to use the sentinel value N.

Returns

A compact child adjacency layout derived from parents.

Definition at line 104 of file layout.hpp.

make_destroy_fanout_dispatch_table()

template<typename Plan , typename Slots , std::size_t... I>

consteval auto yorch::detail::make_destroy_fanout_dispatch_table

(

std::index_sequence< I... >

)

Definition at line 141 of file serial_dfs_explicit_heap_stack.hpp.

make_destroy_node_dispatch_table()

template<typename Plan , typename Slots , std::size_t... I>

consteval auto yorch::detail::make_destroy_node_dispatch_table

(

std::index_sequence< I... >

)

Builds the runtime dispatch table for payload destruction.

This is the destruction-side counterpart to make_enter_node_dispatch_table(...). Once a frame leaves the active DFS path, the loop uses dispatch[node_index](slots) to call the matching slots.destroy<I>() instantiation.

Definition at line 125 of file serial_dfs_explicit_heap_stack.hpp.

make_enter_node_dispatch_table() [1/2]

template<typename Plan , typename Slots , std::size_t... I>

consteval auto yorch::detail::make_enter_node_dispatch_table

(

std::index_sequence< I... >

)

Builds the runtime dispatch table for node entry without external context.

After expansion this returns an array equivalent to:

{ &enter_node_runtime<0, Plan, Slots>, &enter_node_runtime<1, Plan, Slots>, ... }

The explicit-stack loop can then execute dispatch[node_index](plan, slots) to bridge from runtime node indices back into compile-time node-specific code.

Definition at line 97 of file serial_dfs_explicit_heap_stack.hpp.

make_enter_node_dispatch_table() [2/2]

template<typename Plan , typename Slots , typename Ctx , std::size_t... I>

consteval auto yorch::detail::make_enter_node_dispatch_table

(

std::index_sequence< I... >

)

Builds the runtime dispatch table for node entry with external context.

Definition at line 109 of file serial_dfs_explicit_heap_stack.hpp.

make_erased_slots_tuple()

template<typename Layout , std::size_t... K>

auto yorch::detail::make_erased_slots_tuple

(

std::index_sequence< K... >

)

-> std::tuple< erased_slot< Layout::physical_slot_sizes[K], Layout::physical_slot_alignments[K], Layout::template physical_slot_policy< K > >... >

Type factory for a layout's erased-slot storage tuple.

This declaration is intentionally body-less: callers use it only in decltype(...) to expand physical slot indices K... into std::tuple<erased_slot<size, alignment, policy>...>.

make_exec_context() [1/4]

template<typename Ctx >

constexpr auto yorch::detail::make_exec_context ( Ctx &  ctx, no_prev    ) -> exec_context<Ctx>

constexprnoexcept

Definition at line 25 of file node_entry.hpp.

make_exec_context() [2/4]

template<typename Ctx , typename Prev >

constexpr auto yorch::detail::make_exec_context ( Ctx &  ctx, Prev  prev  ) -> exec_context<Ctx, Prev>

constexprnoexcept

Definition at line 31 of file node_entry.hpp.

make_exec_context() [3/4]

constexpr auto yorch::detail::make_exec_context ( no_prev  ) -> exec_context<void>

constexprnoexcept

Definition at line 36 of file node_entry.hpp.

make_exec_context() [4/4]

template<typename Prev >

constexpr auto yorch::detail::make_exec_context ( Prev  prev ) -> exec_context<void, Prev>

constexprnoexcept

Definition at line 42 of file node_entry.hpp.

make_level_array()

template<typename... Nodes>

consteval auto yorch::detail::make_level_array

(

)

Definition at line 9 of file layout.hpp.

make_node_prev_view()

template<typename Plan , std::size_t I, typename Slots , typename FanoutState >

constexpr auto yorch::detail::make_node_prev_view ( Slots &  slots, FanoutState &  fanout  )

constexpr

Definition at line 48 of file node_entry.hpp.

make_one_to_one_physical_slot_indices()

template<typename Plan >

consteval auto yorch::detail::make_one_to_one_physical_slot_indices

(

)

Builds the one-to-one node -> physical slot index table.

In this layout, every owned-storage node gets its own distinct physical slot. Nodes without owned storage keep the no_physical_slot sentinel instead.

Definition at line 72 of file layout.hpp.

make_parent_index_array()

template<std::size_t N>

consteval auto yorch::detail::make_parent_index_array

(

const std::array< std::size_t, N > &

levels

)

Reconstructs each node's direct parent index from the recorded level sequence.

For every non-root node, the direct parent is the nearest earlier node whose level is exactly one less than the current node's level. The root keeps the sentinel value N, which means "no parent".

This rule relies on the current task_tree recording convention: nodes are stored in insertion order as a valid tree-shaped level sequence, so scanning backward to the nearest level - 1 entry recovers the direct parent.

Template Parameters

N	Number of nodes in the recorded level sequence.

Parameters

levels

Node levels in insertion order.

Returns

An array of parent indices aligned with levels.

Definition at line 40 of file layout.hpp.

make_payload_node_array()

template<typename Plan , std::size_t... I>

consteval auto yorch::detail::make_payload_node_array

(

std::index_sequence< I... >

)

Builds the compile-time node -> has-payload table for a plan.

Each entry is true when the corresponding node needs owned physical slot storage. Nodes whose logical output is statically forwarded from their direct parent do not contribute storage here.

Definition at line 24 of file layout.hpp.

make_physical_slot_alignments()

template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>

consteval auto yorch::detail::make_physical_slot_alignments	(	const std::array< std::size_t, Plan::node_count > &	indices,
		std::index_sequence< I... >
	)

Computes the required alignment for each physical slot.

This mirrors make_physical_slot_sizes(...), but records the maximum alignof(output_type<I>) for every physical slot. When multiple nodes share one erased slot, the slot must satisfy the strictest alignment requirement among all mapped payload owners.

Template Parameters

PhysicalSlotCount	Number of physical slots in the layout.
I	Node indices supplied by the std::index_sequence<I...> argument.

Parameters

indices

Node -> physical slot mapping; no_physical_slot entries are ignored.

Definition at line 223 of file layout.hpp.

make_physical_slot_policies()

template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>

consteval auto yorch::detail::make_physical_slot_policies	(	const std::array< std::size_t, Plan::node_count > &	indices,
		std::index_sequence< I... >
	)

Computes the storage policy for each physical slot.

The fold expression expands over node indices, uses indices[I] to find the physical slot for node I, and joins that node's slot_logical_policy_for<I> into the accumulated slot_physical_policy. Nodes mapped to no_physical_slot are ignored. When multiple nodes share one physical slot, the result is maybe_payload if any owner is logically maybe_payload; otherwise it remains must_payload.

Template Parameters

PhysicalSlotCount	Number of physical slots in the layout.
I	Node indices supplied by the std::index_sequence<I...> argument.

Parameters

indices

Node -> physical slot mapping; no_physical_slot entries are ignored.

Definition at line 256 of file layout.hpp.

make_physical_slot_sizes()

template<typename Plan , std::size_t PhysicalSlotCount, std::size_t... I>

consteval auto yorch::detail::make_physical_slot_sizes	(	const std::array< std::size_t, Plan::node_count > &	indices,
		std::index_sequence< I... >
	)

Computes the required raw storage size for each physical slot.

indices is the node -> physical slot mapping produced by a slot layout. The fold expression expands over node indices, skips void nodes, then uses indices[I] to update the size for the physical slot owned by node I. When multiple nodes map to the same physical slot, the stored size is the maximum sizeof(output_type<I>) among those owners.

Template Parameters

PhysicalSlotCount	Number of physical slots in the layout.
I	Node indices supplied by the std::index_sequence<I...> argument.

Parameters

indices

Node -> physical slot mapping; no_physical_slot entries are ignored.

Definition at line 192 of file layout.hpp.

make_plan_fanout_stage_tuple()

template<typename Plan , std::size_t... I>

consteval auto yorch::detail::make_plan_fanout_stage_tuple

(

std::index_sequence< I... >

)

-> std::tuple< typename fanout_stage_slot< Plan, I >::type... >

make_prepare_fanout_dispatch_table()

template<typename Plan , typename Slots , std::size_t... I>

consteval auto yorch::detail::make_prepare_fanout_dispatch_table

(

std::index_sequence< I... >

)

Definition at line 133 of file serial_dfs_explicit_heap_stack.hpp.

make_requires_fanout_staging_table()

template<typename Plan , std::size_t... I>

consteval auto yorch::detail::make_requires_fanout_staging_table

(

std::index_sequence< I... >

)

Definition at line 149 of file serial_dfs_explicit_heap_stack.hpp.

make_serial_dfs_compact_slot_layout()

template<typename Plan >

consteval auto yorch::detail::make_serial_dfs_compact_slot_layout

(

)

Builds the serial-DFS compact node -> physical slot layout.

The serial executor only keeps owned payload slots on the current root-to-node DFS path live at the same time. Sibling subtrees run one after another, so payload nodes at the same path payload depth can safely reuse the same physical slot.

For example, given:

0: int
|- 1: string
|  `- 2: void
`- 3: void
   `- 4: bool

the payload depths are node 0 -> 1, node 1 -> 2, node 2 -> 2, node 3 -> 1, and node 4 -> 2. Payload nodes use depth - 1 as the physical slot index, so node 0 -> slot 0, while node 1 and node 4 both map to slot 1. The final physical_slot_count is the maximum payload depth across the tree.

Definition at line 123 of file layout.hpp.

make_slot_index_array()

template<std::size_t N>

consteval auto yorch::detail::make_slot_index_array

(

)

Definition at line 14 of file layout.hpp.

make_slot_logical_policy_array()

template<typename Plan , std::size_t... I>

consteval auto yorch::detail::make_slot_logical_policy_array

(

std::index_sequence< I... >

)

Builds the compile-time node -> logical slot policy table.

Each entry mirrors Plan::slot_logical_policy_for<I>. Layouts use this collected table when multiple logical nodes map to the same physical slot and their logical policies must be joined into one storage-level slot_physical_policy.

Definition at line 39 of file layout.hpp.

make_typed_slots_tuple()

template<typename Plan , std::size_t... K>

auto yorch::detail::make_typed_slots_tuple

(

std::index_sequence< K... >

)

-> std::tuple< typed_slot< typename Plan::template output_type< one_to_one_physical_slot_owner_node< Plan, K >()>, Plan::template slot_logical_policy_for< one_to_one_physical_slot_owner_node< Plan, K >()> >... >

Type factory for a plan's typed one-to-one slot tuple.

This declaration is intentionally body-less: callers use it only in decltype(...) to expand physical slot indices K... into typed slots for their unique payload-owner node. Void-output nodes do not appear in this tuple, so its size matches the one-to-one layout's physical_slot_count.

merge_prev_access_summary()

constexpr prev_access_summary yorch::detail::merge_prev_access_summary ( prev_access_summary  lhs, const prev_access_summary &  rhs  )

constexprnoexcept

Definition at line 24 of file prev_access_task_traits.hpp.

node_forward_prev_source_valid()

template<typename Plan , std::size_t I>
requires prev_access_validatable_plan_node<Plan, I>

consteval bool yorch::detail::node_forward_prev_source_valid

(

)

Definition at line 67 of file prev_access_plan_validation.hpp.

node_prev_access_valid()

template<typename Plan , std::size_t I>
requires prev_access_validatable_plan_node<Plan, I>

consteval bool yorch::detail::node_prev_access_valid

(

)

Checks whether node I's declared prev-access mode is locally valid.

Fan-out compatibility is validated separately by the fan-out policy layer.

Definition at line 59 of file prev_access_plan_validation.hpp.

node_prev_source_valid()

template<typename Plan , std::size_t I>
requires prev_access_validatable_plan_node<Plan, I>

consteval bool yorch::detail::node_prev_source_valid

(

)

Checks whether node I is structurally allowed to use direct-parent access at all.

Definition at line 31 of file prev_access_plan_validation.hpp.

node_uses_mismatched_forward_prev_parent_type()

template<typename Plan , std::size_t I>
requires plan_validatable_node<Plan, I>

consteval bool yorch::detail::node_uses_mismatched_forward_prev_parent_type

(

)

Definition at line 82 of file plan_validation.hpp.

node_uses_root_forward_prev()

template<typename Plan , std::size_t I>
requires plan_validatable_node<Plan, I>

consteval bool yorch::detail::node_uses_root_forward_prev

(

)

Definition at line 59 of file plan_validation.hpp.

node_uses_root_prev_access()

template<typename Plan , std::size_t I>
requires plan_validatable_node<Plan, I>

consteval bool yorch::detail::node_uses_root_prev_access

(

)

Definition at line 33 of file plan_validation.hpp.

node_uses_void_parent_forward_prev()

template<typename Plan , std::size_t I>
requires plan_validatable_node<Plan, I>

consteval bool yorch::detail::node_uses_void_parent_forward_prev

(

)

Definition at line 68 of file plan_validation.hpp.

node_uses_void_parent_prev_access()

template<typename Plan , std::size_t I>
requires plan_validatable_node<Plan, I>

consteval bool yorch::detail::node_uses_void_parent_prev_access

(

)

Definition at line 43 of file plan_validation.hpp.

normalize_task_result()

template<typename R >

constexpr step_result yorch::detail::normalize_task_result ( R &&  r )

constexpr

Normalizes a raw task return into scheduler-facing step_result.

Plain value payloads are treated as successful completion, step_result passes through unchanged, and task_result<T> contributes only its control status here. Payload extraction itself is handled by later execution stages.

Template Parameters

R	Raw return object type.

Parameters

r	Raw return object emitted by invoke_raw(...).

Returns

Normalized step_result.

Definition at line 24 of file result.hpp.

one_to_one_physical_slot_owner_node()

template<typename Plan , std::size_t PhysicalSlot>

consteval std::size_t yorch::detail::one_to_one_physical_slot_owner_node

(

)

Finds the unique node that owns a one-to-one physical slot.

The one-to-one layout maps each payload-producing node to a distinct physical slot and skips void nodes. The typed backend tuple is therefore expanded by physical slot index, not by node index; this helper reverses the mapping so make_typed_slots_tuple(...) can recover the owner node's output_type and slot_logical_policy.

For example, if nodes 0:int, 1:string, 2:void, 3:void, 4:bool map to slots 0, 1, no_physical_slot, no_physical_slot, 2. then physical slot 2 is owned by node 4.

Definition at line 361 of file layout.hpp.

parent_consume_only_prev_child_count_impl()

template<typename Plan , std::size_t Parent, std::size_t... Ord>

consteval std::size_t yorch::detail::parent_consume_only_prev_child_count_impl

(

std::index_sequence< Ord... >

)

Definition at line 67 of file fanout.hpp.

parent_copy_only_prev_child_count_impl()

template<typename Plan , std::size_t Parent, std::size_t... Ord>

consteval std::size_t yorch::detail::parent_copy_only_prev_child_count_impl

(

std::index_sequence< Ord... >

)

Definition at line 57 of file fanout.hpp.

parent_exclusive_prev_child_count_impl()

template<typename Plan , std::size_t Parent, std::size_t... Ord>

consteval std::size_t yorch::detail::parent_exclusive_prev_child_count_impl

(

std::index_sequence< Ord... >

)

Definition at line 48 of file fanout.hpp.

parent_fanout_policy_valid()

template<typename Plan , std::size_t Parent>
requires fanout_validatable_plan_node<Plan, Parent>

consteval bool yorch::detail::parent_fanout_policy_valid

(

)

Definition at line 91 of file fanout.hpp.

parent_has_non_copy_or_consume_prev_child_impl()

template<typename Plan , std::size_t Parent, std::size_t... Ord>

consteval bool yorch::detail::parent_has_non_copy_or_consume_prev_child_impl

(

std::index_sequence< Ord... >

)

Definition at line 78 of file fanout.hpp.

plan_fanout_policy_valid_impl()

template<typename Plan , std::size_t... I>
requires (fanout_validatable_plan_node<Plan, I> && ...)

consteval bool yorch::detail::plan_fanout_policy_valid_impl

(

std::index_sequence< I... >

)

Definition at line 119 of file fanout.hpp.

plan_forward_prev_source_valid_impl()

template<typename Plan , std::size_t... I>
requires (prev_access_validatable_plan_node<Plan, I> && ...)

consteval bool yorch::detail::plan_forward_prev_source_valid_impl

(

std::index_sequence< I... >

)

Definition at line 94 of file prev_access_plan_validation.hpp.

plan_prev_access_valid_impl()

template<typename Plan , std::size_t... I>
requires (prev_access_validatable_plan_node<Plan, I> && ...)

consteval bool yorch::detail::plan_prev_access_valid_impl

(

std::index_sequence< I... >

)

Definition at line 88 of file prev_access_plan_validation.hpp.

plan_prev_source_valid_impl()

template<typename Plan , std::size_t... I>
requires (prev_access_validatable_plan_node<Plan, I> && ...)

consteval bool yorch::detail::plan_prev_source_valid_impl

(

std::index_sequence< I... >

)

Definition at line 82 of file prev_access_plan_validation.hpp.

policy_catch_failure_result()

template<typename R , typename Policy >

auto yorch::detail::policy_catch_failure_result ( Policy &  policy, const std::exception_ptr &  ep  )

inlinenoexcept

Invokes a fallback policy to produce the exception-path raw result.

Template Parameters

R	Raw task return type of the wrapped task.
Policy	Policy type.

Parameters

policy	Stored fallback policy.
ep	Captured exception from the wrapped task.

Returns

A raw result compatible with R.

Definition at line 39 of file result_helpers.hpp.

prepare_fanout_runtime()

template<std::size_t I, typename Plan , typename Slots >

constexpr void yorch::detail::prepare_fanout_runtime ( Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Definition at line 71 of file serial_dfs_explicit_heap_stack.hpp.

prev_access_summary_is_locally_valid()

constexpr bool yorch::detail::prev_access_summary_is_locally_valid ( const prev_access_summary &  summary )

constexprnoexcept

Definition at line 67 of file prev_access_task_traits.hpp.

raw_result_requests_retry()

template<typename R >

constexpr bool yorch::detail::raw_result_requests_retry ( const R &  r )

constexprnoexcept

Definition at line 70 of file result_helpers.hpp.

resolve_member_receiver() [1/3]

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

constexpr auto yorch::detail::resolve_member_receiver ( consume_prev_t< T >  spec, exec_context< Ctx, Prev > &  ec  )

constexprnoexcept

Definition at line 88 of file member_receiver.hpp.

resolve_member_receiver() [2/3]

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

constexpr auto yorch::detail::resolve_member_receiver ( copy_prev_t< T >  spec, exec_context< Ctx, Prev > &  ec  )

constexprnoexcept

Definition at line 75 of file member_receiver.hpp.

resolve_member_receiver() [3/3]

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

constexpr auto yorch::detail::resolve_member_receiver ( Spec &  spec, exec_context< Ctx, Prev > &  ec  )

constexprnoexcept

Definition at line 101 of file member_receiver.hpp.

retry_exhausted_as_failure()

template<typename Raw >

constexpr auto yorch::detail::retry_exhausted_as_failure ( const Raw &  raw )

constexprnoexcept

Definition at line 89 of file result_helpers.hpp.

run_children() [1/2]

template<std::size_t I, std::size_t Ord = 0, typename Plan , typename Slots >

constexpr step_result yorch::detail::run_children ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Definition at line 84 of file serial_dfs.hpp.

run_children() [2/2]

template<std::size_t I, std::size_t Ord = 0, typename Plan , typename Slots , typename Ctx >

constexpr step_result yorch::detail::run_children ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout, Ctx &  ctx  )

constexpr

Definition at line 117 of file serial_dfs.hpp.

run_explicit_heap_stack() [1/2]

template<typename Plan , typename Slots >

constexpr step_result yorch::detail::run_explicit_heap_stack ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Definition at line 322 of file serial_dfs_explicit_heap_stack.hpp.

run_explicit_heap_stack() [2/2]

template<typename Plan , typename Slots , typename Ctx >

constexpr step_result yorch::detail::run_explicit_heap_stack ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout, Ctx &  ctx  )

constexpr

Definition at line 343 of file serial_dfs_explicit_heap_stack.hpp.

run_explicit_heap_stack_loop()

template<typename Plan , typename EnterInvoker , typename DestroyInvoker , typename PrepareFanoutInvoker , typename DestroyFanoutInvoker >

constexpr step_result yorch::detail::run_explicit_heap_stack_loop ( const auto &  requires_fanout_staging_by_index, EnterInvoker  enter_node_by_index, DestroyInvoker  destroy_node_payload_by_index, PrepareFanoutInvoker  prepare_fanout_by_index, DestroyFanoutInvoker  destroy_fanout_by_index  )

constexpr

Executes serial DFS using a heap-backed explicit stack.

The loop itself only knows runtime node indices stored in frames, so all type-specific work is delegated to the enter/destroy dispatch callables. Together they form the bridge between:

• runtime traversal state: frame.node_index
• compile-time node logic: enter_node<I>(...) and slots.destroy<I>()

Definition at line 166 of file serial_dfs_explicit_heap_stack.hpp.

run_node() [1/2]

template<std::size_t I, typename Plan , typename Slots >

constexpr step_result yorch::detail::run_node ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout  )

constexpr

Definition at line 45 of file serial_dfs.hpp.

run_node() [2/2]

template<std::size_t I, typename Plan , typename Slots , typename Ctx >

constexpr step_result yorch::detail::run_node ( Plan &  plan, Slots &  slots, plan_fanout_state< Plan > &  fanout, Ctx &  ctx  )

constexpr

Definition at line 64 of file serial_dfs.hpp.

store_node_output()

template<std::size_t I, typename Slots , typename Raw >

constexpr bool yorch::detail::store_node_output ( Slots &  slots, Raw &  raw  )

constexpr

Materializes the payload portion of a node's raw task return into the node's compiled slot, when that return category actually carries a value.

This helper is the value-storage counterpart to extract_step_result(...). The executor first derives control-flow status from the raw return, then uses this function to decide whether the current node produced a payload that should remain alive for its subtree and therefore be written into slot I.

The storage rules are:

• void and step_result do not carry a payload, so no slot write happens
• plain T writes that returned value directly into slot I
• task_result<T> writes only the wrapped value and only when the step status is success; non-success task_result<T> values leave the slot empty

Payloads are moved into the slot because the slot becomes the owning storage for the remainder of the node's subtree traversal.

Template Parameters

I	Node index whose slot should receive the payload.
Slots	Concrete plan_exec_slots<...>-like storage type.
Raw	Raw return object type produced by invoke_raw(...).

Parameters

slots	Plan slot storage used by the current DFS execution.
raw	Raw task return object to inspect and, when applicable, move from.

Definition at line 69 of file result.hpp.

summarize_prev_access_spec()

template<typename Spec >

consteval prev_access_summary yorch::detail::summarize_prev_access_spec

(

)

Definition at line 37 of file prev_access_task_traits.hpp.

summarize_task_binding_impl()

template<typename View , std::size_t... I>

consteval prev_access_summary yorch::detail::summarize_task_binding_impl

(

std::index_sequence< I... >

)

Definition at line 174 of file prev_access_task_traits.hpp.

task_binding_prev_access_bindings_valid_impl()

template<typename View , std::size_t... I>

consteval bool yorch::detail::task_binding_prev_access_bindings_valid_impl

(

std::index_sequence< I... >

)

Definition at line 150 of file prev_access_task_traits.hpp.

validate_bind()

template<typename F , typename... Specs>

consteval bind_error yorch::detail::validate_bind

(

)

Definition at line 45 of file validate.hpp.

validate_bind_forward_prev()

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

consteval bind_forward_prev_error yorch::detail::validate_bind_forward_prev

(

)

Definition at line 123 of file forward_prev.hpp.

validate_bind_forward_prev_member()

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

consteval bind_forward_prev_member_error yorch::detail::validate_bind_forward_prev_member

(

)

Definition at line 191 of file forward_prev.hpp.

validate_bind_into()

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

consteval bind_into_error yorch::detail::validate_bind_into

(

)

Definition at line 81 of file validate.hpp.

validate_bind_into_member()

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

consteval bind_into_member_error yorch::detail::validate_bind_into_member

(

)

Definition at line 172 of file validate.hpp.

validate_bind_member()

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

consteval bind_member_error yorch::detail::validate_bind_member

(

)

Definition at line 135 of file validate.hpp.

validate_plan()

template<typename Plan >

consteval plan_validation_error yorch::detail::validate_plan

(

)

Definition at line 128 of file plan_validation.hpp.

validate_plan_impl()

template<typename Plan , std::size_t... I>
requires (plan_validatable_node<Plan, I> && ...)

consteval plan_validation_error yorch::detail::validate_plan_impl

(

std::index_sequence< I... >

)

Definition at line 103 of file plan_validation.hpp.

void_task_success_result()

template<typename PolicyResult >

constexpr auto yorch::detail::void_task_success_result ( )

constexprnoexcept

Produces the success-path raw result for a wrapped void task when a custom fallback policy is installed.

The policy decides the exception-path step_result, so successful void execution must mirror that same raw result shape.

Template Parameters

PolicyResult

Raw result type returned by the policy.

Returns

Success result matching PolicyResult.

Definition at line 63 of file result_helpers.hpp.

Variable Documentation

always_false_v

template<typename >

constexpr bool yorch::detail::always_false_v = false

inlineconstexpr

Definition at line 11 of file resolve.hpp.

append_level_valid_v

template<std::size_t Level, typename... Nodes>

constexpr bool yorch::detail::append_level_valid_v

inlineconstexpr

Initial value:

= [] {
    if constexpr (sizeof...(Nodes) == 0) {
        return Level == 0;
    } else {
        constexpr auto prev_level = last_node_t<Nodes...>::level;
        return Level != 0 && Level <= prev_level + 1;
    }
}()

Definition at line 45 of file metadata.hpp.

bind_forward_prev_bindings_supported_v

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

constexpr bool yorch::detail::bind_forward_prev_bindings_supported_v

inlineconstexpr

Initial value:

=
    forward_prev_bindings_supported_impl<T, F, Specs...>(
        std::index_sequence_for<Specs...> {})

Definition at line 89 of file forward_prev.hpp.

bind_forward_prev_member_bindings_supported_v

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

constexpr bool yorch::detail::bind_forward_prev_member_bindings_supported_v

inlineconstexpr

Initial value:

=
    forward_prev_member_bindings_supported_impl<T, F, ReceiverSpec, Specs...>(
        std::index_sequence_for<Specs...> {})

Definition at line 118 of file forward_prev.hpp.

bind_forward_prev_member_payload_matches_v

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

constexpr bool yorch::detail::bind_forward_prev_member_payload_matches_v

inlineconstexpr

Initial value:

=
    std::is_same_v<T, forward_prev_unique_prev_payload_t<ReceiverSpec, Specs...>>

Definition at line 114 of file forward_prev.hpp.

bind_forward_prev_payload_matches_v

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

constexpr bool yorch::detail::bind_forward_prev_payload_matches_v

inlineconstexpr

Initial value:

=
    std::is_same_v<T, forward_prev_unique_prev_payload_t<Specs...>>

Definition at line 85 of file forward_prev.hpp.

bind_from_lvalue_nothrow_v

template<typename Arg , typename Source >

constexpr bool yorch::detail::bind_from_lvalue_nothrow_v

inlineconstexpr

Initial value:

=
    supports_bind_from_lvalue_v<Arg, Source> &&
    (
        std::is_reference_v<Arg> ||
        std::is_nothrow_constructible_v<std::remove_cvref_t<Arg>, Source&>
    )

Definition at line 22 of file resolve.hpp.

bind_tasks_always_false_v

template<typename >

constexpr bool yorch::detail::bind_tasks_always_false_v = false

inlineconstexpr

Definition at line 8 of file common.hpp.

canonical_output_owner_node_v

template<typename Plan , std::size_t I>

constexpr std::size_t yorch::detail::canonical_output_owner_node_v

inlineconstexpr

Initial value:

=
    canonical_output_owner_node_impl<Plan, I>::value

Definition at line 47 of file plan_exec_slots.hpp.

catch_policy_supported_v

template<typename R , typename Policy >

constexpr bool yorch::detail::catch_policy_supported_v

inlineconstexpr

Initial value:

=
    catch_policy_supported<R, Policy>::value

Definition at line 177 of file traits.hpp.

compiled_child_layout_v

template<typename... Nodes>

constexpr auto yorch::detail::compiled_child_layout_v

inlineconstexpr

Initial value:

=
    make_child_layout(compiled_parent_indices_v<Nodes...>)

Definition at line 137 of file layout.hpp.

compiled_levels_v

template<typename... Nodes>

constexpr auto yorch::detail::compiled_levels_v = make_level_array<Nodes...>()

inlineconstexpr

Definition at line 130 of file layout.hpp.

compiled_parent_indices_v

template<typename... Nodes>

constexpr auto yorch::detail::compiled_parent_indices_v

inlineconstexpr

Initial value:

=
    make_parent_index_array(compiled_levels_v<Nodes...>)

Definition at line 133 of file layout.hpp.

compiled_slot_indices_v

template<typename... Nodes>

constexpr auto yorch::detail::compiled_slot_indices_v

inlineconstexpr

Initial value:

=
    make_slot_index_array<sizeof...(Nodes)>()

Definition at line 141 of file layout.hpp.

consume_bind_nothrow_v

template<typename Arg , typename T >

constexpr bool yorch::detail::consume_bind_nothrow_v

inlineconstexpr

Initial value:

=
    std::is_same_v<Arg, std::remove_cvref_t<T>&&> ||
    std::is_nothrow_constructible_v<std::remove_cvref_t<Arg>, std::remove_cvref_t<T>&&>

Definition at line 73 of file resolve.hpp.

ctx_get_nothrow_v

template<typename Ctx , typename T >

constexpr bool yorch::detail::ctx_get_nothrow_v

inlineconstexpr

Initial value:

=
    noexcept(std::declval<Ctx&>().template get<from_ctx_source_t<T>>())

Definition at line 45 of file resolve.hpp.

declared_task_raw_result_matches_invoke_raw_v

template<typename Task , typename Ctx , typename Prev >

constexpr bool yorch::detail::declared_task_raw_result_matches_invoke_raw_v

inlineconstexpr

Initial value:

=
    declared_task_raw_result_matches_invoke_raw<Task, Ctx, Prev>::value

Definition at line 103 of file traits.hpp.

default_catch_supported_v

template<typename R >

constexpr bool yorch::detail::default_catch_supported_v

inlineconstexpr

Initial value:

=
    std::is_void_v<R> ||
    std::is_same_v<R, step_result>

Reports whether the default catch_as_failure(task) adapter can synthesize a failure result for raw return type R.

The no-policy overload intentionally stays conservative: it only supports return categories where the library can manufacture a failure result without inventing a payload object.

Template Parameters

R	Raw task return type.

Definition at line 29 of file traits.hpp.

direct_out_arg_v

template<typename T >

constexpr bool yorch::detail::direct_out_arg_v

inlineconstexpr

Initial value:

=
    direct_out_arg<std::remove_cvref_t<T>>::value

Definition at line 166 of file traits.hpp.

forward_prev_member_receiver_binding_supported_v

template<typename T , typename F , typename ReceiverSpec >

constexpr bool yorch::detail::forward_prev_member_receiver_binding_supported_v

inlineconstexpr

Initial value:

=
    (!is_prev_access_spec_v<std::remove_cvref_t<ReceiverSpec>>) ||
    (is_borrow_prev_mut_spec_v<std::remove_cvref_t<ReceiverSpec>> &&
     std::is_same_v<
         typename normalized_prev_access_spec_traits<std::remove_cvref_t<ReceiverSpec>>::payload_type,
         T> &&
     member_receiver_prev_access_valid_v<std::remove_cvref_t<ReceiverSpec>, F>)

Definition at line 94 of file forward_prev.hpp.

forward_prev_prev_access_count_v

template<typename... Specs>

constexpr std::size_t yorch::detail::forward_prev_prev_access_count_v

inlineconstexpr

Initial value:

=
    (0U + ... + (is_prev_access_spec_v<std::remove_cvref_t<Specs>> ? 1U : 0U))

Definition at line 15 of file forward_prev.hpp.

forward_prev_spec_matches_binding_v

template<typename T , typename Arg , typename Spec >

constexpr bool yorch::detail::forward_prev_spec_matches_binding_v

inlineconstexpr

Initial value:

=
    (is_borrow_prev_mut_spec_v<Spec> &&
     std::is_same_v<typename normalized_prev_access_spec_traits<Spec>::payload_type, T> &&
     std::is_same_v<Arg, T&>)

Definition at line 69 of file forward_prev.hpp.

has_declared_task_output_v

template<typename Task >

constexpr bool yorch::detail::has_declared_task_output_v

inlineconstexpr

Initial value:

=
    has_declared_task_output<Task>::value

Definition at line 53 of file traits.hpp.

is_adapter_chain_v

template<typename T >

constexpr bool yorch::detail::is_adapter_chain_v

inlineconstexpr

Initial value:

=
    is_adapter_chain<std::remove_cvref_t<T>>::value

Definition at line 77 of file adapters.hpp.

is_adapter_descriptor_v

template<typename Desc >

constexpr bool yorch::detail::is_adapter_descriptor_v

inlineconstexpr

Initial value:

=
    is_adapter_descriptor<std::remove_cvref_t<Desc>>::value

Definition at line 63 of file adapters.hpp.

is_borrow_prev_mut_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_borrow_prev_mut_spec_v

inlineconstexpr

Initial value:

=
    is_borrow_prev_mut_spec<Spec>::value

Definition at line 128 of file prev_access_specs.hpp.

is_borrow_prev_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_borrow_prev_spec_v

inlineconstexpr

Initial value:

=
    is_borrow_prev_spec<Spec>::value

Definition at line 118 of file prev_access_specs.hpp.

is_consume_prev_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_consume_prev_spec_v

inlineconstexpr

Initial value:

=
    is_consume_prev_spec<Spec>::value

Definition at line 148 of file prev_access_specs.hpp.

is_copy_prev_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_copy_prev_spec_v

inlineconstexpr

Initial value:

=
    is_copy_prev_spec<Spec>::value

Definition at line 138 of file prev_access_specs.hpp.

is_exclusive_prev_access_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_exclusive_prev_access_spec_v

inlineconstexpr

Initial value:

=
    normalized_prev_access_spec_traits<Spec>::is_exclusive

Definition at line 156 of file prev_access_specs.hpp.

is_member_function_pointer_callable_v

template<typename T >

constexpr bool yorch::detail::is_member_function_pointer_callable_v

inlineconstexpr

Initial value:

=
    is_member_function_pointer_callable<T>::value

Definition at line 79 of file traits.hpp.

is_prev_access_spec_v

template<typename Spec >

constexpr bool yorch::detail::is_prev_access_spec_v

inlineconstexpr

Initial value:

=
    normalized_prev_access_spec_traits<Spec>::is_prev_access

Definition at line 152 of file prev_access_specs.hpp.

last_arg_index_v

template<typename F >

constexpr std::size_t yorch::detail::last_arg_index_v

inlineconstexpr

Initial value:

=
    function_traits<std::remove_cvref_t<F>>::arity - 1

Definition at line 144 of file traits.hpp.

max_level_v

template<typename... Nodes>

constexpr std::size_t yorch::detail::max_level_v = max_level<Nodes...>::value

inlineconstexpr

Definition at line 42 of file metadata.hpp.

member_last_arg_index_v

template<typename F >

constexpr std::size_t yorch::detail::member_last_arg_index_v

inlineconstexpr

Initial value:

=
    member_function_traits<std::remove_cvref_t<F>>::arity - 1

Definition at line 152 of file traits.hpp.

member_receiver_is_const_v

template<typename F >

constexpr bool yorch::detail::member_receiver_is_const_v

inlineconstexpr

Initial value:

=
    std::is_const_v<std::remove_reference_t<member_receiver_arg_t<F>>>

Definition at line 19 of file prev_access_specs.hpp.

member_receiver_prev_access_valid_v

template<typename Spec , typename F >

constexpr bool yorch::detail::member_receiver_prev_access_valid_v

inlineconstexpr

Initial value:

=
    member_receiver_prev_access_valid<Spec, F>::value

Definition at line 175 of file prev_access_specs.hpp.

no_physical_slot

constexpr std::size_t yorch::detail::no_physical_slot = std::numeric_limits<std::size_t>::max()

inlineconstexpr

Sentinel physical slot index meaning "this node has no storage".

Layouts assign real physical slot indices only to payload-producing nodes. Nodes with void output keep this value instead, and compact slot storage also reuses it to mark that no node currently owns an erased slot.

Definition at line 59 of file policy.hpp.

no_prev_always_false_v

template<typename >

constexpr bool yorch::detail::no_prev_always_false_v = false

inlineconstexpr

Definition at line 17 of file context.hpp.

node_uses_consume_only_prev_access_v

template<typename Plan , std::size_t Child>

constexpr bool yorch::detail::node_uses_consume_only_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_consume_only_prev_access_v<typename Plan::template task_type<Child>>

Definition at line 44 of file fanout.hpp.

node_uses_copy_only_prev_access_v

template<typename Plan , std::size_t Child>

constexpr bool yorch::detail::node_uses_copy_only_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_copy_only_prev_access_v<typename Plan::template task_type<Child>>

Definition at line 39 of file fanout.hpp.

node_uses_staged_copy_prev_v

template<typename Plan , std::size_t Child>

constexpr bool yorch::detail::node_uses_staged_copy_prev_v

inlineconstexpr

Initial value:

= [] {
    if constexpr (Plan::template parent_index<Child> == Plan::no_parent) {
        return false;
    } else {
        return parent_requires_fanout_staging_v<Plan, Plan::template parent_index<Child>> &&
               node_uses_copy_only_prev_access_v<Plan, Child>;
    }
}()

Definition at line 144 of file fanout.hpp.

parent_has_staged_copy_children_v

template<typename Plan , std::size_t Parent>

constexpr bool yorch::detail::parent_has_staged_copy_children_v

inlineconstexpr

Initial value:

=
    parent_requires_fanout_staging_v<Plan, Parent>

Definition at line 139 of file fanout.hpp.

parent_requires_fanout_staging_v

template<typename Plan , std::size_t Parent>

constexpr bool yorch::detail::parent_requires_fanout_staging_v

inlineconstexpr

Initial value:

=
    std::is_same_v<typename Plan::template fanout_policy_type<Parent>,
                   yorch::fanout_consume_with_copies_policy> &&
    (parent_consume_only_prev_child_count_impl<Plan, Parent>(
         std::make_index_sequence<Plan::template child_count<Parent>> {}) == 1) &&
    (parent_copy_only_prev_child_count_impl<Plan, Parent>(
         std::make_index_sequence<Plan::template child_count<Parent>> {}) != 0)

Definition at line 129 of file fanout.hpp.

payload_node_array_v

template<typename Plan >

constexpr auto yorch::detail::payload_node_array_v

inlineconstexpr

Initial value:

=
    make_payload_node_array<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 46 of file layout.hpp.

payload_node_count_v

template<typename Plan >

constexpr std::size_t yorch::detail::payload_node_count_v

inlineconstexpr

Initial value:

= [] {
    std::size_t count = 0;
    for (const bool payload : payload_node_array_v<Plan>) {
        if (payload) {
            ++count;
        }
    }
    return count;
}()

Definition at line 54 of file layout.hpp.

plan_fanout_policy_valid_v

template<typename Plan >

constexpr bool yorch::detail::plan_fanout_policy_valid_v

inlineconstexpr

Initial value:

=
    plan_fanout_policy_valid_impl<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 124 of file fanout.hpp.

plan_forward_prev_source_valid_v

template<typename Plan >

constexpr bool yorch::detail::plan_forward_prev_source_valid_v

inlineconstexpr

Initial value:

=
    plan_forward_prev_source_valid_impl<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 107 of file prev_access_plan_validation.hpp.

plan_prev_access_valid_v

template<typename Plan >

constexpr bool yorch::detail::plan_prev_access_valid_v

inlineconstexpr

Initial value:

=
    plan_prev_access_valid_impl<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 103 of file prev_access_plan_validation.hpp.

plan_prev_source_valid_v

template<typename Plan >

constexpr bool yorch::detail::plan_prev_source_valid_v

inlineconstexpr

Initial value:

=
    plan_prev_source_valid_impl<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 99 of file prev_access_plan_validation.hpp.

plan_valid_v

template<typename Plan >

constexpr bool yorch::detail::plan_valid_v

inlineconstexpr

Initial value:

=
    plan_validation_error_v<Plan> == plan_validation_error::ok

Definition at line 163 of file plan_validation.hpp.

plan_validation_always_false_v

template<typename >

constexpr bool yorch::detail::plan_validation_always_false_v = false

inlineconstexpr

Definition at line 13 of file plan_validation.hpp.

plan_validation_error_v

template<typename Plan >

constexpr plan_validation_error yorch::detail::plan_validation_error_v

inlineconstexpr

Initial value:

=
    validate_plan_impl<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 124 of file plan_validation.hpp.

prev_access_binding_valid_v

template<typename Spec , typename Arg >

constexpr bool yorch::detail::prev_access_binding_valid_v

inlineconstexpr

Initial value:

=
    prev_access_binding_valid<Spec, Arg>::value

Definition at line 165 of file prev_access_specs.hpp.

prev_get_source_nothrow_v

template<typename Prev , typename Source >

constexpr bool yorch::detail::prev_get_source_nothrow_v

inlineconstexpr

Initial value:

=
    noexcept(std::declval<Prev&>().template get<Source>())

Definition at line 49 of file resolve.hpp.

resolve_borrow_prev_mut_nothrow_v

template<typename Arg , typename T , typename Prev >

constexpr bool yorch::detail::resolve_borrow_prev_mut_nothrow_v

inlineconstexpr

Initial value:

=
    prev_get_source_nothrow_v<Prev, borrow_prev_mut_source_t<T>>

Definition at line 62 of file resolve.hpp.

resolve_borrow_prev_nothrow_v

template<typename Arg , typename T , typename Prev >

constexpr bool yorch::detail::resolve_borrow_prev_nothrow_v

inlineconstexpr

Initial value:

=
    prev_get_source_nothrow_v<Prev, borrow_prev_source_t<T>>

Definition at line 58 of file resolve.hpp.

resolve_const_value_nothrow_v

template<typename Arg , typename T >

constexpr bool yorch::detail::resolve_const_value_nothrow_v

inlineconstexpr

Initial value:

=
    std::is_reference_v<Arg> ||
    std::is_nothrow_constructible_v<std::remove_cvref_t<Arg>, const T&>

Definition at line 88 of file resolve.hpp.

resolve_consume_prev_nothrow_v

template<typename Arg , typename T , typename Prev >

constexpr bool yorch::detail::resolve_consume_prev_nothrow_v

inlineconstexpr

Initial value:

=
    prev_get_source_nothrow_v<Prev, consume_prev_source_t<T>> &&
    consume_bind_nothrow_v<Arg, consume_prev_source_t<T>>

Definition at line 78 of file resolve.hpp.

resolve_copy_prev_nothrow_v

template<typename T , typename Prev >

constexpr bool yorch::detail::resolve_copy_prev_nothrow_v

inlineconstexpr

Initial value:

=
    prev_get_source_nothrow_v<Prev, copy_prev_source_t<T>> &&
    std::is_nothrow_constructible_v<
        std::remove_cvref_t<copy_prev_source_t<T>>,
        const std::remove_cvref_t<copy_prev_source_t<T>>&>

Definition at line 66 of file resolve.hpp.

resolve_from_ctx_nothrow_v

template<typename Arg , typename T , typename Ctx >

constexpr bool yorch::detail::resolve_from_ctx_nothrow_v

inlineconstexpr

Initial value:

=
    ctx_get_nothrow_v<Ctx, T> &&
    bind_from_lvalue_nothrow_v<Arg, from_ctx_source_t<T>>

Definition at line 53 of file resolve.hpp.

resolve_value_nothrow_v

template<typename Arg , typename T >

constexpr bool yorch::detail::resolve_value_nothrow_v

inlineconstexpr

Initial value:

=
    std::is_reference_v<Arg> ||
    std::is_nothrow_constructible_v<std::remove_cvref_t<Arg>, T&>

Definition at line 83 of file resolve.hpp.

retry_status_capable_result_v

template<typename R >

constexpr bool yorch::detail::retry_status_capable_result_v

inlineconstexpr

Initial value:

=
    std::is_same_v<std::remove_cvref_t<R>, step_result> ||
    is_task_result_v<std::remove_cvref_t<R>>

Definition at line 84 of file result_helpers.hpp.

slot_logical_policy_array_v

template<typename Plan >

constexpr auto yorch::detail::slot_logical_policy_array_v

inlineconstexpr

Initial value:

=
    make_slot_logical_policy_array<Plan>(std::make_index_sequence<Plan::node_count> {})

Definition at line 50 of file layout.hpp.

supports_bind_from_lvalue_v

template<typename Arg , typename Source >

constexpr bool yorch::detail::supports_bind_from_lvalue_v

inlineconstexpr

Initial value:

=
    !std::is_rvalue_reference_v<Arg> &&
    (
        std::is_reference_v<Arg> ||
        std::is_constructible_v<std::remove_cvref_t<Arg>, Source&>
    )

Definition at line 14 of file resolve.hpp.

task_output_storage_mode_v

template<typename Task >

constexpr detail::output_storage_mode yorch::detail::task_output_storage_mode_v

inlineconstexpr

Initial value:

=
    task_output_storage_mode<Task>::value

Definition at line 153 of file traits.hpp.

task_prev_access_valid_v

template<typename Task >

constexpr bool yorch::detail::task_prev_access_valid_v

inlineconstexpr

Initial value:

=
    task_prev_access_valid<Task>::value

Definition at line 306 of file prev_access_task_traits.hpp.

task_slot_logical_policy_v

template<typename Task >

constexpr slot_logical_policy yorch::detail::task_slot_logical_policy_v

inlineconstexpr

Initial value:

=
    task_slot_logical_policy<Task>::value

Definition at line 193 of file traits.hpp.

task_uses_borrow_prev_mut_v

template<typename Task >

constexpr bool yorch::detail::task_uses_borrow_prev_mut_v

inlineconstexpr

Initial value:

=
    task_uses_borrow_prev_mut<Task>::value

Definition at line 326 of file prev_access_task_traits.hpp.

task_uses_borrow_prev_v

template<typename Task >

constexpr bool yorch::detail::task_uses_borrow_prev_v

inlineconstexpr

Initial value:

=
    task_uses_borrow_prev<Task>::value

Definition at line 322 of file prev_access_task_traits.hpp.

task_uses_consume_only_prev_access_v

template<typename Task >

constexpr bool yorch::detail::task_uses_consume_only_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_consume_prev_v<Task>

Definition at line 23 of file fanout.hpp.

task_uses_consume_prev_v

template<typename Task >

constexpr bool yorch::detail::task_uses_consume_prev_v

inlineconstexpr

Initial value:

=
    task_uses_consume_prev<Task>::value

Definition at line 318 of file prev_access_task_traits.hpp.

task_uses_copy_only_prev_access_v

template<typename Task >

constexpr bool yorch::detail::task_uses_copy_only_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_copy_prev_v<Task> &&
    !task_uses_borrow_prev_v<Task> &&
    !task_uses_borrow_prev_mut_v<Task> &&
    !task_uses_consume_prev_v<Task>

Definition at line 16 of file fanout.hpp.

task_uses_copy_prev_v

template<typename Task >

constexpr bool yorch::detail::task_uses_copy_prev_v

inlineconstexpr

Initial value:

=
    task_uses_copy_prev<Task>::value

Definition at line 330 of file prev_access_task_traits.hpp.

task_uses_direct_output_protocol_v

template<typename Task >

constexpr bool yorch::detail::task_uses_direct_output_protocol_v

inlineconstexpr

Initial value:

=
    std::is_same_v<
        declared_task_output_protocol_t<Task>,
        direct_output_protocol_tag>

Definition at line 74 of file traits.hpp.

task_uses_exclusive_prev_access_v

template<typename Task >

constexpr bool yorch::detail::task_uses_exclusive_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_exclusive_prev_access<Task>::value

Definition at line 314 of file prev_access_task_traits.hpp.

task_uses_forward_prev_output_protocol_v

template<typename Task >

constexpr bool yorch::detail::task_uses_forward_prev_output_protocol_v

inlineconstexpr

Initial value:

=
    std::is_same_v<
        declared_task_output_protocol_t<Task>,
        forward_prev_output_protocol_tag>

Definition at line 80 of file traits.hpp.

task_uses_prev_access_v

template<typename Task >

constexpr bool yorch::detail::task_uses_prev_access_v

inlineconstexpr

Initial value:

=
    task_uses_prev_access<Task>::value

Definition at line 310 of file prev_access_task_traits.hpp.

type_count_v

template<typename T , typename... Ts>

constexpr std::size_t yorch::detail::type_count_v = (std::size_t{0} + ... + (std::is_same_v<T, Ts> ? 1 : 0))

inlineconstexpr

Definition at line 11 of file context.hpp.

unique_types_v

template<typename... Ts>

constexpr bool yorch::detail::unique_types_v = ((type_count_v<Ts, Ts...> == 1) && ...)

inlineconstexpr

Definition at line 14 of file context.hpp.