Struct Rich 

pub struct Rich<'a, T, S = SimpleSpan> { /* private fields */ }

A rich default error type that tracks error spans, expected inputs, and the actual input found at an error site.

Please note that it uses a Vec to remember expected symbols. If you find this to be too slow, you can implement Error for your own error type or use Simple instead.

Implementations

impl<'a, T, S> Rich<'a, T, S>

pub fn custom<M>(span: S, msg: M) -> Rich<'a, T, S>

where M: ToString,

Create an error with a custom message and span

pub fn span(&self) -> &S

Get the span associated with this error.

pub fn reason(&self) -> &RichReason<'a, T>

Get the reason for this error.

pub fn into_reason(self) -> RichReason<'a, T>

Take the reason from this error.

pub fn found(&self) -> Option<&T>

Get the token found by this error when parsing. None implies that the error expected the end of input.

pub fn contexts(&self) -> impl Iterator<Item = (&RichPattern<'a, T>, &S)>

Return an iterator over the labelled contexts of this error, from least general to most.

‘Context’ here means parser patterns that the parser was in the process of parsing when the error occurred. To add labelled contexts, see Parser::labelled.

pub fn into_owned<'b>(self) -> Rich<'b, T, S>

where T: Clone,

Convert this error into an owned version of itself by cloning any borrowed internal tokens, if necessary.

pub fn expected(&self) -> impl ExactSizeIterator

Get an iterator over the expected items associated with this error

pub fn map_token<U, F>(self, f: F) -> Rich<'a, U, S>

where F: FnMut(T) -> U, T: Clone,

Transform this error’s tokens using the given function.

This is useful when you wish to combine errors from multiple compilation passes (lexing and parsing, say) where the token type for each pass is different (char vs MyToken, say).

Trait Implementations

impl<'a, T, S> Clone for Rich<'a, T, S>

where T: Clone, S: Clone,

fn clone(&self) -> Rich<'a, T, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for Rich<'_, T, S>

where T: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<T, S> Display for Rich<'_, T, S>

where T: Display, S: Display,

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

Formats the value using the given formatter.

impl<'a, I> Error<'a, I> for Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

where I: Input<'a>, <I as Input<'a>>::Token: PartialEq,

fn merge( self, other: Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>, ) -> Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

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

impl<'a, T, S> Hash for Rich<'a, T, S>

where T: Hash, S: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, I, L> LabelError<'a, I, L> for Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

where I: Input<'a>, <I as Input<'a>>::Token: PartialEq, L: Into<RichPattern<'a, <I as Input<'a>>::Token>>,

fn expected_found<E>( expected: E, found: Option<Maybe<<I as Input<'a>>::Token, &'a <I as Input<'a>>::Token>>, span: <I as Input<'a>>::Span, ) -> Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

where E: IntoIterator<Item = L>,

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

fn merge_expected_found<E>( self, new_expected: E, new_found: Option<Maybe<<I as Input<'a>>::Token, &'a <I as Input<'a>>::Token>>, _span: <I as Input<'a>>::Span, ) -> Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

where E: IntoIterator<Item = L>,

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

fn replace_expected_found<E>( self, new_expected: E, new_found: Option<Maybe<<I as Input<'a>>::Token, &'a <I as Input<'a>>::Token>>, span: <I as Input<'a>>::Span, ) -> Rich<'a, <I as Input<'a>>::Token, <I as Input<'a>>::Span>

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<'a>>::Span)

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

impl<'a, T, S> PartialEq for Rich<'a, T, S>

where T: PartialEq, S: PartialEq,

fn eq(&self, other: &Rich<'a, T, S>) -> 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<'a, T, S> Eq for Rich<'a, T, S>

where T: Eq, S: Eq,

impl<'a, T, S> StructuralPartialEq for Rich<'a, T, S>