This post introduces Optique, a new library created to address the pervasive problem of repetitive and often messy validation code in CLI tools. The author was motivated by the observation that nearly every CLI tool reinvents the wheel with similar validation patterns for dependent options, mutually exclusive options, and environment-specific requirements. Optique leverages parser combinators and TypeScript's type inference to ensure that CLI arguments are parsed directly into valid configurations, eliminating the need for manual validation. By describing the desired CLI configuration with Optique, TypeScript automatically infers the types and constraints, catching potential bugs at compile time. The author shares their experience of deleting large chunks of validation code and simplifying refactoring tasks. Optique aims to provide a more robust and maintainable approach to CLI argument parsing, potentially saving developers from writing the same validation logic repeatedly.
  • TehPers@beehaw.orgEnglish
    2·
    7 days ago

    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 clap to do this in Rust though (specifically mutually-exclusive arg groups).

      • TehPers@beehaw.orgEnglish
        7·
        7 days ago

        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.

        • ExFed@programming.dev
          4·
          7 days ago

          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 ;) .

      • TehPers@beehaw.orgEnglish
        4·
        7 days ago

        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.

        • Ephera@lemmy.mlEnglish
          2·
          6 days ago

          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.