Derive args group, apply default arg value if group omitted

[devklick]

I have an optional arg group, and if the group is omitted, I want to apply a default value to one of the args in the group. Is this possible?

#[derive(Parser)]
struct CliArgs {
    #[command(flatten)]
    arg_group: ArgGroup,
}

#[derive(Args)]
#[group(multiple = false)]
struct ArgGroup {
    #[arg(long)]
    one: bool, // if group omitted, set this true

    #[arg(long)]
    two: bool,

    #[arg(long)]
    three: bool,
}

The end result should be:

• If cli called without args, one is set to true, two and three are left as false
• If cli called with --one, one is set to true, two and three are left as false
• If cli called with --two, two is set to true, one and three are left as false
• If cli called with --three, three is set to true, one and two are left as false
• If cli called with any combination of --one, --two or --three, the cli should return an error

What I've tried

args macro

Specifying the default parameter in the args macro is no good, because it will apply this value even if the user specifies a different parameter within that group. e.g:

    #[arg(long, default_value_t = true)]
    one: bool,

Would set both one to true if the user specifies --two or --three

impl Default

I figured I could maybe implement the Default trait, and clap might just know to use that as the default value for the group when the group is omitted, but that doesnt seem to be the case. I also cant see any way to specify the default value for a group, e.g.

• You cant specify the default value where you declare the group

#[derive(Args, Debug)]
#[group(multiple = false, default_value_t=ArgGroup::default())] // default_value_t doesnt exist
struct ArgGroup { }

• You cant specify the default value when flattening the group into your struct

struct CliArgs {
    #[command(flatten, default_value_t=ArgGroup::default())] // default_value_t doesnt exist
    arg_group: ArgGroup,
}

Alternative

Of course, I could always apply some post-clap default values, but it feels a bit messy, and would quickly become more complicated if the arg group has more args, args of different types, etc.

fn main() {
    let args = CliArgs::parse();
    let (one, two, three) = match (args.arg_group.one, args.arg_group.two, args.arg_group.three) {
        (false, false, false) => (true, false, false),
        (one, two, three) => (one, two, three),
    };
    println!("one = {one}, two = {two}, three = {three}");
}

I'm using clap version 4.5.17 with the derive feature.

[epage]

Sorry, catching up from a couple of conferences and other stuff.

For me, I would do something like

#[derive(Parser)]
struct CliArgs {
    #[command(flatten)]
    arg_group: Option<ArgGroup>,
}

#[derive(Args)]
struct ArgGroup {
    #[arg(long)]
    one: bool, // if group omitted, set this true

    #[arg(long)]
    two: bool,

    #[arg(long)]
    three: bool,
}

impl Default for ArgGroup {
    fn default() -> Self {
        ArgGroup {
            one: true,
            two: false,
            three: false,
        }
    }
}

cli.arg_group.unwrap_or_default()