1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
const std = @import("std");
const root = @import("root.zig");
const Result = root.Result;
pub fn Parser(T: type) type {
const R = Result(T);
return struct {
parse: *const fn ([]const u8) anyerror!R,
pub fn parseAll(self: *const @This(), buffer: []const u8) !T {
const value, const next = try self.parse(buffer);
if (next.len > 0) {
return error.NotExhaustive;
}
return value;
}
pub fn fromType(P: type) @This() {
return .{ .parse = P.parse };
}
pub fn variants(V: type) @This() {
if (@typeInfo(T) != .@"union") {
@compileError("variants is only allowed with an union as result type");
}
return .{
.parse = struct {
fn parse(buffer: []const u8) !R {
inline for (std.meta.fields(T)) |field| {
if (@field(V, field.name).parse(buffer)) |result| {
const value, const next = result;
return .{
@unionInit(T, field.name, value),
next,
};
} else |_| {}
}
return error.Variants;
}
}.parse,
};
}
pub fn any(P: type, comptime parsers: []const struct { Parser(P), T }) @This() {
return .{
.parse = struct {
fn parse(buffer: []const u8) !R {
inline for (parsers) |pair| {
const parser, const value = pair;
if (parser.parse(buffer)) |result| {
_, const next = result;
return .{ value, next };
} else |_| {}
}
return error.Any;
}
}.parse,
};
}
};
}
|
