From 6b09187899e86eabc25ed2ff96f4c2e51f130c00 Mon Sep 17 00:00:00 2001
From: Bruce Hill <bitbucket@bruce-hill.com>
Date: Fri, 12 Jan 2018 16:33:11 -0800
Subject: [PATCH] Switched to use load() with environment table instead of
 passing in nomsu to everything. This has some nice code cleanliness benefits.

---
 compile_lib.sh          |   2 +-
 lib/collections.nom     |  22 ++++----
 lib/control_flow.nom    |  24 ++++-----
 lib/math.nom            |  18 +++----
 lib/metaprogramming.nom |  52 +++++++++---------
 lib/operators.nom       |   4 +-
 lib/text.nom            |   4 +-
 nomsu.lua               | 115 +++++++++++++++++++++++++++-------------
 nomsu.moon              |  87 ++++++++++++++++--------------
 utils.lua               |  11 ++--
 10 files changed, 194 insertions(+), 145 deletions(-)

diff --git a/compile_lib.sh b/compile_lib.sh
index 6e4e78a..5757b6e 100755
--- a/compile_lib.sh
+++ b/compile_lib.sh
@@ -16,7 +16,7 @@ if [ "$FLUSH" = true ] ; then
     done
 fi
 
-for file in $(cat lib/core.nom | lua -e "for filename in io.read('*a'):gmatch('require \"([^\"]*)\"') do print(filename) end") ; do
+for file in $(cat lib/core.nom | lua -e "for filename in io.read('*a'):gmatch('use \"([^\"]*)\"') do print(filename) end") ; do
     compilefile="${file/\.nom/.lua}"
     if [ ! -e "$compilefile" ] || [ "$file" -nt "$compilefile" ] ; then
         echo "Compiling $file into $compilefile"
diff --git a/lib/collections.nom b/lib/collections.nom
index 52e6675..376b861 100644
--- a/lib/collections.nom
+++ b/lib/collections.nom
@@ -16,7 +16,7 @@ parse [..]
 compile [..]
     %index st to last in %list, %index nd to last in %list, %index rd to last in %list
     %index th to last in %list
-..to: "nomsu.utils.nth_to_last(\(%list as lua), \(%index as lua))"
+..to: "utils.nth_to_last(\(%list as lua), \(%index as lua))"
 
 parse [first in %list, first %list] as: 1 st in %list
 parse [last in %list, last %list] as: 1 st to last in %list
@@ -45,7 +45,7 @@ compile [..]
 ..to: "((\(%list as lua))[\(%index as lua)] ~= nil)"
 
 compile [length of %list, size of %list, size %list, number of %list, len %list] to:
-    "nomsu.utils.size(\(%list as lua))"
+    "utils.size(\(%list as lua))"
 
 # Chained lookup
 compile [%list ->* %indices] to:
