Add parseYaml function for custom types

Author: RossComputerGuy

README.md

@@ -122,6 +122,39 @@ nested:
 finally: [ 8.17, 19.78, 17, 21  ]
 ```
 
+4. For parsing types not supported, add a `parseYaml` function:
+
+```zig
+const Simple = struct {
+    names: []const []const u8,
+    numbers: []const i16,
+    nested: struct {
+        some: []const u8,
+        wick: []const u8,
+    },
+    tagged: union(enum) {
+        pub fn parseYaml(yaml: Yaml, arena: std.mem.Allocator, value: Yaml.Value) Yaml.Error!@This() {
+            const map = try value.asMap();
+
+            inline for (@typeInfo(@This()).@"union".fields) |field| {
+                if (map.get(field.name)) |entry| {
+                    return @unionInit(@This(), field.name, try yaml.parseValue(arena, field.type, entry));
+                }
+            }
+
+            return error.TypeMismatch;
+        }
+    },
+    finally: [4]f16,
+};
+
+var arena = std.heap.ArenaAllocator.init(gpa);
+defer arena.deinit();
+
+const simple = try yaml.parse(arena.allocator(), Simple);
+try std.testing.expectEqual(simple.names.len, 3);
+```
+
 ### Error handling
 
 The library currently reports user-friendly, more informative parsing errors only which are stored out-of-band.

src/Yaml.zig

@@ -89,7 +89,7 @@ pub fn parse(self: Yaml, arena: Allocator, comptime T: type) Error!T {
     }
 }
 
-fn parseValue(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
+pub fn parseValue(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
     return switch (@typeInfo(T)) {
         .int => self.parseInt(T, value),
         .bool => self.parseBoolean(bool, value),
@@ -109,19 +109,19 @@ fn parseValue(self: Yaml, arena: Allocator, comptime T: type, value: Value) Erro
     };
 }
 
-fn parseInt(self: Yaml, comptime T: type, value: Value) Error!T {
+pub fn parseInt(self: Yaml, comptime T: type, value: Value) Error!T {
     _ = self;
     const scalar = try value.asScalar();
     return try std.fmt.parseInt(T, scalar, 0);
 }
 
-fn parseFloat(self: Yaml, comptime T: type, value: Value) Error!T {
+pub fn parseFloat(self: Yaml, comptime T: type, value: Value) Error!T {
     _ = self;
     const scalar = try value.asScalar();
     return try std.fmt.parseFloat(T, scalar);
 }
 
-fn parseBoolean(self: Yaml, comptime T: type, value: Value) Error!T {
+pub fn parseBoolean(self: Yaml, comptime T: type, value: Value) Error!T {
     _ = self;
     const raw = try value.asScalar();
 
@@ -145,9 +145,13 @@ fn parseBoolean(self: Yaml, comptime T: type, value: Value) Error!T {
     return error.TypeMismatch;
 }
 
-fn parseUnion(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
+pub fn parseUnion(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
     const union_info = @typeInfo(T).@"union";
 
+    if (@hasDecl(T, "parseYaml")) {
+        return T.parseYaml(self, arena, value);
+    }
+
     if (union_info.tag_type) |_| {
         inline for (union_info.fields) |field| {
             if (self.parseValue(arena, field.type, value)) |u_value| {
@@ -164,16 +168,20 @@ fn parseUnion(self: Yaml, arena: Allocator, comptime T: type, value: Value) Erro
     return error.UnionTagMissing;
 }
 
-fn parseOptional(self: Yaml, arena: Allocator, comptime T: type, value: ?Value) Error!T {
+pub fn parseOptional(self: Yaml, arena: Allocator, comptime T: type, value: ?Value) Error!T {
     const unwrapped = value orelse return null;
     const opt_info = @typeInfo(T).optional;
     return @as(T, try self.parseValue(arena, opt_info.child, unwrapped));
 }
 
-fn parseStruct(self: Yaml, arena: Allocator, comptime T: type, map: Map) Error!T {
+pub fn parseStruct(self: Yaml, arena: Allocator, comptime T: type, map: Map) Error!T {
     const struct_info = @typeInfo(T).@"struct";
     var parsed: T = undefined;
 
+    if (@hasDecl(T, "parseYaml")) {
+        return T.parseYaml(self, arena, .{ .map = map });
+    }
+
     inline for (struct_info.fields) |field| {
         var value: ?Value = map.get(field.name) orelse blk: {
             const field_name = try mem.replaceOwned(u8, arena, field.name, "_", "-");
@@ -199,7 +207,7 @@ fn parseStruct(self: Yaml, arena: Allocator, comptime T: type, map: Map) Error!T
     return parsed;
 }
 
-fn parsePointer(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
+pub fn parsePointer(self: Yaml, arena: Allocator, comptime T: type, value: Value) Error!T {
     const ptr_info = @typeInfo(T).pointer;
 
     switch (ptr_info.size) {
@@ -218,7 +226,7 @@ fn parsePointer(self: Yaml, arena: Allocator, comptime T: type, value: Value) Er
     }
 }
 
-fn parseArray(self: Yaml, arena: Allocator, comptime T: type, list: List) Error!T {
+pub fn parseArray(self: Yaml, arena: Allocator, comptime T: type, list: List) Error!T {
     const array_info = @typeInfo(T).array;
     if (array_info.len != list.len) return error.ArraySizeMismatch;