Counterpoint: Yes, parse don’t validate, but CLIs should not be dealing with dependency management.
I love Python’s
argparsebecause:- It’s “Parse, don’t validate” (even supports
FileTypeas a target) - It enforces or strongly encourages good CLI design
- Required arguments should in most situations be positional arguments, not flags. It’s
curl <URL>notcurl --url <URL>. - Flags should not depend on each other. That usually indicates spaghetti CLI design. Don’t do
server --serve --port 8080andserver --reloadwith rules for mix-and-matching those, doserver serve --port 8080andserver reloadwith two separate subparsers. - Mutually exclusive flags sometimes make sense but usually don’t. Don’t do
--xml --json, do-f [xml|json]. - This
or(pattern of yours IMO should always be replaced by a subparser (which can use inheritance!). As a user the options’ data model should be immediately intuitive to me as I look at the--helpand having mutually exclusive flags forces the user to do the extra work of dependency management. Don’t doserver --env prod --auth abc --ssl, doserver serve prod --auth abc --sslwhereprodis its own subparser inheriting fromAbstractServeParseror whatever.
- Required arguments should in most situations be positional arguments, not flags. It’s
Thinking of CLI flags as a direct mapping to runtime variables is the fundamental mistake here I think. A CLI should be a mapping to the set(s) of behavior(s) of your application. A good CLI may have mandatory positional arguments but has 0 mandatory flags, 0 mutually exclusive flags, and if it implements multiple separate behaviors should be a tree of subparsers. Any mandatory or mutually exclusive flags should be an immediate warning that you’re not being very UNIX-y in your CLI design.
- It’s “Parse, don’t validate” (even supports
https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/ - Edit: Ah I see, the author of this article is pointing to this older article too and admits being influenced by it. So never mind.
I’m not sure the value added is worth the extra layer.
I guess my command line options just aren’t all that complicated.
I like the concept, and it’s great in TS. Unfortunately, not as doable in other languages.
I’m a bit curious if it’s possible to extend
clapto do this in Rust though (specifically mutually-exclusive arg groups).clap already supports all this: https://docs.rs/clap/latest/clap/struct.Arg.html#method.conflicts_with It’s just a great library, having you could think of and applying the same parse-don’t-validate mentality.
This doesn’t represent the mutual exclusivity through the type system (which is what the article is all about).
I love clap and I use it a lot, but the only way to represent the exclusivity through the type system in Rust is through an enum.
Agreed. As nice as clap is, it’s not a combinator. Parser combinators have a the really nice feature of sharing the same “shape” as the data they parse, which makes them trivial to generate from a schema … or to just use them to represent your schema in the first place ;) .
Clap has dependent options and mutually-exclusive argument groups built-in: https://docs.rs/clap/latest/clap/_derive/_tutorial/index.html#argument-relations
For the environment-specific requirements, you can use compiler feature flags…
Mentioned this to the other commenter, but this doesn’t use the type system to enforce the mutual exclusivity constraint. In Rust, the main way to do that via the type system is through enums.
Ah, fair enough. Not sure how to do that then.
I was gonna say, I feel like the current method does a good enough job documenting that validation has happened, but I guess you do want it reflected in the structure of the type, so that the code that takes the information from the struct can safely make the assumption that some of the options don’t exist. And then, yeah, it would be nice to not need a separate parsing step for that.