@@ -99,13 +99,13 @@ immediately:
         assume ((%item's "type") is "Var") or barf ".."
             List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
         return ".."
-            (function(nomsu);
+            (function();
                 local comprehension = {};
                 for i,\(%item as lua) in ipairs(\(%iterable as lua)) do;
                     comprehension[i] = \(%expression as lua);
                 end;
                 return comprehension;
-            end)(nomsu)
+            end)()
     parse [%expression for all %iterable] as: %expression for % in %iterable
 
     compile [%expression for %key = %value in %iterable] to:
@@ -114,13 +114,13 @@ immediately:
         assume ((%value's "type") is "Var") or barf ".."
             List comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%value's "type")
         return ".."
-            (function(nomsu);
+            (function();
                 local comprehension = {};
                 for \(%key as lua), \(%value as lua) in pairs(\(%iterable as lua)) do;
                     comprehension[i] = \(%expression as lua);
                 end;
                 return comprehension;
-            end)(nomsu)
+            end)()
 
 # Dict comprehensions
 immediately:
@@ -128,13 +128,13 @@ immediately:
         assume ((%item's "type") is "Var") or barf ".."
             Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item's "type")
         return ".."
-            (function(nomsu);
+            (function();
                 local comprehension = {};
                 for i,\(%item as lua) in ipairs(\(%iterable as lua)) do;
                     comprehension[\(%key as lua)] = \(%value as lua);
                 end;
                 return comprehension;
-            end)(nomsu)
+            end)()
     parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
 
     compile [%key = %value for %src_key = %src_value in %iterable] to:
@@ -143,18 +143,18 @@ immediately:
         assume ((%src_value's "type") is "Var") or barf ".."
             Dict comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%src_value's "type")
         return ".."
-            (function(nomsu);
+            (function();
                 local comprehension = {};
                 for \(%src_key as lua), \(%src_value as lua) in pairs(\(%iterable as lua)) do;
                     comprehension[\(%key as lua)] = \(%value as lua);
                 end;
                 return comprehension;
-            end)(nomsu)
+            end)()
 
 # Sorting:
 compile [sort %items] to: "table.sort(\(%items as lua))"
 compile [sort %items by %key_expr] to: ".."
-    nomsu.utils.sort(\(%items as lua), function(\(\% as lua))
+    utils.sort(\(%items as lua), function(\(\% as lua))
         return \(%key_expr as lua);
     end)
 
diff --git a/lib/control_flow.nom b/lib/control_flow.nom
index f2500c5..1510903 100644
--- a/lib/control_flow.nom
+++ b/lib/control_flow.nom
@@ -50,13 +50,13 @@ immediately:
                 doesn't have a proper ternary operator!)
                 To see why this is necessary consider: (random()<.5 and false or 99)
             return ".."
-                (function(nomsu)
+                (function()
                     if \(%condition as lua) then
                         return \(%when_true_expr as lua);
                     else
                         return \(%when_false_expr as lua);
                     end
-                end)(nomsu)
+                end)()
 
 # GOTOs
 immediately:
@@ -344,10 +344,10 @@ immediately:
     ..to code: ".."
         do
             local fell_through = false;
-            local ok, ret = pcall(function(nomsu)
+            local ok, ret = pcall(function()
                 \(%action as lua statements)
                 fell_through = true;
-            end, nomsu);
+            end);
             if ok then
                 \(%success as lua statements)
             end
@@ -375,15 +375,15 @@ immediately:
     compile [do %action then always %final_action] to code: ".."
         do
             local fell_through = false;
-            local ok, ret1 = pcall(function(nomsu)
+            local ok, ret1 = pcall(function()
                 \(%action as lua statements)
                 fell_through = true;
-            end, nomsu);
-            local ok2, ret2 = pcall(function(nomsu)
+            end);
+            local ok2, ret2 = pcall(function()
                 \(%final_action as lua statements)
-            end, nomsu);
-            if not ok then nomsu:error(ret1); end
-            if not ok2 then nomsu:error(ret2); end
+            end);
+            if not ok then error(ret1); end
+            if not ok2 then error(ret2); end
             if not fell_through then
                 return ret1;
             end
@@ -402,12 +402,12 @@ immediately:
                 local \(join %temp_vars with ", ") = \(join %old_vals with ", ");
                 \(join %old_vals with ", ") = \(join %new_vals with ", ");
                 local fell_through = false;
-                local ok, ret = pcall(function(nomsu)
+                local ok, ret = pcall(function()
                     do
                         \(%action as lua statements)
                     end
                     fell_through = true;
-                end, nomsu);
+                end);
                 \(join %old_vals with ", ") = \(join %temp_vars with ", ");
                 if not ok then error(ret, 0); end
                 if not fell_through then return ret end
diff --git a/lib/math.nom b/lib/math.nom
index 85e8ac5..9e9af98 100644
--- a/lib/math.nom
+++ b/lib/math.nom
@@ -38,30 +38,30 @@ action [%n to the nearest %rounder]:
 # Any/all/none
 compile [all of %items, all %items] to:
     "(\(join ((% as lua) for all (%items' "value")) with " and "))"
-    ..if ((%items' "type") is "List") else "nomsu.utils.all(\(%items as lua))"
+    ..if ((%items' "type") is "List") else "utils.all(\(%items as lua))"
 parse [not all of %items, not all %items] as: not (all of %items)
 compile [any of %items, any %items] to:
     "(\(join ((% as lua) for all (%items' "value")) with " or "))"
-    ..if ((%items' "type") is "List") else "nomsu.utils.any(\(%items as lua))"
+    ..if ((%items' "type") is "List") else "utils.any(\(%items as lua))"
 parse [none of %items, none %items] as: not (any of %items)
 compile [sum of %items, sum %items] to:
     "(\(join ((% as lua) for all (%items' "value")) with " + "))"
-    ..if ((%items' "type") is "List") else "nomsu.utils.sum(\(%items as lua))"
+    ..if ((%items' "type") is "List") else "utils.sum(\(%items as lua))"
 compile [product of %items, product %items] to:
     "(\(join ((% as lua) for all (%items' "value")) with " * "))"
-    ..if ((%items' "type") is "List") else "nomsu.utils.product(\(%items as lua))"
+    ..if ((%items' "type") is "List") else "utils.product(\(%items as lua))"
 action [avg of %items, average of %items]:
-    =lua "(nomsu.utils.sum(\%items)/#\%items)"
+    =lua "(utils.sum(\%items)/#\%items)"
 compile [min of %items, smallest of %items, lowest of %items] to:
-    "nomsu.utils.min(\(%items as lua))"
+    "utils.min(\(%items as lua))"
 compile [max of %items, biggest of %items, largest of %items, highest of %items] to:
-    "nomsu.utils.max(\(%items as lua))"
+    "utils.max(\(%items as lua))"
 compile [min of %items by %value_expr] to: ".."
-    nomsu.utils.min(\(%items as lua), function(\(\% as lua))
+    utils.min(\(%items as lua), function(\(\% as lua))
         return \(%value_expr as lua)
     end)
 compile [max of %items by %value_expr] to: ".."
-    nomsu.utils.max(\(%items as lua), function(\(\% as lua))
+    utils.max(\(%items as lua), function(\(\% as lua))
         return \(%value_expr as lua)
     end)
 
diff --git a/lib/metaprogramming.nom b/lib/metaprogramming.nom
index 55e9bea..aee5b67 100644
--- a/lib/metaprogramming.nom
+++ b/lib/metaprogramming.nom
@@ -11,19 +11,19 @@ immediately:
                 names[i] = alias.src;
             end
             local _, arg_names, _ = nomsu:get_stub(spec.value[1]);
-            local args = {"nomsu"};
-            for i, a in ipairs(arg_names) do args[i+1] = "_"..nomsu:var_to_lua_identifier(a); end
-            names, args = nomsu:repr(names), table.concat(args, ", ");
+            local args = {};
+            for i, a in ipairs(arg_names) do args[i] = "_"..nomsu:var_to_lua_identifier(a); end
+            names, args = repr(names), table.concat(args, ", ");
             return names, args;
         end
 
 # Compile-time action to make compile-time actions:
 immediately:
     lua> ".."
-        nomsu:define_compile_action("compile %names to %body", \(__line_no__), function(nomsu, \%names, \%body)
-            nomsu:assert(\%names.type == "List",
+        nomsu:define_compile_action("compile %names to %body", \(__line_no__), function(\%names, \%body)
+            assert(\%names.type == "List",
                 "Invalid type for compile definition names. Expected List, but got: "..tostring(\%names.type));
-            nomsu:assert(\%body.type == "Block",
+            assert(\%body.type == "Block",
                 "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
             local names, args = nomsu:parse_spec(\%names);
             local body_lua = nomsu:tree_to_lua(\%body);
@@ -35,16 +35,16 @@ immediately:
             end
             local function compile_action_wrapper(...) return {expr=compile_action(...)}; end
             nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s);
-        end]]):format(args, body_lua, names, nomsu:repr(\%names:get_line_no()),
-            nomsu:repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src)));
+        end]]):format(args, body_lua, names, repr(\%names:get_line_no()),
+            repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src)));
             return {statements=lua};
         end, \(__src__ 1));
 
     lua> ".."
-        nomsu:define_compile_action("compile %names to code %body", \(__line_no__), function(nomsu, \%names, \%body)
-            nomsu:assert(\%names.type == "List",
+        nomsu:define_compile_action("compile %names to code %body", \(__line_no__), function(\%names, \%body)
+            assert(\%names.type == "List",
                 "Invalid type for compile definition names. Expected List, but got: "..tostring(\%names.type));
-            nomsu:assert(\%body.type == "Block",
+            assert(\%body.type == "Block",
                 "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
             local names, args = nomsu:parse_spec(\%names);
             local body_lua = nomsu:tree_to_lua(\%body);
@@ -56,8 +56,8 @@ immediately:
             end
             local function compile_action_wrapper(...) return {statements=compile_action(...)}; end
             nomsu:define_compile_action(%s, %s, compile_action_wrapper, %s);
-        end]]):format(args, body_lua, names, nomsu:repr(\%names:get_line_no()),
-            nomsu:repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src)));
+        end]]):format(args, body_lua, names, repr(\%names:get_line_no()),
+            repr(("compile %s\\n..to code %s"):format(\%names.src, \%body.src)));
             return {statements=lua};
         end, \(__src__ 1));
 
@@ -65,9 +65,9 @@ immediately:
 immediately:
     compile [action %names %body] to code:
         lua> ".."
-            nomsu:assert(\%names.type == "List",
+            assert(\%names.type == "List",
                 "Invalid type for action definition names. Expected List, but got: "..tostring(\%names.type));
-            nomsu:assert(\%body.type == "Block",
+            assert(\%body.type == "Block",
                 "Invalid type for action definition body. Expected Block, but got: "..tostring(\%body.type));
             local names, args = nomsu:parse_spec(\%names);
             local body_lua = nomsu:tree_to_lua(\%body);
@@ -76,34 +76,34 @@ immediately:
             local def_lua = ([[
             nomsu:define_action(%s, \(__line_no__), function(%s)
                 %s
-            end, %s);]]):format(names, args, body_lua, nomsu:repr(src));
+            end, %s);]]):format(names, args, body_lua, repr(src));
             return def_lua;
 
 # Macro to make nomsu macros:
 immediately:
     lua> ".."
-        nomsu:define_compile_action("parse %shorthand as %longhand", \(__line_no__), (function(nomsu, \%shorthand, \%longhand)
-            nomsu:assert(\%shorthand.type == "List",
+        nomsu:define_compile_action("parse %shorthand as %longhand", \(__line_no__), (function(\%shorthand, \%longhand)
+            assert(\%shorthand.type == "List",
                 "Invalid type for parse definition shorthand. Expected List, but got: "..tostring(\%shorthand.type));
-            nomsu:assert(\%longhand.type == "Block",
+            assert(\%longhand.type == "Block",
                 "Invalid type for parse definition body. Expected Block, but got: "..tostring(\%longhand.type));
             local names, args = nomsu:parse_spec(\%shorthand);
             local template = {};
             for i, line in ipairs(\%longhand.value) do
                 template[i] = nomsu:dedent(line.src);
             end
-            template = nomsu:repr(table.concat(template, "\\n"));
+            template = repr(table.concat(template, "\\n"));
             local _, arg_names, _ = nomsu:get_stub(\%shorthand.value[1]);
             local replacements = {};
-            for i, a in ipairs(arg_names) do replacements[i] = "["..nomsu:repr(a).."]=_"..nomsu:var_to_lua_identifier(a); end
+            for i, a in ipairs(arg_names) do replacements[i] = "["..repr(a).."]=_"..nomsu:var_to_lua_identifier(a); end
             replacements = "{"..table.concat(replacements, ", ").."}";
             local lua_code = ([[
         nomsu:define_compile_action(%s, %s, (function(%s)
             local template = nomsu:parse(%s, %s);
             local replacement = nomsu:replaced_vars(template, %s);
             return nomsu:tree_to_lua(replacement);
-        end), %s)]]):format(names, nomsu:repr(\%shorthand:get_line_no()), args, template,
-            nomsu:repr(\%shorthand:get_line_no()), replacements, nomsu:repr(nomsu:source_code(0)));
+        end), %s)]]):format(names, repr(\%shorthand:get_line_no()), args, template,
+            repr(\%shorthand:get_line_no()), replacements, repr(nomsu:source_code(0)));
             return {statements=lua_code};
         end), \(__src__ 1));
 
@@ -124,7 +124,7 @@ immediately:
     action [%tree as value]:
         =lua "nomsu:tree_to_value(\%tree)"
     compile [repr %obj] to:
-        "nomsu:repr(\(%obj as lua))"
+        "repr(\(%obj as lua))"
     compile [indented %obj] to:
         "nomsu:indent(\(%obj as lua))"
     compile [dedented %obj] to:
@@ -153,7 +153,7 @@ action [help %action]:
     lua> ".."
         local fn_def = nomsu.defs[nomsu:get_stub(\%action)]
         if not fn_def then
-            nomsu:writeln("Action not found: "..nomsu:repr(\%action));
+            nomsu:writeln("Action not found: "..repr(\%action));
         else
             nomsu:writeln(fn_def.src or "<unknown source code>");
         end
@@ -182,7 +182,7 @@ compile [say %str] to:
         if \%str.type == "Text" then
             return "nomsu:writeln("..\(%str as lua)..")";
         else
-            return "nomsu:writeln(nomsu:stringify("..\(%str as lua).."))";
+            return "nomsu:writeln(stringify("..\(%str as lua).."))";
         end
 
 # Error functions
diff --git a/lib/operators.nom b/lib/operators.nom
index 89f940e..b697aad 100644
--- a/lib/operators.nom
+++ b/lib/operators.nom
@@ -20,7 +20,7 @@ immediately:
             if safe[\%a.type] or safe[\%b.type] then
                 return "("..a_lua.." == "..b_lua..")";
             else
-                return "nomsu.utils.equivalent("..a_lua..", "..b_lua..")";
+                return "utils.equivalent("..a_lua..", "..b_lua..")";
             end
     compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to:
         lua> ".."
@@ -29,7 +29,7 @@ immediately:
             if safe[\%a.type] or safe[\%b.type] then
                 return "("..a_lua.." ~= "..b_lua..")";
             else
-                return "(not nomsu.utils.equivalent("..a_lua..", "..b_lua.."))";
+                return "(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: "nomsu.ids[\(% as lua)]"
diff --git a/lib/text.nom b/lib/text.nom
index 7c06d07..a1331ef 100644
--- a/lib/text.nom
+++ b/lib/text.nom
@@ -8,7 +8,7 @@ use "lib/metaprogramming.nom"
 action [join %strs with %glue]:
     lua> ".."
         local str_bits = {}
-        for i,bit in ipairs(\%strs) do str_bits[i] = nomsu:stringify(bit) end
+        for i,bit in ipairs(\%strs) do str_bits[i] = stringify(bit) end
         return table.concat(str_bits, \%glue)
 parse [join %strs] as: join %strs with ""
 
@@ -49,7 +49,7 @@ lua do> ".."
         local color = "'"..c.."'";
         local reset = "'"..colors["reset color"].."'";
         nomsu:define_compile_action(name, \(__line_no__), function() return {expr=color}; end, \(__src__ 1));
-        nomsu:define_compile_action(name.." %", \(__line_no__), function(nomsu, _)
+        nomsu:define_compile_action(name.." %", \(__line_no__), function(_)
             return {expr=color..".."..nomsu:tree_to_lua(_).expr..".."..reset};
         end, \(__src__ 1));
     end
diff --git a/nomsu.lua b/nomsu.lua
index 04d74c0..4aa80a8 100644
--- a/nomsu.lua
+++ b/nomsu.lua
@@ -442,7 +442,10 @@ do
     end,
     run_file = function(self, filename)
       if filename:match(".*%.lua") then
-        return dofile(filename)(self)
+        local file = io.open(filename)
+        local contents = file:read("*a")
+        file:close()
+        return assert(load(contents, nil, nil, self.environment))()
       end
       if filename:match(".*%.nom") then
         if not self.skip_precompiled then
@@ -472,13 +475,11 @@ do
       return loaded[filename]
     end,
     run_lua = function(self, lua_code)
-      local load_lua_fn, err = load(([[return function(nomsu)
-    %s
-end]]):format(lua_code))
+      local run_lua_fn, err = load(lua_code, nil, nil, self.environment)
       if self.debug then
         self:writeln(tostring(colored.bright("RUNNING LUA:")) .. "\n" .. tostring(colored.blue(colored.bright(lua_code))))
       end
-      if not load_lua_fn then
+      if not run_lua_fn then
         local n = 1
         local fn
         fn = function()
@@ -488,21 +489,18 @@ end]]):format(lua_code))
         local code = "1  |" .. lua_code:gsub("\n", fn)
         self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(err))
       end
-      local run_lua_fn = load_lua_fn()
-      run_lua_fn(self)
-      return ret
+      return run_lua_fn()
     end,
     tree_to_value = function(self, tree, filename)
-      local code = "return (function(nomsu)\nreturn " .. tostring(self:tree_to_lua(tree).expr) .. ";\nend);"
-      code = "-- Tree to value: " .. tostring(filename) .. "\n" .. code
+      local code = "return " .. tostring(self:tree_to_lua(tree).expr) .. ";"
       if self.debug then
         self:writeln(tostring(colored.bright("RUNNING LUA TO GET VALUE:")) .. "\n" .. tostring(colored.blue(colored.bright(code))))
       end
-      local lua_thunk, err = load(code)
+      local lua_thunk, err = load(code, nil, nil, self.environment)
       if not lua_thunk then
         self:error("Failed to compile generated code:\n" .. tostring(colored.bright(colored.blue(colored.onblack(code)))) .. "\n\n" .. tostring(colored.red(err)))
       end
-      return (lua_thunk())(self)
+      return lua_thunk()
     end,
     tree_to_nomsu = function(self, tree, force_inline)
       if force_inline == nil then
@@ -780,7 +778,7 @@ end]]):format(lua_code))
               return _accum_0
             end)()))))
           end
