Parse different arguments to the same field from &ArgMatches

[I60R]

Example: there is -v which increases log verbosity, and -q which decreases it, and that should be backed by single log_level field in Options struct.

Alacritty implements that pattern with use of clap and manually filled struct; but with use of structopt there will be no other way as split log_level into two fields: q and v.

I propose something like parse(from_matches = "parser") to avoid that.

#[derive(StructOpt))]
struct Options {
    #[structopt(parse(from_matches = "parse_log_level"))]
    log_level: log::LevelFilter,

    ...
}

fn parse_log_level(matches: &ArgMatches) -> log::LevelFilter {
    match matches.occurrences_of("v") {
        0 => match matches.occurrences_of("q") {
            0 => log::LevelFilter::Warn,
            1 => log::LevelFilter::Error,
            2 | _ => log::LevelFilter::Off
        },
        1 => log::LevelFilter::Info,
        2 => log::LevelFilter::Debug,
        3 | _ => log::LevelFilter::Trace
    }
}

---

Also, I have a use case where parser like that may greatly simplify my code

[TeXitoi]

That's a quite complicated feature to design. Maybe using the parse feature, giving a custom parsing command that takes the 2 parameters and returns the value, with a way to list on a struct field that this field is linked to 2 options.

Fuzzy try:

fn parse_log_level(quiet: u32, verbose: u32) -> log::LevelFilter {
    match (quiet, verbose) {
        (0, 0) => log::LevelFilter::Warn,
        (0, 1) => log::LevelFilter::Error,
        (0, _) => log::LevelFilter::Off,
        (1, _) => log::LevelFilter::Info,
        (2, _) => log::LevelFilter::Debug,
        (_, _) => log::LevelFilter::Trace,
    }
}

#[derive(StructOpt)]
struct Opt {
    #[structopt(
        multiarg(short = "v", long = "verbose", parse(from_occurence)),
        multiarg(short = "q", long = "quiet", parse(from_occurence)),
        parse(from_multiargs = "parse_log_level"),
    )]
    verbose: log::LevelFilter,
}

[I60R]

What are your thoughts about delegating q and v fields into separate struct?
That will be very similar to flatten feature that additionally invokes .from() on flattened struct:

#[derive(StructOpt)]
struct Opt {
    #[structopt(collapse(LogLevelOpt)]
    verbose: log::LevelFilter,

    ...
}

#[derive(StructOpt)]
struct LogLevelOpt {
    #[structopt(short = "v", long = "verbose", parse(from_occurences)]
    verbose: u8,

    #[structopt(short = "q", long = "quiet", parse(from_occurences)]
    quiet: u8,
}

impl Into<log::LevelFilter> for LogLevelOpt {
    fn into(self) -> log::LevelFilter {
        match (self.quiet, self.verbose) {
            (0, 0) => log::LevelFilter::Warn,
            (0, 1) => log::LevelFilter::Error,
            (0, _) => log::LevelFilter::Off,
            (1, _) => log::LevelFilter::Info,
            (2, _) => log::LevelFilter::Debug,
            (_, _) => log::LevelFilter::Trace,
        }
    }
}

Also, there might be other version that uses custom function instead of from:

#[derive(StructOpt)]
struct Opt {
    #[structopt(collapse(LogLevelOpt), parse(from_collapsed = "custom_function")]
    verbose: log::LevelFilter,

    ...
}

#[derive(StructOpt)]
struct LogLevelOpt {
    ...
}

fn custom_function(opt: LogLevelOpt) -> log::LevelFilter {
   ...
}

[TeXitoi]

@I60R That's another path that looks promising. I prefer it to my proposition.

[eugmes]

I have another use case that I think may benefit from having multiple arguments apply to the same field, and it is hard or impossible to implement this using multiple separate arguments.

I have a program that's processes some Unicode characters, user should be able to enable or disable processing of some ranges, multiple enable/disable arguments are possible, they should be processes in order they are supplied. For example:

--include-range 100-200 --exclude-range 120-130

The result should be the same as:

--include-range 100-119 --include-range 131-200

I would like to model this as follows:

enum UnicodeRange {...}

enum RangeSpec {
    Included {
        include_range: UnicodeRange,
    },
    Excluded {
        exclude_range: UnicodeRange,
    },
}

struct Opt {
    ...
    #[structopt(???)]
    ranges: Vec[RangeSpec],
    ...
}

I could not find any good way to do this. Note that separate arguments would not work because the order is important.

I've tried to use flatten, but structopt insists on adding subcommands :/.

[TeXitoi]

@eugmes this is similar to your use case: #476

[eugmes]

@TeXitoi indeed it is. Thanks a lot!

[TeXitoi]

This is an enhancement, and structopt is now feature frozen.