Combinatoric example

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

pub fn options() -> OptionParser<Options> {
    let jobs = long("jobs")
        .help("Number of jobs")
        .argument("JOBS")
        .fallback(42)
        .debug_fallback();
    construct!(Options { jobs }).to_options()
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
#[allow(dead_code)]
pub struct Options {
    /// Number of jobs
    #[bpaf(argument("JOBS"), fallback(42), debug_fallback)]
    jobs: usize,
}

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


Output

`fallback` changes parser to fallback to a default value used when argument is not specified

$ app 
Options { jobs: 42 }

If value is present - fallback value is ignored

$ app --jobs 10
Options { jobs: 10 }

Parsing errors are preserved and preserved to user

$ app --jobs ten
Error: couldn't parse ten: invalid digit found in string

With [`display_fallback`](ParseFallback::display_fallback) and
[`debug_fallback`](ParseFallback::debug_fallback) you can make it so default value
is visible in `--help` output

$ app --help

Usage: app [--jobs=JOBS]

Available options:

    --jobs=JOBS

Number of jobs

[default: 42]

-h, --help

Prints help information

