Combinatoric example

```no_run
#[derive(Debug, Clone)]
pub struct Options {
    argument: Vec<u32>,
    switches: Vec<bool>,
}

pub fn options() -> OptionParser<Options> {
    let argument = long("argument")
        .help("important argument")
        .argument("ARG")
        .many();
    let switches = long("switch").help("some switch").switch().many();
    construct!(Options { argument, switches }).to_options()
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    /// important argument
    argument: Vec<u32>,
    /// some switch
    #[bpaf(long("switch"), switch)]
    switches: Vec<bool>,
}

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


Output

In usage lines `many` items are indicated with `...`

$ app --help

Usage: app [--argument=ARG]... [--switch]...

Available options:

    --argument=ARG

important argument

    --switch

some switch

-h, --help

Prints help information

Run inner parser as many times as possible collecting all the new results
First `false` is collected from a switch even if it is not consuming anything

$ app --argument 10 --argument 20
Options { argument: [10, 20], switches: [false] }

If there's no matching parameters - it would produce an empty vector. Note, in case of
[`switch`](NamedArg::switch) parser or other parsers that can succeed without consuming anything
it would capture that value so `many` captures the first one of those.
You can use [`req_flag`](NamedArg::req_flag) to avoid that.

$ app 
Options { argument: [], switches: [false] }

For parsers that can succeed without consuming anything such as `flag` or `switch` - `many`
only collects values as long as they produce something

$ app --switch --switch
Options { argument: [], switches: [true, true] }

