4 files changed, 182 insertions, 168 deletions

diff --git a/clap.zig b/clap.zig
index 8d721fa..ee713a7 100644
--- a/clap.zig
+++ b/clap.zig
@@ -122,81 +122,81 @@ fn parseParamRest(line: []const u8) Param(Help) {
     return .{ .id = .{ .msg = mem.trim(u8, line, " \t") } };
 }
 
-fn expectParam(expect: Param(Help), actual: Param(Help)) void {
-    testing.expectEqualStrings(expect.id.msg, actual.id.msg);
-    testing.expectEqualStrings(expect.id.value, actual.id.value);
-    testing.expectEqual(expect.names.short, actual.names.short);
-    testing.expectEqual(expect.takes_value, actual.takes_value);
+fn expectParam(expect: Param(Help), actual: Param(Help)) !void {
+    try testing.expectEqualStrings(expect.id.msg, actual.id.msg);
+    try testing.expectEqualStrings(expect.id.value, actual.id.value);
+    try testing.expectEqual(expect.names.short, actual.names.short);
+    try testing.expectEqual(expect.takes_value, actual.takes_value);
     if (expect.names.long) |long| {
-        testing.expectEqualStrings(long, actual.names.long.?);
+        try testing.expectEqualStrings(long, actual.names.long.?);
     } else {
-        testing.expectEqual(@as(?[]const u8, null), actual.names.long);
+        try testing.expectEqual(@as(?[]const u8, null), actual.names.long);
     }
 }
 
 test "parseParam" {
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "value" },
         .names = .{ .short = 's', .long = "long" },
         .takes_value = .one,
     }, try parseParam("-s, --long <value> Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "value" },
         .names = .{ .short = 's', .long = "long" },
         .takes_value = .many,
     }, try parseParam("-s, --long <value>... Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "value" },
         .names = .{ .long = "long" },
         .takes_value = .one,
     }, try parseParam("--long <value> Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "value" },
         .names = .{ .short = 's' },
         .takes_value = .one,
     }, try parseParam("-s <value> Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text" },
         .names = .{ .short = 's', .long = "long" },
     }, try parseParam("-s, --long Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text" },
         .names = .{ .short = 's' },
     }, try parseParam("-s Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text" },
         .names = .{ .long = "long" },
     }, try parseParam("--long Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "A | B" },
         .names = .{ .long = "long" },
         .takes_value = .one,
     }, try parseParam("--long <A | B> Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "A" },
         .names = .{},
         .takes_value = .one,
     }, try parseParam("<A> Help text"));
 
-    expectParam(Param(Help){
+    try expectParam(Param(Help){
         .id = .{ .msg = "Help text", .value = "A" },
         .names = .{},
         .takes_value = .many,
     }, try parseParam("<A>... Help text"));
 
-    testing.expectError(error.TrailingComma, parseParam("--long, Help"));
-    testing.expectError(error.TrailingComma, parseParam("-s, Help"));
-    testing.expectError(error.InvalidShortParam, parseParam("-ss Help"));
-    testing.expectError(error.InvalidShortParam, parseParam("-ss <value> Help"));
-    testing.expectError(error.InvalidShortParam, parseParam("- Help"));
+    try testing.expectError(error.TrailingComma, parseParam("--long, Help"));
+    try testing.expectError(error.TrailingComma, parseParam("-s, Help"));
+    try testing.expectError(error.InvalidShortParam, parseParam("-ss Help"));
+    try testing.expectError(error.InvalidShortParam, parseParam("-ss <value> Help"));
+    try testing.expectError(error.InvalidShortParam, parseParam("- Help"));
 }
 
 /// Optional diagnostics used for reporting useful errors
@@ -227,24 +227,24 @@ pub const Diagnostic = struct {
     }
 };
 
