Struct wlambda::vval::Env

pub struct Env {
    pub args: Vec<VVal>,
    pub fun: Rc<VValFun>,
    pub bp: usize,
    pub sp: usize,
    pub argc: usize,
    pub user: Rc<RefCell<dyn Any>>,
    pub exports: HashMap<String, VVal>,
}

The runtime environment of the evaluator.

Fields

args: Vec<VVal>

The argument stack, limited to STACK_SIZE.

fun: Rc<VValFun>

A reference to the currently executed function.

Used for accessing the up values and other details about the function.

bp: usize

The basepointer to reference arguments and local variables.

• bp + n (n >= 0) references a local variable
• bp - n (n > 0) references an argument

sp: usize

The current stack pointer.

argc: usize

The argument count to the current call.

user: Rc<RefCell<dyn Any>>

A user defined variable that holds user context information. See also the with_user_do function.

exports: HashMap<String, VVal>

The exported names of this module.

Methods

impl Env

pub fn new() -> Env

pub fn new_with_user(user: Rc<RefCell<dyn Any>>) -> Env

pub fn get_user(&self) -> Rc<RefCell<dyn Any>>

Returns the passed in user context value.

pub fn with_user_do<T: 'static, F, X>(&mut self, f: F) -> X where
    F: Fn(&mut T) -> X, 

Easier access to the user data field in Env

In the following example the user supplies a registry vector for storing VVals. A callback is stored, which is then later executed.

use wlambda::{VVal, EvalContext, GlobalEnv};
use wlambda::vval::Env;
use std::rc::Rc;
use std::cell::RefCell;

let global = GlobalEnv::new_default();

global.borrow_mut().add_func("reg", |env: &mut Env, _argc: usize| {
    let fun = env.arg(0);
    env.with_user_do(|v: &mut Vec<VVal>| v.push(fun.clone()));
    Ok(VVal::Nul)
}, Some(1), Some(1));

let reg : Rc<RefCell<Vec<VVal>>> =
    Rc::new(RefCell::new(Vec::new()));

let mut ctx = EvalContext::new_with_user(global, reg.clone());
ctx.eval("reg { _ + 10 }").unwrap();

let n = reg.borrow_mut()[0].clone();
let ret = ctx.call(&n, &vec![VVal::Int(11)]).unwrap();
assert_eq!(ret.i(), 21);

pub fn export_name(&mut self, name: &str, value: &VVal)

pub fn set_bp(&mut self, env_size: usize) -> usize

pub fn reset_bp(&mut self, env_size: usize, oldbp: usize)

pub fn with_local_call_info<T>(
    &mut self,
    argc: usize,
    f: T
) -> Result<VVal, StackAction> where
    T: Fn(&mut Env) -> Result<VVal, StackAction>, 

pub fn with_fun_info<T>(
    &mut self,
    fu: Rc<VValFun>,
    argc: usize,
    f: T
) -> Result<VVal, StackAction> where
    T: Fn(&mut Env) -> Result<VVal, StackAction>, 

pub fn with_restore_sp<T>(&mut self, f: T) -> Result<VVal, StackAction> where
    T: Fn(&mut Env) -> Result<VVal, StackAction>, 

pub fn with_pushed_sp<T>(&mut self, n: usize, f: T) -> Result<VVal, StackAction> where
    T: Fn(&mut Env) -> Result<VVal, StackAction>, 

pub fn push_sp(&mut self, n: usize)

pub fn push(&mut self, v: VVal) -> usize

pub fn popn(&mut self, n: usize)

pub fn dump_stack(&self)

Prints a dump of the stack state.

pub fn argv(&mut self) -> VVal

pub fn get_up_raw(&mut self, i: usize) -> VVal

pub fn get_up(&mut self, i: usize) -> VVal

pub fn set_arg(&mut self, i: usize, v: VVal)

pub fn arg_ref(&self, i: usize) -> Option<&VVal>

pub fn arg_err_internal(&self, i: usize) -> Option<VVal>

pub fn arg(&self, i: usize) -> VVal

pub fn get_local(&mut self, i: usize) -> VVal

pub fn set_up(&mut self, index: usize, value: &VVal)

pub fn set_local(&mut self, i: usize, value: &VVal)

pub fn set_consume(&mut self, i: usize, value: VVal)

Trait Implementations

impl Clone for Env

fn clone(&self) -> Env

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Env

fn default() -> Self

Returns the "default value" for a type.

impl Debug for Env

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.