restructure parser

1 files changed, 0 insertions, 117 deletions

diff --git a/src/z/js/parser/parser.zig b/src/z/js/parser/parser.zig
deleted file mode 100644
index b73d895..0000000
--- a/src/z/js/parser/parser.zig
+++ /dev/null
@@ -1,117 +0,0 @@
-const std = @import("std");
-
-const mod = @import("root.zig");
-const Result = mod.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,
-            };
-        }
-    };
-}
-
-test "variants" {
-    const Char = union(enum) {
-        upper: u8,
-        lower: u8,
-        space: void,
-    };
-
-    const parser: Parser(Char) = .variants(struct {
-        const upper: Parser(u8) = .any(void, &.{
-            .{ mod.builtin.literal("A"), 'A' },
-            .{ mod.builtin.literal("B"), 'B' },
-        });
-
-        const lower: Parser(u8) = .any(void, &.{
-            .{ mod.builtin.literal("a"), 'a' },
-            .{ mod.builtin.literal("b"), 'b' },
-        });
-
-        const space: Parser(void) = mod.builtin.literal(" ");
-    });
-
-    {
-        const result = try parser.parseAll("a");
-        try std.testing.expect(result.lower == 'a');
-    }
-
-    {
-        const result = try parser.parseAll("b");
-        try std.testing.expect(result.lower == 'b');
-    }
-
-    {
-        const result = try parser.parseAll("A");
-        try std.testing.expect(result.upper == 'A');
-    }
-
-    {
-        const result = try parser.parseAll("B");
-        try std.testing.expect(result.upper == 'B');
-    }
-
-    {
-        const result = try parser.parseAll(" ");
-        try std.testing.expect(result == .space);
-    }
-
-    try std.testing.expect(parser.parseAll("c") == error.Variants);
-}