Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub doc_name: String,
    pub facts: HashMap<FactPath, FactData>,
    pub rules: Vec<ExecutableRule>,
    pub sources: HashMap<String, String>,
}

A complete execution plan ready for the evaluator

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

Fields

doc_name: String

Main document name

facts: HashMap<FactPath, FactData>

Per-fact data: value, type-only, or document reference (aligned with FactData).

rules: Vec<ExecutableRule>

Rules to execute in topological order (sorted by dependencies)

sources: HashMap<String, String>

Source code for error messages

Implementations

impl ExecutionPlan

pub fn schema(&self) -> DocumentSchema

Build a DocumentSchema summarising all of this plan’s facts and rules.

All facts with a typed schema (local and cross-document) are included. Document-reference facts (which have no schema type) are excluded. Only local rules (no cross-document segments) are included. Results are sorted alphabetically by name for deterministic output.

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

Build a DocumentSchema scoped to specific rules.

The returned schema contains only the facts needed by the given rules (transitively, via needs_facts) and only those rules. This is the “what do I need to evaluate these rules?” view.

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

pub fn get_fact_path_by_str(&self, name: &str) -> Option<&FactPath>

Look up a fact by its path string (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 document).

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

Look up a rule by its full path.

pub fn get_fact_value(&self, path: &FactPath) -> Option<&LiteralValue>

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

pub fn with_fact_values( self, values: HashMap<String, String>, limits: &ResourceLimits, ) -> Result<Self, LemmaError>

Provide string values for facts.

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

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<'de> Deserialize<'de> for ExecutionPlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ExecutionPlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.