Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub spec_name: String,
    pub commentary: Option<String>,
    pub data: IndexMap<DataPath, DataDefinition>,
    pub rules: Vec<ExecutableRule>,
    pub reference_evaluation_order: Vec<DataPath>,
    pub meta: HashMap<String, MetaValue>,
    pub resolved_types: ResolvedSpecTypes,
    pub signature_index: HashMap<Vec<(String, i32)>, (String, Arc<LemmaType>)>,
    pub effective: EffectiveDate,
    pub sources: Vec<SpecSource>,
}

A complete execution plan ready for the evaluator

Contains the topologically sorted list of rules to execute, along with all data. Self-contained structure - no spec lookups required during evaluation.

Fields

spec_name: String

Main spec name

commentary: Option<String>

Optional commentary from the """...""" block in the spec source.

data: IndexMap<DataPath, DataDefinition>

Per-data data in definition order: value, type-only, or spec reference.

rules: Vec<ExecutableRule>

Rules to execute in topological order (sorted by dependencies)

reference_evaluation_order: Vec<DataPath>

Order in which DataDefinition::Reference entries must be resolved at evaluation time so that chained references (reference → reference → data) copy values in the correct sequence. Empty when the plan has no references.

meta: HashMap<String, MetaValue>

Spec metadata

resolved_types: ResolvedSpecTypes

Main-spec types from planning. [ResolvedSpecTypes::unit_index] is expression-scope units (local types plus direct uses imports). Rule-result units live on each [ExecutableRule::rule_type], not in this index.

signature_index: HashMap<Vec<(String, i32)>, (String, Arc<LemmaType>)>

Reverse index: canonical-form unit signature Vec<(unit_name, exponent)> → (unit_name, owning type). Built from expression-scope units during planning so cross-type Multiply/Divide arithmetic can deterministically resolve a combined signature back to a single named unit. Ambiguous signatures (the same key matched by units in two distinct types) are rejected at planning time.

effective: EffectiveDate

sources: Vec<SpecSource>

Canonical source for all specs in this plan (one entry per spec, includes repository). Reconstructed from AST — not raw file content.

Implementations

impl ExecutionPlan

pub fn schema(&self) -> SpecSchema

Build a SpecSchema describing this plan’s public IO contract.

Only data transitively reachable from at least one local rule (via needs_data) are included. Spec-reference data (which have no schema type) are also excluded. Only local rules (no cross-spec segments) are included. Data and rules are sorted by source position (definition order).

pub fn interface_schema(&self) -> SpecSchema

Every typed data input and local rule — the full spec surface.

pub fn schema_for_rules( &self, rule_names: &[String], ) -> Result<SpecSchema, Error>

Build a SpecSchema scoped to specific rules.

The returned schema contains only the data needed by the given rules (transitively, via needs_data) and only those rules. This is the “what do I need to evaluate these rules?” view. Data are sorted by source position (definition order).

Returns Err if any rule name is not found in the plan.

pub fn get_data_path_by_str(&self, name: &str) -> Option<&DataPath>

Look up a data by its input key (e.g., “age” or “rules.base_price”).

pub fn get_rule(&self, name: &str) -> Option<&ExecutableRule>

Look up a local rule by its name (rule in the main spec).

pub fn get_rule_by_path(&self, rule_path: &RulePath) -> Option<&ExecutableRule>

Look up a rule by its full path.

pub fn get_data_value(&self, path: &DataPath) -> Option<&LiteralValue>

Get the literal value for a data path, if it exists and has a literal value.

pub fn set_data_values( self, values: HashMap<String, DataValueInput>, limits: &ResourceLimits, ) -> Result<Self, Error>

Provide typed data values from a client.

Parses each value to its expected type, validates constraints, and applies to the plan.

pub fn with_defaults(self) -> Self

Promote declared defaults on type declarations into concrete DataDefinition::Value entries. Call BEFORE Self::set_data_values so user-provided values override defaults. Reference resolution is handled by the evaluator at runtime.

Trait Implementations

impl Clone for ExecutionPlan

fn clone(&self) -> ExecutionPlan

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExecutionPlan

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&ExecutionPlan> for ExecutionPlanSerialized

fn from(plan: &ExecutionPlan) -> Self

Converts to this type from the input type.

impl TryFrom<ExecutionPlanSerialized> for ExecutionPlan

type Error = Error

The type returned in the event of a conversion error.

fn try_from(serialized: ExecutionPlanSerialized) -> Result<Self, Self::Error>

Performs the conversion.