[−][src]Struct wlambda::compiler::GlobalEnv
Holds global environment variables.
This data structure is part of the API. It's there to make functions or values available to a WLambda program.
This environment structure is usually wrapped inside an EvalContext which augments it for calling the compiler and allows evaluation of the code.
See also:
- GlobalEnv::add_func() of how to create a function and put it into the global variable.
- And GlobalEnv::set_module() of how to supply your own importable modules. See also SymbolTable has a good example how that could work.
- And GlobalEnv::set_var().
- And GlobalEnv::get_var().
Methods
impl GlobalEnv
[src]
pub fn add_func<T>(
&mut self,
fnname: &str,
fun: T,
min_args: Option<usize>,
max_args: Option<usize>
) where
T: 'static + Fn(&mut Env, usize) -> Result<VVal, StackAction>,
[src]
&mut self,
fnname: &str,
fun: T,
min_args: Option<usize>,
max_args: Option<usize>
) where
T: 'static + Fn(&mut Env, usize) -> Result<VVal, StackAction>,
Adds a function to a GlobalEnv
.
This is an example of how to add a function:
use wlambda::compiler::GlobalEnv; use wlambda::vval::{Env, VVal}; let g = GlobalEnv::new(); g.borrow_mut().add_func( "push", |env: &mut Env, argc: usize| { if argc < 2 { return Ok(VVal::Nul); } let v = env.arg(0); v.push(env.arg(1).clone()); Ok(v.clone()) }, Some(2), Some(2));
pub fn set_var(&mut self, var: &str, val: &VVal)
[src]
Sets a global variable to a value.
See also EvalContext::set_global_var()
pub fn get_var(&mut self, var: &str) -> Option<VVal>
[src]
Returns the value of a global variable.
See also EvalContext::get_global_var()
pub fn set_module(&mut self, mod_name: &str, symtbl: SymbolTable)
[src]
Sets a symbol table for a module before a module asks for it. Modules set via this function have precedence over resolved modules via set_resolver().
Here is an example how to setup your own module:
use wlambda::{VVal, EvalContext, GlobalEnv, SymbolTable}; let my_mod = SymbolTable::new();
pub fn import_module_as(&mut self, mod_name: &str, prefix: &str)
[src]
Imports all symbols from the designated module with the specified
prefix applied. This does not call out to the resolver and
only works on previously set_module
modules.
pub fn set_resolver(&mut self, res: Rc<RefCell<dyn ModuleResolver>>)
[src]
Sets the module resolver. There is a LocalFileModuleResolver available which loads the modules relative to the current working directory.
Please note that modules made available using set_module
have priority
over modules that are provided by the resolver.
use std::rc::Rc; use std::cell::RefCell; let global = wlambda::compiler::GlobalEnv::new_default(); let lfmr = Rc::new(RefCell::new( wlambda::compiler::LocalFileModuleResolver::new())); global.borrow_mut().set_resolver(lfmr);
pub fn new() -> GlobalEnvRef
[src]
Creates a new completely empty GlobalEnv.
There is no core language, no std lib. You have
to add all that on your own via set_var
and set_module
.
pub fn new_default() -> GlobalEnvRef
[src]
Returns a default global environment. Where default means what the author of WLambda decided what is default at the moment. For more precise global environment, that is not a completely moving target consider the alternate constructor variants.
Global environments constructed with this typically contain:
set_module("wlambda", wlambda::prelude::core_symbol_table())
set_module("std", wlambda::prelude::std_symbol_table())
set_resolver(Rc::new(RefCell::new(wlambda::compiler::LocalFileModuleResolver::new()))
import_module_as("wlambda", "")
import_module_as("std", "std")
On top of that, the WLambda
module has been imported without a prefix
and the std
module has been loaded with an std:
prefix.
This means you can load and eval scripts you see all over this documentation.
pub fn import_modules_from(&mut self, parent_global_env: &GlobalEnv)
[src]
This function adds the modules that were loaded into memory
from the given parent_global_env
to the current environment.
pub fn new_empty_default() -> GlobalEnvRef
[src]
This is like new_default
but does not import anything, neither the
core language nor the std module.
Trait Implementations
Auto Trait Implementations
impl !Send for GlobalEnv
impl !Sync for GlobalEnv
impl Unpin for GlobalEnv
impl !UnwindSafe for GlobalEnv
impl !RefUnwindSafe for GlobalEnv
Blanket Implementations
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,