Struct shrimple_parser::ParsingError

pub struct ParsingError<'rest, Reason> {
    pub rest: &'rest str,
    pub reason: Option<Reason>,
}

Error returned by a parser.

A parsing error may be either recoverable or fatal, parser methods such as Parser::or allow trying different paths if a recoverable error occurs, whereas a fatal error is not intended to be recovered from and should just be propagated.

This error isn’t an error per Rust’s definition, it doesn’t implement std::error::Error, the reason being that it lacks any information that’d make it actually useful, to make the error more useful, consider the following options:

• ParsingError::with_src_loc
• Parser::with_full_error

Fields

rest: &'rest str

The rest of the input that could not be processed.

reason: Option<Reason>

What the parser expected, the reason for the error. None means that the error is recoverable.

Implementations

impl<'rest, Reason> ParsingError<'rest, Reason>

pub const fn new(rest: &'rest str, expected: Reason) -> Self

Create a new fatal parsing error.

pub const fn new_recoverable(rest: &'rest str) -> Self

Create a new recoverable parsing error.

pub const fn is_recoverable(&self) -> bool

Returns a boolean indicating whether the error is recoverable.

pub fn reason<NewReason>( self, expected: NewReason ) -> ParsingError<'rest, NewReason>

Changes the reason associated with the error, making the error fatal.

pub fn map_reason<NewReason>( self, f: impl FnOnce(Reason) -> NewReason ) -> ParsingError<'rest, NewReason>

Transforms the reason by calling f, except if it’s a recoverable error, in which case it remains recoverable.

pub fn narrow_reason<NewReason>( self, expected: NewReason ) -> ParsingError<'rest, NewReason>

Changes the reason associated with error, except if it’s a recoverable error, in which case it remains recoverable.

pub fn with_src_loc<'path>( self, path: &'path Path, src: &str ) -> FullParsingError<'path, Reason>

Turns this error into a FullParsingError for more informative error report.

Trait Implementations

impl<'rest, Reason: Clone> Clone for ParsingError<'rest, Reason>

fn clone(&self) -> ParsingError<'rest, Reason>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'rest, Reason: Debug> Debug for ParsingError<'rest, Reason>

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

Formats the value using the given formatter.

impl<'rest, Reason: PartialEq> PartialEq for ParsingError<'rest, Reason>

fn eq(&self, other: &ParsingError<'rest, Reason>) -> 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<'rest, Reason: Copy> Copy for ParsingError<'rest, Reason>

impl<'rest, Reason: Eq> Eq for ParsingError<'rest, Reason>

impl<'rest, Reason> StructuralPartialEq for ParsingError<'rest, Reason>