Combinatoric example

```no_run
#[derive(Debug, Clone)]
pub struct Options {
    verbose: bool,
    binary: String,
    args: Vec<String>,
}

pub fn options() -> OptionParser<Options> {
    let verbose = short('v')
        .long("verbose")
        .help("Produce detailed report")
        .switch();
    let binary = long("bin").help("Binary to execute").argument("BIN");
    let args = positional("ARG")
        .help("Arguments for the binary")
        .strict()
        .many();
    construct!(Options {
        verbose,
        binary,
        args
    })
    .to_options()
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(short, long)]
    /// Produce detailed report
    verbose: bool,
    #[bpaf(long("bin"), argument("BIN"))]
    /// Binary to execute
    binary: String,
    #[bpaf(positional("ARG"), strict, many)]
    /// Arguments for the binary
    args: Vec<String>,
}

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


Output

Usage line for a cargo-run like app that takes an app name and possibly many strictly
positional child arguments can look like this:

$ app --help

Usage: app [-v] --bin=BIN -- [ARG]...

Available positional items:

ARG

Arguments for the binary

Available options:

-v, --verbose

Produce detailed report

    --bin=BIN

Binary to execute

-h, --help

Prints help information

Here any argument passed before double dash goes to the parser itself

$ app --bin dd --verbose
Options { verbose: true, binary: "dd", args: [] }

Anything after it - collected into strict arguments

$ app --bin dd -- --verbose
Options { verbose: false, binary: "dd", args: ["--verbose"] }