-          local lua = self.defs[tree.stub].fn(self, unpack(args))
+          local lua = self.defs[tree.stub].fn(unpack(args))
           remove(self.compilestack)
           return lua
         elseif not def and self.__class.math_patt:match(tree.stub) then
@@ -836,7 +834,6 @@ end]]):format(lua_code))
           end
           args = new_args
         end
-        insert(args, 1, "nomsu")
         remove(self.compilestack)
         return {
           expr = self.__class:comma_separated_items("nomsu.defs[" .. tostring(repr(tree.stub)) .. "].fn(", args, ")")
@@ -1164,8 +1161,9 @@ end]]):format(lua_code))
       return self:dedent(self.compilestack[#self.compilestack - level].src)
     end,
     initialize_core = function(self)
+      local nomsu = self
       local nomsu_string_as_lua
-      nomsu_string_as_lua = function(self, code)
+      nomsu_string_as_lua = function(code)
         local concat_parts = { }
         local _list_0 = code.value
         for _index_0 = 1, #_list_0 do
@@ -1173,65 +1171,65 @@ end]]):format(lua_code))
           if type(bit) == "string" then
             insert(concat_parts, bit)
           else
-            local lua = self:tree_to_lua(bit)
+            local lua = nomsu:tree_to_lua(bit)
             if lua.statements then
