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
sourceimpl GlobalEnv
impl GlobalEnv
sourcepub 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>,
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>,
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.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for GlobalEnv
impl !Send for GlobalEnv
impl !Sync for GlobalEnv
impl Unpin for GlobalEnv
impl !UnwindSafe for GlobalEnv
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more