Enum RuntimeError 

pub enum RuntimeError {
    TypeError(String),
    UndefinedVariable {
        name: String,
    },
    DivisionByZero,
    IntOverflow,
    IndexOutOfBounds {
        index: i64,
        len: usize,
    },
    ListIndexAbort {
        op: &'static str,
        index: i64,
        len: usize,
    },
    FieldNotFound {
        field: String,
        type_name: String,
    },
    NotCallable {
        value: String,
    },
    ArityMismatch {
        expected: usize,
        got: usize,
    },
    Propagated(Box<Value>),
    IntParseFailed(String),
    FloatParseFailed(String),
    Return(Box<Value>),
    Break(Option<Box<Value>>),
    Continue,
    Unreachable,
    MatchFailed,
    NoEffectHandler {
        effect: String,
    },
    NotImplemented(String),
    AssertionFailed(String),
}

An error that can occur during Bock program evaluation.

Three variants (Return, Break, Continue) are control-flow signals rather than true errors; they are propagated up through eval_expr and caught at the appropriate statement handler (function body, loop body).

Variants

TypeError(String)

UndefinedVariable

Fields

name: String

DivisionByZero

IntOverflow

IndexOutOfBounds

Fields

index: i64

len: usize

ListIndexAbort

DQ30 (§18.3 / §10.5): an in-place List mutator (remove_at/insert/set) was called with an out-of-bounds index — a violated index contract, surfaced as a runtime abort. The message is the normalized cross-target form List.<op>: index <i> out of bounds (len <n>), matching the synthesized js/ts/python/go aborts (R11 interpreter parity).

Fields

op: &'static str

index: i64

len: usize

FieldNotFound

Fields

field: String

type_name: String

NotCallable

Fields

value: String

ArityMismatch

Fields

expected: usize

got: usize

Propagated(Box<Value>)

Raised when ? is applied to None or Err(e) (§7.10). Carries the whole propagating value — Value::Optional(None) or Value::Result(Err(e)) — and is caught at the enclosing function-call boundary (call_closure / run_method_body), where it becomes the function’s return value: the caller observes a normal Result/Optional, exactly as the compiled targets early-return it. Like Return/Break/Continue, this is a control-flow signal, not a true error; it only surfaces as a runtime error if ? executes outside any function boundary (e.g. a top-level REPL expression).

IntParseFailed(String)

FloatParseFailed(String)

Return(Box<Value>)

Carries the return value from a return expression.

Break(Option<Box<Value>>)

Carries an optional break value from a break expression.

Continue

Signals continue inside a loop.

Unreachable

MatchFailed

NoEffectHandler

Fields

effect: String

NotImplemented(String)

AssertionFailed(String)

Raised when a test assertion (e.g., expect(x).to_equal(y)) fails.

Trait Implementations

impl Debug for RuntimeError

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

Formats the value using the given formatter.

impl Display for RuntimeError

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

Formats the value using the given formatter.

impl Error for RuntimeError

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 PartialEq for RuntimeError

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