-              self:error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
+              error("Cannot use [[" .. tostring(bit.src) .. "]] as a string interpolation value, since it's not an expression.")
             end
             insert(concat_parts, lua.expr)
           end
         end
         return concat(concat_parts)
       end
-      self:define_compile_action("do %block", "nomsu.moon", function(self, _block)
+      self:define_compile_action("do %block", "nomsu.moon", function(_block)
         local make_line
         make_line = function(lua)
           return lua.expr and (lua.expr .. ";") or lua.statements
         end
         if _block.type == "Block" then
-          return self:tree_to_lua(_block)
+          return nomsu:tree_to_lua(_block)
         else
           return {
-            expr = tostring(self:tree_to_lua(_block)) .. "(nomsu)"
+            expr = tostring(nomsu:tree_to_lua(_block)) .. "(nomsu)"
           }
         end
       end)
-      self:define_compile_action("immediately %block", "nomsu.moon", function(self, _block)
-        local lua = self:tree_to_lua(_block)
+      self:define_compile_action("immediately %block", "nomsu.moon", function(_block)
+        local lua = nomsu:tree_to_lua(_block)
         local lua_code = lua.statements or (lua.expr .. ";")
         lua_code = "-- Immediately:\n" .. lua_code
-        self:run_lua(lua_code)
+        nomsu:run_lua(lua_code)
         return {
           statements = lua_code
         }
       end)
-      self:define_compile_action("lua> %code", "nomsu.moon", function(self, _code)
-        local lua = nomsu_string_as_lua(self, _code)
+      self:define_compile_action("lua> %code", "nomsu.moon", function(_code)
+        local lua = nomsu_string_as_lua(_code)
         return {
           statements = lua
         }
       end)
-      self:define_compile_action("=lua %code", "nomsu.moon", function(self, _code)
-        local lua = nomsu_string_as_lua(self, _code)
+      self:define_compile_action("=lua %code", "nomsu.moon", function(_code)
+        local lua = nomsu_string_as_lua(_code)
         return {
           expr = lua
         }
       end)
-      self:define_compile_action("__line_no__", "nomsu.moon", function(self)
+      self:define_compile_action("__line_no__", "nomsu.moon", function()
         return {
-          expr = repr(self.compilestack[#self.compilestack]:get_line_no())
+          expr = repr(nomsu.compilestack[#nomsu.compilestack]:get_line_no())
         }
       end)
-      self:define_compile_action("__src__ %level", "nomsu.moon", function(self, _level)
+      self:define_compile_action("__src__ %level", "nomsu.moon", function(_level)
         return {
-          expr = repr(self:source_code(self:tree_to_value(_level)))
+          expr = repr(nomsu:source_code(nomsu:tree_to_value(_level)))
         }
       end)
-      self:define_action("run file %filename", "nomsu.moon", function(self, _filename)
-        return self:run_file(_filename)
+      self:define_action("run file %filename", "nomsu.moon", function(_filename)
+        return nomus:run_file(_filename)
       end)
-      return self:define_compile_action("use %filename", "nomsu.moon", function(self, _filename)
-        local filename = self:tree_to_value(_filename)
-        self:require_file(filename)
+      return self:define_compile_action("use %filename", "nomsu.moon", function(_filename)
+        local filename = nomsu:tree_to_value(_filename)
+        nomsu:require_file(filename)
         return {
           statements = "nomsu:require_file(" .. tostring(repr(filename)) .. ");"
         }
@@ -1272,13 +1270,56 @@ end]]):format(lua_code))
       end
       self.compilestack = { }
       self.debug = false
-      self.utils = utils
       self.repr = function(self, ...)
         return repr(...)
       end
       self.stringify = function(self, ...)
         return stringify(...)
       end
+      self.environment = {
+        nomsu = self,
+        repr = repr,
+        stringify = stringify,
+        utils = utils,
+        lpeg = lpeg,
+        re = re,
+        next = next,
+        unpack = unpack,
+        setmetatable = setmetatable,
+        coroutine = coroutine,
+        rawequal = rawequal,
+        getmetatable = getmetatable,
+        pcall = pcall,
+        error = error,
+        package = package,
+        os = os,
+        require = require,
+        tonumber = tonumber,
+        tostring = tostring,
+        string = string,
+        xpcall = xpcall,
+        module = module,
+        print = print,
+        loadfile = loadfile,
+        rawset = rawset,
+        _VERSION = _VERSION,
+        collectgarbage = collectgarbage,
+        rawget = rawget,
+        bit32 = bit32,
+        rawlen = rawlen,
+        table = table,
+        assert = assert,
+        dofile = dofile,
+        loadstring = loadstring,
+        type = type,
+        select = select,
+        debug = debug,
+        math = math,
+        io = io,
+        pairs = pairs,
+        load = load,
+        ipairs = ipairs
+      }
       if not parent then
         return self:initialize_core()
       end
diff --git a/nomsu.moon b/nomsu.moon
index c37f8e0..ac5fa32 100755
--- a/nomsu.moon
+++ b/nomsu.moon
@@ -164,9 +164,17 @@ class NomsuCompiler
             setmetatable(@defs["#loaded_files"], {__index:parent["#loaded_files"]})
         @compilestack = {}
         @debug = false
-        @utils = utils
-        @repr = (...)=> repr(...)
-        @stringify = (...)=> stringify(...)
+
+        @environment = {
+            -- Discretionary/convenience stuff
+            nomsu:self, repr:repr, stringify:stringify, utils:utils, lpeg:lpeg, re:re,
+            -- Lua stuff:
+            :next, :unpack, :setmetatable, :coroutine, :rawequal, :getmetatable, :pcall,
+            :error, :package, :os, :require, :tonumber, :tostring, :string, :xpcall, :module,
+            :print, :loadfile, :rawset, :_VERSION, :collectgarbage, :rawget, :bit32, :rawlen,
+            :table, :assert, :dofile, :loadstring, :type, :select, :debug, :math, :io, :pairs,
+            :load, :ipairs,
+        }
         if not parent
             @initialize_core!
     
@@ -303,7 +311,10 @@ class NomsuCompiler
 
     run_file: (filename)=>
         if filename\match(".*%.lua")
-            return dofile(filename)(@)
+            file = io.open(filename)
+            contents = file\read("*a")
+            file\close!
+            return assert(load(contents, nil, nil, @environment))!
         if filename\match(".*%.nom")
             if not @skip_precompiled -- Look for precompiled version
                 file = io.open(filename\gsub("%.nom", ".lua"), "r")
@@ -327,32 +338,26 @@ class NomsuCompiler
         return loaded[filename]
 
     run_lua: (lua_code)=>
-        load_lua_fn, err = load([[
-return function(nomsu)
-    %s
-end]]\format(lua_code))
+        run_lua_fn, err = load(lua_code, nil, nil, @environment)
         if @debug
             @writeln "#{colored.bright "RUNNING LUA:"}\n#{colored.blue colored.bright(lua_code)}"
-        if not load_lua_fn
+        if not run_lua_fn
             n = 1
             fn = ->
                 n = n + 1
                 ("\n%-3d|")\format(n)
             code = "1  |"..lua_code\gsub("\n", fn)
             @error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{err}")
-        run_lua_fn = load_lua_fn!
-        run_lua_fn(self)
-        return ret
+        return run_lua_fn!
     
     tree_to_value: (tree, filename)=>
-        code = "return (function(nomsu)\nreturn #{@tree_to_lua(tree).expr};\nend);"
-        code = "-- Tree to value: #{filename}\n"..code
+        code = "return #{@tree_to_lua(tree).expr};"
         if @debug
             @writeln "#{colored.bright "RUNNING LUA TO GET VALUE:"}\n#{colored.blue colored.bright(code)}"
-        lua_thunk, err = load(code)
+        lua_thunk, err = load(code, nil, nil, @environment)
         if not lua_thunk
             @error("Failed to compile generated code:\n#{colored.bright colored.blue colored.onblack code}\n\n#{colored.red err}")
-        return (lua_thunk!)(self)
+        return lua_thunk!
 
     tree_to_nomsu: (tree, force_inline=false)=>
         -- Return <nomsu code>, <is safe for inline use>
@@ -527,7 +532,7 @@ end]]\format(lua_code))
                     if @debug
                         @write "#{colored.bright "RUNNING MACRO"} #{colored.underscore colored.magenta(tree.stub)} "
                         @writeln "#{colored.bright "WITH ARGS:"} #{colored.dim repr [(repr a)\sub(1,50) for a in *args]}"
-                    lua = @defs[tree.stub].fn(self, unpack(args))
+                    lua = @defs[tree.stub].fn(unpack(args))
                     remove @compilestack
                     return lua
                 elseif not def and @@math_patt\match(tree.stub)
@@ -557,7 +562,6 @@ end]]\format(lua_code))
                     new_args = [args[p] for p in *def.arg_positions]
                     args = new_args
                 
-                insert args, 1, "nomsu"
                 remove @compilestack
                 return expr:@@comma_separated_items("nomsu.defs[#{repr tree.stub}].fn(", args, ")")
 
@@ -578,7 +582,7 @@ end]]\format(lua_code))
                         @writeln "#{colored.bright "EXPR:"} #{lua.expr}, #{colored.bright "STATEMENT:"} #{lua.statements}"
                     if lua.statements
                         @error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
