Enum spaik::error::ErrorKind

pub enum ErrorKind {
    SendError {
        obj_dbg: String,
    },
    STypeError {
        expect: String,
        got: String,
    },
    UnexpectedDottedList,
    TypeError {
        expect: Builtin,
        got: Builtin,
    },
    TypeNError {
        expect: Vec<Builtin>,
        got: Builtin,
    },
    ArgTypeError {
        expect: Vec<Builtin>,
        got: Vec<Builtin>,
    },
    IfaceNotImplemented {
        got: Vec<SymID>,
    },
    EnumError {
        expect: Vec<SymID>,
        got: SymID,
    },
    ArgError {
        expect: ArgSpec,
        got_num: u32,
    },
    OutsideContext {
        op: Builtin,
        ctx: Builtin,
    },
    SyntaxErrorMsg {
        msg: String,
    },
    LinkError {
        dst: String,
        src: usize,
    },
    ConversionError {
        from: &'static str,
        to: &'static str,
        val: String,
    },
    NotEnough {
        expect: usize,
        got: usize,
    },
    SomeError {
        msg: String,
    },
    UndefinedFunction {
        name: SymID,
    },
    UndefinedVariable {
        var: SymID,
    },
    ModuleLoadError {
        lib: SymID,
    },
    ModuleNotFound {
        lib: SymID,
    },
    Unsupported {
        op: &'static str,
    },
    Traceback {
        tb: Box<Traceback>,
    },
    IndexError {
        idx: usize,
    },
    Exit {
        status: SymID,
    },
    IOError {
        kind: ErrorKind,
    },
    MissingFeature {
        flag: &'static str,
    },
    CharSpecError {
        spec: SymID,
    },
    LibError {
        name: SymID,
    },
    TrailingDelimiter {
        close: &'static str,
    },
    UnclosedDelimiter {
        open: &'static str,
    },
    TrailingModifiers {
        mods: String,
    },
    TrailingEscape,
    NoSuchEscapeChar {
        chr: char,
    },
    UnterminatedString,
    MacroexpandRecursionLimit {
        lim: usize,
    },
    SyntaxError(SyntaxErrorKind),
    IDError {
        id: usize,
    },
    None,
}

Variants

SendError

Fields

obj_dbg: String

STypeError

Fields

expect: String

got: String

UnexpectedDottedList

TypeError

Fields

expect: Builtin

got: Builtin

TypeNError

Fields

expect: Vec<Builtin>

got: Builtin

ArgTypeError

Fields

expect: Vec<Builtin>

got: Vec<Builtin>

IfaceNotImplemented

Fields

got: Vec<SymID>

EnumError

Fields

expect: Vec<SymID>

got: SymID

ArgError

Fields

expect: ArgSpec

got_num: u32

OutsideContext

Fields

op: Builtin

ctx: Builtin

SyntaxErrorMsg

Fields

msg: String

LinkError

Fields

dst: String

src: usize

ConversionError

Fields

from: &'static str

to: &'static str

val: String

NotEnough

Fields

expect: usize

got: usize

SomeError

Fields

msg: String

UndefinedFunction

Fields

name: SymID

UndefinedVariable

Fields

var: SymID

ModuleLoadError

Fields

lib: SymID

ModuleNotFound

Fields

lib: SymID

Unsupported

Fields

op: &'static str

Traceback

Fields

tb: Box<Traceback>

IndexError

Fields

idx: usize

Exit

Fields

status: SymID

IOError

Fields

kind: ErrorKind

MissingFeature

Fields

flag: &'static str

CharSpecError

Fields

spec: SymID

LibError

Fields

name: SymID

TrailingDelimiter

Fields

close: &'static str

UnclosedDelimiter

Fields

open: &'static str

TrailingModifiers

Fields

mods: String

TrailingEscape

NoSuchEscapeChar

Fields

chr: char

UnterminatedString

MacroexpandRecursionLimit

Fields

lim: usize

SyntaxError(SyntaxErrorKind)

IDError

Fields

id: usize

None

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl Error for ErrorKind

fn source(&self) -> Option<&(dyn Error + 'static)>

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, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl From<ErrorKind> for Error

fn from(v: ErrorKind) -> Self

Converts to this type from the input type.

impl PartialEq<ErrorKind> for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ErrorKind