perf(eval): reduce memory usage

14 files changed, 233 insertions, 83 deletions

diff --git a/build.zig b/build.zig
index b68379e..d41b8d1 100644
--- a/build.zig
+++ b/build.zig
@@ -48,4 +48,7 @@ pub fn build(b: *std.Build) void {
     examples_step.dependOn(&installed_lib.step);
     const example_run = b.addRunArtifact(example);
     examples_step.dependOn(&example_run.step);
+
+    const check = b.step("check", "Check if foo compiles");
+    check.dependOn(&lib.step);
 }
diff --git a/src/callout.zig b/src/callout.zig
index 2761944..7badcfc 100644
--- a/src/callout.zig
+++ b/src/callout.zig
@@ -39,7 +39,7 @@ pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
                 break;
             }
         }
-        try root.append(try paragraph.parse(root.allocator(), l));
+        root.append(try paragraph.parse(root.allocator(), l));
         _ = l.peek() orelse return Error.InvalidCallout;
     }
     var el = try Element.Callout.init(alloc, root.element());
diff --git a/src/content.zig b/src/content.zig
index 96a361a..fe1b844 100644
--- a/src/content.zig
+++ b/src/content.zig
@@ -12,16 +12,16 @@ const doTestError = testing.doError;
 pub const Error = error{ ModifierNotClosed, IllegalPlacement } || Allocator.Error;
 
 pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
-    var content = try Element.Empty.init(alloc);
+    var content = try Element.Root.init(alloc);
     const v = l.next().?;
     switch (v.kind) {
         .literal => {
             const el = try Element.Literal.init(alloc, v.content);
-            try content.content.append(alloc, el.element());
+            content.append(el.element());
         },
-        .bold => try content.content.append(alloc, try parseModifier(alloc, l, .bold, "b")),
-        .italic => try content.content.append(alloc, try parseModifier(alloc, l, .italic, "em")),
-        .code => try content.content.append(alloc, try parseModifier(alloc, l, .code, "code")),
+        .bold => content.append(try parseModifier(alloc, l, .bold, "b")),
+        .italic => content.append(try parseModifier(alloc, l, .italic, "em")),
+        .code => content.append(try parseModifier(alloc, l, .code, "code")),
         else => return Error.IllegalPlacement,
     }
     return content.element();
@@ -29,6 +29,8 @@ pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
 
 fn parseModifier(alloc: Allocator, l: *Lexer, knd: Token.Kind, comptime tag: []const u8) Error!Element {
     var el = try Element.Simple(tag).init(alloc);
+    var root = try Element.Root.init(alloc);
+    el.content = root.element();
     while (l.peek()) |next| {
         if (next.kind == knd) {
             // consuming the finisher
@@ -36,7 +38,7 @@ fn parseModifier(alloc: Allocator, l: *Lexer, knd: Token.Kind, comptime tag: []c
             return el.element();
         }
         if (next.kind.isDelimiter()) return Error.ModifierNotClosed;
-        try el.content.append(alloc, try parse(alloc, l));
+        root.append(try parse(alloc, l));
     }
     return Error.ModifierNotClosed;
 }
diff --git a/src/eval/Element.zig b/src/eval/Element.zig
index d804a0c..4600abf 100644
--- a/src/eval/Element.zig
+++ b/src/eval/Element.zig
@@ -11,10 +11,26 @@ pub const Code = blocks.Code;
 pub const Figure = blocks.Figure;
 pub const Callout = blocks.Callout;
 
+pub const Node = struct {
+    ptr: *anyopaque,
+    vtable: struct { element: *const fn (*anyopaque) Element },
+    node: std.DoublyLinkedList.Node = .{},
+
+    pub fn from(n: *std.DoublyLinkedList.Node) *Node {
+        const v: *Node = @fieldParentPtr("node", n);
+        return v;
+    }
+
+    pub fn element(self: Node) Element {
+        return self.vtable.element(self.ptr);
+    }
+};
+
 const Element = @This();
 
 vtable: struct {
     html: *const fn (*anyopaque, Allocator) HTML.Error!HTML,
+    node: *const fn (*anyopaque) *Node,
 },
 ptr: *anyopaque,
 
@@ -29,43 +45,38 @@ pub fn html(self: Element, alloc: Allocator) HTML.Error!HTML {
     return self.vtable.html(self.ptr, alloc);
 }
 
-pub const Empty = struct {
-    content: std.ArrayList(Element),
-
-    const Self = @This();
-
-    pub fn init(alloc: Allocator) !*Self {
-        const v = try alloc.create(Self);
-        v.* = .{ .content = try .initCapacity(alloc, 2) };
-        return v;
-    }
-
-    pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = Self.html } };
-    }
-
-    fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
-        const self: *Self = @ptrCast(@alignCast(context));
-        var el = try HTML.Root.init(alloc);
-        errdefer el.deinit();
-        for (self.content.items) |it| el.append(try it.html(el.allocator()));
-        return el.element();
-    }
-};
+pub fn node(self: Element) *Node {
+    return self.vtable.node(self.ptr);
+}
 
 pub const Literal = struct {
     content: []const u8,
+    node: Node = .{
+        .ptr = undefined,
+        .vtable = .{ .element = fromNode },
+    },
 
     const Self = @This();
 
     pub fn init(alloc: Allocator, content: []const u8) !*Self {
         const v = try alloc.create(Self);
         v.* = .{ .content = content };
+        v.node.ptr = v;
         return v;
     }
 
     pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = Self.html } };
