diff --git a/core/control_flow.nom b/core/control_flow.nom
index 8e7306d..129f236 100644
--- a/core/control_flow.nom
+++ b/core/control_flow.nom
@@ -144,7 +144,7 @@ immediately
         for %var in %start to %stop via %step %body
     ..to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
-        assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
+        assume (%var.type is "Var") or barf "Loop expected variable, not: \%var"
         %lua <-
             Lua ".."
                 for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do
@@ -153,7 +153,7 @@ immediately
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "do next %") and 
-                        %.value.3.value is %var.value
+                        %.3 = %var
         ..: to %lua write "\n    ::continue_\(%var as lua identifier)::;"
         to %lua write "\nend --numeric for-loop"
 
@@ -161,7 +161,7 @@ immediately
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "stop %") and
-                        %.value.2.value is %var.value
+                        %.2 = %var
         ..
             %lua <-
                 Lua ".."
@@ -179,7 +179,7 @@ immediately
 immediately
     compile [for %var in %iterable %body] to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
-        assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
+        assume (%var.type is "Var") or barf "Loop expected variable, not: \%var"
         %lua <-
             Lua ".."
                 for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
@@ -188,14 +188,14 @@ immediately
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "do next %") and
-                        %.value.3.value is %var.value
+                        %.3 = %var
         ..: to %lua write (Lua "\n    ::continue_\(%var as lua identifier)::;")
         to %lua write "\nend --foreach-loop"
         if
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "stop %") and
-                        %.value.2.value is %var.value
+                        %.2 = %var
         ..
             %lua <-
                 Lua ".."
@@ -209,8 +209,8 @@ immediately
 immediately
     compile [for %key = %value in %iterable %body] to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
-        assume (%key.type is "Var") or barf "Loop expected variable, not: \(%key's source code)"
-        assume (%value.type is "Var") or barf "Loop expected variable, not: \(%value's source code)"
+        assume (%key.type is "Var") or barf "Loop expected variable, not: \%key"
+        assume (%value.type is "Var") or barf "Loop expected variable, not: \%value"
         %lua <-
             Lua ".."
                 for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do
@@ -219,14 +219,14 @@ immediately
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "do next %") and
-                        %.value.3.value is %key.value
+                        %.3 = %key
         ..: to %lua write (Lua "\n    ::continue_\(%key as lua identifier)::;")
 
         if
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "do next %") and
-                        %.value.3.value is %value.value
+                        %.3 = %value
         ..: to %lua write (Lua "\n    ::continue_\(%value as lua identifier)::;")
         to %lua write "\nend --foreach-loop"
         
