Struct EvalError 

pub struct EvalError {
    pub kind: ErrorKind,
    pub message: ErrorMessage,
    pub expr: ArenaIndex,
    pub expected: Option<&'static str>,
    pub got: Option<&'static str>,
    pub expected_args: Option<usize>,
    pub got_args: Option<usize>,
    pub backtrace: [StackFrame; 16],
    pub backtrace_len: usize,
    pub parse_error: Option<ParseError>,
}

Evaluation error with context

Fields

kind: ErrorKind

What kind of error

message: ErrorMessage

Human-readable message context

expr: ArenaIndex

The expression that caused the error

expected: Option<&'static str>

Expected type (for type errors)

got: Option<&'static str>

Got type (for type errors)

expected_args: Option<usize>

Expected argument count

got_args: Option<usize>

Got argument count

backtrace: [StackFrame; 16]

Call stack backtrace

backtrace_len: usize

parse_error: Option<ParseError>

Original parse error (if applicable)

Implementations

impl EvalError

pub fn new(kind: ErrorKind) -> Self

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

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

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

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

pub fn with_backtrace(self, stack: &[StackFrame], len: usize) -> Self

impl EvalError

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.