+        return .{ .ptr = self, .vtable = .{ .html = Self.html, .node = getNode } };
+    }
+
+    fn getNode(context: *anyopaque) *Node {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return &self.node;
+    }
+
+    fn fromNode(context: *anyopaque) Element {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return self.element();
     }
 
     fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
@@ -76,44 +87,49 @@ pub const Literal = struct {
 
 pub fn Simple(comptime tag: []const u8) type {
     return struct {
-        content: std.ArrayList(Element),
+        content: ?Element = null,
+        node: Node,
 
         const Self = @This();
 
         pub fn init(alloc: Allocator) !*Self {
             const v = try alloc.create(Self);
-            v.* = .{ .content = try .initCapacity(alloc, 2) };
+            v.node = .{ .ptr = v, .vtable = .{ .element = fromNode } };
             return v;
         }
 
         pub fn element(self: *Self) Element {
-            return .{ .ptr = self, .vtable = .{ .html = Self.html } };
+            return .{ .ptr = self, .vtable = .{ .html = Self.html, .node = getNode } };
         }
 
         pub fn toTag(self: *Self, alloc: Allocator, comptime target: []const u8) !*Simple(target) {
+            defer alloc.destroy(self);
             const el = try Simple(target).init(alloc);
-            self.conv(alloc, &el.content);
+            el.content = self.content;
             return el;
         }
 
-        pub fn toEmpty(self: *Self, alloc: Allocator) !*Empty {
-            const el = try Empty.init(alloc);
-            self.conv(alloc, &el.content);
+        pub fn toRoot(self: *Self, alloc: Allocator) !*Root {
+            defer alloc.destroy(self);
+            const el = try Root.init(alloc);
+            if (self.content) |it| el.append(it);
             return el;
         }
 
-        fn conv(self: *Self, alloc: Allocator, arr: *std.ArrayList(Element)) void {
-            arr.deinit(alloc);
-            arr.* = self.content;
-            alloc.destroy(self);
+        fn getNode(context: *anyopaque) *Node {
+            const self: *Self = @ptrCast(@alignCast(context));
+            return &self.node;
+        }
+
+        fn fromNode(context: *anyopaque) Element {
+            const self: *Self = @ptrCast(@alignCast(context));
+            return self.element();
         }
 
         fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
             const self: *Self = @ptrCast(@alignCast(context));
             var el = try HTML.Content.init(alloc, tag);
-            var root = try HTML.Root.init(alloc);
-            el.content = root.element();
-            for (self.content.items) |it| root.append(try it.html(root.allocator()));
+            if (self.content) |it| el.content = try it.html(alloc);
             return el.element();
         }
     };
diff --git a/src/eval/Image.zig b/src/eval/Image.zig
index 53478b6..3e0132a 100644
--- a/src/eval/Image.zig
+++ b/src/eval/Image.zig
@@ -2,22 +2,36 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const HTML = @import("html/Element.zig");
 const Element = @import("Element.zig");
+const Node = Element.Node;
 
 const Self = @This();
 
 src: []const u8,
 alt: ?[]const u8 = null,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 pub fn init(alloc: Allocator, src: []const u8) !*Self {
     const v = try alloc.create(Self);
-    v.* = .{
-        .src = src,
-    };
+    v.* = .{ .src = src };
+    v.node.ptr = v;
     return v;
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .ptr = self, .vtable = .{ .html = html } };
+    return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+}
+
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
 }
 
 fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
diff --git a/src/eval/Root.zig b/src/eval/Root.zig
index fc59c1d..d4ccf30 100644
--- a/src/eval/Root.zig
+++ b/src/eval/Root.zig
@@ -3,21 +3,23 @@ const Allocator = std.mem.Allocator;
 const Arena = std.heap.ArenaAllocator;
 const HTML = @import("html/Element.zig");
 const Element = @import("Element.zig");
+const Node = Element.Node;
 
 const Self = @This();
 
-content: std.ArrayList(Element),
+content: std.DoublyLinkedList = .{},
 arena: Arena,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 pub fn init(parent: Allocator) !*Self {
-    var s = Self{
-        .content = undefined,
-        .arena = .init(parent),
-    };
+    var s = Self{ .arena = .init(parent) };
     var alloc = s.arena.allocator();
-    s.content = try .initCapacity(alloc, 2);
     const v = try alloc.create(Self);
     v.* = s;
+    v.node.ptr = v;
     return v;
 }
 
@@ -29,22 +31,32 @@ pub fn allocator(self: *Self) Allocator {
     return self.arena.allocator();
 }
 
-pub fn append(self: *Self, el: Element) !void {
-    try self.content.append(self.allocator(), el);
+pub fn append(self: *Self, el: Element) void {
+    self.content.append(&el.node().node);
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .vtable = .{ .html = html }, .ptr = self };
+    return .{ .vtable = .{ .html = html, .node = getNode }, .ptr = self };
 }
 
 pub fn renderHTML(self: *Self, alloc: Allocator) HTML.Error![]const u8 {
     return try self.element().renderHTML(alloc);
 }
 
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
+}
+
 fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
     const self: *Self = @ptrCast(@alignCast(context));
     const el = try HTML.Root.init(alloc);
