Combinatoric example

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

pub fn options() -> OptionParser<Options> {
    let number = long("number").argument::<u32>("N").guard(
        |n| *n <= 10,
        "Values greater than 10 are only available in the DLC pack!",
    );
    construct!(Options { number }).to_options()
}

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


Derive example

```no_run
fn dlc_check(number: &u32) -> bool {
    *number <= 10
}

const DLC_NEEDED: &str = "Values greater than 10 are only available in the DLC pack!";

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(argument("N"), guard(dlc_check, DLC_NEEDED))]
    number: u32,
}

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


Output

`guard` don't make any changes to generated `--help` message

$ app --help

Usage: app --number=N

Available options:

    --number=N

-h, --help

Prints help information

You can use guard to set boundary limits or perform other checks on parsed values.
Parser accepts numbers below 10

$ app --number 5
Options { number: 5 }

And fails with the error message on higher values:

$ app --number 11
Error: 11: Values greater than 10 are only available in the DLC pack!

But if function inside the parser fails - user will get the error back unless it's handled
in some way

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

