# Enum clap::error::ErrorKind

source · [−]

    #[non_exhaustive]
    pub enum ErrorKind {
    Show 17 variants    InvalidValue,
        UnknownArgument,
        InvalidSubcommand,
        NoEquals,
        ValueValidation,
        TooManyValues,
        TooFewValues,
        WrongNumberOfValues,
        ArgumentConflict,
        MissingRequiredArgument,
        MissingSubcommand,
        InvalidUtf8,
        DisplayHelp,
        DisplayHelpOnMissingArgumentOrSubcommand,
        DisplayVersion,
        Io,
        Format,
    }

Expand description

Command line argument parser kind of error

## Variants (Non-exhaustive)

This enum is marked as 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.

### `InvalidValue`

Occurs when an `Arg` has a set of possible values, and the user provides a value which isn’t in that set.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("speed")
            .value_parser(["fast", "slow"]))
        .try_get_matches_from(vec!["prog", "other"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);

### `UnknownArgument`

Occurs when a user provides a flag, option, argument or subcommand which isn’t defined.

#### Examples

    let result = Command::new("prog")
        .arg(arg!(--flag "some flag"))
        .try_get_matches_from(vec!["prog", "--other"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::UnknownArgument);

### `InvalidSubcommand`

Occurs when the user provides an unrecognized `Subcommand` which meets the threshold for being similar enough to an existing subcommand. If it doesn’t meet the threshold, or the ‘suggestions’ feature is disabled, the more general `UnknownArgument` error is returned.

#### Examples

    let result = Command::new("prog")
       .subcommand(Command::new("config")
           .about("Used for configuration")
           .arg(Arg::new("config_file")
               .help("The configuration file to use")))
       .try_get_matches_from(vec!["prog", "confi"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidSubcommand);

### `NoEquals`

Occurs when the user doesn’t use equals for an option that requires equal sign to provide values.

    let res = Command::new("prog")
        .arg(Arg::new("color")
             .action(ArgAction::Set)
             .require_equals(true)
             .long("color"))
        .try_get_matches_from(vec!["prog", "--color", "red"]);
    assert!(res.is_err());
    assert_eq!(res.unwrap_err().kind(), ErrorKind::NoEquals);

### `ValueValidation`

Occurs when the user provides a value for an argument with a custom validation and the value fails that validation.

#### Examples

    fn is_numeric(val: &str) -> Result<(), String> {
        match val.parse::<i64>() {
            Ok(..) => Ok(()),
            Err(..) => Err(String::from("Value wasn't a number!")),
        }
    }

    let result = Command::new("prog")
        .arg(Arg::new("num")
             .value_parser(value_parser!(u8)))
        .try_get_matches_from(vec!["prog", "NotANumber"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::ValueValidation);

### `TooManyValues`

Occurs when a user provides more values for an argument than were defined by setting `Arg::num_args`.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("arg")
            .num_args(1..=2))
        .try_get_matches_from(vec!["prog", "too", "many", "values"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::TooManyValues);

### `TooFewValues`

Occurs when the user provides fewer values for an argument than were defined by setting `Arg::num_args`.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("some_opt")
            .long("opt")
            .num_args(3..))
        .try_get_matches_from(vec!["prog", "--opt", "too", "few"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::TooFewValues);

### `WrongNumberOfValues`

Occurs when the user provides a different number of values for an argument than what’s been defined by setting `Arg::num_args` or than was implicitly set by `Arg::value_names`.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("some_opt")
            .long("opt")
            .action(ArgAction::Set)
            .num_args(2))
        .try_get_matches_from(vec!["prog", "--opt", "wrong"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);

### `ArgumentConflict`

Occurs when the user provides two values which conflict with each other and can’t be used together.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("debug")
            .long("debug")
            .action(ArgAction::SetTrue)
            .conflicts_with("color"))
        .arg(Arg::new("color")
            .long("color")
            .action(ArgAction::SetTrue))
        .try_get_matches_from(vec!["prog", "--debug", "--color"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::ArgumentConflict);

### `MissingRequiredArgument`

Occurs when the user does not provide one or more required arguments.

#### Examples

    let result = Command::new("prog")
        .arg(Arg::new("debug")
            .required(true))
        .try_get_matches_from(vec!["prog"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::MissingRequiredArgument);

### `MissingSubcommand`

Occurs when a subcommand is required (as defined by `Command::subcommand_required`), but the user does not provide one.

#### Examples

    let err = Command::new("prog")
        .subcommand_required(true)
        .subcommand(Command::new("test"))
        .try_get_matches_from(vec![
            "myprog",
        ]);
    assert!(err.is_err());
    assert_eq!(err.unwrap_err().kind(), ErrorKind::MissingSubcommand);

### `InvalidUtf8`

Occurs when the user provides a value containing invalid UTF-8.

To allow arbitrary data

- Set [`Arg::value_parser(value_parser!(OsString))`] for argument values
- Set `Command::external_subcommand_value_parser` for external-subcommand values

#### Platform Specific

Non-Windows platforms only (such as Linux, Unix, OSX, etc.)

#### Examples

    let result = Command::new("prog")
       .arg(Arg::new("utf8")
           .short('u')
           .action(ArgAction::Set))
       .try_get_matches_from(vec![OsString::from("myprog"),
                                   OsString::from("-u"),
                                   OsString::from_vec(vec![0xE9])]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidUtf8);

### `DisplayHelp`

Not a true “error” as it means `--help` or similar was used. The help message will be sent to `stdout`.

Note: If the help is displayed due to an error (such as missing subcommands) it will be sent to `stderr` instead of `stdout`.

#### Examples

    let result = Command::new("prog")
       .try_get_matches_from(vec!["prog", "--help"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayHelp);

### `DisplayHelpOnMissingArgumentOrSubcommand`

Occurs when either an argument or a `Subcommand` is required, as defined by `Command::arg_required_else_help` , but the user did not provide one.

#### Examples

    let result = Command::new("prog")
        .arg_required_else_help(true)
        .subcommand(Command::new("config")
            .about("Used for configuration")
            .arg(Arg::new("config_file")
                .help("The configuration file to use")))
        .try_get_matches_from(vec!["prog"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand);

### `DisplayVersion`

Not a true “error” as it means `--version` or similar was used. The message will be sent to `stdout`.

#### Examples

    let result = Command::new("prog")
        .version("3.0")
        .try_get_matches_from(vec!["prog", "--version"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayVersion);

### `Io`

Represents an I/O error. Can occur when writing to `stderr` or `stdout` or reading a configuration file.

### `Format`

Represents a Format error (which is a part of `Display`). Typically caused by writing to `stderr` or `stdout`.

## Implementations

source

### impl ErrorKind

source

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

End-user description of the error case, where relevant

## Trait Implementations

source

### impl Clone for ErrorKind

source

#### fn clone(&self) -> ErrorKind

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl Debug for ErrorKind

source

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

Formats the value using the given formatter. Read more

source

### impl Display for ErrorKind

source

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

Formats the value using the given formatter. Read more

source

### impl Hash for ErrorKind

source

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

Feeds this value into the given `Hasher`. Read more

1.3.0 · source

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

Feeds a slice of this type into the given `Hasher`. Read more

source

### impl PartialEq<ErrorKind> for ErrorKind

source

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

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

1.0.0 · source

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

This method tests for `!=`.

source

### impl Copy for ErrorKind

source

### impl Eq for ErrorKind

source

### impl StructuralEq for ErrorKind

source

### impl StructuralPartialEq for ErrorKind

## Auto Trait Implementations

### impl RefUnwindSafe for ErrorKind

### impl Send for ErrorKind

### impl Sync for ErrorKind

### impl Unpin for ErrorKind

### impl UnwindSafe for ErrorKind

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T> ToString for T where
T: Display + ?Sized,

source

#### default fn to_string(&self) -> String

Converts the given value to a `String`. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.