-    if (self.content.items.len == 0) return el.element();
-    for (self.content.items) |it| el.append(try it.html(el.allocator()));
+    var v = self.content.first;
+    while (v) |it| : (v = it.next) el.append(try Node.from(it).element().html(el.allocator()));
     return el.element();
 }
diff --git a/src/eval/Title.zig b/src/eval/Title.zig
index dbb5d38..1841ce7 100644
--- a/src/eval/Title.zig
+++ b/src/eval/Title.zig
@@ -2,20 +2,36 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const HTML = Parent.HTML;
 const Parent = @import("Element.zig");
+const Node = Parent.Node;
 
 level: u3,
 content: Parent,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 const Self = @This();
 
 pub fn init(alloc: Allocator, level: u3, content: Parent) !*Self {
     const v = try alloc.create(Self);
     v.* = .{ .level = level, .content = content };
+    v.node.ptr = v;
     return v;
 }
 
 pub fn element(self: *Self) Parent {
-    return .{ .ptr = self, .vtable = .{ .html = html } };
+    return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+}
+
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Parent {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
 }
 
 fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
diff --git a/src/eval/blocks.zig b/src/eval/blocks.zig
index eb583c7..cbb95b1 100644
--- a/src/eval/blocks.zig
+++ b/src/eval/blocks.zig
@@ -2,21 +2,40 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const HTML = @import("html/Element.zig");
 const Element = @import("Element.zig");
+const Node = Element.Node;
 
 pub const Code = struct {
     content: std.ArrayList(Element),
     attribute: ?[]const u8 = null,
+    node: Node = .{
+        .ptr = undefined,
+        .vtable = .{ .element = fromNode },
+    },
 
     const Self = @This();
 
     pub fn init(alloc: Allocator) !*Self {
         const v = try alloc.create(Self);
         v.* = .{ .content = try .initCapacity(alloc, 2) };
+        v.node.ptr = v;
         return v;
     }
 
     pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = Self.html } };
+        return .{ .ptr = self, .vtable = .{
+            .html = html,
+            .node = getNode,
+        } };
+    }
+
+    fn getNode(context: *anyopaque) *Node {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return &self.node;
+    }
+
+    fn fromNode(context: *anyopaque) Element {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return self.element();
     }
 
     fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
@@ -35,17 +54,32 @@ pub const Code = struct {
 pub const Figure = struct {
     content: Element,
     caption: ?Element = null,
+    node: Node = .{
+        .ptr = undefined,
+        .vtable = .{ .element = fromNode },
+    },
 
     const Self = @This();
 
     pub fn init(alloc: Allocator, content: Element) !*Self {
         const v = try alloc.create(Self);
         v.* = .{ .content = content };
+        v.node.ptr = v;
         return v;
     }
 
     pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = Self.html } };
