Struct Interpreter 

pub struct Interpreter {
    pub env: Environment,
    pub effect_handlers: EffectStack,
    pub builtins: BuiltinRegistry,
    /* private fields */
}

Tree-walking interpreter for Bock AIR.

Evaluates expressions against a typed AIR tree. The Environment manages lexical variable bindings; the EffectStack will be used by P5.5 for algebraic effect dispatch.

Fields

env: Environment

Current variable bindings (nested scopes).

effect_handlers: EffectStack

Algebraic effect handler stack (populated by P5.5).

builtins: BuiltinRegistry

Built-in method and global function dispatch table.

Implementations

impl Interpreter

pub fn new() -> Self

Create a new interpreter with an empty global environment and default built-in functions registered.

pub fn register_enum(&mut self, enum_name: &str, variants: &[AIRNode])

Register all variants of an enum declaration in the environment.

• Unit variants become Value::Enum values.
• Tuple variants become constructor functions wrapping args in Value::Enum.
• Record (struct) variants become constructor functions producing Value::Record.

pub fn register_fn(&mut self, name: &str, params: Vec<String>, body: AIRNode)

Register a named function in the global environment.

The function is stored in the registry and bound by name so that Identifier nodes referencing it will resolve to Value::Function.

pub fn register_fn_with_async( &mut self, name: &str, params: Vec<String>, body: AIRNode, is_async: bool, )

Register a named function whose body may be async.

When is_async is true, calling the function spawns a tokio task and returns a Value::Future; when false, it runs inline like a regular function call.

pub fn register_impl(&mut self, target: &AIRNode, methods: &[AIRNode])

Register methods from an impl block in the method table.

Extracts the target type name and each method’s parameter names + body, storing them in method_table[type_name][method_name].

pub fn register_effect(&mut self, effect_name: &str, operations: &[AIRNode])

Register an effect declaration’s operations so they can be dispatched at runtime through the effect handler stack.

For each operation in the effect, records a mapping from the operation name to the effect name. When a call like log(msg) is evaluated, the interpreter checks this map, finds the effect (Logger), resolves the handler, and dispatches the call.

pub fn invoke_callback<'life0, 'life1, 'life_self, 'async_recursion>( &'life_self mut self, callable: &'life0 Value, args: &'life1 [Value], ) -> Pin<Box<dyn Future<Output = Result<Value, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life_self: 'async_recursion,

Invoke a callable (function value) using the interpreter’s closure machinery.

This is the public entry point for callback invocation from builtins.

pub fn eval_expr<'life0, 'life_self, 'async_recursion>( &'life_self mut self, node: &'life0 AIRNode, ) -> Pin<Box<dyn Future<Output = Result<Value, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Evaluate a single AIR expression node and return its runtime value.

pub fn call_fn_value<'life0, 'life_self, 'async_recursion>( &'life_self mut self, val: &'life0 Value, args: Vec<Value>, ) -> Pin<Box<dyn Future<Output = Result<Value, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Call a Value::Function by its identity, looking up the closure in the function registry. Call a function value with the given arguments.

pub fn eval_block<'life0, 'life1, 'life_self, 'async_recursion>( &'life_self mut self, stmts: &'life0 [AIRNode], tail: Option<&'life1 AIRNode>, ) -> Pin<Box<dyn Future<Output = Result<Value, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life_self: 'async_recursion,

Evaluate a block: push scope, execute statements, eval tail expression.

pub fn try_match_pattern<'life0, 'life1, 'life_self, 'async_recursion>( &'life_self mut self, pattern: &'life0 AIRNode, value: &'life1 Value, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life_self: 'async_recursion,

Attempt to match value against pattern, binding names into the current scope. Returns true on a successful match.

pub fn bind_pattern<'life0, 'life_self, 'async_recursion>( &'life_self mut self, pattern: &'life0 AIRNode, value: Value, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Bind value to pattern in the current scope, for use in let.

pub fn exec_stmt<'life0, 'life_self, 'async_recursion>( &'life_self mut self, node: &'life0 AIRNode, ) -> Pin<Box<dyn Future<Output = Result<Option<Value>, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Execute a statement node.

Returns None for pure statements (let bindings, for/while loops, guard) and Some(value) for expression-statements (including loop which can yield a break value, and blocks).

pub fn exec_block<'life0, 'life_self, 'async_recursion>( &'life_self mut self, block: &'life0 AIRNode, ) -> Pin<Box<dyn Future<Output = Result<Value, RuntimeError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life_self: 'async_recursion,

Execute a block node, returning the value of its tail expression.

Handles NodeKind::Block directly; falls back to eval_expr for any other node kind so callers can pass bare expression nodes too.

Trait Implementations

impl CallbackInvoker for Interpreter

fn invoke<'a>( &'a mut self, callable: &'a Value, args: &'a [Value], ) -> BoxFuture<'a, Result<Value, RuntimeError>>

Invoke callable (a Value::Function) with the given arguments.

impl Clone for Interpreter

fn clone(&self) -> Interpreter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Interpreter

fn default() -> Self

Returns the “default value” for a type.