Combinatoric example

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

pub fn options() -> OptionParser<Options> {
    let argument = short('i').argument::<u32>("ARG");
    construct!(Options { argument })
        .to_options()
        .version("3.1415")
        .descr("This is a short description")
        .header("It can contain multiple blocks, this block goes before options")
        .footer("This one goes after")
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options, version("3.1415"))]
/// This is a short description
///
///
/// It can contain multiple blocks, this block goes before options
///
///
/// This one goes after
pub struct Options {
    #[bpaf(short('i'))]
    argument: u32,
}

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


Output

In addition to all the arguments specified by user `bpaf` adds a few more. One of them is
`--help`:

$ app --help

This is a short description

Usage: app -i=ARG

It can contain multiple blocks, this block goes before options

Available options:

-i=ARG

-h, --help

Prints help information

-V, --version

Prints version information

This one goes after

The other one is `--version` - passing a string literal or something like
`env!("CARGO_PKG_VERSION")` to get version from `cargo` directly usually works

$ app --version

Version: 3.1415

Other than that `bpaf` tries its best to provide a helpful error messages

$ app 
Error: expected -i=ARG, pass --help for usage information

And if all parsers are satisfied [`run`](OptionParser::run) produces the result

$ app -i 10
Options { argument: 10 }

