Struct ExecCtx 

pub struct ExecCtx<R: Rt, E: UserEvent> {
    pub libstate: LibState,
    pub env: Env,
    pub cached: FxHashMap<BindId, Value>,
    pub rt: R,
    pub lambda_defs: FxHashMap<LambdaId, Value>,
    pub deferred_checks: Vec<Box<dyn FnOnce(&mut ExecCtx<R, E>) -> Result<()> + Send + Sync>>,
    pub references: GPooled<Vec<ReferenceSite>>,
    pub module_references: GPooled<Vec<ModuleRefSite>>,
    pub scope_map: GPooled<Vec<ScopeMapEntry>>,
    /* private fields */
}

Fields

libstate: LibState

context global library state for built-in functions

env: Env

the language environment, typdefs, binds, lambdas, etc

cached: FxHashMap<BindId, Value>

the last value of every bound variable

rt: R

the runtime

lambda_defs: FxHashMap<LambdaId, Value>

LambdaDefs indexed by LambdaId, for deferred type checking

deferred_checks: Vec<Box<dyn FnOnce(&mut ExecCtx<R, E>) -> Result<()> + Send + Sync>>

deferred type check closures, evaluated after all primary type checking

references: GPooled<Vec<ReferenceSite>>

Reference sites accumulated during compilation. Each is a textual occurrence of a name and the BindId it resolved to. At compile boundaries, swap with a fresh REFERENCE_SITE_POOL container via mem::replace (not mem::take — Default routes to the unsized thread-local registry, not our named pool). Only populated when env.lsp_mode is set.

module_references: GPooled<Vec<ModuleRefSite>>

Module reference sites — use foo; and mod foo; mentions. Same scoping rules as references.

scope_map: GPooled<Vec<ScopeMapEntry>>

Per-compile scope map. compile() pushes one entry every time it’s invoked, recording the scope it was called with. IDE tooling reads this to answer cursor → scope queries.

Implementations

impl<R: Rt, E: UserEvent> ExecCtx<R, E>

pub fn clear(&mut self)

pub fn new(user: R) -> Result<Self>

Build a new execution context.

This is a very low level interface that you can use to build a custom runtime with deep integration to your code. It is very difficult to use, and if you don’t implement everything correctly the semantics of the language can be wrong.

Most likely you want to use the rt module instead.

pub fn register_builtin<T: BuiltIn<R, E>>(&mut self) -> Result<()>

pub fn wrap_lambda(&mut self, def: LambdaDef<R, E>) -> Value

Wrap a LambdaDef into a Value that can be returned from a builtin as a first-class function value. The runtime handles the resulting Value as a callable lambda — call sites resolve against the LambdaDef’s init to construct an Apply impl. Also registers the LambdaDef in lambda_defs so deferred typechecking can find it.

pub fn set_var(&mut self, id: BindId, v: Value)

Built in functions should call this when variables are set unless they are sure the variable does not need to be cached. This will also call the user ctx set_var.

pub fn with_restored<T, F: FnOnce(&mut Self) -> T>( &mut self, env: Env, f: F, ) -> T

Restore the lexical environment to the snapshot env for the duration of f restoring it to it’s original value afterwords. by_id and lambdas defined by the closure will be retained.

pub fn with_restored_mut<T, F: FnOnce(&mut Self) -> T>( &mut self, env: &mut Env, f: F, ) -> T

Restore the lexical environment to the snapshot env for the duration of f restoring it to it’s original value afterwords. by_id and lambdas defined by the closure will be retained. env will be mutated instead of requiring a clone, this allows maintaining continuity in two different envs across multiple invocations