Parse "Escaped positional" arguments into Map?

[vi013t]

Is there a (derive) way to parse "raw" arguments into a map? I see here a reference on parsing escaped arguments after --. So as the example shows, the following struct:

#[derive(Parser)] // requires `derive` feature
#[command(version, about, long_about = None)]
struct Cli {
    #[arg(last = true)]
    slop: Vec<String>,
}

is parsed as follows:

$ escaped-positional-derive -- -f -p=bob sloppy slop slop
-f used: false
-p's value: None
'slops' values: ["-f", "-p=bob", "sloppy", "slop", "slop"]

I was wondering if there was a built-in way to parse these raw arguments into a map. So the above example (modified) would yield something like:

$ escaped-positional-derive -- -f -p=bob --sloppy slop --slop=slop
-f used: false
-p's value: None
'slops' values: [
    ("f": ""),
    ( "p": "bob"),
    ("sloppy": "slop"),
    ("slop": "slop")
]

In general, I'd like if something along the following lines holds true:

• If an argument (a token starting with -) is passed and the next token is not an argument, map that value to that argument (i.e., --option value would map "option" to "value")
  • Bonus points if it could separate short arguments, like -sSl becomes three separate mappings for s, S, and l
• If an argument is passed that contains an =, it is sliced on the first equal into a key-value pair (i.e., --option=value would map "option" to "value")
• If an argument is passed with no value (meaning it's the last argument or followed by another argument instead of a value), it is present in the map, but mapped to an empty string
• If a non-argument is passed (like a string of just sloppy slop slop slop) an error is thrown

It doesn't have to be that specific, but I was wondering if clap has any built-in functionality for this sort of behavior, or if we are left to parse these kinds of arguments ourselves.

[epage]

This would run counter to the intention of the escaped arguments: they are unparsed values.

You could then take those arguments and parse them as you need. If you want them to be completely dynamic like this, you could use something like clap_lex to do so.

[vi013t]

I guess then I'm not looking for "escaped" or "unparsed" values necessarily - I'm looking for parsed, well-structured arguments, that don't have a specific explicitly stated set of keys. Is clap_lex the best way to handle something like that?

[epage]

clap_lex (already a dependency through clap) or lexopt would be good for doing these types of arguments, etc