Struct Interpreter 

pub struct Interpreter { /* private fields */ }

A Sema Lisp interpreter instance.

Use InterpreterBuilder for fine-grained control, or call Interpreter::new for a default interpreter with stdlib enabled.

Implementations

impl Interpreter

pub fn new() -> Self

pub fn builder() -> InterpreterBuilder

Create an InterpreterBuilder for fine-grained configuration.

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

Evaluate a single parsed Value expression.

Definitions (define) persist across calls.

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

Parse and evaluate a string containing one or more Sema expressions.

Definitions (define) persist across calls, so you can define a function in one call and use it in the next.

pub fn register_fn<F>(&self, name: &str, f: F)

where F: Fn(&[Value]) -> Result<Value> + 'static,

Register a native function that can be called from Sema code.

Example

use sema::{Interpreter, Value, SemaError};

let interp = Interpreter::new();
interp.register_fn("square", |args: &[Value]| {
    if let Some(n) = args[0].as_int() {
        Ok(Value::int(n * n))
    } else {
        Err(SemaError::type_error("integer", args[0].type_name()))
    }
});

pub fn load_file(&self, path: impl AsRef<Path>) -> EvalResult

Load and evaluate a .sema file.

Definitions persist in the global environment, just like [eval_str].

let interp = Interpreter::new();
interp.load_file("prelude.sema").unwrap();
interp.eval_str("(my-prelude-fn 42)").unwrap();

pub fn preload_module(&self, name: &str, source: &str) -> Result<()>

Pre-load a module into the module cache so that (import "name") resolves without reading from disk.

The name is the string users pass to import. The source is evaluated in an isolated module environment, and all top-level bindings (or only export-ed ones) are cached.

let interp = Interpreter::new();
interp.preload_module("utils", r#"
    (define (double x) (* x 2))
"#).unwrap();

interp.eval_str(r#"(import "utils")"#).unwrap();
interp.eval_str("(double 21)").unwrap(); // => 42

Use (module name (export ...) ...) to control which bindings are visible:

let interp = Interpreter::new();
interp.preload_module("math", r#"
    (module math (export square)
      (define (square x) (* x x))
      (define internal 42))
"#).unwrap();

pub fn global_env(&self) -> &Rc<Env>

Return a reference to the global environment.

pub fn env(&self) -> &Rc<Env>

Trait Implementations

impl Default for Interpreter

fn default() -> Self

Returns the “default value” for a type.