Merge branch 'master' of github.com:Hejsil/zig-clap

6 files changed, 50 insertions, 70 deletions

diff --git a/README.md b/README.md
index 92de659..8081d84 100644
--- a/README.md
+++ b/README.md
@@ -15,23 +15,21 @@ A simple and easy to use command line argument parser library for Zig.
 
 ### `StreamingClap`
 
-The `StreamingClap` is base of all the other parsers. It's a streaming parser that uses an
+The `StreamingClap` is the base of all the other parsers. It's a streaming parser that uses an
 `args.Iterator` to provide it with arguments lazily.
 
 ```rust
 const params = []clap.Param(u8){
-    clap.Param(void).flag('h', false, clap.Names.both("help")),
-    clap.Param(void).option('n', true, clap.Names.both("number")),
-    clap.Param(void).positional('f'),
+    clap.Param(u8).flag('h', clap.Names.both("help")),
+    clap.Param(u8).option('n', clap.Names.both("number")),
+    clap.Param(u8).positional('f'),
 };
 
-var os_iter = clap.args.OsIterator.init(allocator);
-const iter = &os_iter.iter;
-defer os_iter.deinit();
-
+var iter = clap.args.OsIterator.init(allocator);
+defer iter.deinit();
 const exe = try iter.next();
 
-var parser = clap.StreamingClap(u8, clap.args.OsIterator.Error).init(params, iter);
+var parser = clap.StreamingClap(u8, clap.args.OsIterator).init(params, &iter);
 
 while (try parser.next()) |arg| {
     switch (arg.param.id) {
@@ -40,7 +38,7 @@ while (try parser.next()) |arg| {
         'f' => debug.warn("{}\n", arg.value.?),
         else => unreachable,
     }
- }
+}
 ```
 
 ### `ComptimeClap`
@@ -50,18 +48,16 @@ them available through three functions (`flag`, `option`, `positionals`).
 
 ```rust
 const params = comptime []clap.Param(void){
-    clap.Param(void).flag({}, false, clap.Names.both("help")),
-    clap.Param(void).option({}, true, clap.Names.both("number")),
+    clap.Param(void).flag({}, clap.Names.both("help")),
+    clap.Param(void).option({}, clap.Names.both("number")),
     clap.Param(void).positional({}),
 };
 
-var os_iter = clap.args.OsIterator.init(allocator);
-const iter = &os_iter.iter;
-defer os_iter.deinit();
-
+var iter = clap.args.OsIterator.init(allocator);
+defer iter.deinit();
 const exe = try iter.next();
 
-var args = try clap.ComptimeClap(void, params).parse(allocator, clap.args.OsIterator.Error, iter);
+var args = try clap.ComptimeClap(void, params).parse(allocator, clap.args.OsIterator, &iter);
 defer args.deinit();
 
 if (args.flag("--help"))
@@ -78,16 +74,14 @@ program can take:
 
 ```rust
 const params = comptime []clap.Param(void){
-    clap.Param(void).init({}, false, clap.Names.both("help")),
+    clap.Param(void).flag({}, clap.Names.both("help")),
 };
 
-var os_iter = clap.args.OsIterator.init(allocator);
-const iter = &os_iter.iter;
-defer os_iter.deinit();
-
+var iter = clap.args.OsIterator.init(allocator);
+defer iter.deinit();
 const exe = try iter.next();
 
-var args = try clap.ComptimeClap(params).parse(allocator, clap.args.OsIterator.Error, iter);
+var args = try clap.ComptimeClap(void, params).parse(allocator, clap.args.OsIterator, &iter);
 defer args.deinit();
 
 if (args.flag("--helps"))
