Enum ess::parser::ParseError

pub enum ParseError<Loc = ByteSpan>where
    Loc: Span,{
    UnexpectedEof,
    List(Box<ParseError>, Loc),
    Sexp(Box<ParseError>, Loc),
    Char(Box<ParseError>, Loc),
    String(Box<ParseError>, Loc),
    Symbol(Box<ParseError>, Loc),
    Number(Box<ParseError>, Loc),
    Unexpected(char, Loc::Begin),
}

Indicates how parsing failed.

Most ParseError variants contain a Box<ParseError> that represents the cause of that error. Using this, ParseError variants can be chained to produce a more complete picture of what exactly went wrong during parsing.

Variants

UnexpectedEof

Parsing reached the end of input where not expecting to, usually this will be contained inside another ParseError like String(box UnexpectedEof, ...) which indicates that the closing quote was never found.

List(Box<ParseError>, Loc)

Some problem occurred while parsing a list, along with the cause of that error.

Sexp(Box<ParseError>, Loc)

Some problem occurred while parsing an s-expression. This will only be generated if EOF is reached unexpectedly at the beginning of parse_expression, so it should probably be removed.

Char(Box<ParseError>, Loc)

Some problem occurred while parsing a character literal, along with the cause of the error.

String(Box<ParseError>, Loc)

Some problem occurred while parsing a string literal, along with the cause of the error.

Symbol(Box<ParseError>, Loc)

Some problem occurred while parsing a symbol, along with the cause of the error.

Number(Box<ParseError>, Loc)

Some problem occurred while parsing a number literal, along with the cause of the error.

Unexpected(char, Loc::Begin)

An unexpected character was found. This will usually be the root cause in some chain of ParseErrors.

Trait Implementations

impl<Loc: Clone> Clone for ParseError<Loc>where
    Loc: Span,
    Loc::Begin: Clone,

fn clone(&self) -> ParseError<Loc>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Loc: Debug> Debug for ParseError<Loc>where
    Loc: Span,
    Loc::Begin: Debug,

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

Formats the value using the given formatter.

impl<Loc: PartialEq> PartialEq<ParseError<Loc>> for ParseError<Loc>where
    Loc: Span,
    Loc::Begin: PartialEq,

fn eq(&self, other: &ParseError<Loc>) -> 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<Loc: Eq> Eq for ParseError<Loc>where
    Loc: Span,
    Loc::Begin: Eq,

impl<Loc> StructuralEq for ParseError<Loc>where
    Loc: Span,

impl<Loc> StructuralPartialEq for ParseError<Loc>where
    Loc: Span,