Struct wlambda::compiler::GlobalEnv [−][src]
pub struct GlobalEnv { pub resolver: Option<Rc<RefCell<dyn ModuleResolver>>>, pub thread_creator: Option<Arc<Mutex<dyn ThreadCreator>>>, // some fields omitted }
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
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));
Sets a global variable to a value.
See also EvalContext::set_global_var()
Returns the value of a global variable.
See also EvalContext::get_global_var()
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()
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);
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.
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);
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
.
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.
This function adds the modules that were loaded into memory
from the given parent_global_env
to the current environment.
Imports all functions from the given SymbolTable with the given prefix to the GlobalEnv.
This is like new_default
but does not import anything, neither the
core language nor the std module.
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.
Returns the thread creator for this GlobalEnv if one is set.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for GlobalEnv
impl !UnwindSafe for GlobalEnv
Blanket Implementations
Mutably borrows from an owned value. Read more