Enum muse_lang::vm::Fault

#[non_exhaustive]
pub enum Fault {
    NoBudget,
    Timeout,
    Waiting,
    Exception(Value),
    FrameChanged,
    Forbidden,
    UnknownSymbol,
    IncorrectNumberOfArguments,
    PatternMismatch,
    OperationOnNil,
    ValueFreed,
    NotAModule,
    NotAFunction,
    StackOverflow,
    StackUnderflow,
    UnsupportedOperation,
    OutOfMemory,
    OutOfBounds,
    NotMutable,
    DivideByZero,
    InvalidInstructionAddress,
    ExpectedSymbol,
    ExpectedInteger,
    ExpectedString,
    ExpectedList,
    InvalidArity,
    InvalidLabel,
    InvalidOpcode,
}

A virtual machine error.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NoBudget

The budget for the virtual machine has been exhausted.

Timeout

Execution did not complete before a timeout occurred.

Waiting

The virtual machine is waiting for an async task.

Exception(Value)

A thrown exception was not handled.

FrameChanged

The execution frame has changed.

Forbidden

A declaration was found, but it is not accessible by the currently executing code.

UnknownSymbol

A symbol could not be resolved to a declaration or function.

IncorrectNumberOfArguments

A function was invoked with an unsupported number of arguments.

PatternMismatch

A pattern could not be matched.

OperationOnNil

An unsupported operation was performed on Value::NIL.

ValueFreed

A value was freed.

This, in general, should not happen, but it can happen through intentional usage or if a type does not implement [Trace] correctly.

NotAModule

A value was expected to be a module, but was not.

NotAFunction

A value was invoked but is not invokable.

StackOverflow

An allocation failed because the stack is full.

StackUnderflow

An attempt to return from the execution root.

UnsupportedOperation

A general error indicating an unsupported operation.

OutOfMemory

An allocation could not be performed due to memory constraints.

OutOfBounds

An operation attempted to access something outside of its bounds.

NotMutable

An assignment was attempted to an immutable declaration.

DivideByZero

A value was divided by zero.

InvalidInstructionAddress

Execution jumped to an invalid instruction address.

ExpectedSymbol

An operation expected a symbol.

ExpectedInteger

An operation expected an integer.

ExpectedString

An operation expected a string.

ExpectedList

An operation expected a list.

InvalidArity

An invalid value was provided for the Arity of a function.

InvalidLabel

An invalid label was encountered.

InvalidOpcode

An instruction referenced an invalid index.

This is differen than a Fault::OutOfBounds because this fault indicates invalid code rather than a logic error.

Implementations

impl Fault

pub fn as_symbol(&self) -> Result<Symbol, Value>

Returns this error as a Symbol.

Errors

Returns the contained exception as Err if this fault is an exception.

pub fn as_exception(&self, vm: &mut VmContext<'_, '_>) -> Value

Converts this fault into an exception.

Trait Implementations

impl Clone for Fault

fn clone(&self) -> Fault

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fault

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

Formats the value using the given formatter.

impl From<ValueFreed> for Fault

fn from(_value: ValueFreed) -> Self

Converts to this type from the input type.

impl PartialEq for Fault

fn eq(&self, other: &Fault) -> 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 Fault