Combinatoric example

```no_run
fn try_to_get_version() -> Result<usize, &'static str> {
    Ok(42)
}

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

pub fn options() -> OptionParser<Options> {
    let version = long("version")
        .help("Specify protocol version")
        .argument("VERS")
        .fallback_with(try_to_get_version)
        .display_fallback();
    construct!(Options { version }).to_options()
}

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


Derive example

```no_run
fn try_to_get_version() -> Result<usize, &'static str> {
    Ok(42)
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(argument("VERS"), fallback_with(try_to_get_version), display_fallback)]
    /// Specify protocol version
    version: usize,
}

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


Output

`fallback_with` changes parser to fallback to a value that comes from a potentially failing
computation when argument is not specified

$ app 
Options { version: 42 }

If value is present - fallback value is ignored

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

Parsing errors are preserved and preserved to user

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

`bpaf` encases parsers with fallback value of some sort in usage with `[]`

$ app --help

Usage: app [--version=VERS]

Available options:

    --version=VERS

Specify protocol version

[default: 42]

-h, --help

Prints help information

