Enum EvalError 

pub enum EvalError {
    UnboundSymbol {
        name: Arc<str>,
        at: Span,
    },
    ArityMismatch {
        fn_name: Arc<str>,
        expected: Arity,
        got: usize,
        at: Span,
    },
    TypeMismatch {
        expected: &'static str,
        got: &'static str,
        at: Span,
    },
    DivisionByZero {
        at: Span,
    },
    MacroExpansionLimit {
        macro_name: Arc<str>,
        limit: usize,
        at: Span,
    },
    NotCallable {
        value_kind: &'static str,
        at: Span,
    },
    SetSealed {
        name: Arc<str>,
        seal: Seal,
        at: Span,
    },
    BadSpecialForm {
        form: Arc<str>,
        reason: String,
        at: Span,
    },
    NativeFn {
        name: Arc<str>,
        reason: String,
        at: Span,
    },
    Reader(LispError),
    Halted,
    NotImplemented(&'static str),
    User {
        value: Value,
        at: Span,
    },
}

Variants

UnboundSymbol

Fields

name: Arc<str>

at: Span

ArityMismatch

Fields

fn_name: Arc<str>

expected: Arity

got: usize

at: Span

TypeMismatch

Fields

expected: &'static str

got: &'static str

at: Span

DivisionByZero

Fields

at: Span

MacroExpansionLimit

A macro rewrite chain exceeded its ceiling.

Names the macro that was rewriting, because that is the one to look at. Before this existed the same condition was fatal runtime error: stack overflow, aborting — uncatchable, and at build time.

Fields

macro_name: Arc<str>

limit: usize

at: Span

NotCallable

Fields

value_kind: &'static str

at: Span

SetSealed

A set! reached a binding in a frame sealed against writes.

Distinct from UnboundSymbol: the name is bound, and the write was refused. Carrying the Seal rather than a prebuilt sentence is deliberate — two callers seal for different reasons, and the wording hard-coded for the first (macro expansion) actively misdirects a reader who hit the second.

Fields

name: Arc<str>

seal: Seal

at: Span

BadSpecialForm

Fields

form: Arc<str>

reason: String

at: Span

NativeFn

Fields

name: Arc<str>

reason: String

at: Span

Reader(LispError)

Halted

NotImplemented(&'static str)

User

A Lisp-side error raised via (throw ...). Caught by (try ... (catch (e) ...)). The carried Value is whatever the user threw — conventionally a Value::Error produced by (error ...) / (ex-info ...), but any Value is allowed.

Fields

value: Value

at: Span

Implementations

impl EvalError

pub fn unbound(name: impl Into<Arc<str>>, at: Span) -> EvalError

pub fn type_mismatch( expected: &'static str, got: &'static str, at: Span, ) -> EvalError

pub fn native_fn( name: impl Into<Arc<str>>, reason: impl Into<String>, at: Span, ) -> EvalError

pub fn bad_form( form: impl Into<Arc<str>>, reason: impl Into<String>, at: Span, ) -> EvalError

pub const fn tag(&self) -> &'static str

The Lisp-visible tag this error surfaces as when a (catch ...) handler observes it.

One table. It used to be two — the tree-walker and the VM each carried a copy, so EvalError had three edit sites per variant and no compiler pressure keeping the two tags equal. A catch that matched under one executor and not the other would have been silent.

pub fn span(&self) -> Option<Span>

The span this error is attached to, if any.

pub fn render(&self, src: &str) -> String

Render this error with source context — finds the line containing the error’s span in src, prints that line, and underlines the span with ^ markers. Produces a multi-line string suitable for CLI / REPL output.

If the error has no span, or its span is synthetic, renders just the error message without source context.

The caret line comes from tatara_lisp::caret_run — the fleet’s ONE caret renderer — rather than the hand-rolled pad this method used to carry. That lift fixed two bugs the local copy had drifted into, both of them mis-placing the underline relative to the span it names:

• it padded with " ".repeat(col - 1), so a tab-indented source line put one space where the source spent a whole tab-stop and the underline slid left of its span;
• it sized the underline as span.end - span.start, a BYTE count, while padding to a CHAR column — so a multi-byte subform drew more carets than it occupies columns.

pending-caret-multiline: a span covering more than one line still draws its full char-width of carets under the single line rendered above it, overflowing that line’s end. Both pre-lift copies did this and the shared renderer preserves it deliberately — clamping the run to the rendered line is a real output change for every whole-form span (which is most of them), so it wants its own measured pass rather than riding along inside this consolidation.

pub fn short_message(&self) -> String

Short, one-line summary of the error kind — no source context.

Trait Implementations

impl Debug for EvalError

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

Formats the value using the given formatter.

impl Display for EvalError

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

Formats the value using the given formatter.

impl Error for EvalError

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<LispError> for EvalError

fn from(source: LispError) -> EvalError

Converts to this type from the input type.