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 dependency sources in the source map or by calling resolve_registry_references separately (e.g. in a lemma fetch command).

Implementations

impl Engine

pub fn new() -> Self

pub fn with_limits(limits: ResourceLimits) -> Self

pub fn load( &mut self, code: impl Into<String>, source: SourceType, ) -> Result<(), Errors>

Load one Lemma source (workspace; not a tagged dependency).

pub fn load_batch( &mut self, sources: HashMap<SourceType, String>, dependency: Option<&str>, ) -> Result<(), Errors>

Load many sources in one planning pass. Pairs are (source_text, source_id).

dependency: when Some, repositories parsed from these sources are tagged with that id (same as previous load(..., Some(id)) for path bundles).

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

Active LemmaSpec slice for name at the resolved effective instant.

When effective is None, uses the current time. The name must be unique across loaded repositories at that instant (same rule as Self::get_plan with repo: None). For repository scope or all temporal rows, use Self::get_workspace or Self::get_repository.

pub fn list(&self) -> Vec<ResolvedRepository>

Every loaded repository in insertion order (includes workspace and dependencies).

Each ResolvedRepository::repository and every LemmaSpec under ResolvedRepository::specs includes source metadata (start_line, source_type) from load.

pub fn get_workspace(&self) -> ResolvedRepository

Workspace-local repository (name == None).

pub fn get_repository( &self, qualifier: &str, ) -> Result<ResolvedRepository, Error>

Resolve a loaded repository by qualifier string. Matches against repository names (which include @ when present).

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

Planning schema for name. When repo is None, the spec must be unambiguous across all loaded repositories; when Some, scoped to that repository qualifier (e.g. "@org/pkg").

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

Evaluate a spec. When repo is None, the spec must be unambiguous across loaded repositories; when Some, scoped to that repository qualifier (e.g. "@org/pkg").

pub fn invert( &self, name: &str, effective: Option<&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.

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

Execution plan for name. When repo is None, the spec must be unambiguous across all loaded repositories; when Some, scoped to that repository qualifier (e.g. "@org/pkg").

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

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

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

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

Evaluate after [ExecutionPlan::set_data_values] without [ExecutionPlan::with_defaults]. Defaults stay suggestions; interactive and inversion use this path.

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

Trait Implementations

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.