14 files changed, 153 insertions, 141 deletions

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 93d00fc..7418c8c 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -4,7 +4,7 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest]
     runs-on: ${{matrix.os}}
     steps:
       - uses: actions/checkout@v1
@@ -12,7 +12,7 @@ jobs:
           submodules: recursive
       - uses: goto-bus-stop/setup-zig@v1.0.0
         with:
-          version: 0.5.0
+          version: 0.6.0
       - run: zig build
   lint:
     runs-on: ubuntu-latest
@@ -20,5 +20,5 @@ jobs:
       - uses: actions/checkout@v1
       - uses: goto-bus-stop/setup-zig@v1.0.0
         with:
-          version: 0.5.0
+          version: 0.6.0
       - run: zig fmt --check .
diff --git a/README.md b/README.md
index 12d691d..2b38281 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,10 @@
 
 A simple and easy to use command line argument parser library for Zig.
 
+Looking for a version that works with `zig master`? The `zig-master` branch has
+you covered. It is maintained by people who live at head (not me) and is merged
+into master on every `zig` release.
+
 ## Features
 
 * Short arguments `-a`
@@ -36,15 +40,15 @@ pub fn main() !void {
         },
     };
 
-    var args = try clap.parse(clap.Help, params, std.heap.direct_allocator);
+    var args = try clap.parse(clap.Help, &params, std.heap.page_allocator);
     defer args.deinit();
 
     if (args.flag("--help"))
-        debug.warn("--help\n");
+        debug.warn("--help\n", .{});
     if (args.option("--number")) |n|
-        debug.warn("--number = {}\n", n);
+        debug.warn("--number = {}\n", .{ n });
     for (args.positionals()) |pos|
-        debug.warn("{}\n", pos);
+        debug.warn("{}\n", .{ pos });
 }
 
 ```
@@ -63,7 +67,7 @@ pub fn main() !void {
         clap.parseParam("-h, --help  Display this help and exit.") catch unreachable,
     };
 
-    var args = try clap.parse(clap.Help, params, std.heap.direct_allocator);
+    var args = try clap.parse(clap.Help, &params, std.heap.direct_allocator);
     defer args.deinit();
 
     _ = args.flag("--helps");
@@ -97,7 +101,7 @@ const clap = @import("clap");
 const debug = std.debug;
 
 pub fn main() !void {
-    const allocator = std.heap.direct_allocator;
+    const allocator = std.heap.page_allocator;
 
     // First we specify what parameters our program can take.
     // We can use `parseParam` to parse a string to a `Param(Help)`
@@ -115,15 +119,15 @@ pub fn main() !void {
     defer iter.deinit();
 
     // Parse the arguments
-    var args = try clap.ComptimeClap(clap.Help, params).parse(allocator, clap.args.OsIterator, &iter);
+    var args = try clap.ComptimeClap(clap.Help, &params).parse(allocator, clap.args.OsIterator, &iter);
     defer args.deinit();
 
     if (args.flag("--help"))
-        debug.warn("--help\n");
+        debug.warn("--help\n", .{});
     if (args.option("--number")) |n|
-        debug.warn("--number = {}\n", n);
+        debug.warn("--number = {}\n", .{ n });
     for (args.positionals()) |pos|
-        debug.warn("{}\n", pos);
+        debug.warn("{}\n", .{ pos });
 }
 
 ```
