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 adapt_reason<NewReason>(self) -> ParsingError<In, NewReason>

where Infallible: From<Reason>,

Convert the reason of an always recoverable error to another type. This will be a no-op since it’s statically guaranteed that the reason doesn’t exist.

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

where In: Input,

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

The error will point to the provided source code. The provided path will only be used for display purposes, this method won’t access the file system.

Examples found in repository

examples/xml.rs (line 110)

fn main() {
    let input = args().nth(1).expect("XML input");
    for fragment in xml_fragments(&*input) {
        match fragment {
            Ok(fragment) => println!("{fragment:?}"),
            Err(e) => eprintln!("{}", e.with_src_loc("<input>", &input)),
        }
    }
}

pub fn with_file_loc<'a>( self, path: impl PathLike<'a>, ) -> Result<FullParsingError<'a, Reason>>

where In: Input,

Available on crate feature std only.

Turns this error into a FullParsingError that points to a file on the machine, for a more informative report.

Errors

Returns an error if std::fs::read_to_string does.

Trait Implementations

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

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

Returns a duplicate 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>