Struct OptionParser 

pub struct OptionParser { /* private fields */ }

The main option parser.

This parser handles the low-level parsing of command-line arguments. It supports both short and long options, with various actions like store, append, and count.

Example

use click::parser::{OptionParser, OptionAction, ParsedValue};

let mut parser = OptionParser::new();
parser.add_option(&["-n", "--name"], "name", OptionAction::Store, 1, None);
parser.add_option(&["-v", "--verbose"], "verbose", OptionAction::Count, 0, None);
parser.add_argument("file", 1);

let args = vec!["-v", "-v", "--name", "test", "input.txt"]
    .into_iter().map(String::from).collect();
let (opts, remaining, order) = parser.parse_args(args).unwrap();

assert_eq!(opts.get("verbose"), Some(&ParsedValue::Count(2)));
assert_eq!(opts.get("name"), Some(&ParsedValue::Single("test".to_string())));

Implementations

impl OptionParser

pub fn new() -> Self

Create a new option parser with default settings.

pub fn allow_interspersed_args(self, allow: bool) -> Self

Set whether to allow interspersed positional arguments.

When true (default), positional args can appear between options. When false, the parser stops on the first non-option.

pub fn ignore_unknown_options(self, ignore: bool) -> Self

Set whether to ignore unknown options.

When true, unknown options are passed through as positional args. When false (default), unknown options cause an error.

pub fn token_normalize_func<F>(self, func: F) -> Self

where F: Fn(&str) -> String + Send + Sync + 'static,

Set a token normalization function.

This function is applied to option names for matching. Useful for case-insensitive option matching.

pub fn add_option( &mut self, opts: &[&str], dest: &str, action: OptionAction, nargs: i32, const_value: Option<&str>, )

Add an option to the parser.

Arguments

• opts - Option strings (e.g., ["-n", "--name"])
• dest - Destination key in the results
• action - Action to perform when option is encountered
• nargs - Number of arguments (1 = single, -1 = variadic, 0 = flag, -2 = optional)
• const_value - Constant value for StoreConst/AppendConst actions

pub fn add_option_ex( &mut self, opts: &[&str], dest: &str, action: OptionAction, nargs: i32, const_value: Option<&str>, flag_needs_value: bool, )

Add an option to the parser with extended options.

Arguments

• opts - Option strings (e.g., ["-n", "--name"])
• dest - Destination key in the results
• action - Action to perform when option is encountered
• nargs - Number of arguments (1 = single, -1 = variadic, 0 = flag, -2 = optional)
• const_value - Constant value for StoreConst/AppendConst actions
• flag_needs_value - If true, value is optional: if next arg looks like an option, returns FlagNeedsValue instead of consuming it

pub fn add_argument(&mut self, dest: &str, nargs: i32)

Add a positional argument to the parser.

Arguments

• dest - Destination key in the results
• nargs - Number of values (1 = single, -1 = variadic)

pub fn parse_args(&self, args: Vec<String>) -> ParseResult

Parse command-line arguments.

Returns

A tuple of:

• Parsed option values (dest -> value)
• Remaining unparsed arguments
• Order of parameters as they were seen

Errors

Returns a ClickError if parsing fails (e.g., unknown option, missing value).

Trait Implementations

impl Debug for OptionParser

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

Formats the value using the given formatter.

impl Default for OptionParser

fn default() -> Self

Returns the “default value” for a type.