Enum arithmetic_parser::ErrorKind

#[non_exhaustive]
pub enum ErrorKind {
    NonAsciiInput,
    Literal(Error),
    LiteralName,
    Type(Error),
    UnsupportedOp(Op),
    UnexpectedChar {
        context: Option<Context>,
    },
    UnexpectedTerm {
        context: Option<Context>,
    },
    Leftovers,
    Incomplete,
    UnfinishedComment,
    ChainedComparison,
    Other {
        kind: ErrorKind,
        context: Option<Context>,
    },
}

Parsing error kind.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NonAsciiInput

Input is not in ASCII.

Literal(Error)

Error parsing literal.

LiteralName

Literal is used where a name is expected, e.g., as a function identifier.

An example of input triggering this error is 1(2, x); 1 is used as the function identifier.

Type(Error)

Error parsing type annotation.

UnsupportedOp(Op)

Unary or binary operation switched off in the parser features.

UnexpectedChar

No rules where expecting this character.

Fields

context: Option<Context>

Parsing context.

UnexpectedTerm

Unexpected expression end.

Fields

context: Option<Context>

Parsing context.

Leftovers

Leftover symbols after parsing.

Incomplete

Input is incomplete.

UnfinishedComment

Unfinished comment.

ChainedComparison

Chained comparison, such as 1 < 2 < 3.

Other

Other parsing error.

Fields

kind: ErrorKind

nom-defined error kind.

context: Option<Context>

Parsing context.

Implementations

impl ErrorKind

pub fn literal<T: Into<Error>>(error: T) -> Self

Creates a Literal variant with the specified error.

pub fn context(&self) -> Option<Context>

Returns optional error context.

pub fn is_incomplete(&self) -> bool

Returns true if this is Incomplete.

Trait Implementations

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl Error for ErrorKind

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

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<'a> FromExternalError<LocatedSpan<&'a str>, ErrorKind> for Error

fn from_external_error( input: InputSpan<'a>, _: NomErrorKind, err: ErrorKind, ) -> Self

Creates a new error from an input position, an ErrorKind indicating the wrapping parser, and an external error