-                    insert concat_parts, "nomsu:stringify(#{lua.expr})"
+                    insert concat_parts, "stringify(#{lua.expr})"
 
                 if string_buffer ~= ""
                     insert concat_parts, repr(string_buffer)
@@ -759,52 +763,53 @@ end]]\format(lua_code))
 
     initialize_core: =>
         -- Sets up some core functionality
-        nomsu_string_as_lua = (code)=>
+        nomsu = self
+        nomsu_string_as_lua = (code)->
             concat_parts = {}
             for bit in *code.value
                 if type(bit) == "string"
                     insert concat_parts, bit
                 else
-                    lua = @tree_to_lua bit
+                    lua = nomsu\tree_to_lua bit
                     if lua.statements
-                        @error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
+                        error "Cannot use [[#{bit.src}]] as a string interpolation value, since it's not an expression."
                     insert concat_parts, lua.expr
             return concat(concat_parts)
 
-        @define_compile_action "do %block", "nomsu.moon", (_block)=>
+        @define_compile_action "do %block", "nomsu.moon", (_block)->
             make_line = (lua)-> lua.expr and (lua.expr..";") or lua.statements
             if _block.type == "Block"
-                return @tree_to_lua(_block)
+                return nomsu\tree_to_lua(_block)
             else
-                return expr:"#{@tree_to_lua _block}(nomsu)"
+                return expr:"#{nomsu\tree_to_lua _block}(nomsu)"
         
