Struct VocabularyParseError 

pub struct VocabularyParseError {
    vocabulary: &'static str,
    input: String,
    accepted: &'static [&'static str],
    form: Option<&'static str>,
}

Error parsing a closed vocabulary from a string.

Carries the accepted spellings so the message can list them; the list comes from the same declaration that built the parser, so a message can never omit an accepted value or advertise a rejected one.

Listing, shape, and both

Not every vocabulary a caller names by string is finite, and the ones that are not still owe the caller a message that corrects the common mistake. Three shapes, and every rejection in the crate is one of them:

Constructor	Accepted set	Message
new	closed	lists it
new + with_tail	closed names plus an open tail	lists the names, then names the tail’s form
of_form	too large to read	names the form only

A rejection carrying neither a list nor a form is refused by tests/closed_vocabulary.rs, which is what makes the third column a promise rather than a habit. of_form is not an escape from listing: it is for an identifier space with a stated form, where enumerating would bury the correction — a currency code rejected for its case wants to be told about case, not handed ISO 4217.

Fields

vocabulary: &'static str

input: String

accepted: &'static [&'static str]

form: Option<&'static str>

Implementations

impl VocabularyParseError

pub fn new( vocabulary: &'static str, input: &str, accepted: &'static [&'static str], ) -> Self

Builds a parse error from the vocabulary’s label, the offending input, and the full accepted set.

pub fn with_tail(self, form: &'static str) -> Self

Adds the open tail to a listing rejection: the vocabulary accepts its listed names and a shape — a frequency, which takes its variant names and any period code; a roll convention, which takes its names and any day of the month. form describes the tail and renders after the list.

pub fn of_form( vocabulary: &'static str, input: &str, form: &'static str, ) -> Self

Builds a parse error for a vocabulary too large to enumerate usefully, carrying the expected form instead of a list.

form SHALL state the shape well enough to correct the common mistake: a currency code rejected for its case says that codes are upper-case.

pub fn input(&self) -> &str

The spelling that failed to parse.

pub fn accepted(&self) -> &'static [&'static str]

Every spelling this vocabulary accepts, empty where the set is carried as a form instead.

pub fn form(&self) -> Option<&'static str>

The shape of what this vocabulary accepts beyond its listed spellings, or None where the list is the whole of it.

pub fn vocabulary(&self) -> &'static str

The vocabulary’s label, as it appears in the message.

Trait Implementations

impl Clone for VocabularyParseError

fn clone(&self) -> VocabularyParseError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VocabularyParseError

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

Formats the value using the given formatter.

impl Display for VocabularyParseError

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

Formats the value using the given formatter.

impl Eq for VocabularyParseError

impl Error for VocabularyParseError

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 From<VocabularyParseError> for FxIndexError

fn from(e: VocabularyParseError) -> Self

Converts to this type from the input type.

impl PartialEq for VocabularyParseError

fn eq(&self, other: &VocabularyParseError) -> 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 StructuralPartialEq for VocabularyParseError