Combinatoric example

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

fn package() -> impl Parser<String> {
    long("package")
        .short('p')
        .help("Package to use")
        .argument("SPEC")
        .adjacent()
}

pub fn options() -> OptionParser<Options> {
    construct!(Options { package() }).to_options()
}

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


Derive example

```no_run
#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
pub struct Options {
    #[bpaf(short, long, argument("SPEC"), adjacent)]
    /// Package to use
    package: String,
}

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


Output

$ app --help

Usage: app -p=SPEC

Available options:

-p, --package=SPEC

Package to use

-h, --help

Prints help information

As with regular [`argument`](NamedArg::argument) its `adjacent` variant is required by default

$ app 
Error: expected --package=SPEC, pass --help for usage information

But unlike regular variant `adjacent` requires name and value to be separated by `=` only

$ app -p=htb
Options { package: "htb" }

$ app --package=bpaf
Options { package: "bpaf" }

Separating them by space results in parse failure

$ app --package htb
Error: expected --package=SPEC, got --package. Pass --help for usage information

$ app -p htb
Error: expected --package=SPEC, got -p. Pass --help for usage information

$ app --package
Error: expected --package=SPEC, got --package. Pass --help for usage information

