8 files changed, 242 insertions, 242 deletions

diff --git a/build.zig b/build.zig
index 3ceba14..cbf8214 100644
--- a/build.zig
+++ b/build.zig
@@ -8,21 +8,21 @@ pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
 
     const example_step = b.step("examples", "Build examples");
-    inline for ([][]const u8{
+    inline for ([_][]const u8{
         "comptime-clap",
         "streaming-clap",
     }) |example_name| {
         const example = b.addExecutable(example_name, "example/" ++ example_name ++ ".zig");
-        example.addPackagePath("clap", "index.zig");
+        example.addPackagePath("clap", "clap.zig");
         example.setBuildMode(mode);
         example_step.dependOn(&example.step);
     }
 
     const test_all_step = b.step("test", "Run all tests in all modes.");
-    inline for ([]Mode{ Mode.Debug, Mode.ReleaseFast, Mode.ReleaseSafe, Mode.ReleaseSmall }) |test_mode| {
+    inline for ([_]Mode{ Mode.Debug, Mode.ReleaseFast, Mode.ReleaseSafe, Mode.ReleaseSmall }) |test_mode| {
         const mode_str = comptime modeToString(test_mode);
 
-        const tests = b.addTest("index.zig");
+        const tests = b.addTest("clap.zig");
         tests.setBuildMode(test_mode);
         tests.setNamePrefix(mode_str ++ " ");
 
diff --git a/src/index.zig b/clap.zig
index 40ad849..8823b59 100644
--- a/src/index.zig
+++ b/clap.zig
@@ -4,9 +4,9 @@ const debug = std.debug;
 const io = std.io;
 const mem = std.mem;
 
-pub const @"comptime" = @import("comptime.zig");
-pub const args = @import("args.zig");
-pub const streaming = @import("streaming.zig");
+pub const @"comptime" = @import("src/comptime.zig");
+pub const args = @import("src/args.zig");
+pub const streaming = @import("src/streaming.zig");
 
 test "clap" {
     _ = @"comptime";
@@ -20,38 +20,10 @@ pub const StreamingClap = streaming.StreamingClap;
 /// The names a ::Param can have.
 pub const Names = struct {
     /// '-' prefix
-    short: ?u8,
+    short: ?u8 = null,
 
     /// '--' prefix
-    long: ?[]const u8,
-
-    /// Initializes a short name
-    pub fn short(s: u8) Names {
-        return Names{
-            .short = s,
-            .long = null,
-        };
-    }
-
-    /// Initializes a long name
-    pub fn long(l: []const u8) Names {
-        return Names{
-            .short = null,
-            .long = l,
-        };
-    }
-
-    /// Initializes a name that is long and short, from the same string.
-    /// ::short is set to ::name[0], and ::long is set to ::name.
-    /// This function asserts that ::name.len != 0
-    pub fn both(name: []const u8) Names {
-        debug.assert(name.len != 0);
-
-        return Names{
-            .short = name[0],
-            .long = name,
-        };
-    }
+    long: ?[]const u8 = null,
 };
 
 /// Represents a parameter for the command line.
@@ -77,35 +49,9 @@ pub const Names = struct {
 ///     * Positional parameters must take a value.
 pub fn Param(comptime Id: type) type {
     return struct {
-        id: Id,
-        takes_value: bool,
-        names: Names,
-
-        pub fn flag(id: Id, names: Names) @This() {
-            return init(id, false, names);
-        }
-
-        pub fn option(id: Id, names: Names) @This() {
-            return init(id, true, names);
-        }
-
-        pub fn positional(id: Id) @This() {
-            return init(id, true, Names{ .short = null, .long = null });
-        }
-
-        pub fn init(id: Id, takes_value: bool, names: Names) @This() {
-            // Assert, that if the param have no name, then it has to take
-            // a value.
-            debug.assert(names.long != null or
-                names.short != null or
-                takes_value);
-
-            return @This(){
-                .id = id,
-                .takes_value = takes_value,
-                .names = names,
-            };
-        }
+        id: Id = Id{},
+        names: Names = Names{},
+        takes_value: bool = false,
     };
 }
 
@@ -227,34 +173,38 @@ test "clap.help" {
     var slice_stream = io.SliceOutStream.init(buf[0..]);
     try help(
         &slice_stream.stream,
-        []Param([]const u8){
-            Param([]const u8).flag(
-                "Short flag.",
-                Names.short('a'),
-            ),
-            Param([]const u8).option(
-                "Short option.",
-                Names.short('b'),
-            ),
-            Param([]const u8).flag(
-                "Long flag.",
-                Names.long("aa"),
-            ),
-            Param([]const u8).option(
-                "Long option.",
-                Names.long("bb"),
-            ),
-            Param([]const u8).flag(
-                "Both flag.",
-                Names.both("cc"),
-            ),
-            Param([]const u8).option(
-                "Both option.",
-                Names.both("dd"),
-            ),
-            Param([]const u8).positional(
-                "Positional. This should not appear in the help message.",
-            ),
+        [_]Param([]const u8){
+            Param([]const u8){
+                .id = "Short flag.",
+                .names = Names{ .short = 'a' },
+            },
+            Param([]const u8){
+                .id = "Short option.",
+                .names = Names{ .short = 'b' },
+                .takes_value = true,
+            },
+            Param([]const u8){
+                .id = "Long flag.",
+                .names = Names{ .long = "aa" },
+            },
+            Param([]const u8){
+                .id = "Long option.",
+                .names = Names{ .long = "bb" },
+                .takes_value = true,
+            },
+            Param([]const u8){
+                .id = "Both flag.",
+                .names = Names{ .short = 'c', .long = "cc" },
+            },
+            Param([]const u8){
+                .id = "Both option.",
+                .names = Names{ .short = 'd', .long = "dd" },
+                .takes_value = true,
+            },
+            Param([]const u8){
+                .id = "Positional. This should not appear in the help message.",
+                .takes_value = true,
+            },
         },
     );
 
diff --git a/example/comptime-clap.zig b/example/comptime-clap.zig
index 8d2d8a8..935381f 100644
--- a/example/comptime-clap.zig
+++ b/example/comptime-clap.zig
@@ -13,16 +13,20 @@ pub fn main() !void {
     defer direct_allocator.deinit();
 
     // First we specify what parameters our program can take.
-    const params = comptime []clap.Param([]const u8){
-        clap.Param([]const u8).flag(
-            "Display this help and exit.",
-            clap.Names.both("help"),
-        ),
-        clap.Param([]const u8).option(
-            "An option parameter, which takes a value.",
-            clap.Names.both("number"),
-        ),
-        clap.Param([]const u8).positional(""),
+    const params = comptime [_]clap.Param([]const u8){
+        clap.Param([]const u8){
+            .id = "Display this help and exit.",
+            .names = clap.Names{ .short = 'h', .long = "help" },
+        },
+        clap.Param([]const u8){
+            .id = "An option parameter, which takes a value.",
+            .names = clap.Names{ .short = 'n', .long = "number" },
+            .takes_value = true,
+        },
+        clap.Param([]const u8){
+            .id = "",
+            .takes_value = true,
+        },
     };
 
     // We then initialize an argument iterator. We will use the OsIterator as it nicely
diff --git a/example/streaming-clap.zig b/example/streaming-clap.zig
index aad3e71..71a2fca 100644
--- a/example/streaming-clap.zig
+++ b/example/streaming-clap.zig
@@ -9,10 +9,20 @@ pub fn main() !void {
     defer direct_allocator.deinit();
 
     // First we specify what parameters our program can take.
-    const params = []clap.Param(u8){
-        clap.Param(u8).flag('h', clap.Names.both("help")),
-        clap.Param(u8).option('n', clap.Names.both("number")),
-        clap.Param(u8).positional('f'),
+    const params = [_]clap.Param(u8){
+        clap.Param(u8){
+            .id = 'h',
+            .names = clap.Names{ .short = 'h', .long = "help" },
+        },
+        clap.Param(u8){
+            .id = 'n',
+            .names = clap.Names{ .short = 'n', .long = "number" },
+            .takes_value = true,
+        },
+        clap.Param(u8){
+            .id = 'f',
+            .takes_value = true,
+        },
     };
 
     // We then initialize an argument iterator. We will use the OsIterator as it nicely
@@ -24,7 +34,10 @@ pub fn main() !void {
     const exe = try iter.next();
 
     // Finally we initialize our streaming parser.
-    var parser = clap.StreamingClap(u8, clap.args.OsIterator).init(params, &iter);
+    var parser = clap.StreamingClap(u8, clap.args.OsIterator){
+        .params = params,
+        .iter = &iter,
+    };
 
     // Because we use a streaming parser, we have to consume each argument parsed individually.
     while (try parser.next()) |arg| {
diff --git a/index.zig b/index.zig
deleted file mode 100644
index b867913..0000000
--- a/index.zig
+++ /dev/null
@@ -1 +0,0 @@
-pub use @import("src/index.zig");
diff --git a/src/args.zig b/src/args.zig
index a34c14c..4234ada 100644
--- a/src/args.zig
+++ b/src/args.zig
@@ -21,14 +21,7 @@ pub const SliceIterator = struct {
     const Error = error{};
 
     args: []const []const u8,
-    index: usize,
-
-    pub fn init(args: []const []const u8) SliceIterator {
-        return SliceIterator{
-            .args = args,
-            .index = 0,
-        };
-    }
+    index: usize = 0,
 
     pub fn next(iter: *SliceIterator) Error!?[]const u8 {
         if (iter.args.len <= iter.index)
@@ -40,8 +33,8 @@ pub const SliceIterator = struct {
 };
 
 test "clap.args.SliceIterator" {
-    const args = [][]const u8{ "A", "BB", "CCC" };
-    var iter = SliceIterator.init(args);
+    const args = [_][]const u8{ "A", "BB", "CCC" };
+    var iter = SliceIterator{ .args = args };
 
     for (args) |a| {
         const b = try iter.next();
diff --git a/src/comptime.zig b/src/comptime.zig
index b9021de..b585598 100644
--- a/src/comptime.zig
+++ b/src/comptime.zig
@@ -1,4 +1,4 @@
-const clap = @import("index.zig");
+const clap = @import("../clap.zig");
 const std = @import("std");
 
 const testing = std.testing;
@@ -8,7 +8,7 @@ const mem = std.mem;
 pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id)) type {
     var flags: usize = 0;
     var options: usize = 0;
-    var converted_params: []const clap.Param(usize) = []clap.Param(usize){};
+    var converted_params: []const clap.Param(usize) = [_]clap.Param(usize){};
     for (params) |param| {
         const index = blk: {
             if (param.names.long == null and param.names.short == null)
@@ -24,8 +24,12 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
             break :blk res;
         };
 
-        const converted = clap.Param(usize).init(index, param.takes_value, param.names);
-        converted_params = converted_params ++ []clap.Param(usize){converted};
+        const converted = clap.Param(usize){
+            .id = index,
+            .names = param.names,
+            .takes_value = param.takes_value,
+        };
+        converted_params = converted_params ++ [_]clap.Param(usize){converted};
     }
 
     return struct {
@@ -37,13 +41,16 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
         pub fn parse(allocator: *mem.Allocator, comptime ArgIter: type, iter: *ArgIter) !@This() {
             var pos = std.ArrayList([]const u8).init(allocator);
             var res = @This(){
-                .options = []?[]const u8{null} ** options,
-                .flags = []bool{false} ** flags,
+                .options = [_]?[]const u8{null} ** options,
+                .flags = [_]bool{false} ** flags,
                 .pos = undefined,
                 .allocator = allocator,
             };
 
-            var stream = clap.StreamingClap(usize, ArgIter).init(converted_params, iter);
+            var stream = clap.StreamingClap(usize, ArgIter){
+                .params = converted_params,
+                .iter = iter,
+            };
             while (try stream.next()) |arg| {
                 const param = arg.param;
                 if (param.names.long == null and param.names.short == null) {
@@ -90,7 +97,7 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
             comptime {
                 for (converted_params) |param| {
                     if (param.names.short) |s| {
-                        if (mem.eql(u8, name, "-" ++ []u8{s}))
+                        if (mem.eql(u8, name, "-" ++ [_]u8{s}))
                             return param;
                     }
                     if (param.names.long) |l| {
@@ -106,27 +113,38 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
 }
 
 test "clap.comptime.ComptimeClap" {
-    const Clap = ComptimeClap(void, comptime []clap.Param(void){
-        clap.Param(void).flag({}, clap.Names{
-            .short = 'a',
-            .long = "aa",
-        }),
-        clap.Param(void).flag({}, clap.Names{
-            .short = 'b',
-            .long = "bb",
-        }),
-        clap.Param(void).option({}, clap.Names{
-            .short = 'c',
-            .long = "cc",
-        }),
-        clap.Param(void).positional({}),
+    const Clap = ComptimeClap(void, [_]clap.Param(void){
+        clap.Param(void){
+            .names = clap.Names{
+                .short = 'a',
+                .long = "aa",
+            }
+        },
+        clap.Param(void){
+            .names = clap.Names{
+                .short = 'b',
+                .long = "bb",
+            }
+        },
+        clap.Param(void){
+            .names = clap.Names{
+                .short = 'c',
+                .long = "cc",
+            },
+            .takes_value = true,
+        },
+        clap.Param(void){
+            .takes_value = true,
+        },
     });
 
     var buf: [1024]u8 = undefined;
     var fb_allocator = heap.FixedBufferAllocator.init(buf[0..]);
-    var iter = clap.args.SliceIterator.init([][]const u8{
-        "-a", "-c", "0", "something",
-    });
+    var iter = clap.args.SliceIterator{
+        .args = [_][]const u8{
+            "-a", "-c", "0", "something",
+        },
+    };
     var args = try Clap.parse(&fb_allocator.allocator, clap.args.SliceIterator, &iter);
     defer args.deinit();
 
diff --git a/src/streaming.zig b/src/streaming.zig
index 7bdc71f..9da120c 100644
--- a/src/streaming.zig
+++ b/src/streaming.zig
@@ -1,5 +1,5 @@
 const builtin = @import("builtin");
-const clap = @import("index.zig");
+const clap = @import("../clap.zig");
 const std = @import("std");
 
 const args = clap.args;
@@ -14,14 +14,7 @@ pub fn Arg(comptime Id: type) type {
         const Self = @This();
 
         param: *const clap.Param(Id),
-        value: ?[]const u8,
-
-        pub fn init(param: *const clap.Param(Id), value: ?[]const u8) Self {
-            return Self{
-                .param = param,
-                .value = value,
-            };
-        }
+        value: ?[]const u8 = null,
     };
 }
 
@@ -42,17 +35,7 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
 
         params: []const clap.Param(Id),
         iter: *ArgIterator,
-        state: State,
-
-        pub fn init(params: []const clap.Param(Id), iter: *ArgIterator) @This() {
-            var res = @This(){
-                .params = params,
-                .iter = iter,
-                .state = State.Normal,
-            };
-
-            return res;
-        }
+        state: State = State.Normal,
 
         /// Get the next ::Arg that matches a ::Param.
         pub fn next(parser: *@This()) !?Arg(Id) {
@@ -107,7 +90,7 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
                                     if (maybe_value != null)
                                         return error.DoesntTakeValue;
 
-                                    return Arg(Id).init(param, null);
+                                    return Arg(Id){ .param = param };
                                 }
 
                                 const value = blk: {
@@ -117,7 +100,7 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
                                     break :blk (try parser.iter.next()) orelse return error.MissingValue;
                                 };
 
-                                return Arg(Id).init(param, value);
+                                return Arg(Id){ .param = param, .value = value };
                             }
                         },
                         ArgInfo.Kind.Short => {
@@ -133,7 +116,7 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
                                 if (param.names.short) |_|
                                     continue;
 
-                                return Arg(Id).init(param, arg);
+                                return Arg(Id){ .param = param, .value = arg };
                             }
                         },
                     }
@@ -169,18 +152,17 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
                 }
 
                 if (!param.takes_value)
-                    return Arg(Id).init(param, null);
+                    return Arg(Id){ .param = param };
 
                 if (arg.len <= next_index) {
                     const value = (try parser.iter.next()) orelse return error.MissingValue;
-                    return Arg(Id).init(param, value);
+                    return Arg(Id){ .param = param, .value = value };
                 }
 
-                if (arg[next_index] == '=') {
-                    return Arg(Id).init(param, arg[next_index + 1 ..]);
-                }
+                if (arg[next_index] == '=')
+                    return Arg(Id){ .param = param, .value = arg[next_index + 1 ..] };
 
-                return Arg(Id).init(param, arg[next_index..]);
+                return Arg(Id){ .param = param, .value = arg[next_index..] };
             }
 
             return error.InvalidArgument;
@@ -189,8 +171,11 @@ pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
 }
 
 fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, results: []const Arg(u8)) void {
-    var iter = args.SliceIterator.init(args_strings);
-    var c = StreamingClap(u8, args.SliceIterator).init(params, &iter);
+    var iter = args.SliceIterator{ .args = args_strings };
+    var c = StreamingClap(u8, args.SliceIterator){
+        .params = params,
+        .iter = &iter
+    };
 
     for (results) |res| {
         const arg = (c.next() catch unreachable) orelse unreachable;
@@ -209,10 +194,20 @@ fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, r
 }
 
 test "clap.streaming.StreamingClap: short params" {
-    const params = []clap.Param(u8){
-        clap.Param(u8).flag(0, clap.Names.short('a')),
-        clap.Param(u8).flag(1, clap.Names.short('b')),
-        clap.Param(u8).option(2, clap.Names.short('c')),
+    const params = [_]clap.Param(u8){
+        clap.Param(u8){
+            .id = 0,
+            .names = clap.Names{ .short = 'a' },
+        },
+        clap.Param(u8){
+            .id = 1,
+            .names = clap.Names{ .short = 'b' },
+        },
+        clap.Param(u8){
+            .id = 2,
+            .names = clap.Names{ .short = 'c' },
+            .takes_value = true,
+        },
     };
 
     const a = &params[0];
@@ -221,33 +216,43 @@ test "clap.streaming.StreamingClap: short params" {
 
     testNoErr(
         params,
-        [][]const u8{
+        [_][]const u8{
             "-a", "-b", "-ab", "-ba",
             "-c", "0", "-c=0", "-ac",
             "0", "-ac=0",
         },
-        []const Arg(u8){
-            Arg(u8).init(a, null),
-            Arg(u8).init(b, null),
-            Arg(u8).init(a, null),
-            Arg(u8).init(b, null),
-            Arg(u8).init(b, null),
-            Arg(u8).init(a, null),
-            Arg(u8).init(c, "0"),
-            Arg(u8).init(c, "0"),
-            Arg(u8).init(a, null),
-            Arg(u8).init(c, "0"),
-            Arg(u8).init(a, null),
-            Arg(u8).init(c, "0"),
+        [_]Arg(u8){
+            Arg(u8){ .param = a },
+            Arg(u8){ .param = b },
+            Arg(u8){ .param = a },
+            Arg(u8){ .param = b },
+            Arg(u8){ .param = b },
+            Arg(u8){ .param = a },
+            Arg(u8){ .param = c, .value = "0" },
+            Arg(u8){ .param = c, .value = "0" },
+            Arg(u8){ .param = a },
+            Arg(u8){ .param = c, .value = "0" },
+            Arg(u8){ .param = a },
+            Arg(u8){ .param = c, .value = "0" },
         },
     );
 }
 
 test "clap.streaming.StreamingClap: long params" {
-    const params = []clap.Param(u8){
-        clap.Param(u8).flag(0, clap.Names.long("aa")),
-        clap.Param(u8).flag(1, clap.Names.long("bb")),
-        clap.Param(u8).option(2, clap.Names.long("cc")),
+    const params = [_]clap.Param(u8){
+        clap.Param(u8){
+            .id = 0,
+            .names = clap.Names{ .long = "aa" },
+        },
+        clap.Param(u8){
+            .id = 1,
+            .names = clap.Names{ .long = "bb" },
+        },
+        clap.Param(u8){
+            .id = 2,
+            .names = clap.Names{ .long = "cc" },
+            .takes_value = true,
+        },
     };
 
     const aa = &params[0];
@@ -256,48 +261,66 @@ test "clap.streaming.StreamingClap: long params" {
 
     testNoErr(
         params,
-        [][]const u8{
+        [_][]const u8{
             "--aa", "--bb",
             "--cc", "0",
             "--cc=0",
         },
-        []const Arg(u8){
-            Arg(u8).init(aa, null),
-            Arg(u8).init(bb, null),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(cc, "0"),
+        [_]Arg(u8){
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = bb },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = cc, .value = "0" },
         },
     );
 }
 
 test "clap.streaming.StreamingClap: positional params" {
-    const params = []clap.Param(u8){clap.Param(u8).positional(0)};
+    const params = [_]clap.Param(u8){
+        clap.Param(u8){
+            .id = 0,
+            .takes_value = true,
+        },
+    };
 
     testNoErr(
         params,
-        [][]const u8{ "aa", "bb" },
-        []const Arg(u8){
-            Arg(u8).init(&params[0], "aa"),
-            Arg(u8).init(&params[0], "bb"),
+        [_][]const u8{ "aa", "bb" },
+        [_]Arg(u8){
+            Arg(u8){ .param = &params[0], .value = "aa" },
+            Arg(u8){ .param = &params[0], .value = "bb" },
         },
     );
 }
 
 test "clap.streaming.StreamingClap: all params" {
-    const params = []clap.Param(u8){
-        clap.Param(u8).flag(0, clap.Names{
-            .short = 'a',
-            .long = "aa",
-        }),
-        clap.Param(u8).flag(1, clap.Names{
-            .short = 'b',
-            .long = "bb",
-        }),
-        clap.Param(u8).option(2, clap.Names{
-            .short = 'c',
-            .long = "cc",
-        }),
-        clap.Param(u8).positional(3),
+    const params = [_]clap.Param(u8){
+        clap.Param(u8){
+            .id = 0,
+            .names = clap.Names{
+                .short = 'a',
+                .long = "aa",
+            },
+        },
+        clap.Param(u8){
+            .id = 1,
+            .names = clap.Names{
+                .short = 'b',
+                .long = "bb",
+            },
+        },
+        clap.Param(u8){
+            .id = 2,
+            .names = clap.Names{
+                .short = 'c',
+                .long = "cc",
+            },
+            .takes_value = true,
+        },
+        clap.Param(u8){
+            .id = 3,
+            .takes_value = true,
+        },
     };
 
     const aa = &params[0];
@@ -307,30 +330,30 @@ test "clap.streaming.StreamingClap: all params" {
 
     testNoErr(
         params,
-        [][]const u8{
+        [_][]const u8{
             "-a", "-b", "-ab", "-ba",
             "-c", "0", "-c=0", "-ac",
             "0", "-ac=0", "--aa", "--bb",
             "--cc", "0", "--cc=0", "something",
         },
-        []const Arg(u8){
-            Arg(u8).init(aa, null),
-            Arg(u8).init(bb, null),
-            Arg(u8).init(aa, null),
-            Arg(u8).init(bb, null),
-            Arg(u8).init(bb, null),
-            Arg(u8).init(aa, null),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(aa, null),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(aa, null),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(aa, null),
-            Arg(u8).init(bb, null),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(cc, "0"),
-            Arg(u8).init(positional, "something"),
+        [_]Arg(u8){
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = bb },
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = bb },
+            Arg(u8){ .param = bb },
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = aa },
+            Arg(u8){ .param = bb },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = cc, .value = "0" },
+            Arg(u8){ .param = positional, .value = "something" },
         },
     );
 }