-fn testDiag(diag: Diagnostic, err: anyerror, expected: []const u8) void {
+fn testDiag(diag: Diagnostic, err: anyerror, expected: []const u8) !void {
     var buf: [1024]u8 = undefined;
     var slice_stream = io.fixedBufferStream(&buf);
     diag.report(slice_stream.writer(), err) catch unreachable;
-    testing.expectEqualStrings(expected, slice_stream.getWritten());
+    try testing.expectEqualStrings(expected, slice_stream.getWritten());
 }
 
 test "Diagnostic.report" {
-    testDiag(.{ .arg = "c" }, error.InvalidArgument, "Invalid argument 'c'\n");
-    testDiag(.{ .name = .{ .long = "cc" } }, error.InvalidArgument, "Invalid argument '--cc'\n");
-    testDiag(.{ .name = .{ .short = 'c' } }, error.DoesntTakeValue, "The argument '-c' does not take a value\n");
-    testDiag(.{ .name = .{ .long = "cc" } }, error.DoesntTakeValue, "The argument '--cc' does not take a value\n");
-    testDiag(.{ .name = .{ .short = 'c' } }, error.MissingValue, "The argument '-c' requires a value but none was supplied\n");
-    testDiag(.{ .name = .{ .long = "cc" } }, error.MissingValue, "The argument '--cc' requires a value but none was supplied\n");
-    testDiag(.{ .name = .{ .short = 'c' } }, error.InvalidArgument, "Invalid argument '-c'\n");
-    testDiag(.{ .name = .{ .long = "cc" } }, error.InvalidArgument, "Invalid argument '--cc'\n");
-    testDiag(.{ .name = .{ .short = 'c' } }, error.SomethingElse, "Error while parsing arguments: SomethingElse\n");
-    testDiag(.{ .name = .{ .long = "cc" } }, error.SomethingElse, "Error while parsing arguments: SomethingElse\n");
+    try testDiag(.{ .arg = "c" }, error.InvalidArgument, "Invalid argument 'c'\n");
+    try testDiag(.{ .name = .{ .long = "cc" } }, error.InvalidArgument, "Invalid argument '--cc'\n");
+    try testDiag(.{ .name = .{ .short = 'c' } }, error.DoesntTakeValue, "The argument '-c' does not take a value\n");
+    try testDiag(.{ .name = .{ .long = "cc" } }, error.DoesntTakeValue, "The argument '--cc' does not take a value\n");
+    try testDiag(.{ .name = .{ .short = 'c' } }, error.MissingValue, "The argument '-c' requires a value but none was supplied\n");
+    try testDiag(.{ .name = .{ .long = "cc" } }, error.MissingValue, "The argument '--cc' requires a value but none was supplied\n");
+    try testDiag(.{ .name = .{ .short = 'c' } }, error.InvalidArgument, "Invalid argument '-c'\n");
+    try testDiag(.{ .name = .{ .long = "cc" } }, error.InvalidArgument, "Invalid argument '--cc'\n");
+    try testDiag(.{ .name = .{ .short = 'c' } }, error.SomethingElse, "Error while parsing arguments: SomethingElse\n");
+    try testDiag(.{ .name = .{ .long = "cc" } }, error.SomethingElse, "Error while parsing arguments: SomethingElse\n");
 }
 
 pub fn Args(comptime Id: type, comptime params: []const Param(Id)) type {
@@ -338,7 +338,7 @@ pub fn helpFull(
     const max_spacing = blk: {
         var res: usize = 0;
         for (params) |param| {
-            var cs = io.countingOutStream(io.null_writer);
+            var cs = io.countingWriter(io.null_writer);
             try printParam(cs.writer(), Id, param, Error, context, valueText);
             if (res < cs.bytes_written)
                 res = @intCast(usize, cs.bytes_written);
@@ -355,7 +355,7 @@ pub fn helpFull(
         try stream.print("\t", .{});
         try printParam(cs.writer(), Id, param, Error, context, valueText);
         try stream.writeByteNTimes(' ', max_spacing - @intCast(usize, cs.bytes_written));
-        try stream.print("\t{}\n", .{try helpText(context, param)});
+        try stream.print("\t{s}\n", .{try helpText(context, param)});
     }
 }
 
@@ -450,7 +450,7 @@ test "clap.help" {
     @setEvalBranchQuota(10000);
     try help(
         slice_stream.writer(),
-        comptime &[_]Param(Help){
+        comptime &.{
             parseParam("-a                Short flag.") catch unreachable,
             parseParam("-b <V1>           Short option.") catch unreachable,
             parseParam("--aa              Long flag.") catch unreachable,
@@ -471,7 +471,7 @@ test "clap.help" {
         "\t-d, --dd <V3>   \tBoth option.\n" ++
         "\t-d, --dd <V3>...\tBoth repeated option.\n";
 
-    testing.expectEqualStrings(expected, slice_stream.getWritten());
+    try testing.expectEqualStrings(expected, slice_stream.getWritten());
 }
 
 /// Will print a usage message in the following format:
@@ -569,40 +569,40 @@ fn testUsage(expected: []const u8, params: []const Param(Help)) !void {
     var buf: [1024]u8 = undefined;
     var fbs = io.fixedBufferStream(&buf);
     try usage(fbs.writer(), params);
-    testing.expectEqualStrings(expected, fbs.getWritten());
+    try testing.expectEqualStrings(expected, fbs.getWritten());
 }
 
 test "usage" {
     @setEvalBranchQuota(100000);
-    try testUsage("[-ab]", comptime &[_]Param(Help){
-        parseParam("-a") catch unreachable,
-        parseParam("-b") catch unreachable,
+    try testUsage("[-ab]", &.{
+        try parseParam("-a"),
+        try parseParam("-b"),
     });
-    try testUsage("[-a <value>] [-b <v>]", comptime &[_]Param(Help){
-        parseParam("-a <value>") catch unreachable,
-        parseParam("-b <v>") catch unreachable,
+    try testUsage("[-a <value>] [-b <v>]", &.{
+        try parseParam("-a <value>"),
+        try parseParam("-b <v>"),
     });
-    try testUsage("[--a] [--b]", comptime &[_]Param(Help){
-        parseParam("--a") catch unreachable,
-        parseParam("--b") catch unreachable,
+    try testUsage("[--a] [--b]", &.{
+        try parseParam("--a"),
+        try parseParam("--b"),
     });
-    try testUsage("[--a <value>] [--b <v>]", comptime &[_]Param(Help){
-        parseParam("--a <value>") catch unreachable,
-        parseParam("--b <v>") catch unreachable,
+    try testUsage("[--a <value>] [--b <v>]", &.{
+        try parseParam("--a <value>"),
+        try parseParam("--b <v>"),
     });
-    try testUsage("<file>", comptime &[_]Param(Help){
-        parseParam("<file>") catch unreachable,
+    try testUsage("<file>", &.{
+        try parseParam("<file>"),
     });
-    try testUsage("[-ab] [-c <value>] [-d <v>] [--e] [--f] [--g <value>] [--h <v>] [-i <v>...] <file>", comptime &[_]Param(Help){
-        parseParam("-a") catch unreachable,
-        parseParam("-b") catch unreachable,
-        parseParam("-c <value>") catch unreachable,
-        parseParam("-d <v>") catch unreachable,
-        parseParam("--e") catch unreachable,
-        parseParam("--f") catch unreachable,
-        parseParam("--g <value>") catch unreachable,
-        parseParam("--h <v>") catch unreachable,
-        parseParam("-i <v>...") catch unreachable,
-        parseParam("<file>") catch unreachable,
+    try testUsage("[-ab] [-c <value>] [-d <v>] [--e] [--f] [--g <value>] [--h <v>] [-i <v>...] <file>", &.{
+        try parseParam("-a"),
+        try parseParam("-b"),
+        try parseParam("-c <value>"),
+        try parseParam("-d <v>"),
+        try parseParam("--e"),
+        try parseParam("--f"),
+        try parseParam("--g <value>"),
+        try parseParam("--h <v>"),
+        try parseParam("-i <v>..."),
+        try parseParam("<file>"),
     });
 }
diff --git a/clap/args.zig b/clap/args.zig
index f9ad218..555e8ab 100644
--- a/clap/args.zig
+++ b/clap/args.zig
@@ -34,8 +34,8 @@ pub const SliceIterator = struct {
 };
 
 test "SliceIterator" {
-    const args = &[_][]const u8{ "A", "BB", "CCC" };
-    var iter = SliceIterator{ .args = args };
+    const args = [_][]const u8{ "A", "BB", "CCC" };
+    var iter = SliceIterator{ .args = &args };
 
     for (args) |a| {
         const b = try iter.next();
@@ -266,76 +266,76 @@ pub const ShellIterator = struct {
     }
 };
 
-fn testShellIteratorOk(str: []const u8, allocations: usize, expect: []const []const u8) void {
+fn testShellIteratorOk(str: []const u8, allocations: usize, expect: []const []const u8) !void {
     var allocator = testing.FailingAllocator.init(testing.allocator, allocations);
     var it = ShellIterator.init(&allocator.allocator, str);
     defer it.deinit();
 
     for (expect) |e| {
         if (it.next()) |actual| {
-            testing.expect(actual != null);
-            testing.expectEqualStrings(e, actual.?);
-        } else |err| testing.expectEqual(@as(anyerror![]const u8, e), err);
+            try testing.expect(actual != null);
+            try testing.expectEqualStrings(e, actual.?);
+        } else |err| try testing.expectEqual(@as(anyerror![]const u8, e), err);
     }
 
     if (it.next()) |actual| {
-        testing.expectEqual(@as(?[]const u8, null), actual);
-        testing.expectEqual(allocations, allocator.allocations);
-    } else |err| testing.expectEqual(@as(anyerror!void, {}), err);
+        try testing.expectEqual(@as(?[]const u8, null), actual);
+        try testing.expectEqual(allocations, allocator.allocations);
+    } else |err| try testing.expectEqual(@as(anyerror!void, {}), err);
 }
 
-fn testShellIteratorErr(str: []const u8, expect: anyerror) void {
+fn testShellIteratorErr(str: []const u8, expect: anyerror) !void {
     var it = ShellIterator.init(testing.allocator, str);
     defer it.deinit();
 
     while (it.next() catch |err| {
-        testing.expectError(expect, @as(anyerror!void, err));
+        try testing.expectError(expect, @as(anyerror!void, err));
         return;
     }) |_| {}
 
-    testing.expectError(expect, @as(anyerror!void, {}));
+    try testing.expectError(expect, @as(anyerror!void, {}));
 }
 
 test "ShellIterator" {
-    testShellIteratorOk("a", 0, &[_][]const u8{"a"});
-    testShellIteratorOk("'a'", 0, &[_][]const u8{"a"});
-    testShellIteratorOk("\"a\"", 0, &[_][]const u8{"a"});
-    testShellIteratorOk("a b", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("'a' b", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("\"a\" b", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("a 'b'", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("a \"b\"", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("'a b'", 0, &[_][]const u8{"a b"});
-    testShellIteratorOk("\"a b\"", 0, &[_][]const u8{"a b"});
-    testShellIteratorOk("\"a\"\"b\"", 1, &[_][]const u8{"ab"});
-    testShellIteratorOk("'a''b'", 1, &[_][]const u8{"ab"});
-    testShellIteratorOk("'a'b", 1, &[_][]const u8{"ab"});
-    testShellIteratorOk("a'b'", 1, &[_][]const u8{"ab"});
-    testShellIteratorOk("a\\ b", 1, &[_][]const u8{"a b"});
-    testShellIteratorOk("\"a\\ b\"", 1, &[_][]const u8{"a b"});
-    testShellIteratorOk("'a\\ b'", 0, &[_][]const u8{"a\\ b"});
-    testShellIteratorOk("   a     b      ", 0, &[_][]const u8{ "a", "b" });
-    testShellIteratorOk("\\  \\ ", 0, &[_][]const u8{ " ", " " });
-
-    testShellIteratorOk(
+    try testShellIteratorOk("a", 0, &.{"a"});
+    try testShellIteratorOk("'a'", 0, &.{"a"});
+    try testShellIteratorOk("\"a\"", 0, &.{"a"});
+    try testShellIteratorOk("a b", 0, &.{ "a", "b" });
+    try testShellIteratorOk("'a' b", 0, &.{ "a", "b" });
+    try testShellIteratorOk("\"a\" b", 0, &.{ "a", "b" });
+    try testShellIteratorOk("a 'b'", 0, &.{ "a", "b" });
+    try testShellIteratorOk("a \"b\"", 0, &.{ "a", "b" });
+    try testShellIteratorOk("'a b'", 0, &.{"a b"});
+    try testShellIteratorOk("\"a b\"", 0, &.{"a b"});
+    try testShellIteratorOk("\"a\"\"b\"", 1, &.{"ab"});
+    try testShellIteratorOk("'a''b'", 1, &.{"ab"});
+    try testShellIteratorOk("'a'b", 1, &.{"ab"});
+    try testShellIteratorOk("a'b'", 1, &.{"ab"});
+    try testShellIteratorOk("a\\ b", 1, &.{"a b"});
+    try testShellIteratorOk("\"a\\ b\"", 1, &.{"a b"});
+    try testShellIteratorOk("'a\\ b'", 0, &.{"a\\ b"});
+    try testShellIteratorOk("   a     b      ", 0, &.{ "a", "b" });
+    try testShellIteratorOk("\\  \\ ", 0, &.{ " ", " " });
+
+    try testShellIteratorOk(
         \\printf 'run\nuninstall\n'
-    , 0, &[_][]const u8{ "printf", "run\\nuninstall\\n" });
-    testShellIteratorOk(
+    , 0, &.{ "printf", "run\\nuninstall\\n" });
+    try testShellIteratorOk(
         \\setsid -f steam "steam://$action/$id"
-    , 0, &[_][]const u8{ "setsid", "-f", "steam", "steam://$action/$id" });
-    testShellIteratorOk(
+    , 0, &.{ "setsid", "-f", "steam", "steam://$action/$id" });
+    try testShellIteratorOk(
         \\xargs -I% rg --no-heading --no-line-number --only-matching
         \\    --case-sensitive --multiline --text --byte-offset '(?-u)%' $@
         \\
-    , 0, &[_][]const u8{
+    , 0, &.{
         "xargs",            "-I%",             "rg",               "--no-heading",
         "--no-line-number", "--only-matching", "--case-sensitive", "--multiline",
         "--text",           "--byte-offset",   "(?-u)%",           "$@",
     });
 
-    testShellIteratorErr("'a", error.QuoteNotClosed);
-    testShellIteratorErr("'a\\", error.QuoteNotClosed);
-    testShellIteratorErr("\"a", error.QuoteNotClosed);
-    testShellIteratorErr("\"a\\", error.QuoteNotClosed);
-    testShellIteratorErr("a\\", error.DanglingEscape);
+    try testShellIteratorErr("'a", error.QuoteNotClosed);
+    try testShellIteratorErr("'a\\", error.QuoteNotClosed);
+    try testShellIteratorErr("\"a", error.QuoteNotClosed);
+    try testShellIteratorErr("\"a\\", error.QuoteNotClosed);
+    try testShellIteratorErr("a\\", error.DanglingEscape);
 }
diff --git a/clap/comptime.zig b/clap/comptime.zig
index 122ff16..7808f52 100644
--- a/clap/comptime.zig
+++ b/clap/comptime.zig
@@ -14,7 +14,7 @@ pub fn ComptimeClap(
     var flags: usize = 0;
     var single_options: usize = 0;
     var multi_options: usize = 0;
-    var converted_params: []const clap.Param(usize) = &[_]clap.Param(usize){};
+    var converted_params: []const clap.Param(usize) = &.{};
     for (params) |param| {
         var index: usize = 0;
         if (param.names.long != null or param.names.short != null) {
@@ -27,18 +27,18 @@ pub fn ComptimeClap(
             ptr.* += 1;
         }
 
-        const converted = clap.Param(usize){
+        converted_params = converted_params ++ [_]clap.Param(usize){.{
             .id = index,
             .names = param.names,
             .takes_value = param.takes_value,
-        };
-        converted_params = converted_params ++ [_]clap.Param(usize){converted};
+        }};
     }
 
     return struct {
-        single_options: [single_options]?[]const u8,
         multi_options: [multi_options][]const []const u8,
-        flags: [flags]bool,
+        single_options: [single_options][]const u8,
+        single_options_is_set: std.PackedIntArray(u1, single_options),
+        flags: std.PackedIntArray(u1, flags),
         pos: []const []const u8,
         allocator: *mem.Allocator,
 
@@ -52,9 +52,12 @@ pub fn ComptimeClap(
             var pos = std.ArrayList([]const u8).init(allocator);
 
             var res = @This(){
-                .single_options = [_]?[]const u8{null} ** single_options,
-                .multi_options = [_][]const []const u8{undefined} ** multi_options,
-                .flags = [_]bool{false} ** flags,
+                .multi_options = .{undefined} ** multi_options,
+                .single_options = .{undefined} ** single_options,
+                .single_options_is_set = std.PackedIntArray(u1, single_options).init(
+                    .{0} ** single_options,
+                ),
+                .flags = std.PackedIntArray(u1, flags).init(.{0} ** flags),
                 .pos = undefined,
                 .allocator = allocator,
             };
@@ -69,16 +72,18 @@ pub fn ComptimeClap(
                     try pos.append(arg.value.?);
                 } else if (param.takes_value == .one) {
                     debug.assert(res.single_options.len != 0);
-                    if (res.single_options.len != 0)
+                    if (res.single_options.len != 0) {
                         res.single_options[param.id] = arg.value.?;
+                        res.single_options_is_set.set(param.id, 1);
+                    }
                 } else if (param.takes_value == .many) {
                     debug.assert(multis.len != 0);
                     if (multis.len != 0)
                         try multis[param.id].append(arg.value.?);
                 } else {
-                    debug.assert(res.flags.len != 0);
-                    if (res.flags.len != 0)
-                        res.flags[param.id] = true;
+                    debug.assert(res.flags.len() != 0);
+                    if (res.flags.len() != 0)
+                        res.flags.set(param.id, 1);
                 }
             }
 
@@ -100,7 +105,7 @@ pub fn ComptimeClap(
             if (param.takes_value != .none)
                 @compileError(name ++ " is an option and not a flag.");
 
-            return parser.flags[param.id];
+            return parser.flags.get(param.id) != 0;
         }
 
         pub fn option(parser: @This(), comptime name: []const u8) ?[]const u8 {
@@ -109,6 +114,8 @@ pub fn ComptimeClap(
                 @compileError(name ++ " is a flag and not an option.");
             if (param.takes_value == .many)
                 @compileError(name ++ " takes many options, not one.");
+            if (parser.single_options_is_set.get(param.id) == 0)
+                return null;
             return parser.single_options[param.id];
         }
 
@@ -146,30 +153,37 @@ pub fn ComptimeClap(
 }
 
 test "" {
-    const Clap = ComptimeClap(clap.Help, comptime &[_]clap.Param(clap.Help){
-        clap.parseParam("-a, --aa    ") catch unreachable,
-        clap.parseParam("-b, --bb    ") catch unreachable,
+    const Clap = ComptimeClap(clap.Help, comptime &.{
+        clap.parseParam("-a, --aa") catch unreachable,
+        clap.parseParam("-b, --bb") catch unreachable,
         clap.parseParam("-c, --cc <V>") catch unreachable,
         clap.parseParam("-d, --dd <V>...") catch unreachable,
         clap.parseParam("<P>") catch unreachable,
     });
 
     var iter = clap.args.SliceIterator{
-        .args = &[_][]const u8{
+        .args = &.{
             "-a", "-c", "0", "something", "-d", "a", "--dd", "b",
         },
     };
     var args = try Clap.parse(&iter, .{ .allocator = testing.allocator });
     defer args.deinit();
 
-    testing.expect(args.flag("-a"));
-    testing.expect(args.flag("--aa"));
-    testing.expect(!args.flag("-b"));
-    testing.expect(!args.flag("--bb"));
-    testing.expectEqualStrings("0", args.option("-c").?);
-    testing.expectEqualStrings("0", args.option("--cc").?);
-    testing.expectEqual(@as(usize, 1), args.positionals().len);
-    testing.expectEqualStrings("something", args.positionals()[0]);
-    testing.expectEqualSlices([]const u8, &[_][]const u8{ "a", "b" }, args.options("-d"));
-    testing.expectEqualSlices([]const u8, &[_][]const u8{ "a", "b" }, args.options("--dd"));
+    try testing.expect(args.flag("-a"));
+    try testing.expect(args.flag("--aa"));
+    try testing.expect(!args.flag("-b"));
+    try testing.expect(!args.flag("--bb"));
+    try testing.expectEqualStrings("0", args.option("-c").?);
+    try testing.expectEqualStrings("0", args.option("--cc").?);
+    try testing.expectEqual(@as(usize, 1), args.positionals().len);
+    try testing.expectEqualStrings("something", args.positionals()[0]);
+    try testing.expectEqualSlices([]const u8, &.{ "a", "b" }, args.options("-d"));
+    try testing.expectEqualSlices([]const u8, &.{ "a", "b" }, args.options("--dd"));
+}
+
+test "empty" {
+    const Clap = ComptimeClap(clap.Help, comptime &.{});
+    var iter = clap.args.SliceIterator{ .args = &.{} };
+    var args = try Clap.parse(&iter, .{ .allocator = testing.allocator });
+    defer args.deinit();
 }
diff --git a/clap/streaming.zig b/clap/streaming.zig
index a2a0ca8..e2f1311 100644
--- a/clap/streaming.zig
+++ b/clap/streaming.zig
@@ -203,7 +203,7 @@ 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 {
+fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, results: []const Arg(u8)) !void {
     var iter = args.SliceIterator{ .args = args_strings };
     var c = StreamingClap(u8, args.SliceIterator){
         .params = params,
@@ -211,22 +211,22 @@ fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, r
     };
 
     for (results) |res| {
-        const arg = (c.next() catch unreachable) orelse unreachable;
-        testing.expectEqual(res.param, arg.param);
+        const arg = (try c.next()) orelse return error.TestFailed;
+        try testing.expectEqual(res.param, arg.param);
         const expected_value = res.value orelse {
-            testing.expectEqual(@as(@TypeOf(arg.value), null), arg.value);
+            try testing.expectEqual(@as(@TypeOf(arg.value), null), arg.value);
             continue;
         };
-        const actual_value = arg.value orelse unreachable;
-        testing.expectEqualSlices(u8, expected_value, actual_value);
+        const actual_value = arg.value orelse return error.TestFailed;
+        try testing.expectEqualSlices(u8, expected_value, actual_value);
     }
 
-    if (c.next() catch unreachable) |_|
-        unreachable;
+    if (try c.next()) |_|
+        return error.TestFailed;
 }
 
-fn testErr(params: []const clap.Param(u8), args_strings: []const []const u8, expected: []const u8) void {
-    var diag = clap.Diagnostic{};
+fn testErr(params: []const clap.Param(u8), args_strings: []const []const u8, expected: []const u8) !void {
+    var diag: clap.Diagnostic = undefined;
     var iter = args.SliceIterator{ .args = args_strings };
     var c = StreamingClap(u8, args.SliceIterator){
         .params = params,
@@ -236,12 +236,12 @@ fn testErr(params: []const clap.Param(u8), args_strings: []const []const u8, exp
     while (c.next() catch |err| {
         var buf: [1024]u8 = undefined;
         var fbs = io.fixedBufferStream(&buf);
-        diag.report(fbs.writer(), err) catch unreachable;
-        testing.expectEqualStrings(expected, fbs.getWritten());
+        diag.report(fbs.writer(), err) catch return error.TestFailed;
+        try testing.expectEqualStrings(expected, fbs.getWritten());
         return;
     }) |_| {}
 
-    testing.expect(false);
+    try testing.expect(false);
 }
 
 test "short params" {
@@ -265,14 +265,14 @@ test "short params" {
     const c = &params[2];
     const d = &params[3];
 
-    testNoErr(
+    try testNoErr(
         &params,
-        &[_][]const u8{
+        &.{
             "-a", "-b",    "-ab",  "-ba",
             "-c", "0",     "-c=0", "-ac",
             "0",  "-ac=0", "-d=0",
         },
-        &[_]Arg(u8){
+        &.{
             .{ .param = a },
             .{ .param = b },
             .{ .param = a },
@@ -311,14 +311,14 @@ test "long params" {
     const cc = &params[2];
     const dd = &params[3];
 
-    testNoErr(
+    try testNoErr(
         &params,
-        &[_][]const u8{
+        &.{
             "--aa",   "--bb",
             "--cc",   "0",
             "--cc=0", "--dd=0",
         },
-        &[_]Arg(u8){
+        &.{
             .{ .param = aa },
             .{ .param = bb },
             .{ .param = cc, .value = "0" },
@@ -334,10 +334,10 @@ test "positional params" {
         .takes_value = .one,
     }};
 
-    testNoErr(
+    try testNoErr(
         &params,
-        &[_][]const u8{ "aa", "bb" },
-        &[_]Arg(u8){
+        &.{ "aa", "bb" },
+        &.{
             .{ .param = &params[0], .value = "aa" },
             .{ .param = &params[0], .value = "bb" },
         },
@@ -367,16 +367,16 @@ test "all params" {
     const cc = &params[2];
     const positional = &params[3];
 
-    testNoErr(
+    try testNoErr(
         &params,
-        &[_][]const u8{
+        &.{
             "-a",   "-b",    "-ab",    "-ba",
             "-c",   "0",     "-c=0",   "-ac",
             "0",    "-ac=0", "--aa",   "--bb",
             "--cc", "0",     "--cc=0", "something",
             "-",    "--",    "--cc=0", "-a",
         },
-        &[_]Arg(u8){
+        &.{
             .{ .param = aa },
             .{ .param = bb },
             .{ .param = aa },
@@ -413,12 +413,12 @@ test "errors" {
             .takes_value = .one,
         },
     };
-    testErr(&params, &[_][]const u8{"q"}, "Invalid argument 'q'\n");
-    testErr(&params, &[_][]const u8{"-q"}, "Invalid argument '-q'\n");
-    testErr(&params, &[_][]const u8{"--q"}, "Invalid argument '--q'\n");
-    testErr(&params, &[_][]const u8{"--q=1"}, "Invalid argument '--q'\n");
-    testErr(&params, &[_][]const u8{"-a=1"}, "The argument '-a' does not take a value\n");
-    testErr(&params, &[_][]const u8{"--aa=1"}, "The argument '--aa' does not take a value\n");
-    testErr(&params, &[_][]const u8{"-c"}, "The argument '-c' requires a value but none was supplied\n");
-    testErr(&params, &[_][]const u8{"--cc"}, "The argument '--cc' requires a value but none was supplied\n");
+    try testErr(&params, &.{"q"}, "Invalid argument 'q'\n");
+    try testErr(&params, &.{"-q"}, "Invalid argument '-q'\n");
+    try testErr(&params, &.{"--q"}, "Invalid argument '--q'\n");
+    try testErr(&params, &.{"--q=1"}, "Invalid argument '--q'\n");
+    try testErr(&params, &.{"-a=1"}, "The argument '-a' does not take a value\n");
+    try testErr(&params, &.{"--aa=1"}, "The argument '--aa' does not take a value\n");
+    try testErr(&params, &.{"-c"}, "The argument '-c' requires a value but none was supplied\n");
+    try testErr(&params, &.{"--cc"}, "The argument '--cc' requires a value but none was supplied\n");
 }