Parsing a list of structs?

[jkorinth]

I'm trying to replace a legacy CLI app with Rust + clap, but I got stuck and can't wrap my head around the issue:
The original app parses everything after '--' as an arbitrary length list of struct S:

struct S {
    a: char,
    b: u32,
    c: Option<f32>,
}

E.g., app -- x 1000 -c 3.2 y 2000 z 500 would parse as three elements.

Seems simple enough, but no matter what I try, I can't make this work in clap. My best guess so far:

use clap::Parser;

#[derive(Parser, Debug)]
struct Cli {
    #[arg(last=true)]
    sequence: Vec<S>,
}

#[derive(Debug, Clone, Parser)]
struct S {
    a: char,
    b: u32,
    #[arg(short)]
    c: Option<f32>,
}

fn main() {
    let cli = Cli::parse();
    println!("{cli:?}");
}

This doesn't compile, but I can't make head or tails of the error:

error[E0599]: the method `value_parser` exists for reference `&&&&&&_AutoValueParser<S>`, but its trait bounds were not satisfied
    --> src/main.rs:5:5
     |
5    |     sequence: Vec<S>,
     |     ^^^^^^^^ method cannot be called on `&&&&&&_AutoValueParser<S>` due to unsatisfied trait bounds
...
9    | struct S {
     | --------
     | |
     | doesn't satisfy `S: From<&'s std::ffi::OsStr>`
     | doesn't satisfy `S: From<&'s str>`
     | doesn't satisfy `S: From<OsString>`
     | doesn't satisfy `S: From<std::string::String>`
     | doesn't satisfy `S: FromStr`
     | doesn't satisfy `S: ValueEnum`
     | doesn't satisfy `S: ValueParserFactory`
     |
    ::: /home/jk/.cargo/registry/src/index.crates.io-6f17d22bba15001f/clap_builder-4.5.2/src/builder/value_parser.rs:2462:1
     |
2462 | pub struct _AutoValueParser<T>(std::marker::PhantomData<T>);
     | ------------------------------ doesn't satisfy `_: _ValueParserViaParse`
     |
     = note: the following trait bounds were not satisfied:
             `S: ValueEnum`
             which is required by `&&&&&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaValueEnum`
             `S: ValueParserFactory`
             which is required by `&&&&&&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaFactory`
             `S: From<OsString>`
             which is required by `&&&&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaFromOsString`
             `S: From<&'s std::ffi::OsStr>`
             which is required by `&&&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaFromOsStr`
             `S: From<std::string::String>`
             which is required by `&&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaFromString`
             `S: From<&'s str>`
             which is required by `&_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaFromStr`
             `S: FromStr`
             which is required by `_AutoValueParser<S>: clap::builder::via_prelude::_ValueParserViaParse`

Help?

[epage]

So if I understood correctly: after -- you get 2 positional arguments and an optional named argument, repeat as many times as you want. What decides what is the start of the group?

The challenge for clap with this

• -- is always considered an escape, leaving everything after it as a positional argument (Variant of allow_hyphen_values that treats -- like a regular value #5055). This could be worked around by creating a separate parser for these positionals. It would require overriding the usage message.
• The derive API does not support automatic sequencing like this (Variant of allow_hyphen_values that treats -- like a regular value #5055)
  • You could manually implement support for position-sensitive options to emulate this (find example) but it requires the builder API (derive: Store indices, value source next to field values #3846) and overriding the usage.

[jkorinth]

@epage Ok, I see, thanks for the quick answer. I just tested and found that the -- is not actually required app x 1000 -c 3.2 y 2000 z 500 seems to work the same. I tried to remove #[arg(last=true)] but the problem stays the same.

What decides what is the start of the group?

The original parser assumes that the first argstr that does not start with - is the beginning of the list, and then just applies the three subparsers repeatedly.

-- is always considered an escape, leaving everything after it as a positional argument

Mmh, ok, so I could theoretically just add #[arg(last=true)] rest: Vec<String> and get the rest of the args? Maybe I can just apply the parser manually on that?

What I don't understand is why Vec<u32> can be parsed, even Vec<CustomType> with #[arg(value_parser=...)] custom parsers, but nesting of derived parsers does not work?

I will definitely take a look at the builder API code, thanks.

[jkorinth]

I was also wondering if maybe subcommands would be a better approach? I could use the char as the command, maybe. But as far as I can tell, neither multiple nor recursive commands are allowed atm, right?

[epage]

They are not, see #2222