Simplifying code.

nomsu_tree.lua

@@ -11,19 +11,40 @@ local AST = { }
 AST.is_syntax_tree = function(n)
   return type(n) == 'table' and getmetatable(n) and AST[n.type] == getmetatable(n)
 end
-local Tree
+local types = {
-Tree = function(name, methods)
+  "Number",
-  local cls = methods or { }
+  "Var",
+  "Block",
+  "EscapedNomsu",
+  "Text",
+  "List",
+  "Dict",
+  "DictEntry",
+  "IndexChain",
+  "Action"
+}
+for _index_0 = 1, #types do
+  local name = types[_index_0]
+  local cls = { }
   do
-    cls.type = name
     cls.__class = cls
+    cls.__index = cls
     cls.__name = name
+    cls.type = name
     cls.is_instance = function(self, x)
       return getmetatable(x) == self
     end
-    cls.__index = cls
     cls.__tostring = function(self)
-      return tostring(self.name) .. "(#{table.concat([repr(v) for v in *@]), ', '})"
+      return tostring(self.name) .. "(" .. tostring(concat((function()
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_1 = 1, #self do
+          local v = self[_index_1]
+          _accum_0[_len_0] = repr(v)
+          _len_0 = _len_0 + 1
+        end
+        return _accum_0
+      end)(), ', ')) .. ")"
     end
     cls.map = function(self, fn)
       do
@@ -32,26 +53,29 @@ Tree = function(name, methods)
           return replacement
         end
       end
-      local made_changes, new_vals = false, { }
+      local replacements
-      for i, v in ipairs(self) do
-        if AST.is_syntax_tree(v) then
       do
-            local replacement = v:map(fn)
+        local _accum_0 = { }
-            if replacement then
+        local _len_0 = 1
-              if replacement ~= v then
+        for _index_1 = 1, #self do
-                made_changes = true
+          local v = self[_index_1]
-                v = replacement
+          _accum_0[_len_0] = AST.is_syntax_tree(v) and v:map(fn) or nil
+          _len_0 = _len_0 + 1
         end
+        replacements = _accum_0
       end
-          end
+      if not (next(replacements)) then
-        end
-        new_vals[i] = v
-      end
-      if not (made_changes) then
         return self
       end
-      local replacement = getmetatable(self)(self.source, unpack(new_vals))
+      return (self.__class)(self.source, unpack((function()
-      return replacement
+        local _accum_0 = { }
+        local _len_0 = 1
+        for i, v in ipairs(self) do
+          _accum_0[_len_0] = replacements[i] or v
+          _len_0 = _len_0 + 1
+        end
+        return _accum_0
+      end)()))
     end
   end
   AST[name] = setmetatable(cls, {
@@ -78,17 +102,7 @@ Tree = function(name, methods)
     end
   })
 end
-Tree("Number")
+AST.Action.__init = function(self)
-Tree("Var")
-Tree("Block")
-Tree("EscapedNomsu")
-Tree("Text")
-Tree("List")
-Tree("Dict")
-Tree("DictEntry")
-Tree("IndexChain")
-Tree("Action", {
-  __init = function(self)
   local stub_bits
   do
     local _accum_0 = { }
@@ -101,18 +115,5 @@ Tree("Action", {
     stub_bits = _accum_0
   end
   self.stub = concat(stub_bits, " ")
-  end,
+end
-  get_spec = function(self)
-    return concat((function()
-      local _accum_0 = { }
-      local _len_0 = 1
-      for _index_0 = 1, #self do
-        local a = self[_index_0]
-        _accum_0[_len_0] = type(a) == "string" and a or "%" .. tostring(a[1])
-        _len_0 = _len_0 + 1
-      end
-      return _accum_0
-    end)(), " ")
-  end
-})
 return AST

nomsu_tree.moon

@@ -8,29 +8,22 @@ AST = {}
 AST.is_syntax_tree = (n)->
     type(n) == 'table' and getmetatable(n) and AST[n.type] == getmetatable(n)
 
--- Helper method:
+types = {"Number", "Var", "Block", "EscapedNomsu", "Text", "List", "Dict", "DictEntry",
-Tree = (name, methods)->
+    "IndexChain", "Action"}
-    cls = methods or {}
+for name in *types
+    cls = {}
     with cls
-        .type = name
         .__class = cls
-        .__name = name
-        .is_instance = (x)=> getmetatable(x) == @
         .__index = cls
-        .__tostring = => "#{@name}(#{table.concat([repr(v) for v in *@]), ', '})"
+        .__name = name
+        .type = name
+        .is_instance = (x)=> getmetatable(x) == @
+        .__tostring = => "#{@name}(#{concat([repr(v) for v in *@], ', ')})"
         .map = (fn)=>
             if replacement = fn(@) then return replacement
-            made_changes, new_vals = false, {}
+            replacements = [AST.is_syntax_tree(v) and v\map(fn) or nil for v in *@]
-            for i,v in ipairs @
+            return @ unless next(replacements)
-                if AST.is_syntax_tree(v)
+            return (@__class)(@source, unpack([replacements[i] or v for i,v in ipairs(@)]))
-                    if replacement = v\map(fn)
-                        if replacement ~= v
-                            made_changes = true
-                            v = replacement
-                new_vals[i] = v
-            return @ unless made_changes
-            replacement = getmetatable(self)(@source, unpack(new_vals))
-            return replacement
 
     AST[name] = setmetatable cls,
         __tostring: => @name
@@ -44,20 +37,8 @@ Tree = (name, methods)->
             if inst.__init then inst\__init!
             return inst
 
-Tree "Number"
+AST.Action.__init = =>
-Tree "Var"
-Tree "Block"
-Tree "EscapedNomsu"
-Tree "Text"
-Tree "List"
-Tree "Dict"
-Tree "DictEntry"
-Tree "IndexChain"
-Tree "Action",
-    __init: =>
     stub_bits = [type(a) == 'string' and a or '%' for a in *@]
     @stub = concat stub_bits, " "
-    get_spec: =>
-        concat [type(a) == "string" and a or "%#{a[1]}" for a in *@], " "
 
 return AST