+        return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+    }
+
+    fn getNode(context: *anyopaque) *Node {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return &self.node;
+    }
+
+    fn fromNode(context: *anyopaque) Element {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return self.element();
     }
 
     fn html(context: *anyopaque, parent: Allocator) HTML.Error!HTML {
@@ -67,17 +101,32 @@ pub const Callout = struct {
     content: Element,
     title: ?[]const u8 = null,
     kind: ?[]const u8 = null,
+    node: Node = .{
+        .ptr = undefined,
+        .vtable = .{ .element = fromNode },
+    },
 
     const Self = @This();
 
     pub fn init(alloc: Allocator, content: Element) !*Self {
         const v = try alloc.create(Self);
         v.* = .{ .content = content };
+        v.node.ptr = v;
         return v;
     }
 
     pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = Self.html } };
+        return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+    }
+
+    fn getNode(context: *anyopaque) *Node {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return &self.node;
+    }
+
+    fn fromNode(context: *anyopaque) Element {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return self.element();
     }
 
     fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
diff --git a/src/eval/html/Element.zig b/src/eval/html/Element.zig
index 6073e6a..cf5e74c 100644
--- a/src/eval/html/Element.zig
+++ b/src/eval/html/Element.zig
@@ -29,8 +29,8 @@ pub const Node = struct {
 const Self = @This();
 
 vtable: struct {
-    render: *const fn (self: *anyopaque, alloc: Allocator) Error![]const u8,
-    node: *const fn (self: *anyopaque) *Node,
+    render: *const fn (*anyopaque, Allocator) Error![]const u8,
+    node: *const fn (*anyopaque) *Node,
 },
 ptr: *anyopaque,
 
diff --git a/src/eval/list.zig b/src/eval/list.zig
index 2ba136a..1a7949c 100644
--- a/src/eval/list.zig
+++ b/src/eval/list.zig
@@ -2,10 +2,15 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const HTML = Element.HTML;
 const Element = @import("Element.zig");
+const Node = Element.Node;
 
 fn List(comptime tag: []const u8) type {
     return struct {
         content: std.ArrayList(Element),
+        node: Node = .{
+            .ptr = undefined,
+            .vtable = .{ .element = fromNode },
+        },
 
         const Self = @This();
 
@@ -14,11 +19,22 @@ fn List(comptime tag: []const u8) type {
             v.* = .{
                 .content = try .initCapacity(alloc, 2),
             };
+            v.node.ptr = v;
             return v;
         }
 
         pub fn element(self: *Self) Element {
-            return .{ .ptr = self, .vtable = .{ .html = html } };
+            return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+        }
+
+        fn getNode(context: *anyopaque) *Node {
+            const self: *Self = @ptrCast(@alignCast(context));
+            return &self.node;
+        }
+
+        fn fromNode(context: *anyopaque) Element {
+            const self: *Self = @ptrCast(@alignCast(context));
+            return self.element();
         }
 
         fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
diff --git a/src/eval/paragraph.zig b/src/eval/paragraph.zig
index 8609e79..ca72142 100644
--- a/src/eval/paragraph.zig
+++ b/src/eval/paragraph.zig
@@ -2,6 +2,7 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const HTML = Element.HTML;
 const Element = @import("Element.zig");
+const Node = Element.Node;
 
 pub const Block = Element.Simple("p");
 
@@ -13,6 +14,10 @@ pub const Link = struct {
     link: []const u8,
     content: Element,
     target: ?[]const u8 = null,
+    node: Node = .{
+        .ptr = undefined,
+        .vtable = .{ .element = fromNode },
+    },
 
     const Self = @This();
 
@@ -22,11 +27,22 @@ pub const Link = struct {
             .content = content,
             .link = link,
         };
+        v.node.ptr = v;
         return v;
     }
 
     pub fn element(self: *Self) Element {
-        return .{ .ptr = self, .vtable = .{ .html = html } };
+        return .{ .ptr = self, .vtable = .{ .html = html, .node = getNode } };
+    }
+
+    fn getNode(context: *anyopaque) *Node {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return &self.node;
+    }
+
+    fn fromNode(context: *anyopaque) Element {
+        const self: *Self = @ptrCast(@alignCast(context));
+        return self.element();
     }
 
     fn html(context: *anyopaque, alloc: Allocator) HTML.Error!HTML {
@@ -57,12 +73,14 @@ test "paragraph" {
     try doTest(alloc, lit, "hello world");
 
     var p = try Block.init(alloc);
-    try p.content.append(alloc, lit);
+    var root = try Element.Root.init(alloc);
+    p.content = root.element();
+    root.append(lit);
     try doTest(alloc, p.element(), "<p>hello world</p>");
 
     const link = (try Link.init(alloc, (try Element.Literal.init(alloc, "foo")).element(), "example.org")).element();
     try doTest(alloc, link, "<a href=\"example.org\">foo</a>");
 
-    try p.content.append(alloc, link);
+    root.append(link);
     try doTest(alloc, p.element(), "<p>hello world<a href=\"example.org\">foo</a></p>");
 }
diff --git a/src/link.zig b/src/link.zig
index 612ee8c..ecfad83 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -17,7 +17,7 @@ pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
     const v = l.next().?;
     if (v.kind != .link) return Error.InvalidLink;
     if (!eql(u8, v.content, "[")) return (try Element.Literal.init(alloc, v.content)).element();
-    var el = try Element.Empty.init(alloc);
+    var el = try Element.Root.init(alloc);
     while (l.peek()) |next| switch (next.kind) {
         .weak_delimiter, .strong_delimiter => return Error.InvalidLink,
         .link => {
@@ -26,18 +26,20 @@ pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
             break;
         },
         else => {
-            const in = try content.parse(alloc, l);
-            try el.content.append(alloc, in);
+            const in = try content.parse(el.allocator(), l);
+            el.append(in);
         },
     };
     const href = l.next() orelse return Error.InvalidLink;
     if (href.kind != .literal) return Error.InvalidLink;
     const finisher = l.next() orelse return Error.InvalidLink;
     if (!finisher.equals(.link, ")")) return Error.InvalidLink;
-    const in: Element = if (el.content.items.len > 0)
+    const in: Element = if (el.content.first != null)
         el.element()
-    else
-        (try Element.Literal.init(alloc, href.content)).element();
+    else blk: {
+        el.deinit();
+        break :blk (try Element.Literal.init(alloc, href.content)).element();
+    };
     return (try Link.init(alloc, in, href.content)).element();
 }
 
@@ -74,7 +76,7 @@ pub fn parseImage(alloc: Allocator, l: *Lexer) ImageError!Element {
     }
     const p = try paragraph.parse(alloc, l);
     const p_el: *Element.paragraph.Block = @ptrCast(@alignCast(p.ptr));
-    el.caption = (try p_el.toEmpty(alloc)).element();
+    el.caption = (try p_el.toRoot(alloc)).element();
     return el.element();
 }
 
diff --git a/src/paragraph.zig b/src/paragraph.zig
index e1a01cf..f8c3727 100644
--- a/src/paragraph.zig
+++ b/src/paragraph.zig
@@ -15,25 +15,27 @@ pub const Error = content.Error || link.Error || Allocator.Error;
 
 pub fn parse(alloc: Allocator, l: *Lexer) Error!Element {
     var el = try Paragraph.Block.init(alloc);
+    var root = try Element.Root.init(alloc);
+    el.content = root.element();
     while (l.peek()) |next| switch (next.kind) {
         .strong_delimiter => return el.element(),
         .weak_delimiter => {
             l.consume();
             const future = l.peek() orelse return el.element();
             if (!future.kind.isPar()) return el.element();
-            try el.content.append(alloc, (try Element.Literal.init(alloc, " ")).element());
+            root.append((try Element.Literal.init(alloc, " ")).element());
         },
-        else => try el.content.append(alloc, try parseLine(alloc, l)),
+        else => root.append(try parseLine(alloc, l)),
     };
     return el.element();
 }
 
 pub fn parseLine(alloc: Allocator, l: *Lexer) Error!Element {
-    var line = try Element.Empty.init(alloc);
+    var line = try Element.Root.init(alloc);
     while (l.peek()) |next| switch (next.kind) {
         .weak_delimiter, .strong_delimiter => return line.element(),
-        .link => try line.content.append(alloc, try link.parse(alloc, l)),
-        else => try line.content.append(alloc, try content.parse(alloc, l)),
+        .link => line.append(try link.parse(alloc, l)),
+        else => line.append(try content.parse(alloc, l)),
     };
     return line.element();
 }
diff --git a/src/parser.zig b/src/parser.zig
index 72b803f..c8f1c81 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -39,7 +39,7 @@ fn gen(parent: Allocator, l: *Lexer) Error!*Document {
     errdefer root.deinit();
     const alloc = root.allocator();
     base: while (l.peek()) |it| {
-        try root.append(switch (it.kind) {
+        root.append(switch (it.kind) {
             // other blocks
             .title => try title.parse(alloc, l),
             .list_ordored => try list.parseOrdored(alloc, l),