Struct Interpreter 

pub struct Interpreter {
    pub stack: Vec<Value>,
    pub return_stack: Vec<Value>,
    pub dictionary: HashMap<Rc<str>, DictEntry>,
    pub atoms: HashMap<String, Rc<str>>,
    pub local_frames: Vec<HashMap<Rc<str>, Value>>,
    pub current_pos: Option<SourcePos>,
    pub time_source: Option<Box<dyn TimeSource>>,
    /* private fields */
}

Fields

stack: Vec<Value>

return_stack: Vec<Value>

dictionary: HashMap<Rc<str>, DictEntry>

atoms: HashMap<String, Rc<str>>

local_frames: Vec<HashMap<Rc<str>, Value>>

current_pos: Option<SourcePos>

time_source: Option<Box<dyn TimeSource>>

Implementations

impl Interpreter

pub fn new() -> Self

Examples found in repository

examples/simple_calculator.rs (line 10)

fn main() {
    // Create a new interpreter instance
    let mut interp = Interpreter::new();

    // Define some calculations to perform
    let expressions = vec![
        ("5 3 +", "Addition"),
        ("10 4 -", "Subtraction"),
        ("7 6 *", "Multiplication"),
        ("20 4 /", "Division"),
        ("3 dup *", "3 squared (3 * 3)"),
        ("[1 2 3 4 5] length", "List length"),
    ];

    println!("Uni Calculator Example\n");

    for (expr, description) in expressions {
        // Execute the expression
        match execute_string(expr, &mut interp) {
            Ok(()) => {
                // Get the result from the stack
                if let Some(result) = interp.stack.last() {
                    println!("{}: {} = {}", description, expr, result);
                }
            }
            Err(e) => {
                eprintln!("Error evaluating '{}': {:?}", expr, e);
            }
        }

        // Clear the stack for next calculation
        interp.stack.clear();
    }

    println!("\nDefining and using a custom function:");

    // Define a square function and use it
    match execute_string("'square [dup *] def  5 square", &mut interp) {
        Ok(()) => {
            if let Some(result) = interp.stack.last() {
                println!("5 squared = {}", result);
            }
        }
        Err(e) => {
            eprintln!("Error: {:?}", e);
        }
    }
}

pub fn intern_atom(&mut self, text: &str) -> Rc<str>

pub fn set_pending_doc_target(&mut self, atom: Rc<str>)

pub fn take_pending_doc_target(&mut self) -> Option<Rc<str>>

pub fn attach_doc( &mut self, atom: &Rc<str>, doc: Rc<str>, ) -> Result<(), RuntimeError>

pub fn push(&mut self, value: Value)

pub fn pop(&mut self) -> Result<Value, RuntimeError>

pub fn pop_number(&mut self) -> Result<f64, RuntimeError>

pub fn pop_integer(&mut self) -> Result<usize, RuntimeError>

pub fn make_list(&self, items: Vec<Value>) -> Value

pub fn make_array(&self, items: Vec<Value>) -> Value

pub fn is_null(&self, value: &Value) -> bool

pub fn is_truthy(&self, value: &Value) -> bool

pub fn push_return(&mut self, value: Value)

pub fn pop_return(&mut self) -> Result<Value, RuntimeError>

pub fn peek_return(&self) -> Result<&Value, RuntimeError>

pub fn pop_with_context(&mut self, context: &str) -> Result<Value, RuntimeError>

pub fn set_output(&mut self, output: Box<dyn Output>)

pub fn has_output(&self) -> bool

pub fn set_time_source(&mut self, time_source: Box<dyn TimeSource>)

pub fn has_time_source(&self) -> bool

pub fn writeln(&mut self, text: &str) -> Result<(), ()>

pub fn write_str(&mut self, text: &str) -> Result<(), ()>