Removed the mandatory "_" prefix for Nomsu variables, renamed "list" and

"dict" to "List" and "Dict", or in Nomsu's environment, "_List" and
"_Dict", removed uuid.lua and replaced it with core/id.nom for handling
IDs.

Makefile

@@ -13,7 +13,7 @@ UNINSTALL_VERSION=
 MOON_FILES= code_obj.moon error_handling.moon files.moon nomsu.moon nomsu_compiler.moon \
 			syntax_tree.moon parser.moon containers.moon bitops.moon
 LUA_FILES= code_obj.lua consolecolors.lua error_handling.lua files.lua nomsu.lua nomsu_compiler.lua \
-		   syntax_tree.lua parser.lua containers.lua bitops.lua utils.lua uuid.lua
+		   syntax_tree.lua parser.lua containers.lua bitops.lua utils.lua
 CORE_NOM_FILES= $(wildcard core/*.nom)
 CORE_LUA_FILES= $(patsubst %.nom,%.lua,$(CORE_NOM_FILES))
 LIB_NOM_FILES= $(wildcard lib/*.nom)

README.md

@@ -53,7 +53,6 @@ All `.moon` files have been precompiled into corresponding `.lua` files, so you
 * [code\_obj.moon](code_obj.moon) - Datastructures used for incrementally building generated code, while preserving code origins.
 * [error\_handling.moon](error_handling.moon) - The logic for producing good error messages within Lua that reference the Nomsu source code that led to them.
 * [utils.lua](utils.lua) - A set of utility actions used by nomsu.moon.
-* [uuid.lua](uuid.lua) - A simple Universally Unique Identifier implementation (RFC 4122) used internally to give each object a randomized unique ID.
 * [consolecolors.lua](consolecolors.lua) - Lua module that defines ANSI color codes for colored console output (used internally in nomsu.moon).
 * [examples/how\_do\_i.nom](examples/how_do_i.nom) - A simple walkthrough of some of the features of Nomsu, written in Nomsu code. **This is a good place to start.**
 * [core/\*.nom](core) - Core language definitions of stuff like control flow, operators, and metaprogramming, broken down into different files.

containers.lua

@@ -8,7 +8,7 @@ do
   local _obj_0 = require('utils')
   repr, stringify, equivalent, nth_to_last, size = _obj_0.repr, _obj_0.stringify, _obj_0.equivalent, _obj_0.nth_to_last, _obj_0.size
 end
-local list, dict
+local List, Dict
 local _list_mt = {
   __eq = equivalent,
   __tostring = function(self)
@@ -54,7 +54,7 @@ local _list_mt = {
     return true
   end,
   __add = function(self, other)
-    local ret = list((function()
+    local ret = List((function()
       local _accum_0 = { }
       local _len_0 = 1
       for _index_0 = 1, #self do
@@ -113,7 +113,7 @@ local _list_mt = {
     return rawset(self, k, v)
   end
 }
-list = function(t)
+List = function(t)
   return setmetatable(t, _list_mt)
 end
 local walk_items
@@ -122,7 +122,7 @@ walk_items = function(self, i)
   local k, v = next(self.table, self.key)
   if k ~= nil then
     self.key = k
-    return i, dict({
+    return i, Dict({
       key = k,
       value = v
     })
@@ -149,7 +149,7 @@ local _dict_mt = {
     }, 0
   end,
   __band = function(self, other)
-    return dict((function()
+    return Dict((function()
       local _tbl_0 = { }
       for k, v in pairs(self) do
         if other[k] ~= nil then
@@ -173,7 +173,7 @@ local _dict_mt = {
         ret[k] = v
       end
     end
-    return dict(ret)
+    return Dict(ret)
   end,
   __bxor = function(self, other)
     local ret
@@ -191,7 +191,7 @@ local _dict_mt = {
         ret[k] = nil
       end
     end
-    return dict(ret)
+    return Dict(ret)
   end,
   __add = function(self, other)
     local ret
@@ -209,7 +209,7 @@ local _dict_mt = {
         ret[k] = ret[k] + v
       end
     end
-    return dict(ret)
+    return Dict(ret)
   end,
   __sub = function(self, other)
     local ret
@@ -227,18 +227,18 @@ local _dict_mt = {
         ret[k] = ret[k] - v
       end
     end
-    return dict(ret)
+    return Dict(ret)
   end
 }
-dict = function(t)
+Dict = function(t)
   return setmetatable(t, _dict_mt)
 end
-for i, entry in ipairs(dict({
+for i, entry in ipairs(Dict({
   x = 99
 })) do
   assert(i == 1 and entry.key == "x" and entry.value == 99, "ipairs compatibility issue")
 end
 return {
-  list = list,
+  List = List,
-  dict = dict
+  Dict = Dict
 }

containers.moon

@@ -1,8 +1,9 @@
 -- This file contains container classes, i.e. Lists, Dicts, and Sets
+
 {:insert,:remove,:concat} = table
 {:repr, :stringify, :equivalent, :nth_to_last, :size} = require 'utils'
 
-local list, dict
+local List, Dict
 
 -- List and Dict classes to provide basic equality/tostring functionality for the tables
 -- used in Nomsu. This way, they retain a notion of whether they were originally lists or dicts.
@@ -28,7 +29,7 @@ _list_mt =
             elseif @[i] > other[i] then return false
         return true
     __add: (other)=>
-        ret = list[x for x in *@]
+        ret = List[x for x in *@]
         for x in *other
             insert(ret, x)
         return ret
@@ -55,14 +56,14 @@ _list_mt =
         assert type(k) == 'number', "List indices must be numbers"
         rawset(@, k, v)
 
-list = (t)-> setmetatable(t, _list_mt)
+List = (t)-> setmetatable(t, _list_mt)
 
 walk_items = (i)=>
     i = i + 1
     k, v = next(@table, @key)
     if k != nil
         @key = k
-        return i, dict{key:k, value:v}
+        return i, Dict{key:k, value:v}
 
 _dict_mt =
     __eq:equivalent
@@ -71,33 +72,33 @@ _dict_mt =
         "{"..concat(["#{repr(k)}: #{repr(v)}" for k,v in pairs @], ", ").."}"
     __ipairs: => walk_items, {table:@, key:nil}, 0
     __band: (other)=>
-        dict{k,v for k,v in pairs(@) when other[k] != nil}
+        Dict{k,v for k,v in pairs(@) when other[k] != nil}
     __bor: (other)=>
         ret = {k,v for k,v in pairs(@)}
         for k,v in pairs(other)
             if ret[k] == nil then ret[k] = v
-        return dict(ret)
+        return Dict(ret)
     __bxor: (other)=>
         ret = {k,v for k,v in pairs(@)}
         for k,v in pairs(other)
             if ret[k] == nil then ret[k] = v
             else ret[k] = nil
-        return dict(ret)
+        return Dict(ret)
     __add: (other)=>
         ret = {k,v for k,v in pairs(@)}
         for k,v in pairs(other)
             if ret[k] == nil then ret[k] = v
             else ret[k] += v
-        return dict(ret)
+        return Dict(ret)
     __sub: (other)=>
         ret = {k,v for k,v in pairs(@)}
         for k,v in pairs(other)
             if ret[k] == nil then ret[k] = -v
             else ret[k] -= v
-        return dict(ret)
+        return Dict(ret)
-dict = (t)-> setmetatable(t, _dict_mt)
+Dict = (t)-> setmetatable(t, _dict_mt)
 
-for i,entry in ipairs(dict({x:99}))
+for i,entry in ipairs(Dict({x:99}))
     assert(i == 1 and entry.key == "x" and entry.value == 99, "ipairs compatibility issue")
 
-return {:list, :dict}
+return {:List, :Dict}

core/control_flow.nom

@@ -139,9 +139,10 @@ test:
     repeat 10 times: %x += 1
     assume (%x == 10)
 compile [repeat %n times %body] to:
+    define mangler
     %lua = (..)
         Lua ".."
-            for i=1,\(%n as lua expr) do
+            for \(mangle "i")=1,\(%n as lua expr) do
                 \(%body as lua statements)
     
     if (%body has subtree \(do next)):
@@ -242,9 +243,10 @@ compile [for %var in %iterable %body] to:
     # This uses Lua's approach of only allowing loop-scoped variables in a loop
     unless (%var.type is "Var"):
         compile error at %var.source "Loop expected variable, not: %s"
+    define mangler
     %lua = (..)
         Lua ".."
-            for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
+            for \(mangle "i"),\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
                 \(%body as lua statements)
     
     if (%body has subtree \(do next)):
@@ -391,6 +393,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
     %code = (Lua "")
     %clause = "if"
     %else_allowed = (yes)
+    define mangler
     unless (%body.type is "Block"):
         compile error at %body.source "'if' expected a Block, but got: %s"
     for %line in %body:
@@ -426,7 +429,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
                 
                 if (%i > 1):
                     %code::append " or "
-                %code::append "branch_value == \(%line.%i as lua expr)"
+                %code::append "\(mangle "branch value") == \(%line.%i as lua expr)"
             
             %code::append ".."
                  then
@@ -440,7 +443,7 @@ compile [if %branch_value is %body, when %branch_value is %body] to:
     return (..)
         Lua ".."
             do --if % is
-                local branch_value = \(%branch_value as lua expr)
+                local \(mangle "branch value") = \(%branch_value as lua expr)
                 \%code
             end --if % is
 
@@ -461,18 +464,20 @@ test:
     ..and if it barfs: do nothing
     
     assume (%d.x == "good")
-compile [do %action then always %final_action] to (..)
+compile [do %action then always %final_action] to:
-    Lua ".."
+    define mangler
-        do
+    return (..)
-            local fell_through = false
+        Lua ".."
-            local ok, ret = pcall(function()
+            do
-                \(%action as lua statements)
+                local \(mangle "fell_through") = false
-                fell_through = true
+                local \(mangle "ok"), \(mangle "ret") = pcall(function()
-            end)
+                    \(%action as lua statements)
-            \(%final_action as lua statements)
+                    \(mangle "fell_through") = true
-            if not ok then error(ret, 0) end
+                end)
-            if not fell_through then return ret end
+                \(%final_action as lua statements)
-        end
+                if not \(mangle "ok") then error(ret, 0) end
+                if not \(mangle "fell_through") then return ret end
+            end
 
 test:
     assume ((result of (: return 99)) == 99)
@@ -493,14 +498,15 @@ test:
 # Recurion control flow
 compile [for %var in recursive %structure %body] to (..)
     with local compile actions:
+        define mangler
         compile [recurse %v on %x] to (..)
-            Lua "table.insert(stack\(%v as lua id), \(%x as lua expr))"
+            Lua "table.insert(\(mangle "stack \(%v.1)"), \(%x as lua expr))"
         %lua = (..)
             Lua ".."
                 do
-                    local stack\(%var as lua id) = list{\(%structure as lua expr)}
+                    local \(mangle "stack \(%var.1)") = _List{\(%structure as lua expr)}
-                    while #stack\(%var as lua id) > 0 do
+                    while #\(mangle "stack \(%var.1)") > 0 do
-                        \(%var as lua expr) = table.remove(stack\(%var as lua id), 1)
+                        \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
                         \(%body as lua statements)
         
         if (%body has subtree \(do next)):

core/id.nom

@@ -0,0 +1,56 @@
+#!/usr/bin/env nomsu -V3.7.5.6
+#
+    A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
+
+use "core/metaprogramming.nom"
+use "core/math.nom"
+use "core/collections.nom"
+use "core/control_flow.nom"
+
+%NaN_surrogate = {}
+%nil_surrogate = {}
+%obj_by_id = {}
+set %obj_by_id's metatable to {__mode: "v"}
+%id_by_obj = {}
+set %id_by_obj's metatable to {..}
+    __mode: "k"
+    __index: (..)
+        [%self, %key] ->:
+            if (%key == (nil)): return %self.%nil_surrogate
+            if (%key != %key): return %self.%NaN_surrogate
+            --- %retry ---
+            %id = (uuid)
+            if (%obj_by_id.%id != (nil)): go to %retry
+            %self.%key = %id
+            %obj_by_id.%id = %key
+            return %id
+
+local action [uuid]:
+    # Set all the other bits to randomly (or pseudo-randomly) chosen values.
+    %bytes = [..]
+        randint (2^(4*8)), # time-low
+        randint (2^(2*8)), # time-mid
+        randint (2^(2*8 - 4)), # time-high-and-version
+        randint (2^(1*8 - 2)), # clock-seq-and-reserved
+        randint (2^(1*8)), # clock-seq-low
+        randint (2^(3*8)), randint (2^(3*8)), # node
+    # Set the four most significant bits (bits 12 through 15) of the
+    # time_hi_and_version field to the 4-bit version number from
+    # Section 4.1.3.
+    %bytes.3 += 0x4000
+    # Set the two most significant bits (bits 6 and 7) of the
+    # clock_seq_hi_and_reserved to zero and one, respectively.
+    %bytes.4 += 0xC0
+    return (=lua "('%08x-%04x-%04x-%02x%02x-%6x%6x'):format(unpack(\%bytes))")
+
+# For strict identity checking, use (%x's id) == (%y's id)
+test:
+    assume (([] == []) and ((id of []) != (id of [])))
+    seed random with 0
+    %x = []
+    assume ((id of %x) == (id of %x))
+    seed random with 0
+    assume ((id of %x) != (id of []))
+    seed random
+
+action [id of %, %'s id, %' id] %id_by_obj.%

core/metaprogramming.nom

@@ -4,6 +4,20 @@
     functions to make that easier.
 
 lua> "NOMSU_CORE_VERSION = 7"
+lua> ".."
+    do
+        local mangle_index = 0
+        function mangler()
+            local my_mangle_index = mangle_index
+            mangle_index = mangle_index + 1
+            return function(varname)
+                return string.as_lua_id(varname..(("\\3%X"):format(my_mangle_index)))
+            end
+        end
+    end
+    COMPILE_ACTIONS["define mangler"] = function(nomsu, tree)
+        return LuaCode(tree.source, "local mangle_1 = mangler()")
+    end
 lua> ".."
     COMPILE_ACTIONS["1 -> 2"] = function(nomsu, tree, \%args, \%body)
         local lua = LuaCode.Value(tree.source, "(function(")
@@ -34,7 +48,7 @@ test:
     compile [five] to (Lua value "5")
 test:
     assume ((five) == 5) or barf "Compile to expression failed."
-    compile [loc x] to (Lua "local _x = 99;")
+    compile [loc x] to (Lua "local x = 99;")
 test:
     lua> "do"
     loc x
@@ -158,7 +172,7 @@ compile [parse %actions as %body] to (..)
                 if replacements[t[1]] then
                     return replacements[t[1]]
                 else
-                    return t.type.."{"..repr(t[1].." \\0").."..('%X'):format(__MANGLE_INDEX), source="..repr(tostring(t.source)).."}"
+                    return t.type.."{mangle("..repr(t[1]).."), source="..repr(tostring(t.source)).."}"
                 end
             elseif AST.is_syntax_tree(t) then
                 local ret = {}
@@ -181,7 +195,7 @@ compile [parse %actions as %body] to (..)
             end
         end
         local \%new_body = LuaCode(\%body.source,
-            "__MANGLE_INDEX = (__MANGLE_INDEX or 0) + 1",
+            "local mangle = mangler()",
             "\\nlocal tree = ", make_tree(\%body),
             "\\nlocal lua = nomsu:compile(tree)",
             "\\nreturn lua")
@@ -223,8 +237,9 @@ compile [%tree as inline nomsu] to (..)
 action [%var as lua identifier, %var as lua id] (..)
     lua> ".."
         if type(\%var) == 'string' then return string.as_lua_id(\%var)
-        elseif \%var.type == 'Var' then return "_"..string.as_lua_id(\%var[1])
+        elseif AST.is_syntax_tree(\%var, 'Var') then return string.as_lua_id(\%var[1])
-        elseif \%var.type == 'Action' then return string.as_lua_id(\%var.stub)
+        elseif AST.is_syntax_tree(\%var, 'Action') then return string.as_lua_id(\%var.stub)
+        else error("Unknown type: "..tostring(\%var))
         end
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -266,10 +281,10 @@ compile [%tree has subtree %match_tree] to (..)
 
 action [match %tree with %patt]:
     lua> ".."
-        if \%patt.type == "Var" then return dict{[\%patt[1]]=\%tree} end
+        if \%patt.type == "Var" then return _Dict{[\%patt[1]]=\%tree} end
         if \%patt.type == "Action" and \%patt.stub ~= \%tree.stub then return nil end
         if #\%patt ~= #\%tree then return nil end
-        local matches = dict{}
+        local matches = _Dict{}
         for \%i=1,#\%patt do
             if AST.is_syntax_tree(\%tree[\%i]) then
                 local submatch = \(match %tree.%i with %patt.%i)

core/operators.nom

@@ -19,28 +19,6 @@ compile [%a is %b, %a == %b] to (..)
 compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to (..)
     Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
 
-# For strict identity checking, use (%x's id) is (%y's id)
-test:
-    assume (([] == []) and (([] 's id) != ([] 's id)))
-lua> ".."
-    do
-        local new_uuid = require('uuid')
-        local NaN_surrogate = {}
-        local nil_surrogate = {}
-        IDS = setmetatable({}, {
-            __mode = "k",
-            __index = function(self, key)
-                if key == nil then return self[nil_surrogate]
-                elseif key ~= key then return self[NaN_surrogate] end
-                local id = new_uuid()
-                self[key] = id
-                return id
-            end
-        })
-    end
-
-compile [% 's id, id of %] to (Lua value "IDS[\(% as lua expr)]")
-
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 test:

core/text.nom

@@ -47,7 +47,7 @@ compile [byte %i of %text] to (..)
 
 compile [bytes %start to %stop of %text] to (..)
     Lua value ".."
-        list{(\(%text as lua expr)):byte(\(%start as lua expr), \(%stop as lua expr))}
+        _List{(\(%text as lua expr)):byte(\(%start as lua expr), \(%stop as lua expr))}
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -82,7 +82,7 @@ test:
         ..== ["one", "two"]
 action [lines in %text, lines of %text] (..)
     lua> ".."
-        local result = list{}
+        local result = _List{}
         for line in (\%text):gmatch('[^\\n]+') do
             result[#result+1] = line
         end
@@ -99,7 +99,7 @@ compile [for %match in %text matching %patt %body] to (..)
 compile [%expr for %match in %text matching %patt] to (..)
     Lua value ".."
         (function()
-            local ret = list{}
+            local ret = _List{}
             for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
             %patt as lua expr
         ..) do

lib/object.nom

@@ -90,7 +90,7 @@ compile [object %classname extends %parent %class_body] to:
                 class.__index = class
                 class.class = class
                 class.__tostring = function(inst)
-                    return inst.name..getmetatable(dict{}).__tostring(inst)
+                    return inst.name..getmetatable(_Dict{}).__tostring(inst)
                 end
             
                 \(%class_body as lua statements)

lib/os.nom

@@ -32,7 +32,7 @@ compile [for file %f in %path %body] to (..)
 compile [%expr for file %f in %path] to (..)
     Lua value ".."
         (function()
-            local ret = list{}
+            local ret = _List{}
             for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
                 ret[#ret+1] = \(%expr as lua statements)
             end

nomsu.lua

@@ -138,7 +138,7 @@ if not args or args.help then
   os.exit(EXIT_FAILURE)
 end
 local nomsu = NomsuCompiler
-nomsu.arg = NomsuCompiler.list(args.nomsu_args)
+nomsu.arg = NomsuCompiler._List(args.nomsu_args)
 if args.version then
   nomsu:run([[use "core"
 say (Nomsu version)]])

nomsu.moon

@@ -88,7 +88,7 @@ if not args or args.help
     os.exit(EXIT_FAILURE)
 
 nomsu = NomsuCompiler
-nomsu.arg = NomsuCompiler.list(args.nomsu_args)
+nomsu.arg = NomsuCompiler._List(args.nomsu_args)
 
 if args.version
     nomsu\run [[

nomsu_compiler.lua

@@ -4,10 +4,10 @@ local utils = require('utils')
 local Files = require('files')
 local repr, stringify, equivalent
 repr, stringify, equivalent = utils.repr, utils.stringify, utils.equivalent
-local list, dict
+local List, Dict
 do
   local _obj_0 = require('containers')
-  list, dict = _obj_0.list, _obj_0.dict
+  List, Dict = _obj_0.List, _obj_0.Dict
 end
 colors = require('consolecolors')
 colored = setmetatable({ }, {
@@ -37,7 +37,7 @@ local AST = require("syntax_tree")
 local Parser = require("parser")
 SOURCE_MAP = { }
 string.as_lua_id = function(str)
-  str = gsub(str, "^\0*$", "%1\0")
+  str = gsub(str, "^\3*$", "%1\3")
   str = gsub(str, "x([0-9A-F][0-9A-F])", "x78%1")
   str = gsub(str, "%W", function(c)
     if c == ' ' then
@@ -110,7 +110,7 @@ local NomsuCompiler = setmetatable({
   end
 })
 do
-  NomsuCompiler.NOMSU_COMPILER_VERSION = 6
+  NomsuCompiler.NOMSU_COMPILER_VERSION = 7
   NomsuCompiler.NOMSU_SYNTAX_VERSION = Parser.version
   NomsuCompiler.nomsu = NomsuCompiler
   NomsuCompiler.parse = function(self, ...)
@@ -160,8 +160,8 @@ do
     load = load,
     pairs = pairs,
     ipairs = ipairs,
-    list = list,
+    _List = List,
-    dict = dict
+    _Dict = Dict
   }
   if _VERSION == "Lua 5.4" then
     to_add.ipairs = function(x)
@@ -286,42 +286,41 @@ do
       end
       return lua
     end,
-    ["Lua 1"] = function(self, tree, _code)
+    ["Lua 1"] = function(self, tree, code)
-      return add_lua_string_bits(self, 'statements', _code)
+      return add_lua_string_bits(self, 'statements', code)
     end,
-    ["Lua value 1"] = function(self, tree, _code)
+    ["Lua value 1"] = function(self, tree, code)
-      return add_lua_string_bits(self, 'value', _code)
+      return add_lua_string_bits(self, 'value', code)
     end,
-    ["lua > 1"] = function(self, tree, _code)
+    ["lua > 1"] = function(self, tree, code)
-      if _code.type ~= "Text" then
+      if code.type ~= "Text" then
-        return LuaCode(tree.source, "nomsu:run_lua(", self:compile(_code), ");")
+        return LuaCode(tree.source, "nomsu:run_lua(", self:compile(code), ");")
       end
-      return add_lua_bits(self, "statements", _code)
+      return add_lua_bits(self, "statements", code)
     end,
-    ["= lua 1"] = function(self, tree, _code)
+    ["= lua 1"] = function(self, tree, code)
-      if _code.type ~= "Text" then
+      if code.type ~= "Text" then
-        return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(_code), ":as_statements('return '))")
+        return LuaCode.Value(tree.source, "nomsu:run_lua(", self:compile(code), ":as_statements('return '))")
       end
-      return add_lua_bits(self, "value", _code)
+      return add_lua_bits(self, "value", code)
     end,
-    ["use 1"] = function(self, tree, _path)
+    ["use 1"] = function(self, tree, path)
-      if _path.type == 'Text' and #_path == 1 and type(_path[1]) == 'string' then
+      if path.type == 'Text' and #path == 1 and type(path[1]) == 'string' then
-        local path = _path[1]
+        for _, f in Files.walk(path[1]) do
-        for _, f in Files.walk(path) do
           self:run_file(f)
         end
       end
-      return LuaCode(tree.source, "for i,f in Files.walk(", self:compile(_path), ") do nomsu:run_file(f) end")
+      return LuaCode(tree.source, "for i,f in Files.walk(", self:compile(path), ") do nomsu:run_file(f) end")
     end,
     ["tests"] = function(self, tree)
       return LuaCode.Value(tree.source, "TESTS")
     end,
-    ["test 1"] = function(self, tree, _body)
+    ["test 1"] = function(self, tree, body)
       local test_str = table.concat((function()
         local _accum_0 = { }
         local _len_0 = 1
-        for _index_0 = 1, #_body do
+        for _index_0 = 1, #body do
-          local line = _body[_index_0]
+          local line = body[_index_0]
           _accum_0[_len_0] = tostring(self:tree_to_nomsu(line))
           _len_0 = _len_0 + 1
         end
@@ -329,10 +328,10 @@ do
       end)(), "\n")
       return LuaCode(tree.source, "TESTS[" .. tostring(repr(tostring(tree.source))) .. "] = ", repr(test_str))
     end,
-    ["is jit"] = function(self, tree, _code)
+    ["is jit"] = function(self, tree, code)
       return LuaCode.Value(tree.source, jit and "true" or "false")
     end,
-    ["Lua version"] = function(self, tree, _code)
+    ["Lua version"] = function(self, tree, code)
       return LuaCode.Value(tree.source, repr(_VERSION))
     end
   }, {
@@ -646,7 +645,7 @@ do
       end
       return lua
     elseif "List" == _exp_0 then
-      local lua = LuaCode.Value(tree.source, "list{")
+      local lua = LuaCode.Value(tree.source, "_List{")
       lua:concat_append((function()
         local _accum_0 = { }
         local _len_0 = 1
@@ -660,7 +659,7 @@ do
       lua:append("}")
       return lua
     elseif "Dict" == _exp_0 then
-      local lua = LuaCode.Value(tree.source, "dict{")
+      local lua = LuaCode.Value(tree.source, "_Dict{")
       lua:concat_append((function()
         local _accum_0 = { }
         local _len_0 = 1
@@ -722,7 +721,7 @@ do
     elseif "Number" == _exp_0 then
       return LuaCode.Value(tree.source, tostring(tree[1]))
     elseif "Var" == _exp_0 then
-      return LuaCode.Value(tree.source, "_", string.as_lua_id(tree[1]))
+      return LuaCode.Value(tree.source, string.as_lua_id(tree[1]))
     elseif "FileChunks" == _exp_0 then
       return error("Cannot convert FileChunks to a single block of lua, since each chunk's " .. "compilation depends on the earlier chunks")
     else

nomsu_compiler.moon

@@ -14,7 +14,7 @@ re = require 're'
 utils = require 'utils'
 Files = require 'files'
 {:repr, :stringify, :equivalent} = utils
-{:list, :dict} = require 'containers'
+{:List, :Dict} = require 'containers'
 export colors, colored
 colors = require 'consolecolors'
 colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..tostring(msg or '')..colors.reset)})
@@ -33,9 +33,9 @@ SOURCE_MAP = {}
 -- but not idempotent, i.e. if (x != y) then (as_lua_id(x) != as_lua_id(y)),
 -- but as_lua_id(x) is not necessarily equal to as_lua_id(as_lua_id(x))
 string.as_lua_id = (str)->
-    -- Empty strings are not valid lua identifiers, so treat them like "\0",
+    -- Empty strings are not valid lua identifiers, so treat them like "\3",
-    -- and treat "\0" as "\0\0", etc. to preserve injectivity.
+    -- and treat "\3" as "\3\3", etc. to preserve injectivity.
-    str = gsub str, "^\0*$", "%1\0"
+    str = gsub str, "^\3*$", "%1\3"
     -- Escape 'x' when it precedes something that looks like an uppercase hex sequence.
     -- This way, all Lua IDs can be unambiguously reverse-engineered, but normal usage
     -- of 'x' won't produce ugly Lua IDs.
@@ -74,7 +74,7 @@ NomsuCompiler = setmetatable {name:"Nomsu"},
     __index: (k)=> if _self = rawget(@, "self") then _self[k] else nil
     __tostring: => @name
 with NomsuCompiler
-    .NOMSU_COMPILER_VERSION = 6
+    .NOMSU_COMPILER_VERSION = 7
     .NOMSU_SYNTAX_VERSION = Parser.version
     .nomsu = NomsuCompiler
     .parse = (...)=> Parser.parse(...)
@@ -90,7 +90,7 @@ with NomsuCompiler
         :table, :assert, :dofile, :loadstring, :type, :select, :math, :io, :load,
         :pairs, :ipairs,
         -- Nomsu types:
-        :list, :dict,
+        _List:List, _Dict:Dict,
     }
     if _VERSION == "Lua 5.4"
         to_add.ipairs = (x)->
@@ -187,38 +187,37 @@ with NomsuCompiler
                     lua\append " "
             return lua
 
-        ["Lua 1"]: (tree, _code)=>
+        ["Lua 1"]: (tree, code)=>
-            return add_lua_string_bits(@, 'statements', _code)
+            return add_lua_string_bits(@, 'statements', code)
     
-        ["Lua value 1"]: (tree, _code)=>
+        ["Lua value 1"]: (tree, code)=>
-            return add_lua_string_bits(@, 'value', _code)
+            return add_lua_string_bits(@, 'value', code)
 
-        ["lua > 1"]: (tree, _code)=>
+        ["lua > 1"]: (tree, code)=>
-            if _code.type != "Text"
+            if code.type != "Text"
-                return LuaCode tree.source, "nomsu:run_lua(", @compile(_code), ");"
+                return LuaCode tree.source, "nomsu:run_lua(", @compile(code), ");"
-            return add_lua_bits(@, "statements", _code)
+            return add_lua_bits(@, "statements", code)
 
-        ["= lua 1"]: (tree, _code)=>
+        ["= lua 1"]: (tree, code)=>
-            if _code.type != "Text"
+            if code.type != "Text"
-                return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(_code), ":as_statements('return '))"
+                return LuaCode.Value tree.source, "nomsu:run_lua(", @compile(code), ":as_statements('return '))"
-            return add_lua_bits(@, "value", _code)
+            return add_lua_bits(@, "value", code)
 
-        ["use 1"]: (tree, _path)=>
+        ["use 1"]: (tree, path)=>
-            if _path.type == 'Text' and #_path == 1 and type(_path[1]) == 'string'
+            if path.type == 'Text' and #path == 1 and type(path[1]) == 'string'
-                path = _path[1]
+                for _,f in Files.walk(path[1])
-                for _,f in Files.walk(path)
                     @run_file(f)
-            return LuaCode(tree.source, "for i,f in Files.walk(", @compile(_path), ") do nomsu:run_file(f) end")
+            return LuaCode(tree.source, "for i,f in Files.walk(", @compile(path), ") do nomsu:run_file(f) end")
 
         ["tests"]: (tree)=> LuaCode.Value(tree.source, "TESTS")
-        ["test 1"]: (tree, _body)=>
+        ["test 1"]: (tree, body)=>
-            test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *_body], "\n"
+            test_str = table.concat [tostring(@tree_to_nomsu(line)) for line in *body], "\n"
             LuaCode tree.source, "TESTS[#{repr(tostring(tree.source))}] = ", repr(test_str)
 
-        ["is jit"]: (tree, _code)=>
+        ["is jit"]: (tree, code)=>
             return LuaCode.Value(tree.source, jit and "true" or "false")
 
-        ["Lua version"]: (tree, _code)=>
+        ["Lua version"]: (tree, code)=>
             return LuaCode.Value(tree.source, repr(_VERSION))
     }, {
         __index: (stub)=>
@@ -417,13 +416,13 @@ with NomsuCompiler
                 return lua
 
             when "List"
-                lua = LuaCode.Value tree.source, "list{"
+                lua = LuaCode.Value tree.source, "_List{"
                 lua\concat_append([@compile(e) for e in *tree], ", ", ",\n  ")
                 lua\append "}"
                 return lua
 
             when "Dict"
-                lua = LuaCode.Value tree.source, "dict{"
+                lua = LuaCode.Value tree.source, "_Dict{"
                 lua\concat_append([@compile(e) for e in *tree], ", ", ",\n  ")
                 lua\append "}"
                 return lua
@@ -481,7 +480,7 @@ with NomsuCompiler
                 return LuaCode.Value(tree.source, tostring(tree[1]))
 
             when "Var"
-                return LuaCode.Value(tree.source, "_", string.as_lua_id(tree[1]))
+                return LuaCode.Value(tree.source, string.as_lua_id(tree[1]))
 
             when "FileChunks"
                 error("Cannot convert FileChunks to a single block of lua, since each chunk's "..

parser.lua

@@ -1,6 +1,6 @@
 local lpeg = require('lpeg')
 local re = require('re')
-lpeg.setmaxstack(10000)
+lpeg.setmaxstack(20000)
 local P, R, S, C, Cmt, Carg
 P, R, S, C, Cmt, Carg = lpeg.P, lpeg.R, lpeg.S, lpeg.C, lpeg.Cmt, lpeg.Carg
 local match, sub

parser.moon

@@ -1,7 +1,7 @@
 -- This file contains the parser, which converts Nomsu text into abstract syntax trees
 lpeg = require 'lpeg'
 re = require 're'
-lpeg.setmaxstack 10000
+lpeg.setmaxstack 20000
 {:P,:R,:S,:C,:Cmt,:Carg} = lpeg
 {:match, :sub} = string
 {:insert, :remove} = table

uuid.lua

@@ -1,24 +0,0 @@
--- A simple UUID function based on RFC 4122: http://www.ietf.org/rfc/rfc4122.txt
-local unpack = unpack or table.unpack
-local function uuid()
-    local r = math.random
-    -- Set all the other bits to randomly (or pseudo-randomly) chosen values.
-    local bytes = {
-        r(2^(4*8)), --time-low
-        r(2^(2*8)), --time-mid
-        r(2^(2*8-4)), --time-high-and-version
-        r(2^(1*8-2)), --clock-seq-and-reserved
-        r(2^(1*8)), --clock-seq-low
-        r(2^(3*8)), r(2^(3*8)), --node
-    } 
-    -- Set the four most significant bits (bits 12 through 15) of the
-    -- time_hi_and_version field to the 4-bit version number from
-    -- Section 4.1.3.
-    bytes[3] = bytes[3] + 0x4000
-    -- Set the two most significant bits (bits 6 and 7) of the
-    -- clock_seq_hi_and_reserved to zero and one, respectively.
-    bytes[4] = bytes[4] + 0xC0
-    return ("%08x-%04x-%04x-%02x%02x-%6x%6x"):format(unpack(bytes))
-end
-
-return uuid