Enum ParseError 

pub enum ParseError {
    NoCommand,
    Resolve(ResolveError),
    MissingArgument(String),
    UnexpectedArgument(String),
    MissingFlag(String),
    FlagMissingValue {
        name: String,
    },
    UnknownFlag(String),
    UnknownSubcommand {
        parent: String,
        got: String,
    },
    InvalidChoice {
        flag: String,
        value: String,
        choices: Vec<String>,
    },
    MutuallyExclusive {
        flags: Vec<String>,
    },
}

Errors produced by Parser::parse.

Variants

NoCommand

The argv slice was empty — no command name was provided.

Resolve(ResolveError)

The command (or subcommand) token could not be resolved.

Wraps a ResolveError transparently so callers can match on ResolveError::Unknown and ResolveError::Ambiguous directly.

MissingArgument(String)

A required positional argument was not supplied.

The inner String is the argument’s canonical name.

UnexpectedArgument(String)

More positional arguments were supplied than the command declares.

The inner String is the first unexpected token.

MissingFlag(String)

A required flag was not supplied, and no environment-variable fallback (registered with crate::FlagBuilder::env) provided a value.

The inner String is the flag’s long name (without --).

FlagMissingValue

A value-taking flag was provided without a following value.

Fields

name: String

The long name of the flag that was missing its value.

UnknownFlag(String)

A flag token (--name or -c) was not recognized by the resolved command.

The inner String includes the leading dashes, e.g. "--foo" or "-x". This variant is also raised when --no-{name} negation syntax is used with an unknown flag name or with a value-taking flag (which cannot be negated).

UnknownSubcommand

A word token following a subcommand-only parent did not match any declared subcommand.

Only raised when the parent command has no positional arguments defined; otherwise the word is treated as a positional value.

Fields

parent: String

The canonical name of the parent command.

got: String

The unrecognised token as supplied by the caller.

InvalidChoice

A flag value was provided that is not in the flag’s allowed choices.

Fields

flag: String

The flag’s long name.

value: String

The invalid value that was supplied.

choices: Vec<String>

The allowed values.

MutuallyExclusive

Two or more mutually exclusive flags were provided in the same invocation.

The flags field lists the conflicting flags (with -- prefix).

Fields

flags: Vec<String>

The conflicting flag names that were all set (with -- prefix).

Trait Implementations

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, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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 From<ParseError> for CliError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ResolveError> for ParseError

fn from(source: ResolveError) -> Self

Converts to this type from the input type.

impl PartialEq for ParseError

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