Enum ParseError 

#[non_exhaustive]
pub enum ParseError {
    Empty,
    TooLong,
    InvalidLetter,
}

The reason a string could not be parsed as a SIN token.

Returned by the parsing entry points (crate::Identifier::parse, core::str::FromStr, TryFrom) and by crate::Letter::try_from_char.

This enum is #[non_exhaustive]: future revisions may add variants without a breaking change, so downstream match expressions should include a wildcard arm.

Length is measured in bytes

A valid token is one ASCII letter, which is always exactly one byte, so the parser can decide on the byte length before looking at any content. The consequence is worth knowing when reading the variant back: an input of one character that occupies several bytes — any non-ASCII character, such as é — is reported as TooLong, not as InvalidLetter. Both say “this is not a token”, and the specification requires only that such input be rejected; only the reported reason differs.

The rule is exact: InvalidLetter means the input was one byte that was not an ASCII letter, and TooLong means it was two bytes or more.

Examples

use sashite_sin::{Identifier, ParseError};

assert_eq!("".parse::<Identifier>(), Err(ParseError::Empty));
assert_eq!("CC".parse::<Identifier>(), Err(ParseError::TooLong));
assert_eq!("1".parse::<Identifier>(), Err(ParseError::InvalidLetter));

// One character, two bytes: rejected as too long.
assert_eq!("é".chars().count(), 1);
assert_eq!("é".parse::<Identifier>(), Err(ParseError::TooLong));

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.

Empty

The input was empty.

TooLong

The input was two bytes or more, and a token is exactly one.

Because the check counts bytes, this also covers an input of a single non-ASCII character; see the note on the enum itself.

InvalidLetter

The input was a single byte that was not an ASCII letter.

Trait Implementations

impl Clone for ParseError

fn clone(&self) -> ParseError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParseError

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Display for ParseError

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

Writes a short, human-readable reason.

The message goes out through core::fmt::Formatter::pad, so width, fill, alignment and precision behave as they do for the equivalent str; writing it straight to the buffer would silently discard those options when a caller lines errors up in a column.

impl Eq for ParseError

impl Error for ParseError

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 Hash for ParseError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ParseError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParseError