Struct Engine 

pub struct Engine { /* private fields */ }

Engine for evaluating Lemma rules

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

Implementations

impl Engine

pub fn new() -> Self

pub fn with_limits(limits: ResourceLimits) -> Self

Create an engine with custom resource limits

pub fn add_lemma_code( &mut self, lemma_code: &str, source: &str, ) -> LemmaResult<()>

pub fn remove_document(&mut self, doc_name: &str)

pub fn list_documents(&self) -> Vec<String>

pub fn get_document(&self, doc_name: &str) -> Option<&LemmaDoc>

pub fn get_execution_plan(&self, doc_name: &str) -> Option<&ExecutionPlan>

Get the execution plan for a document.

The execution plan contains the resolved fact schema, default values, and topologically sorted rules ready for evaluation.

pub fn get_document_rules(&self, doc_name: &str) -> Vec<&LemmaRule>

pub fn get_facts( &self, doc_name: &str, rule_names: &[String], ) -> LemmaResult<HashMap<FactPath, LemmaType>>

Get the facts (with types) required to evaluate a document’s rules.

• If rule_names is empty, returns facts for all local rules in the document.
• Otherwise, returns facts for the specified rules (by name).

Returns a map from FactPath to resolved LemmaType. This is the authoritative API for determining what inputs a rule needs.

pub fn evaluate_json( &self, doc_name: &str, rule_names: Vec<String>, json: &[u8], ) -> LemmaResult<Response>

Evaluate rules in a document with JSON values for facts.

This is a convenience method that accepts JSON directly and converts it to typed values using the document’s fact type declarations.

If rule_names is empty, evaluates all rules. Otherwise, only returns results for the specified rules (dependencies still computed).

Values are provided as JSON bytes (e.g., b"{\"quantity\": 5, \"is_member\": true}"). They are automatically parsed to the expected type based on the document schema.

pub fn evaluate( &self, doc_name: &str, rule_names: Vec<String>, values: HashMap<String, String>, ) -> LemmaResult<Response>

Evaluate rules in a document with string values for facts.

This is the user-friendly API that accepts raw string values and parses them to the appropriate types based on the document’s fact type declarations. Use this for CLI, HTTP APIs, and other user-facing interfaces.

If rule_names is empty, evaluates all rules. Otherwise, only returns results for the specified rules (dependencies still computed).

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

pub fn invert_json( &self, doc_name: &str, rule_name: &str, target: Target, json: &[u8], ) -> LemmaResult<InversionResponse>

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

Values are provided as JSON bytes (e.g., b"{\"quantity\": 5, \"is_member\": true}"). They are automatically parsed to the expected type based on the document schema.

pub fn invert( &self, doc_name: &str, rule_name: &str, target: Target, values: HashMap<String, String>, ) -> LemmaResult<InversionResponse>

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 document schema.

Trait Implementations

impl Default for Engine

fn default() -> Self

Returns the “default value” for a type.