Struct EvaluationContext 

pub struct EvaluationContext<'a> {
    pub current_doc: &'a LemmaDoc,
    pub all_documents: &'a HashMap<String, LemmaDoc>,
    pub sources: &'a HashMap<String, String>,
    pub facts: HashMap<FactReference, LiteralValue>,
    pub timeout_tracker: &'a TimeoutTracker,
    pub limits: &'a ResourceLimits,
    pub rule_results: HashMap<RulePath, OperationResult>,
    pub operations: Vec<OperationRecord>,
}

Context for evaluating a Lemma document

Contains all state needed for a single evaluation:

• Facts (inputs)
• Rule results (computed values)
• Operation records (execution log)
• Timeout tracking

Fields

current_doc: &'a LemmaDoc

Document being evaluated

all_documents: &'a HashMap<String, LemmaDoc>

All loaded documents (needed when facts reference other documents)

sources: &'a HashMap<String, String>

Source text for all documents (for error reporting) Maps source_id -> source text

facts: HashMap<FactReference, LiteralValue>

Fact values (from document + overrides) Maps fact path -> concrete value Only contains facts that have actual values (not TypeAnnotations)

timeout_tracker: &'a TimeoutTracker

Timeout tracker (platform-specific)

limits: &'a ResourceLimits

Resource limits including timeout

rule_results: HashMap<RulePath, OperationResult>

Rule results computed so far (populated during execution) Maps RulePath -> operation result (either Value or Veto)

operations: Vec<OperationRecord>

Operation records - records every operation

Implementations

impl<'a> EvaluationContext<'a>

pub fn new( current_doc: &'a LemmaDoc, all_documents: &'a HashMap<String, LemmaDoc>, sources: &'a HashMap<String, String>, facts: HashMap<FactReference, LiteralValue>, timeout_tracker: &'a TimeoutTracker, limits: &'a ResourceLimits, ) -> Self

Create a new evaluation context

pub fn check_timeout(&self) -> Result<(), LemmaError>

Check if evaluation has exceeded timeout