Combinatoric example

```no_run
#[derive(Debug, Clone)]
pub struct Options {
    argument: usize,
    switch: bool,
}

pub fn options() -> OptionParser<Options> {
    let argument = long("argument")
        .help("An argument")
        .argument::<usize>("ARG");
    let switch = short('s').help("A switch").switch();
    let options = construct!(Options { argument, switch });

    // Given the cargo command is `cargo pretty`.
    cargo_helper("pretty", options).to_options()
}

fn main() {
    println!("{:?}", options().run())
}
```


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options("pretty"))] // Given the cargo command is `cargo pretty`.
pub struct Options {
    /// An argument
    argument: usize,
    /// A switch
    #[bpaf(short)]
    switch: bool,
}

fn main() {
    println!("{:?}", options().run())
}
```


Output

Let's say the goal is to parse an argument and a switch:

$ app --argument 15
Options { argument: 15, switch: false }

But when used as a `cargo` subcommand, cargo will also pass the command name. For example
you can invoke an app with binary name `cargo-asm`

```console
$ cargo asm --lib --everything
...
```

`cargo` will then spawn the executable and pass it following parameters:

```console
$ cargo-asm asm --lib --everything
...
```

If you are not using `cargo_helper` - parser won't know what to do with `asm` part.
`cargo-helper` allows the parser to strip it from the front and everything works as expected.

And it doesn't show up in `--help` so not to confuse users

$ app --help

Usage: app --argument=ARG [-s]

Available options:

    --argument=ARG

An argument

-s

A switch

-h, --help

Prints help information

