A clap-rs inspired command line argument parser design for zig

TheWaWaR · March 31, 2024, 1:12pm

gist.github.com

https://gist.github.com/TheWaWaR/9c4dde075291ed9484f0aca87c47528a

clap-sample.zig

const print = @import("std").debug.print;

const clap = @import("clap");
const Arg = clap.Arg;
const Subcommand = clap.Subcommand;

const Cli = clap.Parser(struct {
    name: Arg(?[]const u8, .{
        .short = "n",
        .help = "Optional name to operate on",

This file has been truncated. show original

The design is inspired by clap-rs, which I used frequently.
The Arg and Subcommand are comptime functions accept a type and a config then generate a parser config. The clap.Parser is to generate the parser code and a final data structure to hold the parsed value.

squeek502 · March 31, 2024, 4:41pm

In case you haven’t seen it, there’s also

TheWaWaR · April 1, 2024, 2:27am

I know this library and also investigated some other libraries like:

GitHub - prajwalch/yazap: 🔧 The ultimate Zig library for seamless command line parsing. Effortlessly handles options, subcommands, and custom arguments with ease.
GitHub - MasterQ32/zig-args: Simple-to-use argument parser with struct-based config

But I want a library:

Support multiple level subcommand
Support parse common types from string
Define the parser as straightforward as possible
Use the parsed result as simple as possible

jiacai2050 · April 1, 2024, 4:38am

Yes there are many arguments parsers in Zig, but none of them could match clap rs.

This is what I write before, i wonder if you like its syntax?

Although sub command is still not supported, but should be easy to implement.

jiacai2050 · April 1, 2024, 11:15am

FYI, I draft a design for subcommands here:

github.com/jiacai2050/zigcli

Simargs support subcommands

opened 11:09AM - 01 Apr 24 UTC

jiacai2050

For now, simargs doesn't sub commands, add subcommands support will make it much… more powerful. The syntax I could think of is like this: ``` zig const App = struct { help: bool = false, global_flags: []const u8, sub_command1: ?struct { flags1: int, }, sub_command2: ?struct { flags1: int, }, }; ``` Here we use nested struct to represent subcommands, and it can be nested at any-level! Also since there are more than once subcommands, we use optional to annotate them.