@@ -235,14 +235,14 @@ immediately
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "stop %") and
-                        %.value.2.value is %key.value
+                        %.2 = %key
         ..: to %stop_labels write "\n::stop_\(%key as lua identifier)::;"
 
         if
             %body has subtree % where
                 (%.type = "Action") and
                     ((%'s stub) is "stop %") and
-                        %.value.2.value is %value.value
+                        %.2 = %value
         ..: to %stop_labels write "\n::stop_\(%value as lua identifier)::;"
 
         if: (length of %stop_labels) > 0
@@ -262,15 +262,14 @@ immediately
         %is_first <- (yes)
         %seen_else <- (no)
         %branches <-
-            %body.value if (%body.type = "Block") else [%body]
+            %body if (%body.type = "Block") else [%body]
         for %func_call in %branches
             assume (%func_call.type is "Action") or barf ".."
                 Invalid format for 'when' statement. Only '*' blocks are allowed.
-            %tokens <- %func_call.value
             with {..}
-                %star: %tokens.1
-                %condition: %tokens.2
-                %action: %tokens.3
+                %star: %func_call.1
+                %condition: %func_call.2
+                %action: %func_call.3
             ..
                 assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
                     Invalid format for 'when' statement. Lines must begin with '*'
@@ -311,12 +310,11 @@ immediately
         %is_first <- (yes)
         %seen_else <- (no)
         %branches <-
-            %body.value if (%body.type = "Block") else [%body]
+            %body if (%body.type = "Block") else [%body]
         for %func_call in %branches
             assume (%func_call.type is "Action") or barf ".."
                 Invalid format for 'when' statement. Only '*' blocks are allowed.
-            %tokens <- %func_call.value
-            with {%star:%tokens.1, %condition:%tokens.2, %action:%tokens.3}
+            with {%star:%func_call.1, %condition:%func_call.2, %action:%func_call.3}
                 assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
                     Invalid format for 'when' statement. Lines must begin with '*'
                 assume %condition or barf ".."
diff --git a/core/math.nom b/core/math.nom
index c507b87..120c210 100644
--- a/core/math.nom
+++ b/core/math.nom
@@ -42,7 +42,7 @@ compile [all of %items, all %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.all(\(%items as lua expr))"
     %clauses <- []
-    for % in (%items' "value")
+    for % in %items
         lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " and "))"
 parse [not all of %items, not all %items] as: not (all of %items)
@@ -50,7 +50,7 @@ compile [any of %items, any %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.any(\(%items as lua expr))"
     %clauses <- []
-    for % in (%items' "value")
+    for % in %items
         lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " or "))"
 parse [none of %items, none %items] as: not (any of %items)
@@ -58,14 +58,14 @@ compile [sum of %items, sum %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.sum(\(%items as lua expr))"
     %clauses <- []
-    for % in (%items' "value")
+    for % in %items
         lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " + "))"
 compile [product of %items, product %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.product(\(%items as lua expr))"
     %clauses <- []
-    for % in (%items' "value")
+    for % in %items
         lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " * "))"
 action [avg of %items, average of %items]
diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom
index 0cc3859..41491c7 100644
--- a/core/metaprogramming.nom
+++ b/core/metaprogramming.nom
@@ -6,9 +6,9 @@
 immediately
     lua> ".."
         nomsu:define_compile_action("compile %actions to %lua", function(tree, \%actions, \%lua)
-            local lua = Lua(tree.source, "nomsu:define_compile_action(")
+            local lua = Lua(nil, "nomsu:define_compile_action(")
             local stubs = {}
-            for i, action in ipairs(\%actions.value) do
+            for i, action in ipairs(\%actions) do
                 stubs[i] = action:get_stub(true)
             end
             stubs = repr(stubs)
@@ -19,7 +19,7 @@ immediately
             end
             lua:append("function(tree")
             local args = {}
-            for i,tok in ipairs(\%actions.value[1].value) do
+            for i,tok in ipairs(\%actions[1]) do
                 if tok.type == "Var" then args[#args+1] = tok:as_lua(nomsu) end
             end
             for i, arg in ipairs(args) do
@@ -36,9 +36,9 @@ immediately
 immediately
     compile [action %actions %body] to
         lua> ".."
-            local lua = Lua(tree.source, "nomsu:define_action(")
+            local lua = Lua(nil, "nomsu:define_action(")
             local stubs = {}
-            for i, action in ipairs(\%actions.value) do
+            for i, action in ipairs(\%actions) do
                 stubs[i] = action:get_stub(true)
             end
             stubs = repr(stubs)
@@ -49,7 +49,7 @@ immediately
             end
             lua:append("function(")
             local args = {}
-            for i,tok in ipairs(\%actions.value[1].value) do
+            for i,tok in ipairs(\%actions[1]) do
                 if tok.type == "Var" then args[#args+1] = tok:as_lua(nomsu) end
             end
             for i, arg in ipairs(args) do
@@ -66,9 +66,9 @@ immediately
 immediately
     compile [parse %shorthand as %longhand] to
         lua> ".."
-            local lua = Lua(tree.source, "nomsu:define_compile_action(")
+            local lua = Lua(nil, "nomsu:define_compile_action(")
             local stubs = {}
-            for i, action in ipairs(\%shorthand.value) do
+            for i, action in ipairs(\%shorthand) do
                 stubs[i] = action:get_stub(true)
             end
             stubs = repr(stubs)
@@ -79,24 +79,24 @@ immediately
             end
             lua:append("function(tree")
             local replacements = {}
-            for i,tok in ipairs(\%shorthand.value[1].value) do
+            for i,tok in ipairs(\%shorthand[1]) do
                 if tok.type == "Var" then
                     local lua_var = tostring(tok:as_lua(nomsu))
-                    replacements[tok.value] = lua_var
+                    replacements[tok] = lua_var
                     lua:append(", ", lua_var)
                 end
             end
             local function make_tree(t)
-                if Tuple:is_instance(t) then
+                if replacements[t] then
+                    return replacements[t]
+                elseif type(t) ~= 'table' and type(t) ~= 'userdata' then
+                    return repr(t)
+                elseif t.is_multi then
                     local bits = {}
                     for i, entry in ipairs(t) do
                         bits[i] = make_tree(entry)
                     end
-                    return "Tuple("..table.concat(bits, ", ")..")"
-                elseif type(t) ~= 'table' and type(t) ~= 'userdata' then
-                    return repr(t)
-                elseif t.type == "Var" and replacements[t.value] then
-                    return replacements[t.value]
+                    return t.type.."("..table.concat(bits, ", ")..")"
                 else
                     return t.type.."("..make_tree(t.value)..")"
                 end
@@ -118,6 +118,12 @@ action [remove action %stub]
         ARG_ORDERS[fn] = nil
 
 immediately
+    action [%tree as nomsu]
+        =lua "\%tree:as_nomsu()"
+
+    action [%tree as inline nomsu]
+        =lua "\%tree:as_nomsu(true)"
+
     action [%tree as lua]
         =lua "\%tree:as_lua(nomsu)"
 
@@ -125,7 +131,7 @@ immediately
         lua> ".."
             local lua = \%tree:as_lua(nomsu)
             if not lua.is_value then
-                error("Invalid thing to convert to lua expr: "..\%tree.source:get_text())
+                error("Invalid thing to convert to lua expr: "..\%tree)
             end
             return lua
 
@@ -156,9 +162,6 @@ immediately
     parse [to %var write %code] as: lua> "\%var:append(\%code);"
 
 immediately
-    action [%tree's source code, %tree' source code]
-        =lua "\%tree.source:get_text()"
-
     compile [repr %obj] to: Lua value "repr(\(%obj as lua expr))"
     compile [%obj as text] to: Lua value "tostring(\(%obj as lua expr))"
     compile [type of %obj] to: Lua value "type(\(%obj as lua expr))"
@@ -170,31 +173,23 @@ immediately
 # Compiler tools
 immediately
     compile [run %code] to
-        Lua value "nomsu:run(Nomsu(\(=lua "tostring(tree.source)"), \(%code as lua expr)))"
+        Lua value "nomsu:run(Nomsu(nil, \(%code as lua expr)))"
 
 immediately
     compile [show lua %block] to
         lua> ".."
             local \%lua = \%block:as_lua(nomsu);
-            return Lua(\%block.source, "print(", repr(tostring(\%lua)), ");");
+            return Lua(nil, "print(", repr(tostring(\%lua)), ");");
 
 immediately
     compile [say %message] to
         lua> ".."
             if \%message.type == "Text" then
-                return Lua(tree.source, "print(", \(%message as lua expr), ");");
+                return Lua(nil, "print(", \(%message as lua expr), ");");
             else
-                return Lua(tree.source, "print(stringify(", \(%message as lua expr), "));");
+                return Lua(nil, "print(stringify(", \(%message as lua expr), "));");
             end
 
-immediately
-    compile [source] to: Lua value "tree.source"
-
-#
-    immediately
-        action [Lua %]: Lua (=lua "tree.source") %
-        action [Lua value %]: Lua value (=lua "tree.source") %
-
 # Return
 immediately
     # Return statement is wrapped in a do..end block because Lua is unhappy if you
@@ -207,7 +202,7 @@ immediately
     compile [barf] to: Lua "error(nil, 0);"
     compile [barf %msg] to: Lua "error(\(%msg as lua expr), 0);"
     compile [assume %condition] to
-        lua> "local \%assumption = 'Assumption failed: '..tostring(\%condition.source:get_text());"
+        lua> "local \%assumption = 'Assumption failed: '..tostring(\%condition:as_nomsu());"
         return
             Lua ".."
                 if not \(%condition as lua expr) then
diff --git a/core/operators.nom b/core/operators.nom
index e3b41e1..adfeeb5 100644
--- a/core/operators.nom
+++ b/core/operators.nom
@@ -28,18 +28,18 @@ immediately
             local safe = {Text=true, Number=true};
             local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
             if safe[\%a.type] or safe[\%b.type] then
-                return Lua.Value(tree.source, "(", a_lua, " == ", b_lua, ")");
+                return Lua.Value(nil, "(", a_lua, " == ", b_lua, ")");
             else
-                return Lua.Value(tree.source, "utils.equivalent(", a_lua, ", ", b_lua, ")");
+                return Lua.Value(nil, "utils.equivalent(", a_lua, ", ", b_lua, ")");
             end
     compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to
         lua> ".."
             local safe = {Text=true, Number=true};
             local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
             if safe[\%a.type] or safe[\%b.type] then
-                return Lua.Value(tree.source, "(", a_lua, " ~= ", b_lua, ")");
+                return Lua.Value(nil, "(", a_lua, " ~= ", b_lua, ")");
             else
-                return Lua.Value(tree.source, "(not utils.equivalent(", a_lua, ", ", b_lua, "))");
+                return Lua.Value(nil, "(not utils.equivalent(", a_lua, ", ", b_lua, "))");
             end
     # For strict identity checking, use (%x's id) is (%y's id)
     compile [%'s id, id of %] to: Lua value "nomsu.ids[\(% as lua expr)]"
@@ -48,11 +48,11 @@ immediately
 immediately
     compile [%var <- %value] to
         lua> "local \%var_lua = \%var:as_lua(nomsu);"
-        assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
+        assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
         lua> "local \%value_lua = \%value:as_lua(nomsu);"
-        assume %value_lua.is_value or barf "Invalid value for assignment: \(%value's source code)"
+        assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
         lua> ".."
-            local lua = Lua(tree.source, \%var_lua, ' = ', \%value_lua, ';');
+            local lua = Lua(nil, \%var_lua, ' = ', \%value_lua, ';');
             if \%var.type == 'Var' then
                 lua:add_free_vars({\%var});
             end
@@ -62,11 +62,11 @@ immediately
     # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
     compile [<- %assignments] to
         assume ((%assignments' "type") is "Dict") or barf ".."
-            Expected a Dict for the assignments part of '<- %' statement, not \(%assignments' source code)
+            Expected a Dict for the assignments part of '<- %' statement, not \%assignments
         lua> ".."
-            local lhs, rhs = Lua(tree.source), Lua(\%assignments.source);
-            for i, item in ipairs(\%assignments.value) do
-                local target, value = item.value[1], item.value[2];
+            local lhs, rhs = Lua(), Lua();
+            for i, item in ipairs(\%assignments) do
+                local target, value = item[1], item[2];
                 local target_lua = target:as_lua(nomsu);
                 if not target_lua.is_value then error("Invalid target for assignment: "..target:get_src()); end
                 local value_lua = value:as_lua(nomsu);
@@ -81,35 +81,35 @@ immediately
                 lhs:append(target_lua);
                 rhs:append(value_lua);
             end
-            return Lua(tree.source, lhs, " = ", rhs, ";");
+            return Lua(nil, lhs, " = ", rhs, ";");
 
 immediately
     compile [external %var <- %value] to
         %var_lua <- (%var as lua)
-        assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
+        assume %var_lua.is_value or barf "Invalid target for assignment: \%var"
         %value_lua <- (%value as lua)
-        assume %value_lua.is_value or barf "Invalid value for assignment: \(%value's source code)"
+        assume %value_lua.is_value or barf "Invalid value for assignment: \%value"
         return: Lua "\(%var_lua) = \(%value_lua);"
 
     compile [with external %externs %body] to
         %body_lua <- (%body as lua statements)
-        lua> "\%body_lua:remove_free_vars(\(%externs.value));"
+        lua> "\%body_lua:remove_free_vars(\(%externs));"
         return %body_lua
 
     compile [with %assignments %body] to
         %lua <- (%body as lua statements)
         lua> ".."
-            local lhs, rhs = Lua(tree.source), Lua(\%assignments.source);
+            local lhs, rhs = Lua(), Lua();
             local vars = {};
-            for i, item in ipairs(\%assignments.value) do
-                local target, value = item.value[1], item.value[2];
+            for i, item in ipairs(\%assignments) do
+                local target, value = item[1], item[2];
                 if not target.type == "Var" then
-                    error("Invalid target for 'with' assignment: "..tostring(target.source:get_text()));
+                    error("Invalid target for 'with' assignment: "..tostring(target));
                 end
                 local target_lua = target:as_lua(nomsu);
                 local value_lua = value:as_lua(nomsu);
                 if not value_lua.is_value then
-                    error("Invalid value for assignment: "..tostring(value.source:get_text()));
+                    error("Invalid value for assignment: "..tostring(value));
                 end
                 if target.type == "Var" then
                     lhs:add_free_vars({target});
diff --git a/core/text.nom b/core/text.nom
index e1aaa9d..7b945cd 100644
--- a/core/text.nom
+++ b/core/text.nom
@@ -27,7 +27,7 @@ lua> ".."
         };
         for name, e in pairs(escapes) do
             local lua = "'"..e.."'";
-            nomsu:define_compile_action(name, function(tree) return Lua.Value(tree.source, lua); end);
+            nomsu:define_compile_action(name, function(tree) return Lua.Value(nil, lua); end);
         end
         local colors = {
             ["reset color"]="\\\\27[0m", bright="\\\\27[1m", dim="\\\\27[2m", underscore="\\\\27[4m",
@@ -42,9 +42,9 @@ lua> ".."
         for name, c in pairs(colors) do
             local color = "'"..c.."'";
             local reset = "'"..colors["reset color"].."'";
-            nomsu:define_compile_action(name, function(tree) return Lua.Value(tree.source, color); end);
+            nomsu:define_compile_action(name, function(tree) return Lua.Value(nil, color); end);
             nomsu:define_compile_action(name.." %", function(\%)
-                return Lua.Value(tree.source, color, "..", \%:as_lua(nomsu), "..", reset);
+                return Lua.Value(nil, color, "..", \%:as_lua(nomsu), "..", reset);
             end);
         end
     end
diff --git a/nomsu.lua b/nomsu.lua
index f7b8938..f4dcb7e 100644
--- a/nomsu.lua
+++ b/nomsu.lua
@@ -146,9 +146,6 @@ local Types = require("nomsu_tree")
 local NOMSU_DEFS
 do
   local _with_0 = { }
-  _with_0.Tuple = function(values)
-    return Tuple(unpack(values))
-  end
   _with_0.nl = P("\r") ^ -1 * P("\n")
   _with_0.ws = S(" \t")
   _with_0.tonumber = tonumber
@@ -228,16 +225,8 @@ end
 setmetatable(NOMSU_DEFS, {
   __index = function(self, key)
     local make_node
-    make_node = function(start, value, stop)
-      if type(value) == 'table' then
-        error("Not a tuple: " .. tostring(repr(value)))
-      end
-      local source = lpeg.userdata.source_code.source
-      start = start + (source.start - 1)
-      stop = stop + (source.start - 1)
-      source = Source(source.filename, start, stop - 1)
-      local node = Types[key](value, source)
-      return node
+    make_node = function(src, ...)
+      return Types[key](...)
     end
     self[key] = make_node
     return make_node
@@ -250,7 +239,7 @@ do
     anon_def <- ({ident} (" "*) ":"
         {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- %2"
     captured_def <- ({ident} (" "*) "(" {ident} ")" (" "*) ":"
-        {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- ({} %3 {}) -> %2"
+        {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- (({} %3) -> %2)"
     ident <- [a-zA-Z_][a-zA-Z0-9_]*
     comment <- "--" [^%nl]*
     ]])
@@ -430,12 +419,6 @@ do
     run_lua = function(self, lua)
       assert(type(lua) ~= 'string', "Attempt to run lua string instead of Lua (object)")
       local lua_string = tostring(lua)
-      if rawget(FILE_CACHE, lua.source.filename) == nil then
-        FILE_CACHE[lua.source.filename] = lua_string
-      end
-      if rawget(FILE_CACHE, lua.source) == nil then
-        FILE_CACHE[lua.source] = lua_string
-      end
       local run_lua_fn, err = load(lua_string, filename, "t", self.environment)
       if not run_lua_fn then
         local n = 1
@@ -450,10 +433,10 @@ do
       return run_lua_fn()
     end,
     tree_to_value = function(self, tree)
-      if tree.type == 'Text' and #tree.value == 1 and type(tree.value[1]) == 'string' then
-        return tree.value[1]
+      if tree.type == 'Text' and #tree == 1 and type(tree[1]) == 'string' then
+        return tree[1]
       end
-      local lua = Lua(tree.source, "return ", tree:as_lua(self), ";")
+      local lua = Lua(nil, "return ", tree:as_lua(self), ";")
       return self:run_lua(lua)
     end,
     walk_tree = function(self, tree, depth)
@@ -464,10 +447,9 @@ do
       if not (Types.is_node(tree)) then
         return 
       end
-      if Tuple:is_instance(tree.value) then
-        local _list_0 = tree.value
-        for _index_0 = 1, #_list_0 do
-          local v = _list_0[_index_0]
+      if tree.is_multi then
+        for _index_0 = 1, #tree do
+          local v = tree[_index_0]
           self:walk_tree(v, depth + 1)
         end
       else
@@ -502,7 +484,7 @@ do
         local lua = _block:as_lua(nomsu):as_statements()
         lua:declare_locals()
         nomsu:run_lua(lua)
-        return Lua(self.source, "if IMMEDIATE then\n    ", lua, "\nend")
+        return Lua(nil, "if IMMEDIATE then\n    ", lua, "\nend")
       end)
       local add_lua_string_bits
       add_lua_string_bits = function(lua, code)
@@ -510,46 +492,42 @@ do
           lua:append(", ", code:as_lua(nomsu))
           return 
         end
-        local _list_0 = code.value
-        for _index_0 = 1, #_list_0 do
-          local bit = _list_0[_index_0]
+        for _index_0 = 1, #code do
+          local bit = code[_index_0]
           lua:append(", ")
           if type(bit) == "string" then
             lua:append(repr(bit))
           else
             local bit_lua = bit:as_lua(nomsu)
             if not (bit_lua.is_value) then
-              local line, src = bit.source:get_line(), bit.source:get_text()
-              error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as a string interpolation value, since it's not an expression.")
+              error("Cannot use " .. tostring(colored.yellow(repr(bit))) .. " as a string interpolation value, since it's not an expression.")
             end
             lua:append(bit_lua)
           end
         end
       end
       self:define_compile_action("Lua %code", function(self, _code)
-        local lua = Lua.Value(self.source, "Lua(", tostring(_code.source))
+        local lua = Lua.Value(nil, "Lua(nil")
         add_lua_string_bits(lua, _code)
         lua:append(")")
         return lua
       end)
       self:define_compile_action("Lua value %code", function(self, _code)
-        local lua = Lua.Value(self.source, "Lua.Value(", tostring(_code.source))
+        local lua = Lua.Value(nil, "Lua.Value(nil")
         add_lua_string_bits(lua, _code)
         lua:append(")")
         return lua
       end)
       local add_lua_bits
       add_lua_bits = function(lua, code)
-        local _list_0 = code.value
-        for _index_0 = 1, #_list_0 do
-          local bit = _list_0[_index_0]
+        for _index_0 = 1, #code do
+          local bit = code[_index_0]
           if type(bit) == "string" then
             lua:append(bit)
           else
             local bit_lua = bit:as_lua(nomsu)
             if not (bit_lua.is_value) then
-              local line, src = bit.source:get_line(), bit.source:get_text()
-              error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as a string interpolation value, since it's not an expression.", 0)
+              error("Cannot use " .. tostring(colored.yellow(repr(bit))) .. " as a string interpolation value, since it's not an expression.", 0)
             end
             lua:append(bit_lua)
           end
@@ -558,20 +536,20 @@ do
       end
       self:define_compile_action("lua> %code", function(self, _code)
         if _code.type ~= "Text" then
-          return Lua(self.source, "nomsu:run_lua(", _code:as_lua(nomsu), ");")
+          return Lua(nil, "nomsu:run_lua(", _code:as_lua(nomsu), ");")
         end
-        return add_lua_bits(Lua(_code.source), _code)
+        return add_lua_bits(Lua(), _code)
       end)
       self:define_compile_action("=lua %code", function(self, _code)
         if _code.type ~= "Text" then
-          return Lua.Value(self.source, "nomsu:run_lua(", _code:as_lua(nomsu), ":as_statements('return '))")
+          return Lua.Value(nil, "nomsu:run_lua(", _code:as_lua(nomsu), ":as_statements('return '))")
         end
-        return add_lua_bits(Lua.Value(_code.source), _code)
+        return add_lua_bits(Lua.Value(), _code)
       end)
       return self:define_compile_action("use %path", function(self, _path)
         local path = nomsu:tree_to_value(_path)
         nomsu:run_file(path)
-        return Lua(self.source, "nomsu:run_file(" .. tostring(repr(path)) .. ");")
+        return Lua(nil, "nomsu:run_file(" .. tostring(repr(path)) .. ");")
       end)
     end
   }
diff --git a/nomsu.moon b/nomsu.moon
index db196fc..7e60cfd 100755
--- a/nomsu.moon
+++ b/nomsu.moon
@@ -129,8 +129,6 @@ Types = require "nomsu_tree"
 
 NOMSU_DEFS = with {}
     -- Newline supports either windows-style CR+LF or unix-style LF
-    .Tuple = (values)->
-        return Tuple(unpack(values))
     .nl = P("\r")^-1 * P("\n")
     .ws = S(" \t")
     .tonumber = tonumber
@@ -196,15 +194,8 @@ NOMSU_DEFS = with {}
         return true
 
 setmetatable(NOMSU_DEFS, {__index:(key)=>
-    make_node = (start, value, stop)->
-        if type(value) == 'table' then error("Not a tuple: #{repr value}")-- = Tuple(value)
-        --source = lpeg.userdata.source_code.source\sub(start,stop-1)
-        source = lpeg.userdata.source_code.source
-        start += source.start-1
-        stop += source.start-1
-        source = Source(source.filename, start, stop-1)
-        node = Types[key](value, source)
-        return node
+    make_node = (src, ...)->
+        Types[key](...)
     self[key] = make_node
     return make_node
 })
@@ -218,7 +209,7 @@ NOMSU_PATTERN = do
     anon_def <- ({ident} (" "*) ":"
         {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- %2"
     captured_def <- ({ident} (" "*) "(" {ident} ")" (" "*) ":"
-        {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- ({} %3 {}) -> %2"
+        {((%nl " "+ [^%nl]*)+) / ([^%nl]*)}) -> "%1 <- (({} %3) -> %2)"
     ident <- [a-zA-Z_][a-zA-Z0-9_]*
     comment <- "--" [^%nl]*
     ]]
@@ -401,13 +392,6 @@ class NomsuCompiler
     run_lua: (lua)=>
         assert(type(lua) != 'string', "Attempt to run lua string instead of Lua (object)")
         lua_string = tostring(lua)
-        --metadata = lua\make_offset_table!
-        --LUA_METADATA[metadata.lua_filename] = metadata
-        if rawget(FILE_CACHE, lua.source.filename) == nil
-            FILE_CACHE[lua.source.filename] = lua_string
-        if rawget(FILE_CACHE, lua.source) == nil
-            FILE_CACHE[lua.source] = lua_string
-            
         run_lua_fn, err = load(lua_string, filename, "t", @environment)
         if not run_lua_fn
             n = 1
@@ -420,16 +404,16 @@ class NomsuCompiler
     
     tree_to_value: (tree)=>
         -- Special case for text literals
-        if tree.type == 'Text' and #tree.value == 1 and type(tree.value[1]) == 'string'
-            return tree.value[1]
-        lua = Lua(tree.source, "return ",tree\as_lua(@),";")
+        if tree.type == 'Text' and #tree == 1 and type(tree[1]) == 'string'
+            return tree[1]
+        lua = Lua(nil, "return ",tree\as_lua(@),";")
         return @run_lua(lua)
 
     walk_tree: (tree, depth=0)=>
         coroutine.yield(tree, depth)
         return unless Types.is_node(tree)
-        if Tuple\is_instance(tree.value)
-            for v in *tree.value
+        if tree.is_multi
+            for v in *tree
                 @walk_tree(v, depth+1)
         else
             @walk_tree(v, depth+1)
@@ -451,61 +435,59 @@ class NomsuCompiler
             lua = _block\as_lua(nomsu)\as_statements!
             lua\declare_locals!
             nomsu\run_lua(lua)
-            return Lua(@source, "if IMMEDIATE then\n    ", lua, "\nend")
+            return Lua(nil, "if IMMEDIATE then\n    ", lua, "\nend")
 
         add_lua_string_bits = (lua, code)->
             if code.type != "Text"
                 lua\append ", ", code\as_lua(nomsu)
                 return
-            for bit in *code.value
+            for bit in *code
                 lua\append ", "
                 if type(bit) == "string"
                     lua\append repr(bit)
                 else
                     bit_lua = bit\as_lua(nomsu)
                     unless bit_lua.is_value
-                        line, src = bit.source\get_line!, bit.source\get_text!
-                        error "#{line}: Cannot use #{colored.yellow src} as a string interpolation value, since it's not an expression."
+                        error "Cannot use #{colored.yellow repr(bit)} as a string interpolation value, since it's not an expression."
                     lua\append bit_lua
 
         @define_compile_action "Lua %code", (_code)=>
-            lua = Lua.Value(@source, "Lua(", tostring(_code.source))
+            lua = Lua.Value(nil, "Lua(nil")
             add_lua_string_bits(lua, _code)
             lua\append ")"
             return lua
 
         @define_compile_action "Lua value %code", (_code)=>
-            lua = Lua.Value(@source, "Lua.Value(", tostring(_code.source))
+            lua = Lua.Value(nil, "Lua.Value(nil")
             add_lua_string_bits(lua, _code)
             lua\append ")"
             return lua
 
         add_lua_bits = (lua, code)->
-            for bit in *code.value
+            for bit in *code
                 if type(bit) == "string"
                     lua\append bit
                 else
                     bit_lua = bit\as_lua(nomsu)
                     unless bit_lua.is_value
-                        line, src = bit.source\get_line!, bit.source\get_text!
-                        error "#{line}: Cannot use #{colored.yellow src} as a string interpolation value, since it's not an expression.", 0
+                        error "Cannot use #{colored.yellow repr(bit)} as a string interpolation value, since it's not an expression.", 0
                     lua\append bit_lua
             return lua
 
         @define_compile_action "lua> %code", (_code)=>
             if _code.type != "Text"
-                return Lua @source, "nomsu:run_lua(", _code\as_lua(nomsu), ");"
-            return add_lua_bits(Lua(_code.source), _code)
+                return Lua nil, "nomsu:run_lua(", _code\as_lua(nomsu), ");"
+            return add_lua_bits(Lua!, _code)
 
         @define_compile_action "=lua %code", (_code)=>
             if _code.type != "Text"
-                return Lua.Value @source, "nomsu:run_lua(", _code\as_lua(nomsu), ":as_statements('return '))"
-            return add_lua_bits(Lua.Value(_code.source), _code)
+                return Lua.Value nil, "nomsu:run_lua(", _code\as_lua(nomsu), ":as_statements('return '))"
+            return add_lua_bits(Lua.Value!, _code)
 
         @define_compile_action "use %path", (_path)=>
             path = nomsu\tree_to_value(_path)
             nomsu\run_file(path)
-            return Lua(@source, "nomsu:run_file(#{repr path});")
+            return Lua(nil, "nomsu:run_file(#{repr path});")
 
 -- Only run this code if this file was run directly with command line arguments, and not require()'d:
 if arg and debug_getinfo(2).func != require
diff --git a/nomsu.peg b/nomsu.peg
index e7c8a7f..14689fc 100644
--- a/nomsu.peg
+++ b/nomsu.peg
@@ -11,18 +11,16 @@ statement: (action / expression) (eol / (({} ([^%nl]* -> "Error while parsing li
 inline_statement: inline_action / inline_expression
 
 inline_block (Block):
-    {| inline_statement (%ws* ";" %ws*  inline_statement)+ |} -> Tuple
+    inline_statement (%ws* ";" %ws*  inline_statement)+
 block (Block):
-    {| statement (nodent (statement / (({} ([^%nl]* -> "Error while parsing block line")) => error)))+ |} -> Tuple
+    statement (nodent (statement / (({} ([^%nl]* -> "Error while parsing block line")) => error)))+
 
-inline_nomsu (Nomsu): "\" noindex_inline_expression
-indented_nomsu (Nomsu):
+inline_nomsu (EscapedNomsu): "\" noindex_inline_expression
+indented_nomsu (EscapedNomsu):
     "\" (noindex_inline_expression / (":" %ws* (inline_block / inline_action / inline_expression) eol) / indented_expression)
 
 index_chain (IndexChain):
-    {|
-        noindex_inline_expression ("." (text_word / noindex_inline_expression))+
-    |} -> Tuple
+    noindex_inline_expression ("." (text_word / noindex_inline_expression))+
 
 noindex_inline_expression:
     number / variable / inline_text / inline_list / inline_dict / inline_nomsu
@@ -47,30 +45,30 @@ expression:
 
 -- Function calls need at least one word in them
 inline_action (Action):
-    {| (inline_expression %ws*)* word (%ws* (inline_expression / word))*
-        (%ws* ":" %ws* (inline_block / inline_action / inline_expression))?|} -> Tuple
+    (inline_expression %ws*)* word (%ws* (inline_expression / word))*
+    (%ws* ":" %ws* (inline_block / inline_action / inline_expression))?
 action (Action):
-    {| (expression (dotdot? %ws*))* word ((dotdot? %ws*) (expression / word))* |} -> Tuple
+    (expression (dotdot? %ws*))* word ((dotdot? %ws*) (expression / word))*
 
 word (Word): { %operator / (!number plain_word) }
 
-text_word (Text): {| {%operator / (!number plain_word)} |} -> Tuple
+text_word (Text): {%operator / (!number plain_word)}
 
 inline_text (Text):
     !('".."' eol)
-    '"' ({|
+    '"' (
         ({~ (('\"' -> '"') / ('\\' -> '\') / %escaped_char / [^%nl\"])+ ~}
         / inline_text_interpolation)*
-    |} -> Tuple) ('"' / (({} ([^%nl]*->'Failed to find a closing " mark on the same line')) => error))
+    ) ('"' / (({} ([^%nl]*->'Failed to find a closing " mark on the same line')) => error))
 
 -- Have to use "%indent" instead of "indent" etc. to avoid messing up text lines that start with "#"
 indented_text (Text):
-    '".."' eol %nl ({|
+    '".."' eol %nl (
         {~ (%nl*) (%indent -> "") ~}
         ({~
             (("\\" -> "\") / (("\" nodent "..") -> "")/ (%nl+ {~ %nodent -> "" ~}) / [^%nl\] / (!text_interpolation "\"))+
         ~} / text_interpolation)*
-    |} -> Tuple) (((!.) &%dedent) / (&(%nl %dedent)) / (({} (non_dedent_error -> "Error while parsing Text")) => error))
+    ) (((!.) &%dedent) / (&(%nl %dedent)) / (({} (non_dedent_error -> "Error while parsing Text")) => error))
 inline_text_interpolation:
     "\" (
         variable / inline_list / inline_dict / inline_text
@@ -93,12 +91,11 @@ variable (Var): "%" { plain_word? }
 
 inline_list (List):
     !('[..]')
-    "[" %ws* ({| (inline_list_item (comma inline_list_item)* comma?)? |} -> Tuple) %ws*
+    "[" %ws* (inline_list_item (comma inline_list_item)* comma?)? %ws*
     ("]" / (({} ([^%nl]*->"Failed to find a closing ] on the same line")) => error))
 indented_list (List):
-    "[..]" indent ({|
+    "[..]" indent
         list_line (nodent list_line)*
-    |} -> Tuple)
     (dedent / (({} (non_dedent_error -> "Error while parsing list")) => error))
 list_line:
      ((action / expression) !comma)
@@ -107,21 +104,20 @@ inline_list_item: inline_block / inline_action / inline_expression
 
 inline_dict (Dict):
     !('{..}')
-    "{" %ws* ({| (inline_dict_entry (comma inline_dict_entry)*)? |} -> Tuple) %ws*
+    "{" %ws* (inline_dict_entry (comma inline_dict_entry)*)? %ws*
     ("}"
       / (({} (%ws* comma? (!. / &%nl)->"Failed to find a closing } on the same line")) => error)
       / (({} ([^%nl]*->"Error while parsing dictionary")) => error))
 indented_dict (Dict):
-    "{..}" indent ({|
+    "{..}" indent
         dict_line (nodent dict_line)*
-    |} -> Tuple)
     (dedent / (({} (non_dedent_error -> "Error while parsing dict")) => error))
 dict_line:
     (dict_entry !comma) / (inline_dict_entry (comma dict_line?)?)
 dict_entry(DictEntry):
-    {| dict_key %ws* ":" %ws* (action / expression) |} -> Tuple
+    dict_key %ws* ":" %ws* (action / expression)
 inline_dict_entry(DictEntry):
-    {| dict_key %ws* (":" %ws* (inline_block / inline_action / inline_expression)?) |} -> Tuple
+    dict_key %ws* (":" %ws* (inline_block / inline_action / inline_expression)?)
 dict_key:
     text_word / inline_expression
 
diff --git a/nomsu_tree.lua b/nomsu_tree.lua
index 68475f6..4d30f38 100644
--- a/nomsu_tree.lua
+++ b/nomsu_tree.lua
@@ -18,59 +18,92 @@ Types.is_node = function(n)
   return type(n) == 'userdata' and getmetatable(n) and Types[n.type] == getmetatable(n)
 end
 local Tree
-Tree = function(name, methods)
+Tree = function(name, kind, methods)
+  assert((kind == 'single') or (kind == 'multi'))
+  local is_multi = (kind == 'multi')
   do
-    methods.__tostring = function(self)
-      return tostring(self.name) .. "(" .. tostring(repr(self.value)) .. ", " .. tostring(repr(self.source)) .. ")"
-    end
     methods.with_value = function(self, value)
-      return getmetatable(self)(value, self.source)
+      return getmetatable(self)(value)
     end
     methods.type = name
     methods.name = name
-    methods.original_nomsu = function(self)
-      local leading_space = 0
-      local src_file = FILE_CACHE[self.source.filename]
-      while src_file:sub(self.source.start - leading_space - 1, self.source.start - leading_space - 1) == " " do
-        leading_space = leading_space + 1
-      end
-      if src_file:sub(self.source.start - leading_space - 1, self.source.start - leading_space - 1) ~= "\n" then
-        leading_space = 0
-      end
-      local ret = tostring(self.source:get_text()):gsub("\n" .. ((" "):rep(leading_space)), "\n")
-      return ret
-    end
-    methods.map = function(self, fn)
-      do
-        local mapped = fn(self)
-        if mapped then
-          return mapped
-        end
-      end
-      if Tuple:is_instance(self.value) then
-        return self:with_value(Tuple(unpack((function()
+    methods.is_multi = is_multi
+    if is_multi then
+      methods.__tostring = function(self)
+        return tostring(self.name) .. "(" .. tostring(table.concat((function()
           local _accum_0 = { }
           local _len_0 = 1
-          local _list_0 = self.value
-          for _index_0 = 1, #_list_0 do
-            local v = _list_0[_index_0]
-            _accum_0[_len_0] = v.map and v:map(fn) or v
+          for _index_0 = 1, #self do
+            local v = self[_index_0]
+            _accum_0[_len_0] = repr(v)
             _len_0 = _len_0 + 1
           end
           return _accum_0
-        end)())))
+        end)(), ', ')) .. ")"
+      end
+      methods.map = function(self, fn)
+        do
+          local ret = fn(self)
+          if ret then
+            return ret
+          end
+        end
+        local new_vals
+        do
+          local _accum_0 = { }
+          local _len_0 = 1
+          for _index_0 = 1, #self do
+            local v = self[_index_0]
+            _accum_0[_len_0] = v.map and v:map(fn) or v
+            _len_0 = _len_0 + 1
+          end
+          new_vals = _accum_0
+        end
+        local ret = getmetatable(self)(unpack(new_vals))
+        return ret
+      end
+    else
+      methods.__tostring = function(self)
+        return tostring(self.name) .. "(" .. tostring(repr(self.value)) .. ")"
+      end
+      methods.map = function(self, fn)
+        return fn(self) or self
       end
-      return self
     end
   end
-  Types[name] = immutable({
-    "value",
-    "source"
-  }, methods)
+  if is_multi then
+    Types[name] = immutable(nil, methods)
+  else
+    Types[name] = immutable({
+      "value"
+    }, methods)
+  end
 end
-Tree("Nomsu", {
+Tree("EscapedNomsu", 'single', {
   as_lua = function(self, nomsu)
-    return Lua.Value(self.source, "nomsu:parse(Nomsu(", repr(self.value.source), ", ", repr(tostring(self.value:as_nomsu(true))), "))")
+    local make_tree
+    make_tree = function(t)
+      if type(t) ~= 'userdata' then
+        return repr(t)
+      end
+      if t.is_multi then
+        local bits
+        do
+          local _accum_0 = { }
+          local _len_0 = 1
+          for _index_0 = 1, #t do
+            local bit = t[_index_0]
+            _accum_0[_len_0] = make_tree(bit)
+            _len_0 = _len_0 + 1
+          end
+          bits = _accum_0
+        end
+        return t.type .. "(" .. table.concat(bits, ", ") .. ")"
+      else
+        return t.type .. "(" .. make_tree(t.value) .. ")"
+      end
+    end
+    return Lua.Value(nil, make_tree(self.value))
   end,
   as_nomsu = function(self, inline)
     if inline == nil then
@@ -79,15 +112,18 @@ Tree("Nomsu", {
     local nomsu = self.value:as_nomsu(true)
     if nomsu == nil and not inline then
       nomsu = self.value:as_nomsu()
-      return nomsu and Nomsu(self.source, "\\:\n    ", nomsu)
+      return nomsu and Nomsu(nil, "\\:\n    ", nomsu)
     end
-    return nomsu and Nomsu(self.source, "\\(", nomsu, ")")
+    return nomsu and Nomsu(nil, "\\(", nomsu, ")")
+  end,
+  map = function(self, fn)
+    return fn(self) or self:map(fn)
   end
 })
-Tree("Block", {
+Tree("Block", 'multi', {
   as_lua = function(self, nomsu)
-    local lua = Lua(self.source)
-    for i, line in ipairs(self.value) do
+    local lua = Lua()
+    for i, line in ipairs(self) do
       local line_lua = line:as_lua(nomsu)
       if i > 1 then
         lua:append("\n")
@@ -101,8 +137,8 @@ Tree("Block", {
       inline = false
     end
     if inline then
-      local nomsu = Nomsu(self.source)
-      for i, line in ipairs(self.value) do
+      local nomsu = Nomsu()
+      for i, line in ipairs(self) do
         if i > 1 then
           nomsu:append("; ")
         end
@@ -114,11 +150,11 @@ Tree("Block", {
       end
       return nomsu
     end
-    local nomsu = Nomsu(self.source)
-    for i, line in ipairs(self.value) do
+    local nomsu = Nomsu()
+    for i, line in ipairs(self) do
       line = assert(line:as_nomsu(nil, true), "Could not convert line to nomsu")
       nomsu:append(line)
-      if i < #self.value then
+      if i < #self then
         nomsu:append("\n")
         if tostring(line):match("\n") then
           nomsu:append("\n")
@@ -129,7 +165,7 @@ Tree("Block", {
   end
 })
 local math_expression = re.compile([[ ([+-] " ")* "%" (" " [*/^+-] (" " [+-])* " %")+ !. ]])
-Tree("Action", {
+Tree("Action", 'multi', {
   as_lua = function(self, nomsu)
     local stub = self:get_stub()
     local compile_action = nomsu.environment.COMPILE_ACTIONS[stub]
@@ -138,9 +174,8 @@ Tree("Action", {
       do
         local _accum_0 = { }
         local _len_0 = 1
-        local _list_0 = self.value
-        for _index_0 = 1, #_list_0 do
-          local arg = _list_0[_index_0]
+        for _index_0 = 1, #self do
+          local arg = self[_index_0]
           if arg.type ~= "Word" then
             _accum_0[_len_0] = arg
             _len_0 = _len_0 + 1
@@ -166,30 +201,29 @@ Tree("Action", {
       return ret
     end
     local action = rawget(nomsu.environment.ACTIONS, stub)
-    local lua = Lua.Value(self.source)
+    local lua = Lua.Value()
     if not action and math_expression:match(stub) then
-      for i, tok in ipairs(self.value) do
+      for i, tok in ipairs(self) do
         if tok.type == "Word" then
           lua:append(tok.value)
         else
           local tok_lua = tok:as_lua(nomsu)
           if not (tok_lua.is_value) then
-            local src = tok.source:get_text()
-            error("non-expression value inside math expression: " .. tostring(colored.yellow(src)))
+            error("non-expression value inside math expression: " .. tostring(colored.yellow(repr(tok))))
           end
           if tok.type == "Action" then
             tok_lua:parenthesize()
           end
           lua:append(tok_lua)
         end
-        if i < #self.value then
+        if i < #self then
           lua:append(" ")
         end
       end
       return lua
     end
     local args = { }
-    for i, tok in ipairs(self.value) do
+    for i, tok in ipairs(self) do
       local _continue_0 = false
       repeat
         if tok.type == "Word" then
@@ -198,8 +232,7 @@ Tree("Action", {
         end
         local arg_lua = tok:as_lua(nomsu)
         if not (arg_lua.is_value) then
-          local line, src = tok.source:get_line(), tok.source:get_text()
-          error(tostring(line) .. ": Cannot use:\n" .. tostring(colored.yellow(src)) .. "\nas an argument to " .. tostring(stub) .. ", since it's not an expression, it produces: " .. tostring(repr(arg_lua)), 0)
+          error("Cannot use:\n" .. tostring(colored.yellow(repr(tok))) .. "\nas an argument to " .. tostring(stub) .. ", since it's not an expression, it produces: " .. tostring(repr(arg_lua)), 0)
         end
         insert(args, arg_lua)
         _continue_0 = true
@@ -240,9 +273,8 @@ Tree("Action", {
       do
         local _accum_0 = { }
         local _len_0 = 1
-        local _list_0 = self.value
-        for _index_0 = 1, #_list_0 do
-          local t = _list_0[_index_0]
+        for _index_0 = 1, #self do
+          local t = self[_index_0]
           _accum_0[_len_0] = (t.type == "Word" and t.value or "%" .. tostring(t.value))
           _len_0 = _len_0 + 1
         end
@@ -252,9 +284,8 @@ Tree("Action", {
       do
         local _accum_0 = { }
         local _len_0 = 1
-        local _list_0 = self.value
-        for _index_0 = 1, #_list_0 do
-          local t = _list_0[_index_0]
+        for _index_0 = 1, #self do
+          local t = self[_index_0]
           _accum_0[_len_0] = (t.type == "Word" and t.value or "%")
           _len_0 = _len_0 + 1
         end
@@ -271,8 +302,8 @@ Tree("Action", {
       can_use_colon = false
     end
     if inline then
-      local nomsu = Nomsu(self.source)
-      for i, bit in ipairs(self.value) do
+      local nomsu = Nomsu()
+      for i, bit in ipairs(self) do
         if bit.type == "Word" then
           if i > 1 then
             nomsu:append(" ")
@@ -294,10 +325,10 @@ Tree("Action", {
       end
       return nomsu
     else
-      local nomsu = Nomsu(self.source)
+      local nomsu = Nomsu()
       local next_space = ""
       local last_colon = nil
-      for i, bit in ipairs(self.value) do
+      for i, bit in ipairs(self) do
         if bit.type == "Word" then
           nomsu:append(next_space, bit.value)
           next_space = " "
@@ -331,9 +362,9 @@ Tree("Action", {
             end
             if bit.type ~= "List" and bit.type ~= "Dict" and bit.type ~= "Text" then
               if i == 1 then
-                arg_nomsu = Nomsu(bit.source, "(..)\n    ", arg_nomsu)
+                arg_nomsu = Nomsu(nil, "(..)\n    ", arg_nomsu)
               else
-                arg_nomsu = Nomsu(bit.source, "\n    ", arg_nomsu)
+                arg_nomsu = Nomsu(nil, "\n    ", arg_nomsu)
               end
             end
             if last_colon == i - 1 and (bit.type == "Action" or bit.type == "Block") then
@@ -351,15 +382,14 @@ Tree("Action", {
     end
   end
 })
-Tree("Text", {
+Tree("Text", 'multi', {
   as_lua = function(self, nomsu)
-    local lua = Lua.Value(self.source)
+    local lua = Lua.Value()
     local string_buffer = ""
-    local _list_0 = self.value
-    for _index_0 = 1, #_list_0 do
+    for _index_0 = 1, #self do
       local _continue_0 = false
       repeat
-        local bit = _list_0[_index_0]
+        local bit = self[_index_0]
         if type(bit) == "string" then
           string_buffer = string_buffer .. bit
           _continue_0 = true
@@ -374,14 +404,13 @@ Tree("Text", {
         end
         local bit_lua = bit:as_lua(nomsu)
         if not (bit_lua.is_value) then
-          local line, src = bit.source:get_line(), bit.source:get_text()
-          error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(bit)) .. " as a string interpolation value, since it's not an expression.", 0)
+          error("Cannot use " .. tostring(colored.yellow(repr(bit))) .. " as a string interpolation value, since it's not an expression.", 0)
         end
         if #lua.bits > 0 then
           lua:append("..")
         end
         if bit.type ~= "Text" then
-          bit_lua = Lua.Value(bit.source, "stringify(", bit_lua, ")")
+          bit_lua = Lua.Value(nil, "stringify(", bit_lua, ")")
         end
         lua:append(bit_lua)
         _continue_0 = true
@@ -406,10 +435,9 @@ Tree("Text", {
       inline = false
     end
     if inline then
-      local nomsu = Nomsu(self.source, '"')
-      local _list_0 = self.value
-      for _index_0 = 1, #_list_0 do
-        local bit = _list_0[_index_0]
+      local nomsu = Nomsu(nil, '"')
+      for _index_0 = 1, #self do
+        local bit = self[_index_0]
         if type(bit) == 'string' then
           nomsu:append((bit:gsub("\\", "\\\\"):gsub("\n", "\\n")))
         else
@@ -431,8 +459,8 @@ Tree("Text", {
       if inline_version and #inline_version <= MAX_LINE then
         return inline_version
       end
-      local nomsu = Nomsu(self.source, '".."\n    ')
-      for i, bit in ipairs(self.value) do
+      local nomsu = Nomsu(nil, '".."\n    ')
+      for i, bit in ipairs(self) do
         if type(bit) == 'string' then
           nomsu:append((bit:gsub("\\", "\\\\"):gsub("\n", "\n    ")))
         else
@@ -448,7 +476,7 @@ Tree("Text", {
               return nil
             end
             nomsu:append("\\\n        ", interp_nomsu)
-            if i < #self.value then
+            if i < #self then
               nomsu:append("\n    ..")
             end
           end
@@ -458,15 +486,14 @@ Tree("Text", {
     end
   end
 })
-Tree("List", {
+Tree("List", 'multi', {
   as_lua = function(self, nomsu)
-    local lua = Lua.Value(self.source, "{")
+    local lua = Lua.Value(nil, "{")
     local line_length = 0
-    for i, item in ipairs(self.value) do
+    for i, item in ipairs(self) do
       local item_lua = item:as_lua(nomsu)
       if not (item_lua.is_value) then
-        local line, src = item.source:get_line(), item.source:get_text()
-        error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as a list item, since it's not an expression.", 0)
+        error("Cannot use " .. tostring(colored.yellow(repr(item))) .. " as a list item, since it's not an expression.", 0)
       end
       lua:append(item_lua)
       local item_string = tostring(item_lua)
@@ -476,7 +503,7 @@ Tree("List", {
       else
         line_length = line_length + #last_line
       end
-      if i < #self.value then
+      if i < #self then
         if line_length >= MAX_LINE then
           lua:append(",\n  ")
           line_length = 0
@@ -494,8 +521,8 @@ Tree("List", {
       inline = false
     end
     if inline then
-      local nomsu = Nomsu(self.source, "[")
-      for i, item in ipairs(self.value) do
+      local nomsu = Nomsu(nil, "[")
+      for i, item in ipairs(self) do
         local item_nomsu = item:as_nomsu(true)
         if not (item_nomsu) then
           return nil
@@ -512,11 +539,10 @@ Tree("List", {
       if inline_version and #inline_version <= MAX_LINE then
         return inline_version
       end
-      local nomsu = Nomsu(self.source, "[..]")
-      local line = Nomsu(self.source, "\n    ")
-      local _list_0 = self.value
-      for _index_0 = 1, #_list_0 do
-        local item = _list_0[_index_0]
+      local nomsu = Nomsu(nil, "[..]")
+      local line = Nomsu(nil, "\n    ")
+      for _index_0 = 1, #self do
+        local item = self[_index_0]
         local item_nomsu = item:as_nomsu(true)
         if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE then
           if #line.bits > 1 then
@@ -532,7 +558,7 @@ Tree("List", {
           end
           if #line.bits > 1 then
             nomsu:append(line)
-            line = Nomsu(item.source, "\n    ")
+            line = Nomsu(nil, "\n    ")
           end
           line:append(item_nomsu)
         end
@@ -544,11 +570,11 @@ Tree("List", {
     end
   end
 })
-Tree("Dict", {
+Tree("Dict", 'multi', {
   as_lua = function(self, nomsu)
-    local lua = Lua.Value(self.source, "{")
+    local lua = Lua.Value(nil, "{")
     local line_length = 0
-    for i, entry in ipairs(self.value) do
+    for i, entry in ipairs(self) do
       local entry_lua = entry:as_lua(nomsu)
       lua:append(entry_lua)
       local entry_lua_str = tostring(entry_lua)
@@ -558,7 +584,7 @@ Tree("Dict", {
       else
         line_length = line_length + #entry_lua_str
       end
-      if i < #self.value then
+      if i < #self then
         if line_length >= MAX_LINE then
           lua:append(",\n  ")
           line_length = 0
@@ -576,8 +602,8 @@ Tree("Dict", {
       inline = false
     end
     if inline then
-      local nomsu = Nomsu(self.source, "{")
-      for i, entry in ipairs(self.value) do
+      local nomsu = Nomsu(nil, "{")
+      for i, entry in ipairs(self) do
         local entry_nomsu = entry:as_nomsu(true)
         if not (entry_nomsu) then
           return nil
@@ -594,11 +620,10 @@ Tree("Dict", {
       if inline_version then
         return inline_version
       end
-      local nomsu = Nomsu(self.source, "{..}")
-      local line = Nomsu(self.source, "\n    ")
-      local _list_0 = self.value
-      for _index_0 = 1, #_list_0 do
-        local entry = _list_0[_index_0]
+      local nomsu = Nomsu(nil, "{..}")
+      local line = Nomsu(nil, "\n    ")
+      for _index_0 = 1, #self do
+        local entry = self[_index_0]
         local entry_nomsu = entry:as_nomsu()
         if not (entry_nomsu) then
           return nil
@@ -611,7 +636,7 @@ Tree("Dict", {
         else
           if #line.bits > 1 then
             nomsu:append(line)
-            line = Nomsu(bit.source, "\n    ")
+            line = Nomsu(nil, "\n    ")
           end
           line:append(entry_nomsu)
         end
@@ -623,33 +648,31 @@ Tree("Dict", {
     end
   end
 })
-Tree("DictEntry", {
+Tree("DictEntry", 'multi', {
   as_lua = function(self, nomsu)
-    local key, value = self.value[1], self.value[2]
+    local key, value = self[1], self[2]
     local key_lua = key:as_lua(nomsu)
     if not (key_lua.is_value) then
-      local line, src = key.source:get_line(), key.source:get_text()
-      error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as a dict key, since it's not an expression.", 0)
+      error("Cannot use " .. tostring(colored.yellow(repr(key))) .. " as a dict key, since it's not an expression.", 0)
     end
-    local value_lua = value and value:as_lua(nomsu) or Lua.Value(key.source, "true")
+    local value_lua = value and value:as_lua(nomsu) or Lua.Value(nil, "true")
     if not (value_lua.is_value) then
-      local line, src = value.source:get_line(), value.source:get_text()
-      error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as a dict value, since it's not an expression.", 0)
+      error("Cannot use " .. tostring(colored.yellow(repr(value))) .. " as a dict value, since it's not an expression.", 0)
     end
     local key_str = tostring(key_lua):match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
     if key_str then
-      return Lua(key.source, key_str, "=", value_lua)
+      return Lua(nil, key_str, "=", value_lua)
     elseif tostring(key_lua):sub(1, 1) == "[" then
-      return Lua(key.source, "[ ", key_lua, "]=", value_lua)
+      return Lua(nil, "[ ", key_lua, "]=", value_lua)
     else
-      return Lua(key.source, "[", key_lua, "]=", value_lua)
+      return Lua(nil, "[", key_lua, "]=", value_lua)
     end
   end,
   as_nomsu = function(self, inline)
     if inline == nil then
       inline = true
     end
-    local key, value = self.value[1], self.value[2]
+    local key, value = self[1], self[2]
     local key_nomsu = key:as_nomsu(true)
     if not (key_nomsu) then
       return nil
@@ -661,7 +684,7 @@ Tree("DictEntry", {
     if value then
       value_nomsu = value:as_nomsu(true)
     else
-      value_nomsu = Nomsu(key.source, "")
+      value_nomsu = Nomsu(nil, "")
     end
     if inline and not value_nomsu then
       return nil
@@ -675,43 +698,35 @@ Tree("DictEntry", {
         return nil
       end
     end
-    return Nomsu(key.source, key_nomsu, ":", value_nomsu)
+    return Nomsu(nil, key_nomsu, ":", value_nomsu)
   end
 })
-Tree("IndexChain", {
+Tree("IndexChain", 'multi', {
   as_lua = function(self, nomsu)
-    local lua = self.value[1]:as_lua(nomsu)
+    local lua = self[1]:as_lua(nomsu)
     if not (lua.is_value) then
-      local line, src = self.value[1].source:get_line(), self.value[1].source:get_text()
-      error(tostring(line) .. ": Cannot index " .. tostring(colored.yellow(src)) .. ", since it's not an expression.", 0)
+      error("Cannot index " .. tostring(colored.yellow(repr(self[1]))) .. ", since it's not an expression.", 0)
     end
     local first_char = tostring(lua):sub(1, 1)
     if first_char == "{" or first_char == '"' or first_char == "[" then
       lua:parenthesize()
     end
-    for i = 2, #self.value do
-      local _continue_0 = false
-      repeat
-        local key = self.value[i]
-        if key.type == 'Text' and #key.value == 1 and type(key.value[1]) == 'string' and key.value[1]:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
-          lua:append("." .. tostring(key.value[1]))
-          _continue_0 = true
-          break
-        end
-        local key_lua = key:as_lua(nomsu)
-        if not (key_lua.is_value) then
-          local line, src = key.source:get_line(), key.source:get_text()
-          error(tostring(line) .. ": Cannot use " .. tostring(colored.yellow(src)) .. " as an index, since it's not an expression.", 0)
-        end
-        if tostring(key_lua):sub(1, 1) == '[' then
-          lua:append("[ ", key_lua, "]")
+    for i = 2, #self do
+      local key = self[i]
+      local key_lua = key:as_lua(nomsu)
+      if not (key_lua.is_value) then
+        error("Cannot use " .. tostring(colored.yellow(repr(key))) .. " as an index, since it's not an expression.", 0)
+      end
+      local key_lua_str = tostring(key_lua)
+      do
+        local lua_id = key_lua_str:match("^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
+        if lua_id then
+          lua:append("." .. tostring(lua_id))
+        elseif key_lua_str:sub(1, 1) == '[' then
+          lua:append("[ ", key_lua, " ]")
         else
           lua:append("[", key_lua, "]")
         end
-        _continue_0 = true
-      until true
-      if not _continue_0 then
-        break
       end
     end
     return lua
@@ -720,8 +735,8 @@ Tree("IndexChain", {
     if inline == nil then
       inline = false
     end
-    local nomsu = Nomsu(self.source)
-    for i, bit in ipairs(self.value) do
+    local nomsu = Nomsu()
+    for i, bit in ipairs(self) do
       if i > 1 then
         nomsu:append(".")
       end
@@ -737,18 +752,18 @@ Tree("IndexChain", {
     return nomsu
   end
 })
-Tree("Number", {
+Tree("Number", 'single', {
   as_lua = function(self, nomsu)
-    return Lua.Value(self.source, tostring(self.value))
+    return Lua.Value(nil, tostring(self.value))
   end,
   as_nomsu = function(self, inline)
     if inline == nil then
       inline = false
     end
-    return Nomsu(self.source, tostring(self.value))
+    return Nomsu(nil, tostring(self.value))
   end
 })
-Tree("Var", {
+Tree("Var", 'single', {
   as_lua_id = function(v)
     return "_" .. (v:gsub("%W", function(c)
       if c == "_" then
@@ -759,16 +774,16 @@ Tree("Var", {
     end))
   end,
   as_lua = function(self, nomsu)
-    return Lua.Value(self.source, self.as_lua_id(self.value))
+    return Lua.Value(nil, self.as_lua_id(self.value))
   end,
   as_nomsu = function(self, inline)
     if inline == nil then
       inline = false
     end
-    return Nomsu(self.source, "%", self.value)
+    return Nomsu(nil, "%", self.value)
   end
 })
-Tree("Word", {
+Tree("Word", 'single', {
   as_lua = function(self, nomsu)
     return error("Attempt to convert Word to lua")
   end,
@@ -776,12 +791,12 @@ Tree("Word", {
     if inline == nil then
       inline = false
     end
-    return Nomsu(self.source, self.value)
+    return Nomsu(nil, self.value)
   end
 })
-Tree("Comment", {
+Tree("Comment", 'single', {
   as_lua = function(self, nomsu)
-    return Lua(self.source, "--" .. self.value:gsub("\n", "\n--") .. "\n")
+    return Lua(nil, "--" .. self.value:gsub("\n", "\n--") .. "\n")
   end,
   as_nomsu = function(self, inline)
     if inline == nil then
@@ -791,9 +806,9 @@ Tree("Comment", {
       return nil
     end
     if self.value:match("\n") then
-      return Nomsu(self.source, "#..", self.value:gsub("\n", "\n    "))
+      return Nomsu(nil, "#..", self.value:gsub("\n", "\n    "))
     else
-      return Nomsu(self.source, "#", self.value)
+      return Nomsu(nil, "#", self.value)
     end
   end
 })
diff --git a/nomsu_tree.moon b/nomsu_tree.moon
index ae345cc..11fed94 100644
--- a/nomsu_tree.moon
+++ b/nomsu_tree.moon
@@ -13,46 +13,57 @@ Types.is_node = (n)->
     type(n) == 'userdata' and getmetatable(n) and Types[n.type] == getmetatable(n)
 
 -- Helper method:
-Tree = (name, methods)->
+Tree = (name, kind, methods)->
+    assert((kind == 'single') or (kind == 'multi'))
+    is_multi = (kind == 'multi')
     with methods
-        .__tostring = => "#{@name}(#{repr(@value)}, #{repr @source})"
-        .with_value = (value)=> getmetatable(self)(value, @source)
+        .with_value = (value)=> getmetatable(self)(value)
         .type = name
         .name = name
-        .original_nomsu = =>
-            leading_space = 0
-            src_file = FILE_CACHE[@source.filename]
-            while src_file\sub(@source.start-leading_space-1, @source.start-leading_space-1) == " "
-                leading_space += 1
-            if src_file\sub(@source.start-leading_space-1, @source.start-leading_space-1) != "\n"
-                leading_space = 0
-            ret = tostring(@source\get_text!)\gsub("\n"..((" ")\rep(leading_space)), "\n")
-            return ret
-        .map = (fn)=>
-            if mapped = fn(self)
-                return mapped
-            if Tuple\is_instance(@value)
-                return @with_value(Tuple(unpack([v.map and v\map(fn) or v for v in *@value])))
-            return self
+        .is_multi = is_multi
+        if is_multi
+            .__tostring = => "#{@name}(#{table.concat [repr(v) for v in *@], ', '})"
+            .map = (fn)=>
+                if ret = fn(@)
+                    return ret
+                new_vals = [v.map and v\map(fn) or v for v in *@]
+                ret = getmetatable(self)(unpack(new_vals))
+                return ret
+        else
+            .__tostring = => "#{@name}(#{repr(@value)})"
+            .map = (fn)=> fn(@) or @
 
-    Types[name] = immutable {"value","source"}, methods
+    if is_multi
+        Types[name] = immutable nil, methods
+    else
+        Types[name] = immutable {"value"}, methods
 
 
-Tree "Nomsu",
+Tree "EscapedNomsu", 'single',
     as_lua: (nomsu)=>
-        Lua.Value(@source, "nomsu:parse(Nomsu(",repr(@value.source),", ",repr(tostring(@value\as_nomsu(true))),"))")
+        make_tree = (t)->
+            if type(t) != 'userdata'
+                return repr(t)
+            if t.is_multi
+                bits = [make_tree(bit) for bit in *t]
+                return t.type.."("..table.concat(bits, ", ")..")"
+            else
+                return t.type.."("..make_tree(t.value)..")"
+        Lua.Value nil, make_tree(@value)
 
     as_nomsu: (inline=false)=>
         nomsu = @value\as_nomsu(true)
         if nomsu == nil and not inline
             nomsu = @value\as_nomsu!
-            return nomsu and Nomsu(@source, "\\:\n    ", nomsu)
-        return nomsu and Nomsu(@source, "\\(", nomsu, ")")
+            return nomsu and Nomsu nil, "\\:\n    ", nomsu
+        return nomsu and Nomsu nil, "\\(", nomsu, ")"
 
-Tree "Block",
+    map: (fn)=> fn(@) or @\map(fn)
+
+Tree "Block", 'multi',
     as_lua: (nomsu)=>
-        lua = Lua(@source)
-        for i,line in ipairs @value
+        lua = Lua!
+        for i,line in ipairs @
             line_lua = line\as_lua(nomsu)
             if i > 1
                 lua\append "\n"
@@ -61,31 +72,31 @@ Tree "Block",
 
     as_nomsu: (inline=false)=>
         if inline
-            nomsu = Nomsu(@source)
-            for i,line in ipairs @value
+            nomsu = Nomsu!
+            for i,line in ipairs @
                 if i > 1
                     nomsu\append "; "
                 line_nomsu = line\as_nomsu(true)
                 return nil unless line_nomsu
                 nomsu\append line_nomsu
             return nomsu
-        nomsu = Nomsu(@source)
-        for i, line in ipairs @value
+        nomsu = Nomsu!
+        for i, line in ipairs @
             line = assert(line\as_nomsu(nil, true), "Could not convert line to nomsu")
             nomsu\append line
-            if i < #@value
+            if i < #@
                 nomsu\append "\n"
                 if tostring(line)\match("\n")
                     nomsu\append "\n"
         return nomsu
 
 math_expression = re.compile [[ ([+-] " ")* "%" (" " [*/^+-] (" " [+-])* " %")+ !. ]]
-Tree "Action",
+Tree "Action", 'multi',
     as_lua: (nomsu)=>
         stub = @get_stub!
         compile_action = nomsu.environment.COMPILE_ACTIONS[stub]
         if compile_action
-            args = [arg for arg in *@value when arg.type != "Word"]
+            args = [arg for arg in *@ when arg.type != "Word"]
             -- Force all compile-time actions to take a tree location
             args = [args[p-1] for p in *nomsu.environment.ARG_ORDERS[compile_action][stub]]
             -- Force Lua to avoid tail call optimization for debugging purposes
@@ -93,33 +104,31 @@ Tree "Action",
             if not ret then error("Failed to produce any Lua")
             return ret
         action = rawget(nomsu.environment.ACTIONS, stub)
-        lua = Lua.Value(@source)
+        lua = Lua.Value!
         if not action and math_expression\match(stub)
             -- This is a bit of a hack, but this code handles arbitrarily complex
             -- math expressions like 2*x + 3^2 without having to define a single
             -- action for every possibility.
-            for i,tok in ipairs @value
+            for i,tok in ipairs @
                 if tok.type == "Word"
                     lua\append tok.value
                 else
                     tok_lua = tok\as_lua(nomsu)
                     unless tok_lua.is_value
-                        src = tok.source\get_text!
-                        error("non-expression value inside math expression: #{colored.yellow src}")
+                        error("non-expression value inside math expression: #{colored.yellow repr(tok)}")
                     if tok.type == "Action"
                         tok_lua\parenthesize!
                     lua\append tok_lua
-                if i < #@value
+                if i < #@
                     lua\append " "
             return lua
 
         args = {}
-        for i, tok in ipairs @value
+        for i, tok in ipairs @
             if tok.type == "Word" then continue
             arg_lua = tok\as_lua(nomsu)
             unless arg_lua.is_value
-                line, src = tok.source\get_line!, tok.source\get_text!
-                error "#{line}: Cannot use:\n#{colored.yellow src}\nas an argument to #{stub}, since it's not an expression, it produces: #{repr arg_lua}", 0
+                error "Cannot use:\n#{colored.yellow repr(tok)}\nas an argument to #{stub}, since it's not an expression, it produces: #{repr arg_lua}", 0
             insert args, arg_lua
 
         if action
@@ -136,14 +145,14 @@ Tree "Action",
 
     get_stub: (include_names=false)=>
         bits = if include_names
-            [(t.type == "Word" and t.value or "%#{t.value}") for t in *@value]
-        else [(t.type == "Word" and t.value or "%") for t in *@value]
+            [(t.type == "Word" and t.value or "%#{t.value}") for t in *@]
+        else [(t.type == "Word" and t.value or "%") for t in *@]
         return concat(bits, " ")
 
     as_nomsu: (inline=false, can_use_colon=false)=>
         if inline
-            nomsu = Nomsu(@source)
-            for i,bit in ipairs @value
+            nomsu = Nomsu!
+            for i,bit in ipairs @
                 if bit.type == "Word"
                     if i > 1
                         nomsu\append " "
@@ -158,11 +167,11 @@ Tree "Action",
                     nomsu\append arg_nomsu
             return nomsu
         else
-            nomsu = Nomsu(@source)
+            nomsu = Nomsu!
             next_space = ""
             -- TODO: track line length as we go and use 80-that instead of 80 for wrapping
             last_colon = nil
-            for i,bit in ipairs @value
+            for i,bit in ipairs @
                 if bit.type == "Word"
                     nomsu\append next_space, bit.value
                     next_space = " "
@@ -189,9 +198,9 @@ Tree "Action",
                         -- These types carry their own indentation
                         if bit.type != "List" and bit.type != "Dict" and bit.type != "Text"
                             if i == 1
-                                arg_nomsu = Nomsu(bit.source, "(..)\n    ", arg_nomsu)
+                                arg_nomsu = Nomsu(nil, "(..)\n    ", arg_nomsu)
                             else
-                                arg_nomsu = Nomsu(bit.source, "\n    ", arg_nomsu)
+                                arg_nomsu = Nomsu(nil, "\n    ", arg_nomsu)
                         
                         if last_colon == i-1 and (bit.type == "Action" or bit.type == "Block")
                             next_space = ""
@@ -202,11 +211,11 @@ Tree "Action",
                         next_space = "\n.."
             return nomsu
 
-Tree "Text",
+Tree "Text", 'multi',
     as_lua: (nomsu)=>
-        lua = Lua.Value(@source)
+        lua = Lua.Value!
         string_buffer = ""
-        for bit in *@value
+        for bit in *@
             if type(bit) == "string"
                 string_buffer ..= bit
                 continue
@@ -216,11 +225,10 @@ Tree "Text",
                 string_buffer = ""
             bit_lua = bit\as_lua(nomsu)
             unless bit_lua.is_value
-                line, src = bit.source\get_line!, bit.source\get_text!
-                error "#{line}: Cannot use #{colored.yellow bit} as a string interpolation value, since it's not an expression.", 0
+                error "Cannot use #{colored.yellow repr(bit)} as a string interpolation value, since it's not an expression.", 0
             if #lua.bits > 0 then lua\append ".."
             if bit.type != "Text"
-                bit_lua = Lua.Value(bit.source, "stringify(",bit_lua,")")
+                bit_lua = Lua.Value(nil, "stringify(",bit_lua,")")
             lua\append bit_lua
 
         if string_buffer ~= "" or #lua.bits == 0
@@ -233,8 +241,8 @@ Tree "Text",
 
     as_nomsu: (inline=false)=>
         if inline
-            nomsu = Nomsu(@source, '"')
-            for bit in *@value
+            nomsu = Nomsu(nil, '"')
+            for bit in *@
                 if type(bit) == 'string'
                     -- TODO: unescape better?
                     nomsu\append (bit\gsub("\\","\\\\")\gsub("\n","\\n"))
@@ -251,8 +259,8 @@ Tree "Text",
             inline_version = @as_nomsu(true)
             if inline_version and #inline_version <= MAX_LINE
                 return inline_version
-            nomsu = Nomsu(@source, '".."\n    ')
-            for i, bit in ipairs @value
+            nomsu = Nomsu(nil, '".."\n    ')
+            for i, bit in ipairs @
                 if type(bit) == 'string'
                     nomsu\append (bit\gsub("\\","\\\\")\gsub("\n","\n    "))
                 else
@@ -265,19 +273,18 @@ Tree "Text",
                         interp_nomsu = bit\as_nomsu!
                         return nil unless interp_nomsu
                         nomsu\append "\\\n        ", interp_nomsu
-                        if i < #@value
+                        if i < #@
                             nomsu\append "\n    .."
             return nomsu
 
-Tree "List",
+Tree "List", 'multi',
     as_lua: (nomsu)=>
-        lua = Lua.Value @source, "{"
+        lua = Lua.Value nil, "{"
         line_length = 0
-        for i, item in ipairs @value
+        for i, item in ipairs @
             item_lua = item\as_lua(nomsu)
             unless item_lua.is_value
-                line, src = item.source\get_line!, item.source\get_text!
-                error "#{line}: Cannot use #{colored.yellow src} as a list item, since it's not an expression.", 0
+                error "Cannot use #{colored.yellow repr(item)} as a list item, since it's not an expression.", 0
             lua\append item_lua
             item_string = tostring(item_lua)
             last_line = item_string\match("[^\n]*$")
@@ -285,7 +292,7 @@ Tree "List",
                 line_length = #last_line
             else
                 line_length += #last_line
-            if i < #@value
+            if i < #@
                 if line_length >= MAX_LINE
                     lua\append ",\n  "
                     line_length = 0
@@ -297,8 +304,8 @@ Tree "List",
 
     as_nomsu: (inline=false)=>
         if inline
-            nomsu = Nomsu(@source, "[")
-            for i, item in ipairs @value
+            nomsu = Nomsu(nil, "[")
+            for i, item in ipairs @
                 item_nomsu = item\as_nomsu(true)
                 return nil unless item_nomsu
                 if i > 1
@@ -310,9 +317,9 @@ Tree "List",
             inline_version = @as_nomsu(true)
             if inline_version and #inline_version <= MAX_LINE
                 return inline_version
-            nomsu = Nomsu(@source, "[..]")
-            line = Nomsu(@source, "\n    ")
-            for item in *@value
+            nomsu = Nomsu(nil, "[..]")
+            line = Nomsu(nil, "\n    ")
+            for item in *@
                 item_nomsu = item\as_nomsu(true)
                 if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE
                     if #line.bits > 1
@@ -324,17 +331,17 @@ Tree "List",
                         return nil unless item_nomsu
                     if #line.bits > 1
                         nomsu\append line
-                        line = Nomsu(item.source, "\n    ")
+                        line = Nomsu(nil, "\n    ")
                     line\append item_nomsu
             if #line.bits > 1
                 nomsu\append line
             return nomsu
 
-Tree "Dict",
+Tree "Dict", 'multi',
     as_lua: (nomsu)=>
-        lua = Lua.Value @source, "{"
+        lua = Lua.Value nil, "{"
         line_length = 0
-        for i, entry in ipairs @value
+        for i, entry in ipairs @
             entry_lua = entry\as_lua(nomsu)
             lua\append entry_lua
             entry_lua_str = tostring(entry_lua)
@@ -344,7 +351,7 @@ Tree "Dict",
                 line_length = #last_line
             else
                 line_length += #entry_lua_str
-            if i < #@value
+            if i < #@
                 if line_length >= MAX_LINE
                     lua\append ",\n  "
                     line_length = 0
@@ -356,8 +363,8 @@ Tree "Dict",
 
     as_nomsu: (inline=false)=>
         if inline
-            nomsu = Nomsu(@source, "{")
-            for i, entry in ipairs @value
+            nomsu = Nomsu(nil, "{")
+            for i, entry in ipairs @
                 entry_nomsu = entry\as_nomsu(true)
                 return nil unless entry_nomsu
                 if i > 1
@@ -368,9 +375,9 @@ Tree "Dict",
         else
             inline_version = @as_nomsu(true)
             if inline_version then return inline_version
-            nomsu = Nomsu(@source, "{..}")
-            line = Nomsu(@source, "\n    ")
-            for entry in *@value
+            nomsu = Nomsu(nil, "{..}")
+            line = Nomsu(nil, "\n    ")
+            for entry in *@
                 entry_nomsu = entry\as_nomsu!
                 return nil unless entry_nomsu
                 if #line + #tostring(entry_nomsu) <= MAX_LINE
@@ -380,82 +387,78 @@ Tree "Dict",
                 else
                     if #line.bits > 1
                         nomsu\append line
-                        line = Nomsu(bit.source, "\n    ")
+                        line = Nomsu(nil, "\n    ")
                     line\append entry_nomsu
             if #line.bits > 1
                 nomsu\append line
             return nomsu
 
-Tree "DictEntry",
+Tree "DictEntry", 'multi',
     as_lua: (nomsu)=>
-        key, value = @value[1], @value[2]
+        key, value = @[1], @[2]
         key_lua = key\as_lua(nomsu)
         unless key_lua.is_value
-            line, src = key.source\get_line!, key.source\get_text!
-            error "#{line}: Cannot use #{colored.yellow src} as a dict key, since it's not an expression.", 0
-        value_lua = value and value\as_lua(nomsu) or Lua.Value(key.source, "true")
+            error "Cannot use #{colored.yellow repr(key)} as a dict key, since it's not an expression.", 0
+        value_lua = value and value\as_lua(nomsu) or Lua.Value(nil, "true")
         unless value_lua.is_value
-            line, src = value.source\get_line!, value.source\get_text!
-            error "#{line}: Cannot use #{colored.yellow src} as a dict value, since it's not an expression.", 0
+            error "Cannot use #{colored.yellow repr(value)} as a dict value, since it's not an expression.", 0
         key_str = tostring(key_lua)\match([=[["']([a-zA-Z_][a-zA-Z0-9_]*)['"]]=])
         return if key_str
-            Lua key.source, key_str,"=",value_lua
+            Lua nil, key_str,"=",value_lua
         elseif tostring(key_lua)\sub(1,1) == "["
             -- NOTE: this *must* use a space after the [ to avoid freaking out
             -- Lua's parser if the inner expression is a long string. Lua
             -- parses x[[[y]]] as x("[y]"), not as x["y"]
-            Lua key.source, "[ ",key_lua,"]=",value_lua
+            Lua nil, "[ ",key_lua,"]=",value_lua
         else
-            Lua key.source, "[",key_lua,"]=",value_lua
+            Lua nil, "[",key_lua,"]=",value_lua
 
     as_nomsu: (inline=true)=>
-        key, value = @value[1], @value[2]
+        key, value = @[1], @[2]
         key_nomsu = key\as_nomsu(true)
         return nil unless key_nomsu
         if key.type == "Action" or key.type == "Block"
             key_nomsu\parenthesize!
         value_nomsu = if value
             value\as_nomsu(true)
-        else Nomsu(key.source, "")
+        else Nomsu(nil, "")
         if inline and not value_nomsu then return nil
         if not value_nomsu
             return nil if inline
             value_nomsu = value\as_nomsu!
             return nil unless value_nomsu
-        return Nomsu key.source, key_nomsu, ":", value_nomsu
+        return Nomsu nil, key_nomsu, ":", value_nomsu
 
 
-Tree "IndexChain",
+Tree "IndexChain", 'multi',
     as_lua: (nomsu)=>
-        lua = @value[1]\as_lua(nomsu)
+        lua = @[1]\as_lua(nomsu)
         unless lua.is_value
-            line, src = @value[1].source\get_line!, @value[1].source\get_text!
-            error "#{line}: Cannot index #{colored.yellow src}, since it's not an expression.", 0
+            error "Cannot index #{colored.yellow repr(@[1])}, since it's not an expression.", 0
         first_char = tostring(lua)\sub(1,1)
         if first_char == "{" or first_char == '"' or first_char == "["
             lua\parenthesize!
 
-        for i=2,#@value
-            key = @value[i]
-            if key.type == 'Text' and #key.value == 1 and type(key.value[1]) == 'string' and key.value[1]\match("^[a-zA-Z_][a-zA-Z0-9_]*$")
-                lua\append ".#{key.value[1]}"
-                continue
+        for i=2,#@
+            key = @[i]
             key_lua = key\as_lua(nomsu)
             unless key_lua.is_value
-                line, src = key.source\get_line!, key.source\get_text!
-                error "#{line}: Cannot use #{colored.yellow src} as an index, since it's not an expression.", 0
-            -- NOTE: this *must* use a space after the [ to avoid freaking out
-            -- Lua's parser if the inner expression is a long string. Lua
-            -- parses x[[[y]]] as x("[y]"), not as x["y"]
-            if tostring(key_lua)\sub(1,1) == '['
-                lua\append "[ ",key_lua,"]"
+                error "Cannot use #{colored.yellow repr(key)} as an index, since it's not an expression.", 0
+            key_lua_str = tostring(key_lua)
+            if lua_id = key_lua_str\match("^['\"]([a-zA-Z_][a-zA-Z0-9_]*)['\"]$")
+                lua\append ".#{lua_id}"
+            elseif key_lua_str\sub(1,1) == '['
+                -- NOTE: this *must* use a space after the [ to avoid freaking out
+                -- Lua's parser if the inner expression is a long string. Lua
+                -- parses x[[[y]]] as x("[y]"), not as x["y"]
+                lua\append "[ ",key_lua," ]"
             else
                 lua\append "[",key_lua,"]"
         return lua
 
     as_nomsu: (inline=false)=>
-        nomsu = Nomsu(@source)
-        for i, bit in ipairs @value
+        nomsu = Nomsu!
+        for i, bit in ipairs @
             if i > 1
                 nomsu\append "."
             bit_nomsu = bit\as_nomsu(true)
@@ -465,39 +468,39 @@ Tree "IndexChain",
             nomsu\append bit_nomsu
         return nomsu
 
-Tree "Number",
+Tree "Number", 'single',
     as_lua: (nomsu)=>
-        Lua.Value(@source, tostring(@value))
+        Lua.Value(nil, tostring(@value))
     
     as_nomsu: (inline=false)=>
-        return Nomsu(@source, tostring(@value))
+        return Nomsu(nil, tostring(@value))
 
-Tree "Var",
+Tree "Var", 'single',
     as_lua_id: (v)->
         "_"..(v\gsub("%W", (c)-> if c == "_" then "__" else ("_%x")\format(c\byte!)))
 
     as_lua: (nomsu)=>
-        Lua.Value(@source, self.as_lua_id(@value))
+        Lua.Value(nil, self.as_lua_id(@value))
 
     as_nomsu: (inline=false)=>
-        return Nomsu(@source, "%", @value)
+        return Nomsu(nil, "%", @value)
 
-Tree "Word",
+Tree "Word", 'single',
     as_lua: (nomsu)=>
         error("Attempt to convert Word to lua")
 
     as_nomsu: (inline=false)=>
-        return Nomsu(@source, @value)
+        return Nomsu(nil, @value)
 
-Tree "Comment",
+Tree "Comment", 'single',
     as_lua: (nomsu)=>
-        Lua(@source, "--"..@value\gsub("\n","\n--").."\n")
+        Lua(nil, "--"..@value\gsub("\n","\n--").."\n")
 
     as_nomsu: (inline=false)=>
         return nil if inline
         if @value\match("\n")
-            return Nomsu(@source, "#..", @value\gsub("\n", "\n    "))
+            return Nomsu(nil, "#..", @value\gsub("\n", "\n    "))
         else
-            return Nomsu(@source, "#", @value)
+            return Nomsu(nil, "#", @value)
 
 return Types
diff --git a/tests/metaprogramming.nom b/tests/metaprogramming.nom
index e94a78f..ac27394 100644
--- a/tests/metaprogramming.nom
+++ b/tests/metaprogramming.nom
@@ -42,7 +42,7 @@ try: foo 99
 
 assume ((\(5 + 5) as value) = 10) or barf "%tree as value failed."
 
-assume (((\(foo %x)'s source code) as text) = "foo %x") or barf "source code failed."
+assume (((\(foo %x) as nomsu) as text) = "foo %x") or barf "source code failed."
 
 assume ((repr [1,2]) = "{1, 2}") or barf "repr failed."