select all possible values for Vec<PossibleValues>

[T-256]

use clap::{Parser, ValueEnum};

#[derive(ValueEnum)]
enum Output {
    X,
    Y,
    Z,
    ...
}


#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Args {
    #[arg(long, num_args = 0.., value_enum, value_delimiter = ',', default_values_t = [Output::X])]
    outputs: Vec<Output>,
}

Via specified num_args = 0.., I'm able to pass empty --outputs to pass empty vector.

I'm also looking for a way to pass vector of full possible values of as vector, so instead of writing --outputs x,y,z,... it'd be nice to have --outputs all.

[apoorva-01]

clap doesn't have a built-in "all" keyword for value enums, and you can't fake it with a value_parser either. A parser only ever turns one token into one value, so there's no way for all to fan out into three. You have to expand it yourself after parsing.

The clean way is to add All as a variant and let ValueEnum::value_variants() give you the rest:

use clap::{Parser, ValueEnum};

#[derive(ValueEnum, Clone, Copy, PartialEq)]
enum Output { All, X, Y, Z }

#[derive(Parser)]
struct Args {
    #[arg(long, value_delimiter = ',', default_value = "x")]
    outputs: Vec<Output>,
}

impl Args {
    fn outputs(&self) -> Vec<Output> {
        if self.outputs.contains(&Output::All) {
            Output::value_variants()
                .iter()
                .copied()
                .filter(|o| *o != Output::All)
                .collect()
        } else {
            self.outputs.clone()
        }
    }
}

Now --outputs all gives you everything and --outputs x,y still works. value_variants() returns them in declaration order, so keeping All first and filtering it out keeps the real list clean.

If you'd rather not have All show up in --help as a value, drop the derive and hand-write to_possible_value for it returning None, but honestly the extra variant is usually fine.