Struct ParsingError

pub struct ParsingError<In, Reason = Infallible> {
    pub rest: In,
    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.

To make the error more useful, consider the following options:

• ParsingError::with_src_loc
• Parser::with_full_error

Fields

rest: In

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<In, Reason> ParsingError<In, Reason>

pub const fn new(rest: In, reason: Reason) -> Self

Create a new fatal parsing error.

pub const fn new_recoverable(rest: In) -> 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, reason: NewReason) -> ParsingError<In, NewReason>

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

pub fn or_reason(self, reason: Reason) -> Self

Makes a recoverable error fatal by giving it a reason, if it’s already fatal, does nothing

pub fn or_reason_if_nonempty(self, reason: Reason) -> Self

where In: Input,

Like ParsingError::or_reason but does nothing if the rest of the input is empty

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

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

pub fn with_src_loc<'path>( self, path: impl PathLike<'path>, input: &str, ) -> FullParsingError<'path, Reason>

where In: Input,

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

Trait Implementations

impl<In: Clone, Reason: Clone> Clone for ParsingError<In, Reason>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<In: Debug, Reason: Debug> Debug for ParsingError<In, Reason>

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

Formats the value using the given formatter.

impl<In: Input, Reason: Display> Display for ParsingError<In, Reason>

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

Formats the value using the given formatter.

impl<In: Input, Reason: Error> Error for ParsingError<In, Reason>

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

Returns 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, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl<In: PartialEq, Reason: PartialEq> PartialEq for ParsingError<In, Reason>

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

impl<In: Eq, Reason: Eq> Eq for ParsingError<In, Reason>

impl<In, Reason> StructuralPartialEq for ParsingError<In, Reason>