refactor: Always access using full namespace

This is my new preferred style of programming Zig :)

1 files changed, 26 insertions, 29 deletions

diff --git a/clap/parsers.zig b/clap/parsers.zig
index 8abdf57..2bf8976 100644
--- a/clap/parsers.zig
+++ b/clap/parsers.zig
@@ -1,8 +1,3 @@
-const std = @import("std");
-
-const fmt = std.fmt;
-const testing = std.testing;
-
 pub const default = .{
     .string = string,
     .str = string,
@@ -26,46 +21,46 @@ pub fn string(in: []const u8) error{}![]const u8 {
 }
 
 test "string" {
-    try testing.expectEqualStrings("aa", try string("aa"));
+    try std.testing.expectEqualStrings("aa", try string("aa"));
 }
 
 /// A parser that uses `std.fmt.parseInt` to parse the string into an integer value.
 /// See `std.fmt.parseInt` documentation for more information.
-pub fn int(comptime T: type, comptime base: u8) fn ([]const u8) fmt.ParseIntError!T {
+pub fn int(comptime T: type, comptime base: u8) fn ([]const u8) std.fmt.ParseIntError!T {
     return struct {
-        fn parse(in: []const u8) fmt.ParseIntError!T {
-            return fmt.parseInt(T, in, base);
+        fn parse(in: []const u8) std.fmt.ParseIntError!T {
+            return std.fmt.parseInt(T, in, base);
         }
     }.parse;
 }
 
 test "int" {
-    try testing.expectEqual(@as(u8, 0), try int(u8, 10)("0"));
-    try testing.expectEqual(@as(u8, 1), try int(u8, 10)("1"));
-    try testing.expectEqual(@as(u8, 10), try int(u8, 10)("10"));
-    try testing.expectEqual(@as(u8, 0b10), try int(u8, 2)("10"));
-    try testing.expectEqual(@as(u8, 0x10), try int(u8, 0)("0x10"));
-    try testing.expectEqual(@as(u8, 0b10), try int(u8, 0)("0b10"));
-    try testing.expectEqual(@as(u16, 0), try int(u16, 10)("0"));
-    try testing.expectEqual(@as(u16, 1), try int(u16, 10)("1"));
-    try testing.expectEqual(@as(u16, 10), try int(u16, 10)("10"));
-    try testing.expectEqual(@as(u16, 0b10), try int(u16, 2)("10"));
-    try testing.expectEqual(@as(u16, 0x10), try int(u16, 0)("0x10"));
-    try testing.expectEqual(@as(u16, 0b10), try int(u16, 0)("0b10"));
+    try std.testing.expectEqual(@as(u8, 0), try int(u8, 10)("0"));
+    try std.testing.expectEqual(@as(u8, 1), try int(u8, 10)("1"));
+    try std.testing.expectEqual(@as(u8, 10), try int(u8, 10)("10"));
+    try std.testing.expectEqual(@as(u8, 0b10), try int(u8, 2)("10"));
+    try std.testing.expectEqual(@as(u8, 0x10), try int(u8, 0)("0x10"));
+    try std.testing.expectEqual(@as(u8, 0b10), try int(u8, 0)("0b10"));
+    try std.testing.expectEqual(@as(u16, 0), try int(u16, 10)("0"));
+    try std.testing.expectEqual(@as(u16, 1), try int(u16, 10)("1"));
+    try std.testing.expectEqual(@as(u16, 10), try int(u16, 10)("10"));
+    try std.testing.expectEqual(@as(u16, 0b10), try int(u16, 2)("10"));
+    try std.testing.expectEqual(@as(u16, 0x10), try int(u16, 0)("0x10"));
+    try std.testing.expectEqual(@as(u16, 0b10), try int(u16, 0)("0b10"));
 }
 
 /// A parser that uses `std.fmt.parseFloat` to parse the string into an float value.
 /// See `std.fmt.parseFloat` documentation for more information.
-pub fn float(comptime T: type) fn ([]const u8) fmt.ParseFloatError!T {
+pub fn float(comptime T: type) fn ([]const u8) std.fmt.ParseFloatError!T {
     return struct {
-        fn parse(in: []const u8) fmt.ParseFloatError!T {
-            return fmt.parseFloat(T, in);
+        fn parse(in: []const u8) std.fmt.ParseFloatError!T {
+            return std.fmt.parseFloat(T, in);
         }
     }.parse;
 }
 
 test "float" {
-    try testing.expectEqual(@as(f32, 0), try float(f32)("0"));
+    try std.testing.expectEqual(@as(f32, 0), try float(f32)("0"));
 }
 
 pub const EnumError = error{
@@ -85,10 +80,10 @@ pub fn enumeration(comptime T: type) fn ([]const u8) EnumError!T {
 
 test "enumeration" {
     const E = enum { a, b, c };
-    try testing.expectEqual(E.a, try enumeration(E)("a"));
-    try testing.expectEqual(E.b, try enumeration(E)("b"));
-    try testing.expectEqual(E.c, try enumeration(E)("c"));
-    try testing.expectError(EnumError.NameNotPartOfEnum, enumeration(E)("d"));
+    try std.testing.expectEqual(E.a, try enumeration(E)("a"));
+    try std.testing.expectEqual(E.b, try enumeration(E)("b"));
+    try std.testing.expectEqual(E.c, try enumeration(E)("c"));
+    try std.testing.expectError(EnumError.NameNotPartOfEnum, enumeration(E)("d"));
 }
 
 fn ReturnType(comptime P: type) type {
@@ -98,3 +93,5 @@ fn ReturnType(comptime P: type) type {
 pub fn Result(comptime P: type) type {
     return @typeInfo(ReturnType(P)).error_union.payload;
 }
+
+const std = @import("std");