Allow for clap to parse argument values into types

This changes

- `.flag`, `.option`, `.options` and `.positionals` are now just fields
  you access on the result of `parse` and `parseEx`.
- `clap.ComptimeClap` has been removed.
- `clap.StreamingClap` is now called `clap.streaming.Clap`
- `parse` and `parseEx` now takes a `value_parsers` argument that
  provides the parsers to parse values.
- Remove `helpEx`, `helpFull`, `usageEx` and `usageFull`. They now just
  expect `Id` to have methods for getting the description and value
  texts.

1 files changed, 365 insertions, 181 deletions

diff --git a/clap.zig b/clap.zig
index 39bbef2..1dc90ee 100644
--- a/clap.zig
+++ b/clap.zig
@@ -1,5 +1,6 @@
 const std = @import("std");
 
+const builtin = std.builtin;
 const debug = std.debug;
 const heap = std.heap;
 const io = std.io;
@@ -8,21 +9,37 @@ const process = std.process;
 const testing = std.testing;
 
 pub const args = @import("clap/args.zig");
+pub const parsers = @import("clap/parsers.zig");
+pub const streaming = @import("clap/streaming.zig");
 
 test "clap" {
     testing.refAllDecls(@This());
 }
 
-pub const ComptimeClap = @import("clap/comptime.zig").ComptimeClap;
-pub const StreamingClap = @import("clap/streaming.zig").StreamingClap;
-
-/// The names a ::Param can have.
+/// The names a `Param` can have.
 pub const Names = struct {
     /// '-' prefix
     short: ?u8 = null,
 
     /// '--' prefix
     long: ?[]const u8 = null,
+
+    pub fn longest(names: *const Names) Longest {
+        if (names.long) |long|
+            return .{ .kind = .long, .name = long };
+        if (names.short) |*short| {
+            // TODO: Zig cannot figure out @as(*const [1]u8, short) in the ano literal
+            const casted: *const [1]u8 = short;
+            return .{ .kind = .short, .name = casted };
+        }
+
+        return .{ .kind = .positinal, .name = "" };
+    }
+
+    pub const Longest = struct {
+        kind: enum { long, short, positinal },
+        name: []const u8,
+    };
 };
 
 /// Whether a param takes no value (a flag), one value, or can be specified multiple times.
@@ -124,18 +141,18 @@ fn parseParamRest(line: []const u8) Param(Help) {
         return .{
             .takes_value = if (takes_many) .many else .one,
             .id = .{
-                .msg = mem.trim(u8, line[help_start..], " \t"),
-                .value = line[1..len],
+                .desc = mem.trim(u8, line[help_start..], " \t"),
+                .val = line[1..len],
             },
         };
     }
 
-    return .{ .id = .{ .msg = mem.trim(u8, line, " \t") } };
+    return .{ .id = .{ .desc = mem.trim(u8, line, " \t") } };
 }
 
 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.expectEqualStrings(expect.id.desc, actual.id.desc);
+    try testing.expectEqualStrings(expect.id.val, actual.id.val);
     try testing.expectEqual(expect.names.short, actual.names.short);
     try testing.expectEqual(expect.takes_value, actual.takes_value);
     if (expect.names.long) |long| {
@@ -147,58 +164,58 @@ fn expectParam(expect: Param(Help), actual: Param(Help)) !void {
 
 test "parseParam" {
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "value" },
+        .id = .{ .desc = "Help text", .val = "val" },
         .names = .{ .short = 's', .long = "long" },
         .takes_value = .one,
-    }, try parseParam("-s, --long <value> Help text"));
+    }, try parseParam("-s, --long <val> Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "value" },
+        .id = .{ .desc = "Help text", .val = "val" },
         .names = .{ .short = 's', .long = "long" },
         .takes_value = .many,
-    }, try parseParam("-s, --long <value>... Help text"));
+    }, try parseParam("-s, --long <val>... Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "value" },
+        .id = .{ .desc = "Help text", .val = "val" },
         .names = .{ .long = "long" },
         .takes_value = .one,
-    }, try parseParam("--long <value> Help text"));
+    }, try parseParam("--long <val> Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "value" },
+        .id = .{ .desc = "Help text", .val = "val" },
         .names = .{ .short = 's' },
         .takes_value = .one,
-    }, try parseParam("-s <value> Help text"));
+    }, try parseParam("-s <val> Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text" },
+        .id = .{ .desc = "Help text" },
         .names = .{ .short = 's', .long = "long" },
     }, try parseParam("-s, --long Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text" },
