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 specs(&self) -> &Context

pub fn specs_mut(&mut self) -> &mut Context

pub fn resolve_effective(raw: Option<&str>) -> Result<DateTimeValue, Error>

Resolve an optional effective datetime string for planning or evaluation.

None or whitespace-only input resolves to DateTimeValue::now. Non-empty invalid strings return a request Error.

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 (workspace, embedded stdlib EMBEDDED_STDLIB_REPOSITORY, dependencies).

Each ResolvedRepository::repository and every LemmaSpec under ResolvedRepository::specs includes source metadata (start_line, source_type) from load. Inspectable stdlib text: Self::format_repository with "lemma".

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 format_repository(&self, repository: &str) -> Result<String, Error>

Canonical Lemma source for every spec in repository, formatted from the in-engine AST.

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 limits(&self) -> &ResourceLimits

Return the resource limits configured for this engine.

Exposed so callers can pass the same limits to DataOverlay::resolve.

pub fn run( &self, repo: Option<&str>, spec: &str, effective: Option<&DateTimeValue>, data_values: HashMap<String, String>, explain: bool, rules: Option<&[String]>, ) -> 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").

When explain is true, each requested rule’s [RuleResult::explanation] contains a structural explanation tree; when false, explanations are omitted.

rules scopes which rule results appear in the response. None means all local rules. Some(&[]) is an error. When explain is true, all local rules (and nested uses rules needed for explanation resolution) are evaluated so explanation trees can embed dependency rules.

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, DataValueInput>, explain: bool, rules: Option<&[String]>, ) -> Result<Response, Error>

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

Spec-declared defaults (-> default ...) are applied by the evaluator when the caller does not supply a value for that data path.

rules: None evaluates all local rules in the response; Some(slice) evaluates only those names (Some(&[]) errors). Each name in Some must be a local rule.

When explain is false, only the VM scope runs (requested rules, or all local when None). When explain is true, all local and nested uses rules run so explanation trees have full rule_results, but only the response scope appears in response.results and receives attached explanations.

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.