pub struct GlobalEnv {
pub resolver: Option<Rc<RefCell<dyn ModuleResolver>>>,
pub thread_creator: Option<Arc<Mutex<dyn ThreadCreator>>>,
/* private fields */
}
Expand description
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().
Fields§
§resolver: Option<Rc<RefCell<dyn ModuleResolver>>>
Holds the default module resolver for this global environment.
If some code executed with this global environment uses !@import
this resolver will be used to resolve the given module name.
thread_creator: Option<Arc<Mutex<dyn ThreadCreator>>>
Holds the default thread creator for this global environment. If some code executed with this global environment spawns a thread, then this thread creator will create the thread handle, which is passed back to WLambda.
Implementations§
Source§impl GlobalEnv
impl GlobalEnv
Sourcepub fn add_func<T>(
&mut self,
fnname: &str,
fun: T,
min_args: Option<usize>,
max_args: Option<usize>,
)
pub fn add_func<T>( &mut self, fnname: &str, fun: T, min_args: Option<usize>, max_args: Option<usize>, )
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::None); }
let v = env.arg(0);
v.push(env.arg(1).clone());
Ok(v.clone())
}, Some(2), Some(2));
Sourcepub fn set_var(&mut self, var: &str, val: &VVal)
pub fn set_var(&mut self, var: &str, val: &VVal)
Sets a global variable to a value.
See also EvalContext::set_global_var()
Sourcepub fn get_var(&self, var: &str) -> Option<VVal>
pub fn get_var(&self, var: &str) -> Option<VVal>
Returns the value of a global variable.
See also EvalContext::get_global_var()
Sourcepub fn get_var_ref(&self, var: &str) -> Option<VVal>
pub fn get_var_ref(&self, var: &str) -> Option<VVal>
Returns the reference to the value of a global variable. This does not dereference the VVal::Ref that usually holds the global variable.
See also EvalContext::get_global_var()
Sourcepub fn set_module(&mut self, mod_name: &str, symtbl: SymbolTable)
pub fn set_module(&mut self, mod_name: &str, symtbl: SymbolTable)
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();
let genv = GlobalEnv::new_default();
genv.borrow_mut().set_module("test", my_mod);
Sourcepub fn import_module_as(&mut self, mod_name: &str, prefix: &str) -> bool
pub fn import_module_as(&mut self, mod_name: &str, prefix: &str) -> bool
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.
Returns true if the module was found.
Sourcepub fn set_resolver(&mut self, res: Rc<RefCell<dyn ModuleResolver>>)
pub fn set_resolver(&mut self, res: Rc<RefCell<dyn ModuleResolver>>)
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);
Sourcepub fn new() -> GlobalEnvRef
pub fn new() -> GlobalEnvRef
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
.
Sourcepub fn new_default() -> GlobalEnvRef
pub fn new_default() -> GlobalEnvRef
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()))
set_thread_creator(Some(Arc::new(Mutex::new(DefaultThreadCreator::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.
Sourcepub fn import_modules_from(&mut self, parent_global_env: &GlobalEnv)
pub fn import_modules_from(&mut self, parent_global_env: &GlobalEnv)
This function adds the modules that were loaded into memory
from the given parent_global_env
to the current environment.
Sourcepub fn import_from_symtbl(&mut self, prefix: &str, symtbl: SymbolTable)
pub fn import_from_symtbl(&mut self, prefix: &str, symtbl: SymbolTable)
Imports all functions from the given SymbolTable with the given prefix to the GlobalEnv.
Sourcepub fn new_empty_default() -> GlobalEnvRef
pub fn new_empty_default() -> GlobalEnvRef
This is like new_default
but does not import anything, neither the
core language nor the std module.
Sourcepub fn set_thread_creator(&mut self, tc: Option<Arc<Mutex<dyn ThreadCreator>>>)
pub fn set_thread_creator(&mut self, tc: Option<Arc<Mutex<dyn ThreadCreator>>>)
Assigns a new thread creator to this GlobalEnv.
It will be used to spawn new threads if std:thread:spawn
from
WLambda’s standard library is called.
Sourcepub fn get_thread_creator(&self) -> Option<Arc<Mutex<dyn ThreadCreator>>>
pub fn get_thread_creator(&self) -> Option<Arc<Mutex<dyn ThreadCreator>>>
Returns the thread creator for this GlobalEnv if one is set.