@@ -140,7 +144,7 @@ const clap = @import("clap");
 const debug = std.debug;
 
 pub fn main() !void {
-    const allocator = std.heap.direct_allocator;
+    const allocator = std.heap.page_allocator;
 
     // First we specify what parameters our program can take.
     const params = [_]clap.Param(u8){
@@ -166,7 +170,7 @@ pub fn main() !void {
 
     // Initialize our streaming parser.
     var parser = clap.StreamingClap(u8, clap.args.OsIterator){
-        .params = params,
+        .params = &params,
         .iter = &iter,
     };
 
@@ -174,13 +178,13 @@ pub fn main() !void {
     while (try parser.next()) |arg| {
         // arg.param will point to the parameter which matched the argument.
         switch (arg.param.id) {
-            'h' => debug.warn("Help!\n"),
-            'n' => debug.warn("--number = {}\n", arg.value.?),
+            'h' => debug.warn("Help!\n", .{}),
+            'n' => debug.warn("--number = {}\n", .{ arg.value.? }),
 
             // arg.value == null, if arg.param.takes_value == false.
             // Otherwise, arg.value is the value passed with the argument, such as "-a=10"
             // or "-a 10".
-            'f' => debug.warn("{}\n", arg.value.?),
+            'f' => debug.warn("{}\n", .{ arg.value.? }),
             else => unreachable,
         }
     }
@@ -201,16 +205,15 @@ const std = @import("std");
 const clap = @import("clap");
 
 pub fn main() !void {
-    const stderr_file = try std.io.getStdErr();
+    const stderr_file = std.io.getStdErr();
     var stderr_out_stream = stderr_file.outStream();
-    const stderr = &stderr_out_stream.stream;
 
     // clap.help is a function that can print a simple help message, given a
     // slice of Param(Help). There is also a helpEx, which can print a
     // help message for any Param, but it is more verbose to call.
     try clap.help(
-        stderr,
-        comptime [_]clap.Param(clap.Help){
+        stderr_out_stream,
+        comptime &[_]clap.Param(clap.Help){
             clap.parseParam("-h, --help     Display this help and exit.         ") catch unreachable,
             clap.parseParam("-v, --version  Output version information and exit.") catch unreachable,
         },
@@ -243,16 +246,14 @@ const std = @import("std");
 const clap = @import("clap");
 
 pub fn main() !void {
-    const stderr_file = try std.io.getStdErr();
-    var stderr_out_stream = stderr_file.outStream();
-    const stderr = &stderr_out_stream.stream;
+    const stderr = std.io.getStdErr().outStream();
 
     // clap.usage is a function that can print a simple usage message, given a
     // slice of Param(Help). There is also a usageEx, which can print a
     // usage message for any Param, but it is more verbose to call.
     try clap.usage(
         stderr,
-        comptime [_]clap.Param(clap.Help){
+        comptime &[_]clap.Param(clap.Help){
             clap.parseParam("-h, --help       Display this help and exit.         ") catch unreachable,
             clap.parseParam("-v, --version    Output version information and exit.") catch unreachable,
             clap.parseParam("    --value <N>  Output version information and exit.") catch unreachable,
diff --git a/build.zig b/build.zig
index e65df7f..f468fb6 100644
--- a/build.zig
+++ b/build.zig
@@ -7,7 +7,7 @@ const Builder = std.build.Builder;
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
 
-    const fmt_step = b.addFmt([_][]const u8{
+    const fmt_step = b.addFmt(&[_][]const u8{
         "build.zig",
         "clap",
     });
@@ -41,7 +41,7 @@ pub fn build(b: *Builder) void {
         example_step.dependOn(&example.step);
     }
 
-    const readme_step = b.step("test", "Remake README.");
+    const readme_step = b.step("readme", "Remake README.");
     const readme = readMeStep(b);
     readme.dependOn(example_step);
     readme_step.dependOn(readme);
@@ -59,17 +59,16 @@ fn readMeStep(b: *Builder) *std.build.Step {
     s.* = std.build.Step.init("ReadMeStep", b.allocator, struct {
         fn make(step: *std.build.Step) anyerror!void {
             @setEvalBranchQuota(10000);
-            const file = try std.fs.File.openWrite("README.md");
-            const stream = &file.outStream().stream;
-            try stream.print(
-                @embedFile("example/README.md.template"),
+            const file = try std.fs.cwd().createFile("README.md", .{});
+            const stream = &file.outStream();
+            try stream.print(@embedFile("example/README.md.template"), .{
                 @embedFile("example/simple.zig"),
                 @embedFile("example/simple-error.zig"),
                 @embedFile("example/comptime-clap.zig"),
                 @embedFile("example/streaming-clap.zig"),
                 @embedFile("example/help.zig"),
                 @embedFile("example/usage.zig"),
-            );
+            });
         }
     }.make);
     return s;
diff --git a/clap.zig b/clap.zig
index 40e76f4..ff423cc 100644
--- a/clap.zig
+++ b/clap.zig
@@ -57,10 +57,14 @@ pub fn Param(comptime Id: type) type {
 /// Takes a string and parses it to a Param(Help).
 /// This is the reverse of 'help' but for at single parameter only.
 pub fn parseParam(line: []const u8) !Param(Help) {
+    var z: usize = 0;
     var res = Param(Help){
         .id = Help{
-            .msg = line[0..0],
-            .value = line[0..0],
+            // For testing, i want to be able to easily compare slices just by pointer,
+            // so I slice by a runtime value here, so that zig does not optimize this
+            // out. Maybe I should write the test better, geeh.
+            .msg = line[z..z],
+            .value = line[z..z],
         },
     };
 
@@ -119,6 +123,7 @@ pub fn parseParam(line: []const u8) !Param(Help) {
 }
 
 test "parseParam" {
+    var z: usize = 0;
     var text: []const u8 = "-s, --long <value> Help text";
     testing.expectEqual(Param(Help){
         .id = Help{
@@ -162,7 +167,7 @@ test "parseParam" {
     testing.expectEqual(Param(Help){
         .id = Help{
             .msg = find(text, "Help text"),
-            .value = text[0..0],
+            .value = text[z..z],
         },
         .names = Names{
             .short = 's',
@@ -175,7 +180,7 @@ test "parseParam" {
     testing.expectEqual(Param(Help){
         .id = Help{
             .msg = find(text, "Help text"),
-            .value = text[0..0],
+            .value = text[z..z],
         },
         .names = Names{
             .short = 's',
@@ -188,7 +193,7 @@ test "parseParam" {
     testing.expectEqual(Param(Help){
         .id = Help{
             .msg = find(text, "Help text"),
-            .value = text[0..0],
+            .value = text[z..z],
         },
         .names = Names{
             .short = null,
@@ -276,14 +281,14 @@ pub fn helpFull(
     params: []const Param(Id),
     comptime Error: type,
     context: var,
-    helpText: fn (@typeOf(context), Param(Id)) Error![]const u8,
-    valueText: fn (@typeOf(context), Param(Id)) Error![]const u8,
+    helpText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
+    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
 ) !void {
     const max_spacing = blk: {
         var res: usize = 0;
         for (params) |param| {
-            var counting_stream = io.CountingOutStream(io.NullOutStream.Error).init(io.null_out_stream);
-            try printParam(&counting_stream.stream, Id, param, Error, context, valueText);
+            var counting_stream = io.countingOutStream(io.null_out_stream);
+            try printParam(counting_stream.outStream(), Id, param, Error, context, valueText);
             if (res < counting_stream.bytes_written)
                 res = counting_stream.bytes_written;
         }
@@ -295,11 +300,11 @@ pub fn helpFull(
         if (param.names.short == null and param.names.long == null)
             continue;
 
-        var counting_stream = io.CountingOutStream(@typeOf(stream.*).Error).init(stream);
-        try stream.print("\t");
-        try printParam(&counting_stream.stream, Id, param, Error, context, valueText);
+        var counting_stream = io.countingOutStream(stream);
+        try stream.print("\t", .{});
+        try printParam(counting_stream.outStream(), Id, param, Error, context, valueText);
         try stream.writeByteNTimes(' ', max_spacing - counting_stream.bytes_written);
-        try stream.print("\t{}\n", try helpText(context, param));
+        try stream.print("\t{}\n", .{try helpText(context, param)});
     }
 }
 
@@ -309,24 +314,24 @@ fn printParam(
     param: Param(Id),
     comptime Error: type,
     context: var,
-    valueText: fn (@typeOf(context), Param(Id)) Error![]const u8,
-) @typeOf(stream.*).Error!void {
+    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
+) !void {
     if (param.names.short) |s| {
-        try stream.print("-{c}", s);
+        try stream.print("-{c}", .{s});
     } else {
-        try stream.print("  ");
+        try stream.print("  ", .{});
     }
     if (param.names.long) |l| {
         if (param.names.short) |_| {
-            try stream.print(", ");
+            try stream.print(", ", .{});
         } else {
-            try stream.print("  ");
+            try stream.print("  ", .{});
         }
 
-        try stream.print("--{}", l);
+        try stream.print("--{}", .{l});
     }
     if (param.takes_value)
-        try stream.print(" <{}>", valueText(context, param));
+        try stream.print(" <{}>", .{valueText(context, param)});
 }
 
 /// A wrapper around helpFull for simple helpText and valueText functions that
@@ -385,10 +390,12 @@ fn getValueSimple(param: Param(Help)) []const u8 {
 
 test "clap.help" {
     var buf: [1024]u8 = undefined;
-    var slice_stream = io.SliceOutStream.init(buf[0..]);
+    var slice_stream = io.fixedBufferStream(&buf);
+
+    @setEvalBranchQuota(10000);
     try help(
-        &slice_stream.stream,
-        comptime [_]Param(Help){
+        slice_stream.outStream(),
+        comptime &[_]Param(Help){
             parseParam("-a             Short flag.  ") catch unreachable,
             parseParam("-b <V1>        Short option.") catch unreachable,
             parseParam("--aa           Long flag.   ") catch unreachable,
@@ -414,18 +421,18 @@ test "clap.help" {
 
     const actual = slice_stream.getWritten();
     if (!mem.eql(u8, actual, expected)) {
-        debug.warn("\n============ Expected ============\n");
-        debug.warn("{}", expected);
-        debug.warn("============= Actual =============\n");
-        debug.warn("{}", actual);
+        debug.warn("\n============ Expected ============\n", .{});
+        debug.warn("{}", .{expected});
+        debug.warn("============= Actual =============\n", .{});
+        debug.warn("{}", .{actual});
 
         var buffer: [1024 * 2]u8 = undefined;
         var fba = std.heap.FixedBufferAllocator.init(&buffer);
 
-        debug.warn("============ Expected (escaped) ============\n");
-        debug.warn("{x}\n", expected);
-        debug.warn("============ Actual (escaped) ============\n");
-        debug.warn("{x}\n", actual);
+        debug.warn("============ Expected (escaped) ============\n", .{});
+        debug.warn("{x}\n", .{expected});
+        debug.warn("============ Actual (escaped) ============\n", .{});
+        debug.warn("{x}\n", .{actual});
         testing.expect(false);
     }
 }
@@ -441,20 +448,21 @@ pub fn usageFull(
     params: []const Param(Id),
     comptime Error: type,
     context: var,
-    valueText: fn (@typeOf(context), Param(Id)) Error![]const u8,
+    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
 ) !void {
-    var cs = io.CountingOutStream(@typeOf(stream.*).Error).init(stream);
+    var cos = io.countingOutStream(stream);
+    const cs = cos.outStream();
     for (params) |param| {
         const name = param.names.short orelse continue;
         if (param.takes_value)
             continue;
 
-        if (cs.bytes_written == 0)
-            try stream.write("[-");
-        try cs.stream.write([_]u8{name});
+        if (cos.bytes_written == 0)
+            try stream.writeAll("[-");
+        try cs.writeByte(name);
     }
-    if (cs.bytes_written != 0)
-        try cs.stream.write("]");
+    if (cos.bytes_written != 0)
+        try cs.writeByte(']');
 
     var positional: ?Param(Id) = null;
     for (params) |param| {
@@ -462,24 +470,27 @@ pub fn usageFull(
             continue;
 
         const prefix = if (param.names.short) |_| "-" else "--";
-        const name = if (param.names.short) |*s| (*const [1]u8)(s)[0..] else param.names.long orelse {
+
+        // Seems the zig compiler is being a little wierd. I doesn't allow me to write
+        // @as(*const [1]u8, s)                  VVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
+        const name = if (param.names.short) |*s| @ptrCast([*]const u8, s)[0..1] else param.names.long orelse {
             positional = param;
             continue;
         };
-        if (cs.bytes_written != 0)
-            try cs.stream.write(" ");
+        if (cos.bytes_written != 0)
+            try cs.writeByte(' ');
 
-        try cs.stream.print("[{}{}", prefix, name);
+        try cs.print("[{}{}", .{ prefix, name });
         if (param.takes_value)
-            try cs.stream.print(" <{}>", try valueText(context, param));
+            try cs.print(" <{}>", .{try valueText(context, param)});
 
-        try cs.stream.write("]");
+        try cs.writeByte(']');
     }
 
     if (positional) |p| {
-        if (cs.bytes_written != 0)
-            try cs.stream.write(" ");
-        try cs.stream.print("<{}>", try valueText(context, p));
+        if (cos.bytes_written != 0)
+            try cs.writeByte(' ');
+        try cs.print("<{}>", .{try valueText(context, p)});
     }
 }
 
@@ -516,46 +527,46 @@ pub fn usage(stream: var, params: []const Param(Help)) !void {
 
 fn testUsage(expected: []const u8, params: []const Param(Help)) !void {
     var buf: [1024]u8 = undefined;
-    var slice_stream = io.SliceOutStream.init(buf[0..]);
-    try usage(&slice_stream.stream, params);
+    var fbs = io.fixedBufferStream(&buf);
+    try usage(fbs.outStream(), params);
 
-    const actual = slice_stream.getWritten();
+    const actual = fbs.getWritten();
     if (!mem.eql(u8, actual, expected)) {
-        debug.warn("\n============ Expected ============\n");
-        debug.warn("{}\n", expected);
-        debug.warn("============= Actual =============\n");
-        debug.warn("{}\n", actual);
+        debug.warn("\n============ Expected ============\n", .{});
+        debug.warn("{}\n", .{expected});
+        debug.warn("============= Actual =============\n", .{});
+        debug.warn("{}\n", .{actual});
 
         var buffer: [1024 * 2]u8 = undefined;
         var fba = std.heap.FixedBufferAllocator.init(&buffer);
 
-        debug.warn("============ Expected (escaped) ============\n");
-        debug.warn("{x}\n", expected);
-        debug.warn("============ Actual (escaped) ============\n");
-        debug.warn("{x}\n", actual);
+        debug.warn("============ Expected (escaped) ============\n", .{});
+        debug.warn("{x}\n", .{expected});
+        debug.warn("============ Actual (escaped) ============\n", .{});
+        debug.warn("{x}\n", .{actual});
         testing.expect(false);
     }
 }
 
 test "usage" {
     @setEvalBranchQuota(100000);
-    try testUsage("[-ab]", comptime [_]Param(Help){
+    try testUsage("[-ab]", comptime &[_]Param(Help){
         parseParam("-a") catch unreachable,
         parseParam("-b") catch unreachable,
     });
-    try testUsage("[-a <value>] [-b <v>]", comptime [_]Param(Help){
+    try testUsage("[-a <value>] [-b <v>]", comptime &[_]Param(Help){
         parseParam("-a <value>") catch unreachable,
         parseParam("-b <v>") catch unreachable,
     });
-    try testUsage("[--a] [--b]", comptime [_]Param(Help){
+    try testUsage("[--a] [--b]", comptime &[_]Param(Help){
         parseParam("--a") catch unreachable,
         parseParam("--b") catch unreachable,
     });
-    try testUsage("[--a <value>] [--b <v>]", comptime [_]Param(Help){
+    try testUsage("[--a <value>] [--b <v>]", comptime &[_]Param(Help){
         parseParam("--a <value>") catch unreachable,
         parseParam("--b <v>") catch unreachable,
     });
-    try testUsage("<file>", comptime [_]Param(Help){
+    try testUsage("<file>", comptime &[_]Param(Help){
         Param(Help){
             .id = Help{
                 .value = "file",
@@ -563,7 +574,7 @@ test "usage" {
             .takes_value = true,
         },
     });
-    try testUsage("[-ab] [-c <value>] [-d <v>] [--e] [--f] [--g <value>] [--h <v>] <file>", comptime [_]Param(Help){
+    try testUsage("[-ab] [-c <value>] [-d <v>] [--e] [--f] [--g <value>] [--h <v>] <file>", comptime &[_]Param(Help){
         parseParam("-a") catch unreachable,
         parseParam("-b") catch unreachable,
         parseParam("-c <value>") catch unreachable,
diff --git a/clap/args.zig b/clap/args.zig
index b699438..0141d86 100644
--- a/clap/args.zig
+++ b/clap/args.zig
@@ -1,6 +1,6 @@
-const builtin = @import("builtin");
 const std = @import("std");
 
+const builtin = std.builtin;
 const debug = std.debug;
 const heap = std.heap;
 const mem = std.mem;
@@ -33,7 +33,7 @@ pub const SliceIterator = struct {
 };
 
 test "clap.args.SliceIterator" {
-    const args = [_][]const u8{ "A", "BB", "CCC" };
+    const args = &[_][]const u8{ "A", "BB", "CCC" };
     var iter = SliceIterator{ .args = args };
 
     for (args) |a| {
@@ -70,7 +70,7 @@ pub const OsIterator = struct {
     }
 
     pub fn next(iter: *OsIterator) Error!?[]const u8 {
-        if (builtin.os == builtin.Os.windows) {
+        if (builtin.os.tag == .windows) {
             return try iter.args.next(&iter.arena.allocator) orelse return null;
         } else {
             return iter.args.nextPosix();
diff --git a/clap/comptime.zig b/clap/comptime.zig
index f5c2762..c25659b 100644
--- a/clap/comptime.zig
+++ b/clap/comptime.zig
@@ -9,7 +9,7 @@ const debug = std.debug;
 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| {
         var index: usize = 0;
         if (param.names.long != null or param.names.short != null) {
@@ -113,7 +113,7 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
 }
 
 test "clap.comptime.ComptimeClap" {
-    const Clap = ComptimeClap(clap.Help, comptime [_]clap.Param(clap.Help){
+    const Clap = ComptimeClap(clap.Help, comptime &[_]clap.Param(clap.Help){
         clap.parseParam("-a, --aa    ") catch unreachable,
         clap.parseParam("-b, --bb    ") catch unreachable,
         clap.parseParam("-c, --cc <V>") catch unreachable,
@@ -125,7 +125,7 @@ test "clap.comptime.ComptimeClap" {
     var buf: [1024]u8 = undefined;
     var fb_allocator = heap.FixedBufferAllocator.init(buf[0..]);
     var iter = clap.args.SliceIterator{
-        .args = [_][]const u8{
+        .args = &[_][]const u8{
             "-a", "-c", "0", "something",
         },
     };
@@ -138,6 +138,6 @@ test "clap.comptime.ComptimeClap" {
     testing.expect(!args.flag("--bb"));
     testing.expectEqualSlices(u8, "0", args.option("-c").?);
     testing.expectEqualSlices(u8, "0", args.option("--cc").?);
-    testing.expectEqual(usize(1), args.positionals().len);
+    testing.expectEqual(@as(usize, 1), args.positionals().len);
     testing.expectEqualSlices(u8, "something", args.positionals()[0]);
 }
diff --git a/clap/streaming.zig b/clap/streaming.zig
index fa7ce80..95ee581 100644
--- a/clap/streaming.zig
+++ b/clap/streaming.zig
@@ -170,7 +170,7 @@ fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, r
         const arg = (c.next() catch unreachable) orelse unreachable;
         testing.expectEqual(res.param, arg.param);
         const expected_value = res.value orelse {
-            testing.expectEqual(@typeOf(arg.value)(null), arg.value);
+            testing.expectEqual(@as(@TypeOf(arg.value), null), arg.value);
             continue;
         };
         const actual_value = arg.value orelse unreachable;
@@ -203,13 +203,13 @@ test "clap.streaming.StreamingClap: short params" {
     const c = &params[2];
 
     testNoErr(
-        params,
-        [_][]const u8{
+        &params,
+        &[_][]const u8{
             "-a", "-b",    "-ab",  "-ba",
             "-c", "0",     "-c=0", "-ac",
             "0",  "-ac=0",
         },
-        [_]Arg(u8){
+        &[_]Arg(u8){
             Arg(u8){ .param = a },
             Arg(u8){ .param = b },
             Arg(u8){ .param = a },
@@ -248,13 +248,13 @@ test "clap.streaming.StreamingClap: long params" {
     const cc = &params[2];
 
     testNoErr(
-        params,
-        [_][]const u8{
+        &params,
+        &[_][]const u8{
             "--aa",   "--bb",
             "--cc",   "0",
             "--cc=0",
         },
-        [_]Arg(u8){
+        &[_]Arg(u8){
             Arg(u8){ .param = aa },
             Arg(u8){ .param = bb },
             Arg(u8){ .param = cc, .value = "0" },
@@ -270,9 +270,9 @@ test "clap.streaming.StreamingClap: positional params" {
     }};
 
     testNoErr(
-        params,
-        [_][]const u8{ "aa", "bb" },
-        [_]Arg(u8){
+        &params,
+        &[_][]const u8{ "aa", "bb" },
+        &[_]Arg(u8){
             Arg(u8){ .param = &params[0], .value = "aa" },
             Arg(u8){ .param = &params[0], .value = "bb" },
         },
@@ -315,15 +315,15 @@ test "clap.streaming.StreamingClap: all params" {
     const positional = &params[3];
 
     testNoErr(
-        params,
-        [_][]const u8{
+        &params,
+        &[_][]const u8{
             "-a",   "-b",    "-ab",    "-ba",
             "-c",   "0",     "-c=0",   "-ac",
             "0",    "-ac=0", "--aa",   "--bb",
             "--cc", "0",     "--cc=0", "something",
             "--",   "-",
         },
-        [_]Arg(u8){
+        &[_]Arg(u8){
             Arg(u8){ .param = aa },
             Arg(u8){ .param = bb },
             Arg(u8){ .param = aa },
diff --git a/example/README.md.template b/example/README.md.template
index 5e75d5d..2afbe86 100644
--- a/example/README.md.template
+++ b/example/README.md.template
@@ -2,6 +2,10 @@
 
 A simple and easy to use command line argument parser library for Zig.
 
+Looking for a version that works with `zig master`? The `zig-master` branch has
+you covered. It is maintained by people who live at head (not me) and is merged
+into master on every `zig` release.
+
 ## Features
 
 * Short arguments `-a`
diff --git a/example/comptime-clap.zig b/example/comptime-clap.zig
index 4d0ace3..f5c0221 100644
--- a/example/comptime-clap.zig
+++ b/example/comptime-clap.zig
@@ -4,7 +4,7 @@ const clap = @import("clap");
 const debug = std.debug;
 
 pub fn main() !void {
-    const allocator = std.heap.direct_allocator;
+    const allocator = std.heap.page_allocator;
 
     // First we specify what parameters our program can take.
     // We can use `parseParam` to parse a string to a `Param(Help)`
@@ -22,13 +22,13 @@ pub fn main() !void {
     defer iter.deinit();
 
     // Parse the arguments
-    var args = try clap.ComptimeClap(clap.Help, params).parse(allocator, clap.args.OsIterator, &iter);
+    var args = try clap.ComptimeClap(clap.Help, &params).parse(allocator, clap.args.OsIterator, &iter);
     defer args.deinit();
 
     if (args.flag("--help"))
-        debug.warn("--help\n");
+        debug.warn("--help\n", .{});
     if (args.option("--number")) |n|
-        debug.warn("--number = {}\n", n);
+        debug.warn("--number = {}\n", .{ n });
     for (args.positionals()) |pos|
-        debug.warn("{}\n", pos);
+        debug.warn("{}\n", .{ pos });
 }
diff --git a/example/help.zig b/example/help.zig
index de8a55a..2775177 100644
--- a/example/help.zig
+++ b/example/help.zig
@@ -2,16 +2,15 @@ const std = @import("std");
 const clap = @import("clap");
 
 pub fn main() !void {
-    const stderr_file = try std.io.getStdErr();
+    const stderr_file = std.io.getStdErr();
     var stderr_out_stream = stderr_file.outStream();
-    const stderr = &stderr_out_stream.stream;
 
     // clap.help is a function that can print a simple help message, given a
     // slice of Param(Help). There is also a helpEx, which can print a
     // help message for any Param, but it is more verbose to call.
     try clap.help(
-        stderr,
-        comptime [_]clap.Param(clap.Help){
+        stderr_out_stream,
+        comptime &[_]clap.Param(clap.Help){
             clap.parseParam("-h, --help     Display this help and exit.         ") catch unreachable,
             clap.parseParam("-v, --version  Output version information and exit.") catch unreachable,
         },
diff --git a/example/simple-error.zig b/example/simple-error.zig
index fc72a03..2c403fc 100644
--- a/example/simple-error.zig
+++ b/example/simple-error.zig
@@ -8,7 +8,7 @@ pub fn main() !void {
         clap.parseParam("-h, --help  Display this help and exit.") catch unreachable,
     };
 
-    var args = try clap.parse(clap.Help, params, std.heap.direct_allocator);
+    var args = try clap.parse(clap.Help, &params, std.heap.direct_allocator);
     defer args.deinit();
 
     _ = args.flag("--helps");
diff --git a/example/simple.zig b/example/simple.zig
index f791447..d546223 100644
--- a/example/simple.zig
+++ b/example/simple.zig
@@ -14,13 +14,13 @@ pub fn main() !void {
         },
     };
 
-    var args = try clap.parse(clap.Help, params, std.heap.direct_allocator);
+    var args = try clap.parse(clap.Help, &params, std.heap.page_allocator);
     defer args.deinit();
 
     if (args.flag("--help"))
-        debug.warn("--help\n");
+        debug.warn("--help\n", .{});
     if (args.option("--number")) |n|
-        debug.warn("--number = {}\n", n);
+        debug.warn("--number = {}\n", .{ n });
     for (args.positionals()) |pos|
-        debug.warn("{}\n", pos);
+        debug.warn("{}\n", .{ pos });
 }
diff --git a/example/streaming-clap.zig b/example/streaming-clap.zig
index 0361d46..4cc43d1 100644
--- a/example/streaming-clap.zig
+++ b/example/streaming-clap.zig
@@ -4,7 +4,7 @@ const clap = @import("clap");
 const debug = std.debug;
 
 pub fn main() !void {
-    const allocator = std.heap.direct_allocator;
+    const allocator = std.heap.page_allocator;
 
     // First we specify what parameters our program can take.
     const params = [_]clap.Param(u8){
@@ -30,7 +30,7 @@ pub fn main() !void {
 
     // Initialize our streaming parser.
     var parser = clap.StreamingClap(u8, clap.args.OsIterator){
-        .params = params,
+        .params = &params,
         .iter = &iter,
     };
 
@@ -38,13 +38,13 @@ pub fn main() !void {
     while (try parser.next()) |arg| {
         // arg.param will point to the parameter which matched the argument.
         switch (arg.param.id) {
-            'h' => debug.warn("Help!\n"),
-            'n' => debug.warn("--number = {}\n", arg.value.?),
+            'h' => debug.warn("Help!\n", .{}),
+            'n' => debug.warn("--number = {}\n", .{ arg.value.? }),
 
             // arg.value == null, if arg.param.takes_value == false.
             // Otherwise, arg.value is the value passed with the argument, such as "-a=10"
             // or "-a 10".
-            'f' => debug.warn("{}\n", arg.value.?),
+            'f' => debug.warn("{}\n", .{ arg.value.? }),
             else => unreachable,
         }
     }
diff --git a/example/usage.zig b/example/usage.zig
index 734d741..25e1a34 100644
--- a/example/usage.zig
+++ b/example/usage.zig
@@ -2,16 +2,14 @@ const std = @import("std");
 const clap = @import("clap");
 
 pub fn main() !void {
-    const stderr_file = try std.io.getStdErr();
-    var stderr_out_stream = stderr_file.outStream();
-    const stderr = &stderr_out_stream.stream;
+    const stderr = std.io.getStdErr().outStream();
 
     // clap.usage is a function that can print a simple usage message, given a
     // slice of Param(Help). There is also a usageEx, which can print a
     // usage message for any Param, but it is more verbose to call.
     try clap.usage(
         stderr,
-        comptime [_]clap.Param(clap.Help){
+        comptime &[_]clap.Param(clap.Help){
             clap.parseParam("-h, --help       Display this help and exit.         ") catch unreachable,
             clap.parseParam("-v, --version    Output version information and exit.") catch unreachable,
             clap.parseParam("    --value <N>  Output version information and exit.") catch unreachable,