Combinatoric example

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

pub fn options() -> OptionParser<Options> {
    let number = long("number")
        .argument::<String>("N")
        // normally you'd use argument::<u32> to get a numeric
        // value and `map` to double it
        .parse::<_, _, ParseIntError>(|s| Ok(u32::from_str(&s)? * 2));
    construct!(Options { number }).to_options()
}

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


Derive example

```no_run
fn twice_the_num(s: String) -> Result<u32, ParseIntError> {
    Ok(u32::from_str(&s)? * 2)
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(argument::<String>("N"), parse(twice_the_num))]
    number: u32,
}

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


Output

`parse` 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 `parse` to apply arbitrary failing transformation to any input.
For example here `--number` takes a numerical value and doubles it

$ app --number 10
Options { number: 20 }

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

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

