Enum ParserError 

pub enum ParserError {
    ExpectedFound {
        span: SimpleSpan,
    },
    UnknownPrefix {
        span: SimpleSpan,
        prefix: String,
    },
    Reserved {
        span: SimpleSpan,
        name: String,
    },
    ArityOverflow {
        span: SimpleSpan,
    },
    UnknownType {
        span: SimpleSpan,
        name: Name,
    },
    IllegalFunctionInPattern {
        span: SimpleSpan,
        name: Name,
    },
}

Variants

ExpectedFound

Fields

span: SimpleSpan

UnknownPrefix

Fields

span: SimpleSpan

prefix: String

Reserved

Fields

span: SimpleSpan

name: String

ArityOverflow

Fields

span: SimpleSpan

UnknownType

Fields

span: SimpleSpan

name: Name

IllegalFunctionInPattern

Fields

span: SimpleSpan

name: Name

Implementations

impl ParserError

pub fn span(&self) -> Span

pub fn adjust(self, start: usize) -> Self

Trait Implementations

impl Clone for ParserError

fn clone(&self) -> ParserError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserError

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

Formats the value using the given formatter.

impl<'a, I> Error<'a, I> for ParserError

where I: ValueInput<'a, Token = Token<'a>, Span = SimpleSpan>,

fn merge(self, other: Self) -> Self

Merge two errors that point to the same input together, combining their information.

impl<'a, I, L> LabelError<'a, I, L> for ParserError

where I: ValueInput<'a, Token = Token<'a>, Span = SimpleSpan>,

fn expected_found<E: IntoIterator<Item = L>>( _expected: E, _found: Option<MaybeRef<'a, I::Token>>, span: I::Span, ) -> Self

Create a new error describing a conflict between expected inputs and that which was actually found.

fn merge_expected_found<E>( self, expected: E, found: Option<Maybe<<I as Input<'src>>::Token, &'src <I as Input<'src>>::Token>>, span: <I as Input<'src>>::Span, ) -> Self

where E: IntoIterator<Item = L>, Self: Error<'src, I>,

Fast path for a.merge(LabelError::expected_found(...)) that may incur less overhead by, for example, reusing allocations.

fn replace_expected_found<E>( self, expected: E, found: Option<Maybe<<I as Input<'src>>::Token, &'src <I as Input<'src>>::Token>>, span: <I as Input<'src>>::Span, ) -> Self

where E: IntoIterator<Item = L>,

Fast path for a = LabelError::expected_found(...) that may incur less overhead by, for example, reusing allocations.

fn label_with(&mut self, label: L)

Annotate the expected patterns within this parser with the given label.

fn in_context(&mut self, label: L, span: <I as Input<'src>>::Span)

Annotate this error, indicating that it occurred within the context denoted by the given label.

impl PartialEq for ParserError

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for ParserError