Enum VMError 

pub enum VMError {
    StackUnderflow,
    StackOverflow,
    TypeError {
        expected: &'static str,
        got: &'static str,
    },
    DivisionByZero,
    UndefinedVariable(String),
    UndefinedProperty(String),
    InvalidCall,
    IndexOutOfBounds {
        index: i32,
        length: usize,
    },
    InvalidOperand,
    ArityMismatch {
        function: String,
        expected: usize,
        got: usize,
    },
    InvalidArgument {
        function: String,
        message: String,
    },
    NotImplemented(String),
    RuntimeError(String),
    Suspended {
        future_id: u64,
        resume_ip: usize,
    },
    Interrupted,
    ResumeRequested,
}

VM runtime errors

Variants

StackUnderflow

Stack underflow

StackOverflow

Stack overflow

TypeError

Type mismatch

Fields

expected: &'static str

got: &'static str

DivisionByZero

Division by zero

UndefinedVariable(String)

Variable not found

UndefinedProperty(String)

Property not found

InvalidCall

Invalid function call

IndexOutOfBounds

Invalid array index

Fields

index: i32

length: usize

InvalidOperand

Invalid operand

ArityMismatch

Wrong number of arguments passed to a function

Fields

function: String

expected: usize

got: usize

InvalidArgument

Invalid argument value (correct type, wrong value)

Fields

function: String

message: String

NotImplemented(String)

Feature not yet implemented

RuntimeError(String)

Runtime error with message

Suspended

VM suspended on await — not a real error, used to propagate suspension up the Rust call stack

Fields

future_id: u64

resume_ip: usize

Interrupted

Execution interrupted by Ctrl+C signal

ResumeRequested

Internal: state.resume() requested VM state restoration. Not a real error — intercepted by the dispatch loop.

Implementations

impl VMError

pub fn type_mismatch(expected: &'static str, got: &'static str) -> VMError

Convenience constructor for TypeError { expected, got }.

pub fn argument_count_error( fn_name: impl Into<String>, expected: usize, got: usize, ) -> VMError

Convenience constructor for argument-count errors.

Produces ArityMismatch { function, expected, got } with a consistent message format: "fn_name() expects N argument(s), got M".

Prefer this over hand-writing VMError::RuntimeError(format!(...)) for arity mismatches — it uses the structured ArityMismatch variant which tools can match on programmatically.

pub fn type_error( fn_name: &str, expected_type: &str, got_value: &str, ) -> VMError

Convenience constructor for type errors in builtin/stdlib functions.

Produces a RuntimeError with the format: "fn_name(): expected <expected_type>, got <got_value>".

Use this when a function receives a value of the wrong type. For the lower-level TypeError { expected, got } variant (which requires &'static str), use VMError::type_mismatch() instead.

Trait Implementations

impl Clone for VMError

fn clone(&self) -> VMError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VMError

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

Formats the value using the given formatter.

impl Display for VMError

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

Formats the value using the given formatter.

impl Error for VMError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ShapeError> for VMError

fn from(err: ShapeError) -> VMError

Converts to this type from the input type.

impl PartialEq for VMError

fn eq(&self, other: &VMError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for VMError