Struct EvalError 

pub struct EvalError {
    pub kind: ErrorKind,
    pub expr: ArenaIndex,
    pub message: &'static str,
    pub expected: Option<&'static str>,
    pub got: Option<&'static str>,
    pub arg_info: Option<ArgCountInfo>,
    pub parse_error: Option<ParseError>,
}

Evaluation error with context - optimized for minimal size.

Size Optimization

This struct is kept small (~88 bytes on 64-bit) to minimize stack usage:

• No inline backtrace array (saves ~256 bytes)
• Static string messages instead of inline buffers (saves ~56 bytes)
• Compact arg count representation (saves ~24 bytes)

Fields

kind: ErrorKind

What kind of error (1 byte + padding)

expr: ArenaIndex

The expression that caused the error

message: &'static str

Human-readable message context (static string, 16 bytes)

expected: Option<&'static str>

Expected and got types for type errors (2 × 16 bytes)

got: Option<&'static str>

arg_info: Option<ArgCountInfo>

Argument count info for WrongArgCount errors (4 bytes)

parse_error: Option<ParseError>

Original parse error (if applicable)

Implementations

impl EvalError

pub const fn new(kind: ErrorKind) -> Self

pub const fn with_expr(self, expr: ArenaIndex) -> Self

pub const fn with_message(self, msg: &'static str) -> Self

pub const fn with_types(self, expected: &'static str, got: &'static str) -> Self

pub const fn with_args(self, expected: usize, got: usize) -> Self

pub fn from_parse_error(e: ParseError, expr: ArenaIndex) -> Self

Create an EvalError from a ParseError with expression context

Trait Implementations

impl Debug for EvalError

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

Formats the value using the given formatter.

impl From<ArenaError> for EvalError

fn from(e: ArenaError) -> Self

Converts to this type from the input type.

impl From<ParseError> for EvalError

fn from(e: ParseError) -> Self

Converts to this type from the input type.