Combinatoric example

```no_run
#[derive(Debug, Clone)]
pub enum Style {
    Intel,
    Att,
    Llvm,
}

#[derive(Debug, Clone)]
pub enum Report {
    /// Include defailed report
    Detailed,
    /// Include minimal report
    Minimal,
    /// No preferences
    Undecided,
}

#[derive(Debug, Clone)]
pub struct Options {
    agree: (),
    style: Style,
    report: Report,
}

pub fn options() -> OptionParser<Options> {
    let agree = long("agree")
        .help("You must agree to perform the action")
        .req_flag(());

    let intel = long("intel")
        .help("Show assembly using Intel style")
        .req_flag(Style::Intel);
    let att = long("att")
        .help("Show assembly using AT&T style")
        .req_flag(Style::Att);
    let llvm = long("llvm").help("Show llvm-ir").req_flag(Style::Llvm);
    let style = construct!([intel, att, llvm]);

    let detailed = long("detailed")
        .help("Include detailed report")
        .req_flag(Report::Detailed);
    let minimal = long("minimal")
        .help("Include minimal report")
        .req_flag(Report::Minimal);
    let report = construct!([detailed, minimal]).fallback(Report::Undecided);

    construct!(Options {
        agree,
        style,
        report
    })
    .to_options()
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
pub enum Style {
    /// Show assembly using Intel style
    Intel,
    /// Show assembly using AT&T style
    Att,
    /// Show llvm-ir
    Llvm,
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(fallback(Report::Undecided))]
pub enum Report {
    /// Include detailed report
    Detailed,
    /// Include minimal report
    Minimal,
    #[bpaf(skip)]
    /// No preferences
    Undecided,
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    /// You must agree to perform the action
    agree: (),
    // external here uses explicit reference to function `style`
    // generated above
    #[bpaf(external(style))]
    style: Style,
    // here reference is implicit and derived from field name: `report`
    #[bpaf(external)]
    report: Report,
}

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


Output

In `--help` message `req_flag` look similarly to [`switch`](NamedArg::switch) and
[`flag`](NamedArg::flag)

$ app --help

Usage: app --agree (--intel | --att | --llvm) [--detailed | --minimal]

Available options:

    --agree

You must agree to perform the action

    --intel

Show assembly using Intel style

    --att

Show assembly using AT&T style

    --llvm

Show llvm-ir

    --detailed

Include detailed report

    --minimal

Include minimal report

-h, --help

Prints help information

Example contains two parsers that fails without any input: `agree` requires passing `--agree`

$ app 
Error: expected --agree, pass --help for usage information

While `style` takes one of several possible values

$ app --agree
Error: expected --intel, --att, or more, pass --help for usage information

It is possible to alter the behavior using [`fallback`](Parser::fallback) or
[`hide`](Parser::hide).

$ app --agree --intel
Options { agree: (), style: Intel, report: Undecided }

While parser for `style` takes any posted output - it won't take multiple of them at once
(unless other combinators such as [`many`](Parser::many) permit it) or [`last`](Parser::last).

$ app --agree --att --llvm
Error: --llvm cannot be used at the same time as --att