-        @define_compile_action "immediately %block", "nomsu.moon", (_block)=>
-            lua = @tree_to_lua(_block)
+        @define_compile_action "immediately %block", "nomsu.moon", (_block)->
+            lua = nomsu\tree_to_lua(_block)
             lua_code = lua.statements or (lua.expr..";")
             lua_code = "-- Immediately:\n"..lua_code
-            @run_lua(lua_code)
+            nomsu\run_lua(lua_code)
             return statements:lua_code
 
-        @define_compile_action "lua> %code", "nomsu.moon", (_code)=>
-            lua = nomsu_string_as_lua(@, _code)
+        @define_compile_action "lua> %code", "nomsu.moon", (_code)->
+            lua = nomsu_string_as_lua(_code)
             return statements:lua
 
-        @define_compile_action "=lua %code", "nomsu.moon", (_code)=>
-            lua = nomsu_string_as_lua(@, _code)
+        @define_compile_action "=lua %code", "nomsu.moon", (_code)->
+            lua = nomsu_string_as_lua(_code)
             return expr:lua
 
-        @define_compile_action "__line_no__", "nomsu.moon", ()=>
-            expr: repr(@compilestack[#@compilestack]\get_line_no!)
+        @define_compile_action "__line_no__", "nomsu.moon", ->
+            expr: repr(nomsu.compilestack[#nomsu.compilestack]\get_line_no!)
 
-        @define_compile_action "__src__ %level", "nomsu.moon", (_level)=>
-            expr: repr(@source_code(@tree_to_value(_level)))
+        @define_compile_action "__src__ %level", "nomsu.moon", (_level)->
+            expr: repr(nomsu\source_code(nomsu\tree_to_value(_level)))
 
-        @define_action "run file %filename", "nomsu.moon", (_filename)=>
-            @run_file(_filename)
+        @define_action "run file %filename", "nomsu.moon", (_filename)->
+            nomus\run_file(_filename)
 
-        @define_compile_action "use %filename", "nomsu.moon", (_filename)=>
-            filename = @tree_to_value(_filename)
-            @require_file(filename)
+        @define_compile_action "use %filename", "nomsu.moon", (_filename)->
+            filename = nomsu\tree_to_value(_filename)
+            nomsu\require_file(filename)
             return statements:"nomsu:require_file(#{repr filename});"
 
 if arg
diff --git a/utils.lua b/utils.lua
index 1e77965..9dee6d7 100644
--- a/utils.lua
+++ b/utils.lua
@@ -42,9 +42,12 @@ local _quote_patt = re.compile("(({'\n' / '\"' / \"'\" / '\\'}->mark_char) / (']
     mark_eq=function(eq)
         _quote_state.min_eq = max(_quote_state.min_eq or 0, #eq+1)
     end})
-local function repr(x)
+local function repr(x, depth)
     -- Create a string representation of the object that is close to the lua code that will
     -- reproduce the object (similar to Python's "repr" function)
+    depth = depth or 10
+    if depth == 0 then return "..." end
+    depth = depth - 1
     local x_type = type(x)
     if x_type == 'table' then
         if getmetatable(x) then
@@ -55,12 +58,12 @@ local function repr(x)
             local i = 1
             for k, v in pairs(x) do
                 if k == i then
-                    ret[#ret+1] = repr(x[i])
+                    ret[#ret+1] = repr(x[i], depth)
                     i = i + 1
                 elseif type(k) == 'string' and k:match("[_a-zA-Z][_a-zA-Z0-9]*") then
-                    ret[#ret+1] = k.."= "..repr(v)
+                    ret[#ret+1] = k.."= "..repr(v,depth)
                 else
-                    ret[#ret+1] = "["..repr(k).."]= "..repr(v)
+                    ret[#ret+1] = "["..repr(k,depth).."]= "..repr(v,depth)
                 end
             end
             return "{"..table.concat(ret, ", ").."}"