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.

[T-256]

Current workaround is to add new variant Output:All in processing logic check for each variant like this:

if value == Output::X or value == Output::All {
    ... 
} else if value == Output::Y or value == Output::All {
    ... 
} else if value == Output::Z or value == Output::All {
    ... 
}

recommended way is to add an option like select_all_values_delimiter = "all".

[epage]

See also #6433 (comment)

[epage]

I would hesitate to add support for all as it feels specialized while it can be handled on the callers end (though they have to watch for --outputs x,all), has semantics to be figured out (behavior with ArgAction::Append vs num_args), and would add more to clap that add to our binary size, build times, and API size.

[T-256]

Ended up with this: (hint: to avoid using eunm_map you can impl ToString and use VARIANTS const)

use clap::Parser;
use enum_map::{Enum, EnumMap};

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

pub const OUTPUT_MAP: EnumMap<Output, &'static str> = EnumMap::from_array([
    /* Output::X=>  */ "x",
    /* Output::Y=>  */ "y",
    /* Output::Z =>  */ "z",
    ...
]);

fn parse_outputs(value: &str) -> Result<Vec<Output>, String> {
    if value == "all" {
        Ok(OUTPUT_MAP.iter().map(|(o, _)| o).collect())
    } else {
        OUTPUT_MAP
            .iter()
            .find_map(|(o, s)| (&value == s).then_some(vec![o]))
            .ok_or_else(|| "invalid variant".into())
    }
}

#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Args {
    #[arg(long, num_args = 0.., value_parser = parse_outputs, value_delimiter = ',', default_values = ["x"])]
    outputs: Vec<Vec<Output>>,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();

    let outputs: Vec<Output> = args
        .outputs
        .iter()
        .flat_map(|x| x.iter())
        .map(|o| o.clone().into())
        .collect();

for clap side, value_parser of args with type of Vec<T> could has return type of Result<Vec<T>, E> next to Result<T, E>. in that case flat_map and duplicated Vec<Vec<output>> would be removed from this code. IOW flat_map could be done in clap side.