Enum ParseErrorKind 

pub enum ParseErrorKind {
    Lex(LexErrorKind),
    Unexpected {
        found: String,
        expected: Vec<&'static str>,
    },
    UnexpectedEnd {
        expected: Vec<&'static str>,
    },
    Unsupported(&'static str),
    Refused(String),
    LimitExceeded(&'static str),
}

Why a parse failed.

Variants

Lex(LexErrorKind)

The lexer refused a byte sequence.

Unexpected

A token appeared where the grammar did not allow it.

Fields

found: String

What was found, as source text.

expected: Vec<&'static str>

The smallest useful set of things that would have been accepted.

UnexpectedEnd

The statement ended before the production did.

Fields

expected: Vec<&'static str>

What would have continued it.

Unsupported(&'static str)

A construct the grammar has but this phase does not implement.

Refused(String)

A statement the schema refuses, in the reference’s own wording.

It is not a syntax error and does not read as one: the statement parsed and the schema will not have it, which is what foreign key mismatch says.

LimitExceeded(&'static str)

A hard limit was exceeded.

Trait Implementations

impl Clone for ParseErrorKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseErrorKind

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

Formats the value using the given formatter.

impl Eq for ParseErrorKind

impl PartialEq for ParseErrorKind

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ParseErrorKind