@@ -106,7 +100,7 @@ zig-clap/example/comptime-clap.zig:41:18: note: called from here
                  ^
 ```
 
-Ofc, this limits you to use only parameters that are comptime known.
+Ofc, this limits you to parameters that are comptime known.
 
 ### `help`
 
diff --git a/example/comptime-clap.zig b/example/comptime-clap.zig
index 00c2a97..8d2d8a8 100644
--- a/example/comptime-clap.zig
+++ b/example/comptime-clap.zig
@@ -27,15 +27,14 @@ pub fn main() !void {
 
     // We then initialize an argument iterator. We will use the OsIterator as it nicely
     // wraps iterating over arguments the most efficient way on each os.
-    var os_iter = clap.args.OsIterator.init(allocator);
-    const iter = &os_iter.iter;
-    defer os_iter.deinit();
+    var iter = clap.args.OsIterator.init(allocator);
+    defer iter.deinit();
 
     // Consume the exe arg.
     const exe = try iter.next();
 
     // Finally we can parse the arguments
-    var args = try clap.ComptimeClap([]const u8, params).parse(allocator, clap.args.OsIterator.Error, iter);
+    var args = try clap.ComptimeClap([]const u8, params).parse(allocator, clap.args.OsIterator, &iter);
     defer args.deinit();
 
     // clap.help is a function that can print a simple help message, given a
diff --git a/example/streaming-clap.zig b/example/streaming-clap.zig
index 77d05e2..aad3e71 100644
--- a/example/streaming-clap.zig
+++ b/example/streaming-clap.zig
@@ -17,15 +17,14 @@ pub fn main() !void {
 
     // We then initialize an argument iterator. We will use the OsIterator as it nicely
     // wraps iterating over arguments the most efficient way on each os.
-    var os_iter = clap.args.OsIterator.init(allocator);
-    const iter = &os_iter.iter;
-    defer os_iter.deinit();
+    var iter = clap.args.OsIterator.init(allocator);
+    defer iter.deinit();
 
     // Consume the exe arg.
     const exe = try iter.next();
 
     // Finally we initialize our streaming parser.
-    var parser = clap.StreamingClap(u8, clap.args.OsIterator.Error).init(params, iter);
+    var parser = clap.StreamingClap(u8, clap.args.OsIterator).init(params, &iter);
 
     // Because we use a streaming parser, we have to consume each argument parsed individually.
     while (try parser.next()) |arg| {
diff --git a/src/args.zig b/src/args.zig
index 304596c..8706ebc 100644
--- a/src/args.zig
+++ b/src/args.zig
@@ -6,51 +6,42 @@ const heap = std.heap;
 const mem = std.mem;
 const os = std.os;
 
-/// A interface for iterating over command line arguments
-pub fn Iterator(comptime E: type) type {
-    return struct {
-        const Self = @This();
-        const Error = E;
-
-        nextFn: fn (iter: *Self) Error!?[]const u8,
+/// An example of what methods should be implemented on an arg iterator.
+pub const ExampleArgIterator = struct {
+    const Error = error{};
 
-        pub fn next(iter: *Self) Error!?[]const u8 {
-            return iter.nextFn(iter);
-        }
-    };
-}
+    pub fn next(iter: *ExampleArgIterator) Error!?[]const u8 {
+        return "2";
+    }
+};
 
-/// An ::ArgIterator, which iterates over a slice of arguments.
+/// An argument iterator which iterates over a slice of arguments.
 /// This implementation does not allocate.
 pub const SliceIterator = struct {
     const Error = error{};
 
     args: []const []const u8,
     index: usize,
-    iter: Iterator(Error),
 
     pub fn init(args: []const []const u8) SliceIterator {
         return SliceIterator{
             .args = args,
             .index = 0,
-            .iter = Iterator(Error){ .nextFn = nextFn },
         };
     }
 
-    fn nextFn(iter: *Iterator(Error)) Error!?[]const u8 {
-        const self = @fieldParentPtr(SliceIterator, "iter", iter);
-        if (self.args.len <= self.index)
+    pub fn next(iter: *SliceIterator) Error!?[]const u8 {
+        if (iter.args.len <= iter.index)
             return null;
 
-        defer self.index += 1;
-        return self.args[self.index];
+        defer iter.index += 1;
+        return iter.args[iter.index];
     }
 };
 
 test "clap.args.SliceIterator" {
     const args = [][]const u8{ "A", "BB", "CCC" };
-    var slice_iter = SliceIterator.init(args);
-    const iter = &slice_iter.iter;
+    var iter = SliceIterator.init(args);
 
     for (args) |a| {
         const b = try iter.next();
@@ -58,20 +49,18 @@ test "clap.args.SliceIterator" {
     }
 }
 
-/// An ::ArgIterator, which wraps the ArgIterator in ::std.
+/// An argument iterator which wraps the ArgIterator in ::std.
 /// On windows, this iterator allocates.
 pub const OsIterator = struct {
     const Error = os.ArgIterator.NextError;
 
     arena: heap.ArenaAllocator,
     args: os.ArgIterator,
-    iter: Iterator(Error),
 
     pub fn init(allocator: *mem.Allocator) OsIterator {
         return OsIterator{
             .arena = heap.ArenaAllocator.init(allocator),
             .args = os.args(),
-            .iter = Iterator(Error){ .nextFn = nextFn },
         };
     }
 
@@ -79,12 +68,11 @@ pub const OsIterator = struct {
         iter.arena.deinit();
     }
 
-    fn nextFn(iter: *Iterator(Error)) Error!?[]const u8 {
-        const self = @fieldParentPtr(OsIterator, "iter", iter);
+    pub fn next(iter: *OsIterator) Error!?[]const u8 {
         if (builtin.os == builtin.Os.windows) {
-            return try self.args.next(&self.arena.allocator) orelse return null;
+            return try iter.args.next(&iter.arena.allocator) orelse return null;
         } else {
-            return self.args.nextPosix();
+            return iter.args.nextPosix();
         }
     }
 };
diff --git a/src/comptime.zig b/src/comptime.zig
index 5339da3..b9021de 100644
--- a/src/comptime.zig
+++ b/src/comptime.zig
@@ -34,7 +34,7 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
         pos: []const []const u8,
         allocator: *mem.Allocator,
 
-        pub fn parse(allocator: *mem.Allocator, comptime ArgError: type, iter: *clap.args.Iterator(ArgError)) !@This() {
+        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,
@@ -43,7 +43,7 @@ pub fn ComptimeClap(comptime Id: type, comptime params: []const clap.Param(Id))
                 .allocator = allocator,
             };
 
-            var stream = clap.StreamingClap(usize, ArgError).init(converted_params, iter);
+            var stream = clap.StreamingClap(usize, ArgIter).init(converted_params, iter);
             while (try stream.next()) |arg| {
                 const param = arg.param;
                 if (param.names.long == null and param.names.short == null) {
@@ -124,10 +124,10 @@ test "clap.comptime.ComptimeClap" {
 
     var buf: [1024]u8 = undefined;
     var fb_allocator = heap.FixedBufferAllocator.init(buf[0..]);
-    var arg_iter = clap.args.SliceIterator.init([][]const u8{
+    var iter = clap.args.SliceIterator.init([][]const u8{
         "-a", "-c", "0", "something",
     });
-    var args = try Clap.parse(&fb_allocator.allocator, clap.args.SliceIterator.Error, &arg_iter.iter);
+    var args = try Clap.parse(&fb_allocator.allocator, clap.args.SliceIterator, &iter);
     defer args.deinit();
 
     testing.expect(args.flag("-a"));
diff --git a/src/streaming.zig b/src/streaming.zig
index cc5da79..7bdc71f 100644
--- a/src/streaming.zig
+++ b/src/streaming.zig
@@ -28,7 +28,7 @@ pub fn Arg(comptime Id: type) type {
 /// A command line argument parser which, given an ::ArgIterator, will parse arguments according
 /// to the ::params. ::StreamingClap parses in an iterating manner, so you have to use a loop together with
 /// ::StreamingClap.next to parse all the arguments of your program.
-pub fn StreamingClap(comptime Id: type, comptime ArgError: type) type {
+pub fn StreamingClap(comptime Id: type, comptime ArgIterator: type) type {
     return struct {
         const State = union(enum) {
             Normal,
@@ -41,10 +41,10 @@ pub fn StreamingClap(comptime Id: type, comptime ArgError: type) type {
         };
 
         params: []const clap.Param(Id),
-        iter: *args.Iterator(ArgError),
+        iter: *ArgIterator,
         state: State,
 
-        pub fn init(params: []const clap.Param(Id), iter: *args.Iterator(ArgError)) @This() {
+        pub fn init(params: []const clap.Param(Id), iter: *ArgIterator) @This() {
             var res = @This(){
                 .params = params,
                 .iter = iter,
@@ -189,8 +189,8 @@ pub fn StreamingClap(comptime Id: type, comptime ArgError: type) type {
 }
 
 fn testNoErr(params: []const clap.Param(u8), args_strings: []const []const u8, results: []const Arg(u8)) void {
-    var arg_iter = args.SliceIterator.init(args_strings);
-    var c = StreamingClap(u8, args.SliceIterator.Error).init(params, &arg_iter.iter);
+    var iter = args.SliceIterator.init(args_strings);
+    var c = StreamingClap(u8, args.SliceIterator).init(params, &iter);
 
     for (results) |res| {
         const arg = (c.next() catch unreachable) orelse unreachable;