Struct Machine

pub struct Machine<'a> {
    pub frames: StackFrames<'a>,
    pub flow: Option<FlowEvent>,
    pub engine: Engine<'a>,
    pub context: EvalContext,
    pub heap: Heap,
}

Fields

frames: StackFrames<'a>

flow: Option<FlowEvent>

engine: Engine<'a>

context: EvalContext

heap: Heap

Implementations

impl<'a> Machine<'a>

pub fn world(&self) -> &dyn World

pub fn syntax_ctx<'w>(&self) -> SyntaxContext<'w>

where 'a: 'w,

impl<'a> Machine<'a>

pub fn new(world: &'a dyn World) -> Self

pub fn with_frame<T>(&mut self, f: impl FnOnce(&mut Machine<'_>) -> T) -> T

Enter a new stack frame to evaluate f. This frame does not have access to any defined variables in other frames, but does share the same heap. This means references passed into this frame can share data.

pub fn maybe_gc(&mut self)

impl<'a> Machine<'a>

pub fn track_tmp_root(&mut self, value: &impl Trace)

pub fn debug_tracked(&self, from: &str)

pub fn temp_root_marker(&mut self) -> TrackMarker

pub fn pop_temp_roots(&mut self, marker: TrackMarker)

pub fn temp_root_scope( &mut self, f: impl FnOnce(&mut Machine<'a>) -> SourceResult<Value>, ) -> SourceResult<Value>

Automatically forgets any tracked values during f after f is finished

pub fn define( &mut self, var: Ident<'_>, value: impl IntoValue, binding_kind: BindingKind, visibility: Visibility, ) -> SourceResult<&mut Binding>

pub fn try_bind( &mut self, name: EcoString, binding: Binding, ) -> SourceResult<&mut Binding>

pub fn bind(&mut self, name: EcoString, binding: Binding) -> &mut Binding

pub fn get(&self, name: &str) -> Result<&Binding, VariableAccessError>

pub fn get_mut( &mut self, name: &str, ) -> Result<&mut Binding, VariableAccessError>

impl<'a> Machine<'a>

pub fn temp_root_guard<'b>(&'b mut self) -> TempRootGuard<'a, 'b>

impl Machine<'_>

pub fn with_closure_capture_errors_mode<T>( &mut self, mode: ErrorMode, f: impl FnOnce(&mut Machine<'_>) -> SourceResult<T>, ) -> SourceResult<T>

Run f with closure capture errors deferred.

This makes the caller responsible for either handling or emitting the unresolved errors.

Trait Implementations

impl Debug for Machine<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Vm<'a> for Machine<'a>

fn heap(&self) -> &Heap

fn heap_mut(&mut self) -> &mut Heap

fn engine(&self) -> &Engine<'a>

fn engine_mut(&mut self) -> &mut Engine<'a>

fn call_func(&mut self, func: &Func, args: Args) -> SourceResult<Value>