Clap — Command Line Argument Parser for Rust

What it is

Clap is the most widely used CLI argument parser for Rust. It offers two styles: a derive macro approach where you annotate a struct with argument definitions, and a builder API for dynamic or complex argument trees. Clap handles help text generation, shell completions, subcommands, argument groups, value validation, and error formatting.

Clap is the Rust equivalent of Python argparse but with compile-time validation and significantly richer features. It suits anyone building command-line tools in Rust, from simple scripts to complex multi-subcommand applications like cargo itself.

How it saves time or tokens

Without Clap, you parse std::env::args manually, write your own help text, handle missing or invalid values, and build shell completion scripts by hand. Clap generates all of this from your struct definition. A CLI with ten flags, three subcommands, and bash/zsh/fish completions takes minutes to define instead of hours.

How to use

1. Add Clap with derive support: cargo add clap --features derive.
2. Define a struct annotated with #[derive(Parser)] and use #[arg(...)] attributes for each field.
3. Call Cli::parse() in main -- Clap reads arguments, validates them, and returns a populated struct.

Example

use clap::Parser;

#[derive(Parser)]
#[command(name = 'myapp', about = 'A sample CLI application')]
struct Cli {
    /// Name of the person to greet
    #[arg(short, long)]
    name: String,

    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
}

fn main() {
    let cli = Cli::parse();
    for _ in 0..cli.count {
        println!('Hello {}!', cli.name);
    }
}

$ cargo run -- --name Alice --count 3
Hello Alice!
Hello Alice!
Hello Alice!

Related on TokRepo

• Automation Tools -- CLI utilities and build tools
• Coding Tools -- Developer productivity libraries

Common pitfalls

• Forgetting the derive feature flag results in cryptic compile errors since the Parser derive macro is feature-gated.
• Using String for optional arguments without wrapping in Option<String> makes Clap require the argument, which confuses users who expect it to be optional.
• Not specifying value_parser for custom types leads to unhelpful error messages when validation fails.