Enum GenericErrorTree

pub enum GenericErrorTree<Location, Tag, Context, ExternalError> {
    Base {
        location: Location,
        kind: BaseErrorKind<Tag, ExternalError>,
    },
    Stack {
        base: Box<Self>,
        contexts: Vec<(Location, StackContext<Context>)>,
    },
    Alt(Vec<Self>),
}

Generic version of ErrorTree, which allows for arbitrary Tag, Context, and ExternalError types. See ErrorTree for more extensive docs and examples.

• Tag is typically something like &'static str or &'static [u8].
• Context is typically &'static str, and it must be in order to interoperate with nom’s context combinator. nom-supreme provides a more generic .context combinator that allows for any kind of context to be attached to an error.
• Error can usually be nothing, as it’s unusual for nom parsers to require external errors. Box<dyn Error + Send + Sync + 'static> is a common catch-all.

Variants

Base

A specific error event at a specific location. Often this will indicate that something like a tag or character was expected at that location.

Fields

location: Location

The location of this error in the input

kind: BaseErrorKind<Tag, ExternalError>

The specific error that occurred

Stack

A stack indicates a chain of error contexts was provided. The stack should be read “backwards”; that is, errors earlier in the Vec occurred “sooner” (deeper in the call stack).

Fields

base: Box<Self>

The original error

contexts: Vec<(Location, StackContext<Context>)>

The stack of contexts attached to that error

Alt(Vec<Self>)

A series of parsers were tried at the same location (for instance, via the alt combinator) and all of them failed. All of the errors in this set are “siblings”.

Implementations

impl<I, T, C, E> GenericErrorTree<I, T, C, E>

pub fn map_locations<I2>( self, convert_location: impl FnMut(I) -> I2, ) -> GenericErrorTree<I2, T, C, E>

Convert all of the locations in this error using some kind of mapping function. This is intended to help add additional context that may not have been available when the nom parsers were running, such as line and column numbers.

Trait Implementations

impl<I, T, E> ContextError<I> for GenericErrorTree<I, T, &'static str, E>

fn add_context(location: I, ctx: &'static str, other: Self) -> Self

Creates a new error from an input position, a static string and an existing error. This is used mainly in the context combinator, to add user friendly information to errors when backtracking through a parse tree

impl<I, T, C, E> ContextError<I, C> for GenericErrorTree<I, T, C, E>

fn add_context(location: I, ctx: C, other: Self) -> Self

Create a new error from an input position, a context, and an existing error. This is used by the .context combinator to add friendly information to errors when backtracking through a parse tree.

impl<Location: Debug, Tag: Debug, Context: Debug, ExternalError: Debug> Debug for GenericErrorTree<Location, Tag, Context, ExternalError>

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

Formats the value using the given formatter.

impl<I: Display, T: Debug, C: Debug, E: Display> Display for GenericErrorTree<I, T, C, E>

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

Formats the value using the given formatter.

impl<I: Display + Debug, T: Debug, C: Debug, E: Display + Debug> Error for GenericErrorTree<I, T, C, E>

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<I, T, C, E> ErrorConvert<GenericErrorTree<(I, usize), T, C, E>> for GenericErrorTree<I, T, C, E>

fn convert(self) -> GenericErrorTree<(I, usize), T, C, E>

Transform to another error type

impl<I, T, C, E> ErrorConvert<GenericErrorTree<I, T, C, E>> for GenericErrorTree<(I, usize), T, C, E>

fn convert(self) -> GenericErrorTree<I, T, C, E>

Transform to another error type

impl<I, I2, T, C, E> ExtractContext<I, GenericErrorTree<I2, T, C, E>> for GenericErrorTree<I, T, C, E>

where I: Clone, I2: RecreateContext<I>,

fn extract_context(self, original_input: I) -> GenericErrorTree<I2, T, C, E>

Given the context attached to a nom error, and given the original input to the nom parser, extract more the useful context information.

impl<I, T, C, E, E2> FromExternalError<I, E2> for GenericErrorTree<I, T, C, E>

where E: From<E2>,

fn from_external_error(location: I, _kind: NomErrorKind, e: E2) -> Self

Create an error from a given external error, such as from FromStr

impl<I: InputLength, T, C, E> ParseError<I> for GenericErrorTree<I, T, C, E>

fn from_error_kind(location: I, kind: NomErrorKind) -> Self

Create a new error at the given position. Interpret kind as an Expectation if possible, to give a more informative error message.

fn append(location: I, kind: NomErrorKind, other: Self) -> Self

Combine an existing error with a new one. This is how error context is accumulated when backtracing. “other” is the original error, and the inputs new error from higher in the call stack.

If other is already an GenericErrorTree::Stack, the context is added to the stack; otherwise, a new stack is created, with other at the root.

fn from_char(location: I, character: char) -> Self

Create an error indicating an expected character at a given position

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

Combine two errors from branches of alt. If either or both errors are already GenericErrorTree::Alt, the different error sets are merged; otherwise, a new GenericErrorTree::Alt is created, containing both self and other.

impl<I, T: AsRef<[u8]>, C, E> TagError<I, T> for GenericErrorTree<I, T, C, E>

fn from_tag(location: I, tag: T) -> Self

Create an error from an expected tag at a location.

fn from_tag_no_case(input: I, tag: T) -> Self

As above, but for a case insensitive tag. By default this just calls from_tag