mod(zlog): pretty printing for user defined types

README.md

@@ -1,3 +1,85 @@
 # zlog
 
-Standard Library log wrapper.
+Standard Library log wrapper. `zlog` provides adjusted `std.log` output and a pretty print function for easy overwriting of user defined types (`struct`, `enum`, `union` and `vector`).
+
+## Usage
+
+The following snippet shows an example usage of `zlog` to change the default log format and add pretty printing to both user defined types (`Options` and `Struct`):
+
+```zig
+const std = @import("std");
+const zlog = @import("zlog");
+
+// use this to overwrite the default log format of `std.log`
+pub const std_options = zlog.std_options;
+
+const Options = enum {
+    a,
+    b,
+    c,
+
+    // copy and paste this function into your user defined types to enable pretty printing for these types
+    pub fn format(value: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) anyerror!void {
+        try zlog.pretty_format(value, fmt, options, writer);
+    }
+};
+
+const Struct = struct {
+    a: usize = 42,
+    b: bool = true,
+    c: [5]u16 = .{ 1, 2, 3, 4, 5 },
+    d: []const u8 = "string",
+    e: Options = Options.b,
+
+    // same function as above...
+    pub fn format(value: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) anyerror!void {
+        try zlog.pretty_format(value, fmt, options, writer);
+    }
+};
+
+pub fn main() void {
+    // initialize zlog with the scope of `main`
+    const log = std.log.scoped(.main);
+    // NOTE: the scope of `default` will result in no scoping being printed in
+    // the resulting output (default behavior of `std.log.defaultLog`)
+
+    // some variables to log
+    const int_var = 42;
+    const array_var = [_]i32{ 1, 2, 3, 4 };
+    const string_var = "This is a test";
+    const option_var = Options.a;
+    const struct_var: Struct = .{};
+
+    // NOTE: Depending on the optimization target some of these log messages
+    // will not show, which is inline with the behavior of `std.log`.
+    log.debug("Debug message {any}", .{int_var});
+    log.info("Info message {any}", .{array_var});
+    log.info("Info message \"{s}\"", .{string_var});
+    log.warn("Warning message {any}", .{option_var});
+    log.err("Error message {any}", .{struct_var});
+}
+```
+
+This will result in the following output:
+
+```
+debug(main):    Debug message 42
+info(main):     Info message { 1, 2, 3, 4 }
+info(main):     Info message "This is a test"
+warning(main):  Warning message main.Options = enum {
+        a,
+        b,
+        c,
+} = a
+error(main):    Error message main.Struct = struct {
+        .a = 42,
+        .b = true,
+        .c = []u16: { 1, 2, 3, 4, 5 },
+        .d = { 115, 116, 114, 105, 110, 103 },
+        .e = main.Options = enum {
+                a,
+                b,
+                c,
+        } = b,
+}
+```