Struct ExecutionPlan 

pub struct ExecutionPlan {
    pub doc_name: String,
    pub fact_schema: HashMap<FactPath, LemmaType>,
    pub fact_values: HashMap<FactPath, LiteralValue>,
    pub doc_refs: HashMap<FactPath, String>,
    pub fact_sources: HashMap<FactPath, Source>,
    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

fact_schema: HashMap<FactPath, LemmaType>

Resolved schema types for value-holding facts.

This is the authoritative schema contract for adapters and validation.

fact_values: HashMap<FactPath, LiteralValue>

Concrete literal values for facts (document-defined literals + user-provided values).

doc_refs: HashMap<FactPath, String>

Document reference facts (path -> referenced document name).

fact_sources: HashMap<FactPath, Source>

Fact-level source information for better errors in adapters/validation.

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 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_values( self, values: HashMap<String, String>, limits: &ResourceLimits, ) -> Result<Self, LemmaError>

Provide string values for facts by parsing them to their expected types.

This is the main entry point for providing user-supplied string values. It parses each string value to the expected type, checks resource limits, and applies the values to the plan.

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

Provide pre-typed values for facts with resource limit checking.

Use this for programmatic APIs where values are already parsed.

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.