Struct Evaluator 

pub struct Evaluator<'a, const N: usize> { /* private fields */ }

Maximum number of macros that can be defined The Lisp evaluator with full trampolined TCO

Implementations

impl<'a, const N: usize> Evaluator<'a, N>

pub fn new(lisp: &'a Lisp<N>) -> Result<Self, EvalError>

Create a new evaluator with standard environment

pub fn lisp(&self) -> &Lisp<N>

Get the Lisp context

pub fn global_env(&self) -> ArenaIndex

Get the global environment

pub fn register_native( &mut self, name: &'static str, func: NativeFn<N>, ) -> Result<(), EvalError>

Register a native Rust function that can be called from Lisp.

The function will be bound to the given name in the global environment.

Example

use grift_eval::{Lisp, Evaluator, ArenaIndex, ArenaResult, FromLisp, ToLisp};

fn my_double<const N: usize>(lisp: &Lisp<N>, args: ArenaIndex) -> ArenaResult<ArenaIndex> {
    let n = isize::from_lisp(lisp, lisp.car(args)?)?;
    (n * 2).to_lisp(lisp)
}

let lisp: Lisp<10000> = Lisp::new();
let mut eval = Evaluator::new(&lisp).unwrap();
eval.register_native("my-double", my_double).unwrap();

// Now you can call (my-double 5) from Lisp to get 10
let result = eval.eval_str("(my-double 5)").unwrap();
assert_eq!(lisp.get(result).unwrap().as_number(), Some(10));

pub fn native_registry(&self) -> &NativeRegistry<N>

Get a reference to the native function registry.

pub fn gc(&self) -> GcStats

Run GC with current roots (global env only)

pub fn define(&mut self, name: ArenaIndex, value: ArenaIndex) -> EvalResult

Define in global environment (NOTE: only allowed at top-level)

pub fn eval(&mut self, expr: ArenaIndex) -> EvalResult

Evaluate an expression (entry point)

pub fn eval_in_env(&mut self, expr: ArenaIndex, env: ArenaIndex) -> EvalResult

Evaluate an expression in a given environment Uses full trampolining - no Rust recursion

This is public so the REPL can evaluate expressions for display

pub fn eval_str(&mut self, input: &str) -> EvalResult

Evaluate a string