Struct Engine 

pub struct Engine { /* private fields */ }

Engine for evaluating Lemma rules.

Pure Rust implementation that evaluates Lemma specs directly from the AST. Uses pre-built execution plans that are self-contained and ready for evaluation.

The engine never performs network calls. External @... references must be pre-resolved before loading — either by including dep files in the file map or by calling resolve_registry_references separately (e.g. in a lemma fetch command).

Implementations

impl Engine

pub fn new() -> Self

pub fn sources(&self) -> &HashMap<String, String>

Source code map (attribute -> content). Used for error display.

pub fn with_limits(limits: ResourceLimits) -> Self

Create an engine with custom resource limits.

pub fn load(&mut self, code: &str, source: SourceType<'_>) -> Result<(), Errors>

Load a single spec from source code. When source is SourceType::Dependency, content is treated as from a registry bundle (from_registry: true).

pub fn load_from_paths<P: AsRef<Path>>( &mut self, paths: &[P], from_registry: bool, ) -> Result<(), Errors>

Load .lemma files from paths (files and/or directories). Directories are expanded one level only (direct child .lemma files). Resource limits max_files, max_loaded_bytes, max_file_size_bytes are enforced in [add_files_inner].

Set from_registry to true for pre-fetched registry bundles (same rules as Context::insert_spec with from_registry). Not available on wasm32 (no filesystem).

pub fn get_spec( &self, spec_id: &str, effective: Option<&DateTimeValue>, ) -> Result<Arc<LemmaSpec>, Error>

Resolve spec_id (name or name~hash) and effective (or now if None) to the loaded spec.

pub fn get_plan_hash( &self, spec_id: &str, effective: &DateTimeValue, ) -> Result<Option<String>, Error>

Plan hash for a spec execution plan resolved by spec_id and effective datetime.

pub fn remove( &mut self, spec_id: &str, effective: Option<&DateTimeValue>, ) -> Result<(), Error>

Remove the temporal version resolved by spec_id (name or name~hash) and effective (or now if None).

pub fn list_specs(&self) -> Vec<Arc<LemmaSpec>>

All specs, all temporal versions, ordered by (name, effective_from).

pub fn list_specs_effective( &self, effective: &DateTimeValue, ) -> Vec<Arc<LemmaSpec>>

Specs active at effective (one per name).

pub fn schema( &self, spec: &str, effective: Option<&DateTimeValue>, ) -> Result<SpecSchema, Error>

Resolve spec identifier (name or name~hash) and return the spec schema. Uses effective or now when None.

pub fn get_plan( &self, spec_id: &str, effective: Option<&DateTimeValue>, ) -> Result<&ExecutionPlan, Error>

Resolve spec identifier and return the execution plan. Uses effective or now when None.

With pin (name~hash): resolves spec by (name, hash) from the plan hash registry. If effective is given, verifies it falls within the pinned slice’s [valid_from, valid_to). Without pin: resolves by (name, effective) temporal slice.

pub fn run_plan( &self, plan: &ExecutionPlan, effective: &DateTimeValue, fact_values: HashMap<String, String>, record_operations: bool, ) -> Result<Response, Error>

Run a plan from [get_plan]: apply fact values and evaluate all rules.

When record_operations is true, each rule’s [RuleResult::operations] will contain a trace of facts used, rules used, computations, and branch evaluations.

pub fn run( &self, spec_id: &str, effective: Option<&DateTimeValue>, fact_values: HashMap<String, String>, record_operations: bool, ) -> Result<Response, Error>

Run a spec: resolve by spec id, then [run_plan]. Returns all rules; filter via Response::filter_rules if needed.

When record_operations is true, each rule’s [RuleResult::operations] will contain a trace of facts used, rules used, computations, and branch evaluations.

pub fn invert( &self, spec_name: &str, effective: &DateTimeValue, rule_name: &str, target: Target, values: HashMap<String, String>, ) -> Result<InversionResponse, Error>

Invert a rule to find input domains that produce a desired outcome.

Values are provided as name -> value string pairs (e.g., “quantity” -> “5”). They are automatically parsed to the expected type based on the spec schema.

Trait Implementations

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.