Optional value of argument

[UltraMachine]

How do I make something like this in bpaf?

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
struct Options {
    // If not present, value is None
    // If only --foo is present, value is Some(None)
    // If --foo=value is present, value is Some(Some("value"))
    foo: Option<Option<String>>,
    // Same as above, but instead of Some(None), it fallbacks to some default value
    bar: Option<String>,
}

[pacak]

This is best expressed with combinatoric API, let's start with foo.

// first we handle two cases where command line option is present but use
// a single `Option` layer. This parser is expected to fail if value is missing

// If only --foo is present, value is Some(None)
let foo_flag = long("foo").req_flag(None);
// If --foo=value is present, value is Some(Some("value"))
let foo_arg = long("foo").argument::<String>("FOO").map(Some);

// now we combine it into a single parser that handles both `--foo` and `--foo=value`
let foo = construct!([foo_arg, foo_flag]) // order inside is important.

// and finally allow parser to fail and produce None if it does:

let foo = foo.optional();

To use this construction inside derive macro you place it in a function first:

fn foo() -> impl Parser<Option<Option<String>> {
    let foo_flag = ...
    ...
    foo.optional()
}

And you can use it in your derived parser with external:

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
struct Options {
    #[bpaf(external)]
    foo: Option<Option<String>>
    ...
}

For bar you do the same, but the last line is bar.fallback(Some("your default string".into())). Or something with fallback_with if you want to avoid allocating strings, but this shouldn't make much difference.

[UltraMachine]

It works for foo perfectly, but not for bar:

fn foo() -> impl Parser<Option<Option<String>>> {
    let foo_flag = long("foo").req_flag(None);
    let foo_arg = long("foo").argument::<String>("FOO").map(Some);
    let foo = construct!([foo_arg, foo_flag]);
    foo.optional()
}

fn bar() -> impl Parser<Option<String>> {
    let bar_flag = long("bar").req_flag(None);
    let bar_arg = long("bar").argument::<String>("BAR").map(Some);
    let bar = construct!([bar_arg, bar_flag]);
    bar.fallback(Some("default".into()))
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options)]
struct Options {
    #[bpaf(external)]
    foo: Option<Option<String>>,
    #[bpaf(external)]
    bar: Option<String>,
}

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

Outputs:

$ cargo run --
Options { foo: None, bar: Some("default") }
$ cargo run -- --foo --bar
Options { foo: Some(None), bar: None }
$ cargo run -- --foo=value --bar=value
Options { foo: Some(Some("value")), bar: Some("value") }

[pacak]

I'm probably lacking coffee. Can you list inputs and expected values for bar?

[UltraMachine]

For bar it should be:

• None when flag is not present
• Some("default") when only --bar present
• Some("value") when --bar=value is present

I think fallback should be somewhere earlier but I can't figure it out 😕

[pacak]

Same idea, splitting it into primitive parsers. None when not present and Some otherwise means .optional() goes at the end, and inner parsers produce value without Option, so --bar should make "default" and --bar=value should make "value". You achieve former with req_flag and later with argument.

    let bar_flag = long("bar").req_flag("default".into());
    let bar_arg = long("bar").argument::<String>("BAR");
    let bar = construct!([bar_arg, bar_flag]);
    bar.optional()