diff --git a/examples/hello.v b/examples/hello.v
index a20f831..f328e4d 100644
--- a/examples/hello.v
+++ b/examples/hello.v
@@ -1 +1 @@
-fn main( a int) {}
+fn main() {}
diff --git a/src/ast.zig b/src/ast.zig
index 5e20aa6..52f25a9 100644
--- a/src/ast.zig
+++ b/src/ast.zig
@@ -3,7 +3,7 @@ const tokens = @import("tokens.zig");
 const Token = tokens.Token;
 
 pub const NodeList = std.ArrayList(*Node);
-pub const ParamList = std.ArrayList(ParamDecl);
+pub const ParamList = std.ArrayList(*ParamDecl);
 
 // TODO convert FnCall to something like PrefixOp / InfixOp / SuffixOp
 pub const NodeType = enum {
@@ -14,10 +14,10 @@ pub const NodeType = enum {
 };
 
 pub const ParamDecl = struct {
-    name: Token,
+    param_name: Token,
 
     // TODO types
-    typ: Token,
+    param_type: Token,
 };
 
 pub const FnDecl = struct {
@@ -43,37 +43,3 @@ pub fn mkRoot(allocator: *std.mem.Allocator) !*Node {
     node.* = Node{ .Root = NodeList.init(allocator) };
     return node;
 }
-
-fn print(ident: usize, comptime fmt: []const u8, args: ...) void {
-    var i: usize = 0;
-    while (i < ident) : (i += 1) {
-        std.debug.warn("\t");
-    }
-
-    std.debug.warn(fmt, args);
-}
-
-pub fn printNode(node: *Node, ident: usize) void {
-    switch (node.*) {
-        .FnDecl => |decl| {
-            print(ident, "FnDecl name='{}'\n", decl.func_name.lexeme);
-
-            for (decl.params.toSlice()) |param| {
-                print(
-                    ident + 1,
-                    "param: '{}' {}\n",
-                    param.name.lexeme,
-                    param.typ.lexeme,
-                );
-            }
-        },
-        .Root => {
-            for (node.Root.toSlice()) |child| {
-                printNode(child, ident + 1);
-            }
-        },
-        else => {
-            print(ident, "unknown node: {}\n", node);
-        },
-    }
-}
diff --git a/src/parser.zig b/src/parser.zig
index e45d404..f07ebc3 100644
--- a/src/parser.zig
+++ b/src/parser.zig
@@ -231,29 +231,13 @@ pub const Parser = struct {
     fn topDecl(self: *@This()) !?*Node {
         return switch (self.peek().ttype) {
             .Fn => blk: {
-                var param_list = ast.ParamList.init(self.allocator);
-                errdefer param_list.deinit();
-
                 _ = try self.consumeSingle(.Fn);
                 var name = try self.consumeSingle(.Identifier);
-
-                _ = try self.consumeSingle(.LeftParen);
-
-                while (self.peek().ttype != .RightParen) {
-                    const param_name = try self.consumeSingle(.Identifier);
-                    const param_type = try self.consumeSingle(.Identifier);
-
-                    try param_list.append(ast.ParamDecl{ .name = param_name, .typ = param_type });
-                }
-
-                _ = try self.consumeSingle(.RightParen);
-
-                _ = try self.consumeSingle(.LeftBrace);
-                // TODO block
-                _ = try self.consumeSingle(.RightBrace);
-
                 std.debug.warn("!fn name: {}\n", name);
-                break :blk try self.mkFnDecl(name, param_list);
+                break :blk try self.mkFnDecl(
+                    name,
+                    ast.ParamList.init(self.allocator),
+                );
             },
             else => |ttype| blk: {
                 self.doError("expected fn, got {}\n", ttype);
diff --git a/src/runner.zig b/src/runner.zig
index 34d81d0..e0f6493 100644
--- a/src/runner.zig
+++ b/src/runner.zig
@@ -48,8 +48,9 @@ pub const Runner = struct {
 
         var it = root.Root.iterator();
 
-        std.debug.warn("parse tree\n");
-        ast.printNode(root, 0);
+        while (it.next()) |node| {
+            std.debug.warn("{}\n", node.*);
+        }
 
         return Result.Ok;
     }