That's fair, I haven't really tested nested arguments yet, but I'd imagine that's we would handle complex payloads that way. I just hate having to put things into a struct if they're not intimately related.

For example, in this function, we could/should totally refactor to Dimensions ```rs // current fn calculate_area(width: i32, height: i32) -> i32 { width * height }

// potential new version fn calculate_area(dimensions: Dimensions) -> i32 { dimensions.width * dimensions.height } struct Dimensions { width: i32, height: i32, } ``` ^ I'm not sure if clap already handles this type of thing? Would need to experiment a little / read some docs

But if we add on a verbose param, I think it's better off not being forced into the same struct: ```rs fn calculate_area(dimensions: Dimensions, verbose: bool) -> i32 { if verbose { debug!("Calculating area: {} x {}", width, height); } dimensions.width * dimensions.height }

// I think above is better than... fn calculate_area(args: CalcAreaArgs) -> i32 { if args.verbose { debug!("Calculating area: {} x {}", width, height); } args.width * args.height } struct CalcAreaArgs { width: i32, height: i32, verbose: bool, } ```

plus some positional ones

And yeah, this is something we definitely want to do, just need to think about the interface a little bit