+        .id = .{ .desc = "Help text" },
         .names = .{ .short = 's' },
     }, try parseParam("-s Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text" },
+        .id = .{ .desc = "Help text" },
         .names = .{ .long = "long" },
     }, try parseParam("--long Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "A | B" },
+        .id = .{ .desc = "Help text", .val = "A | B" },
         .names = .{ .long = "long" },
         .takes_value = .one,
     }, try parseParam("--long <A | B> Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "A" },
+        .id = .{ .desc = "Help text", .val = "A" },
         .names = .{},
         .takes_value = .one,
     }, try parseParam("<A> Help text"));
 
     try expectParam(Param(Help){
-        .id = .{ .msg = "Help text", .value = "A" },
+        .id = .{ .desc = "Help text", .val = "A" },
         .names = .{},
         .takes_value = .many,
     }, try parseParam("<A>... Help text"));
@@ -206,7 +223,7 @@ test "parseParam" {
     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("-ss <val> Help"));
     try testing.expectError(error.InvalidShortParam, parseParam("- Help"));
 }
 
@@ -230,15 +247,15 @@ pub const Diagnostic = struct {
             Arg{ .prefix = "", .name = diag.arg };
 
         switch (err) {
-            error.DoesntTakeValue => try stream.print(
+            streaming.Error.DoesntTakeValue => try stream.print(
                 "The argument '{s}{s}' does not take a value\n",
                 .{ a.prefix, a.name },
             ),
-            error.MissingValue => try stream.print(
+            streaming.Error.MissingValue => try stream.print(
                 "The argument '{s}{s}' requires a value but none was supplied\n",
                 .{ a.prefix, a.name },
             ),
-            error.InvalidArgument => try stream.print(
+            streaming.Error.InvalidArgument => try stream.print(
                 "Invalid argument '{s}{s}'\n",
                 .{ a.prefix, a.name },
             ),
@@ -303,34 +320,6 @@ test "Diagnostic.report" {
     );
 }
 
-pub fn Args(comptime Id: type, comptime params: []const Param(Id)) type {
-    return struct {
-        arena: std.heap.ArenaAllocator,
-        clap: ComptimeClap(Id, params),
-        exe_arg: ?[]const u8,
-
-        pub fn deinit(a: *@This()) void {
-            a.arena.deinit();
-        }
-
-        pub fn flag(a: @This(), comptime name: []const u8) bool {
-            return a.clap.flag(name);
-        }
-
-        pub fn option(a: @This(), comptime name: []const u8) ?[]const u8 {
-            return a.clap.option(name);
-        }
-
-        pub fn options(a: @This(), comptime name: []const u8) []const []const u8 {
-            return a.clap.options(name);
-        }
-
-        pub fn positionals(a: @This()) []const []const u8 {
-            return a.clap.positionals();
-        }
-    };
-}
-
 /// Options that can be set to customize the behavior of parsing.
 pub const ParseOptions = struct {
     /// The allocator used for all memory allocations. Defaults to the `heap.page_allocator`.
@@ -346,59 +335,348 @@ pub const ParseOptions = struct {
 pub fn parse(
     comptime Id: type,
     comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
     opt: ParseOptions,
-) !Args(Id, params) {
+) !Result(Id, params, value_parsers) {
     var arena = heap.ArenaAllocator.init(opt.allocator);
     errdefer arena.deinit();
 
     var iter = try process.ArgIterator.initWithAllocator(arena.allocator());
     const exe_arg = iter.next();
 
-    const clap = try parseEx(Id, params, &iter, .{
+    const result = try parseEx(Id, params, value_parsers, &iter, .{
         // Let's reuse the arena from the `OSIterator` since we already have it.
         .allocator = arena.allocator(),
         .diagnostic = opt.diagnostic,
     });
 
-    return Args(Id, params){
+    return Result(Id, params, value_parsers){
+        .args = result.args,
+        .positionals = result.positionals,
         .exe_arg = exe_arg,
         .arena = arena,
-        .clap = clap,
     };
 }
 
-/// Parses the command line arguments passed into the program based on an
-/// array of `Param`s.
+pub fn Result(
+    comptime Id: type,
+    comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
+) type {
+    return struct {
+        args: Arguments(Id, params, value_parsers, .slice),
+        positionals: []const FindPositionalType(Id, params, value_parsers),
+        exe_arg: ?[]const u8,
+        arena: std.heap.ArenaAllocator,
+
+        pub fn deinit(result: @This()) void {
+            result.arena.deinit();
+        }
+    };
+}
+
+/// Parses the command line arguments passed into the program based on an array of parameters.
+///
+/// The result will contain an `args` field which contains all the non positional arguments passed
+/// in. There is a field in `args` for each parameter. The name of that field will be the result
+/// of this expression:
+/// ```
+/// param.names.longest().name`
+/// ```
+///
+/// The fields can have types other that `[]const u8` and this is based on what `value_parsers`
+/// you provide. The parser to use for each parameter is determined by the following expression:
+/// ```
+/// @field(value_parsers, param.id.value())
+/// ```
+///
+/// Where `value` is a function that returns the name of the value this parameter takes. A parser
+/// is simple a function with the signature:
+/// ```
+/// fn ([]const u8) Error!T
+/// ```
+///
+/// `T` can be any type and `Error` can be any error. You can pass `clap.parsers.default` if you
+/// just wonna get something up and running.
+///
+/// Caller ownes the result and should free it by calling `result.deinit()`
 pub fn parseEx(
     comptime Id: type,
     comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
     iter: anytype,
     opt: ParseOptions,
-) !ComptimeClap(Id, params) {
-    const Clap = ComptimeClap(Id, params);
-    return try Clap.parse(iter, opt);
+) !ResultEx(Id, params, value_parsers) {
+    const allocator = opt.allocator;
+    var positionals = std.ArrayList(
+        FindPositionalType(Id, params, value_parsers),
+    ).init(allocator);
+
+    var arguments = Arguments(Id, params, value_parsers, .list){};
+    errdefer deinitArgs(Id, params, value_parsers, .list, allocator, &arguments);
+
+    var stream = streaming.Clap(Id, @typeInfo(@TypeOf(iter)).Pointer.child){
+        .params = params,
+        .iter = iter,
+        .diagnostic = opt.diagnostic,
+    };
+    while (try stream.next()) |arg| {
+        inline for (params) |*param| {
+            if (param == arg.param) {
+                const parser = comptime switch (param.takes_value) {
+                    .none => undefined,
+                    .one, .many => @field(value_parsers, param.id.value()),
+                };
+
+                // TODO: Update opt.diagnostics when `parser` fails. This is blocked by compiler
+                //       bugs that causes an infinit loop.
+                const longest = comptime param.names.longest();
+                switch (longest.kind) {
+                    .short, .long => switch (param.takes_value) {
+                        .none => @field(arguments, longest.name) = true,
+                        .one => @field(arguments, longest.name) = try parser(arg.value.?),
+                        .many => {
+                            const value = try parser(arg.value.?);
+                            try @field(arguments, longest.name).append(allocator, value);
+                        },
+                    },
+                    .positinal => try positionals.append(try parser(arg.value.?)),
+                }
+            }
+        }
+    }
+
+    var result_args = Arguments(Id, params, value_parsers, .slice){};
+    inline for (@typeInfo(@TypeOf(arguments)).Struct.fields) |field| {
+        if (@typeInfo(field.field_type) == .Struct and
+            @hasDecl(field.field_type, "toOwnedSlice"))
+        {
+            const slice = @field(arguments, field.name).toOwnedSlice(allocator);
+            @field(result_args, field.name) = slice;
+        } else {
+            @field(result_args, field.name) = @field(arguments, field.name);
+        }
+    }
+
+    return ResultEx(Id, params, value_parsers){
+        .args = result_args,
+        .positionals = positionals.toOwnedSlice(),
+        .allocator = allocator,
+    };
+}
+
+pub fn ResultEx(
+    comptime Id: type,
+    comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
+) type {
+    return struct {
+        args: Arguments(Id, params, value_parsers, .slice),
+        positionals: []const FindPositionalType(Id, params, value_parsers),
+        allocator: mem.Allocator,
+
+        pub fn deinit(result: *@This()) void {
+            deinitArgs(Id, params, value_parsers, .slice, result.allocator, &result.args);
+            result.allocator.free(result.positionals);
+        }
+    };
+}
+
+fn FindPositionalType(
+    comptime Id: type,
+    comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
+) type {
+    for (params) |param| {
+        const longest = param.names.longest();
+        if (longest.kind == .positinal)
+            return ParamType(Id, param, value_parsers);
+    }
+
+    return []const u8;
+}
+
+fn ParamType(
+    comptime Id: type,
+    comptime param: Param(Id),
+    comptime value_parsers: anytype,
+) type {
+    const parser = switch (param.takes_value) {
+        .none => parsers.string,
+        .one, .many => @field(value_parsers, param.id.value()),
+    };
+    return parsers.Result(@TypeOf(parser));
+}
+
+fn deinitArgs(
+    comptime Id: type,
+    comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
+    comptime multi_arg_kind: MultiArgKind,
+    allocator: mem.Allocator,
+    arguments: *Arguments(Id, params, value_parsers, multi_arg_kind),
+) void {
+    inline for (params) |param| {
+        const longest = comptime param.names.longest();
+        if (longest.kind == .positinal)
+            continue;
+        if (param.takes_value != .many)
+            continue;
+
+        switch (multi_arg_kind) {
+            .slice => allocator.free(@field(arguments, longest.name)),
+            .list => @field(arguments, longest.name).deinit(allocator),
+        }
+    }
 }
 
+const MultiArgKind = enum { slice, list };
+
+fn Arguments(
+    comptime Id: type,
+    comptime params: []const Param(Id),
+    comptime value_parsers: anytype,
+    comptime multi_arg_kind: MultiArgKind,
+) type {
+    var fields: [params.len]builtin.TypeInfo.StructField = undefined;
+
+    var i: usize = 0;
+    for (params) |param| {
+        const longest = param.names.longest();
+        if (longest.kind == .positinal)
+            continue;
+
+        const T = ParamType(Id, param, value_parsers);
+        const FieldType = switch (param.takes_value) {
+            .none => bool,
+            .one => ?T,
+            .many => switch (multi_arg_kind) {
+                .slice => []const T,
+                .list => std.ArrayListUnmanaged(T),
+            },
+        };
+        fields[i] = .{
+            .name = longest.name,
+            .field_type = FieldType,
+            .default_value = switch (param.takes_value) {
+                .none => &false,
+                .one => &@as(?T, null),
+                .many => switch (multi_arg_kind) {
+                    .slice => &@as([]const T, &[_]T{}),
+                    .list => &std.ArrayListUnmanaged(T){},
+                },
+            },
+            .is_comptime = false,
+            .alignment = @alignOf(FieldType),
+        };
+        i += 1;
+    }
+
+    return @Type(.{ .Struct = .{
+        .layout = .Auto,
+        .fields = fields[0..i],
+        .decls = &.{},
+        .is_tuple = false,
+    } });
+}
+
+test "" {
+    const params = comptime &.{
+        parseParam("-a, --aa") catch unreachable,
+        parseParam("-b, --bb") catch unreachable,
+        parseParam("-c, --cc <str>") catch unreachable,
+        parseParam("-d, --dd <usize>...") catch unreachable,
+        parseParam("<str>") catch unreachable,
+    };
+
+    var iter = args.SliceIterator{
+        .args = &.{ "-a", "-c", "0", "something", "-d", "1", "--dd", "2" },
+    };
+    var res = try parseEx(Help, params, parsers.default, &iter, .{
+        .allocator = testing.allocator,
+    });
+    defer res.deinit();
+
+    try testing.expect(res.args.aa);
+    try testing.expect(!res.args.bb);
+    try testing.expectEqualStrings("0", res.args.cc.?);
+    try testing.expectEqual(@as(usize, 1), res.positionals.len);
+    try testing.expectEqualStrings("something", res.positionals[0]);
+    try testing.expectEqualSlices(usize, &.{ 1, 2 }, res.args.dd);
+}
+
+test "empty" {
+    var iter = args.SliceIterator{ .args = &.{} };
+    var res = try parseEx(u8, &.{}, parsers.default, &iter, .{ .allocator = testing.allocator });
+    defer res.deinit();
+}
+
+fn testErr(
+    comptime params: []const Param(Help),
+    args_strings: []const []const u8,
+    expected: []const u8,
+) !void {
+    var diag = Diagnostic{};
+    var iter = args.SliceIterator{ .args = args_strings };
+    _ = parseEx(Help, params, parsers.default, &iter, .{
+        .allocator = testing.allocator,
+        .diagnostic = &diag,
+    }) catch |err| {
+        var buf: [1024]u8 = undefined;
+        var fbs = io.fixedBufferStream(&buf);
+        diag.report(fbs.writer(), err) catch return error.TestFailed;
+        try testing.expectEqualStrings(expected, fbs.getWritten());
+        return;
+    };
+
+    try testing.expect(false);
+}
+
+test "errors" {
+    const params = comptime [_]Param(Help){
+        parseParam("-a, --aa") catch unreachable,
+        parseParam("-c, --cc <str>") catch unreachable,
+    };
+
+    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",
+    );
+}
+
+pub const Help = struct {
+    desc: []const u8 = "",
+    val: []const u8 = "",
+
+    pub fn description(h: Help) []const u8 {
+        return h.desc;
+    }
+
+    pub fn value(h: Help) []const u8 {
+        return h.val;
+    }
+};
+
 /// Will print a help message in the following format:
 ///     -s, --long <valueText> helpText
 ///     -s,                    helpText
 ///     -s <valueText>         helpText
 ///         --long             helpText
 ///         --long <valueText> helpText
-pub fn helpFull(
-    stream: anytype,
-    comptime Id: type,
-    params: []const Param(Id),
-    comptime Error: type,
-    context: anytype,
-    helpText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
-    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
-) !void {
+pub fn help(stream: anytype, comptime Id: type, params: []const Param(Id)) !void {
     const max_spacing = blk: {
         var res: usize = 0;
         for (params) |param| {
             var cs = io.countingWriter(io.null_writer);
-            try printParam(cs.writer(), Id, param, Error, context, valueText);
+            try printParam(cs.writer(), Id, param);
             if (res < cs.bytes_written)
                 res = @intCast(usize, cs.bytes_written);
         }
@@ -412,13 +690,13 @@ pub fn helpFull(
 
         var cs = io.countingWriter(stream);
         try stream.writeAll("\t");
-        try printParam(cs.writer(), Id, param, Error, context, valueText);
+        try printParam(cs.writer(), Id, param);
         try stream.writeByteNTimes(' ', max_spacing - @intCast(usize, cs.bytes_written));
 
-        const help_text = try helpText(context, param);
-        var help_text_line_it = mem.split(u8, help_text, "\n");
+        const description = param.id.description();
+        var it = mem.split(u8, description, "\n");
         var indent_line = false;
-        while (help_text_line_it.next()) |line| : (indent_line = true) {
+        while (it.next()) |line| : (indent_line = true) {
             if (indent_line) {
                 try stream.writeAll("\t");
                 try stream.writeByteNTimes(' ', max_spacing);
@@ -434,9 +712,6 @@ fn printParam(
     stream: anytype,
     comptime Id: type,
     param: Param(Id),
-    comptime Error: type,
-    context: anytype,
-    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
 ) !void {
     if (param.names.short) |s| {
         try stream.writeAll(&[_]u8{ '-', s });
@@ -458,66 +733,12 @@ fn printParam(
         return;
 
     try stream.writeAll(" <");
-    try stream.writeAll(try valueText(context, param));
+    try stream.writeAll(param.id.value());
     try stream.writeAll(">");
     if (param.takes_value == .many)
         try stream.writeAll("...");
 }
 
-/// A wrapper around helpFull for simple helpText and valueText functions that
-/// cant return an error or take a context.
-pub fn helpEx(
-    stream: anytype,
-    comptime Id: type,
-    params: []const Param(Id),
-    helpText: fn (Param(Id)) []const u8,
-    valueText: fn (Param(Id)) []const u8,
-) !void {
-    const Context = struct {
-        helpText: fn (Param(Id)) []const u8,
-        valueText: fn (Param(Id)) []const u8,
-
-        pub fn help(c: @This(), p: Param(Id)) error{}![]const u8 {
-            return c.helpText(p);
-        }
-
-        pub fn value(c: @This(), p: Param(Id)) error{}![]const u8 {
-            return c.valueText(p);
-        }
-    };
-
-    return helpFull(
-        stream,
-        Id,
-        params,
-        error{},
-        Context{
-            .helpText = helpText,
-            .valueText = valueText,
-        },
-        Context.help,
-        Context.value,
-    );
-}
-
-pub const Help = struct {
-    msg: []const u8 = "",
-    value: []const u8 = "",
-};
-
-/// A wrapper around helpEx that takes a Param(Help).
-pub fn help(stream: anytype, params: []const Param(Help)) !void {
-    try helpEx(stream, Help, params, getHelpSimple, getValueSimple);
-}
-
-fn getHelpSimple(param: Param(Help)) []const u8 {
-    return param.id.msg;
-}
-
-fn getValueSimple(param: Param(Help)) []const u8 {
-    return param.id.value;
-}
-
 test "clap.help" {
     var buf: [1024]u8 = undefined;
     var slice_stream = io.fixedBufferStream(&buf);
@@ -525,6 +746,7 @@ test "clap.help" {
     @setEvalBranchQuota(10000);
     try help(
         slice_stream.writer(),
+        Help,
         comptime &.{
             parseParam("-a                Short flag.") catch unreachable,
             parseParam("-b <V1>           Short option.") catch unreachable,
@@ -556,18 +778,11 @@ test "clap.help" {
 }
 
 /// Will print a usage message in the following format:
-/// [-abc] [--longa] [-d <valueText>] [--longb <valueText>] <valueText>
+/// [-abc] [--longa] [-d <T>] [--longb <T>] <T>
 ///
-/// First all none value taking parameters, which have a short name are
-/// printed, then non positional parameters and finally the positinal.
-pub fn usageFull(
-    stream: anytype,
-    comptime Id: type,
-    params: []const Param(Id),
-    comptime Error: type,
-    context: anytype,
-    valueText: fn (@TypeOf(context), Param(Id)) Error![]const u8,
-) !void {
+/// First all none value taking parameters, which have a short name are printed, then non
+/// positional parameters and finally the positinal.
+pub fn usage(stream: anytype, comptime Id: type, params: []const Param(Id)) !void {
     var cos = io.countingWriter(stream);
     const cs = cos.writer();
     for (params) |param| {
@@ -607,7 +822,7 @@ pub fn usageFull(
         try cs.writeAll(name);
         if (param.takes_value != .none) {
             try cs.writeAll(" <");
-            try cs.writeAll(try valueText(context, param));
+            try cs.writeAll(param.id.value());
             try cs.writeAll(">");
             if (param.takes_value == .many)
                 try cs.writeAll("...");
@@ -621,46 +836,15 @@ pub fn usageFull(
             try cs.writeAll(" ");
 
         try cs.writeAll("<");
-        try cs.writeAll(try valueText(context, p));
+        try cs.writeAll(p.id.value());
         try cs.writeAll(">");
     }
 }
 
-/// A wrapper around usageFull for a simple valueText functions that
-/// cant return an error or take a context.
-pub fn usageEx(
-    stream: anytype,
-    comptime Id: type,
-    params: []const Param(Id),
-    valueText: fn (Param(Id)) []const u8,
-) !void {
-    const Context = struct {
-        valueText: fn (Param(Id)) []const u8,
-
-        pub fn value(c: @This(), p: Param(Id)) error{}![]const u8 {
-            return c.valueText(p);
-        }
-    };
-
-    return usageFull(
-        stream,
-        Id,
-        params,
-        error{},
-        Context{ .valueText = valueText },
-        Context.value,
-    );
-}
-
-/// A wrapper around usageEx that takes a Param(Help).
-pub fn usage(stream: anytype, params: []const Param(Help)) !void {
-    try usageEx(stream, Help, params, getValueSimple);
-}
-
 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);
+    try usage(fbs.writer(), Help, params);
     try testing.expectEqualStrings(expected, fbs.getWritten());
 }