Optimized utils and cleaned up a bit.

nomsu.moon

@@ -13,8 +13,8 @@
 
 re = require 're'
 lpeg = require 'lpeg'
-utils = require 'utils'
+utils = require 'utils2'
-repr = utils.repr
+{:repr, :stringify, :min, :max, :equivalent, :set, :is_list, :sum} = utils
 colors = setmetatable({}, {__index:->""})
 colored = setmetatable({}, {__index:(_,color)-> ((msg)-> colors[color]..msg..colors.reset)})
 {:insert, :remove, :concat} = table
@@ -220,7 +220,7 @@ class NomsuCompiler
         @debug = false
         @utils = utils
         @repr = (...)=> repr(...)
-        @stringify = (...)=> utils.stringify(...)
+        @stringify = (...)=> stringify(...)
         if not parent
             @initialize_core!
     
@@ -252,10 +252,10 @@ class NomsuCompiler
             for i=1,#arg_names-1 do for j=i+1,#arg_names
                 if arg_names[i] == arg_names[j] then @error "Duplicate argument in function #{stub}: '#{arg_names[i]}'"
             if canonical_args
-                assert utils.equivalent(utils.set(arg_names), canonical_args), "Mismatched args"
+                assert equivalent(set(arg_names), canonical_args), "Mismatched args"
-            else canonical_args = utils.set(arg_names)
+            else canonical_args = set(arg_names)
             if canonical_escaped_args
-                assert utils.equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args"
+                assert equivalent(escaped_args, canonical_escaped_args), "Mismatched escaped args"
             else
                 canonical_escaped_args = escaped_args
                 def.escaped_args = escaped_args
@@ -591,7 +591,7 @@ end);]])\format(concat(buffer, "\n"))
             when "number"
                 return repr(value)
             when "table"
-                if utils.is_list(value)
+                if is_list(value)
                     return "[#{concat [@value_to_nomsu(v) for v in *value], ", "}]"
                 else
                     return "(d{#{concat ["#{@value_to_nomsu(k)}=#{@value_to_nomsu(v)}" for k,v in pairs(value)], "; "}})"
@@ -801,7 +801,7 @@ end)]])\format(concat(lua_bits, "\n"))
             x = x\gsub("%s+"," ")\gsub("^%s*","")\gsub("%s*$","")
             stub = x\gsub("%%%S+","%%")\gsub("\\","")
             arg_names = [arg for arg in x\gmatch("%%([^%s]*)")]
-            escaped_args = utils.set [arg for arg in x\gmatch("\\%%([^%s]*)")]
+            escaped_args = set [arg for arg in x\gmatch("\\%%([^%s]*)")]
             return stub, arg_names, escaped_args
         if type(x) != 'table'
             @error "Invalid type for getting stub: #{type(x)} for:\n#{repr x}"
@@ -832,13 +832,13 @@ end)]])\format(concat(lua_bits, "\n"))
         if msg
             error_msg ..= "\n" .. (colored.bright colored.yellow colored.onred msg)
         error_msg ..= "\nCallstack:"
-        maxlen = utils.max([#c[2] for c in *@callstack when c != "#macro"])
+        maxlen = max([#c[2] for c in *@callstack when c != "#macro"])
         for i=#@callstack,1,-1
             if @callstack[i] != "#macro"
                 line_no = @callstack[i][2]
                 if line_no
                     nums = [tonumber(n) for n in line_no\gmatch(":([0-9]+)")]
-                    line_no = line_no\gsub(":.*$", ":#{utils.sum(nums) - #nums + 1}")
+                    line_no = line_no\gsub(":.*$", ":#{sum(nums) - #nums + 1}")
                 error_msg ..= "\n    #{"%-#{maxlen}s"\format line_no}| #{@callstack[i][1]}"
         error_msg ..= "\n    <top level>"
         @callstack = {}
@@ -914,7 +914,7 @@ if arg
         flag <- "-c" / "-i" / "-p" / "-O" / "--help" / "-h"
         input <- "-" / [^;]+
         output <- "-" / [^;]+
-    ]], {set: utils.set})
+    ]], {:set})
     args = concat(arg, ";")..";"
     args = parser\match(args) or {}
     if not args or not args.flags or args.flags["--help"] or args.flags["-h"]

utils.lua

@@ -1,6 +1,5 @@
-local utils
+
-utils = {
+local function is_list(t)
-  is_list = function(t)
     if type(t) ~= 'table' then
         return false
     end
@@ -12,45 +11,36 @@ utils = {
         i = i + 1
     end
     return true
-  end,
+end
-  size = function(t)
+
-    do
+local function size(t)
     local n = 0
     for _ in pairs(t) do
         n = n + 1
     end
     return n
 end
-  end,
+
-  repr = function(x)
+local function repr(x)
-    local _exp_0 = type(x)
+    local x_type = type(x)
-    if 'table' == _exp_0 then
+    if x_type == 'table' then
         local mt = getmetatable(x)
         if mt and mt.__tostring then
             return mt.__tostring(x)
-      elseif utils.is_list(x) then
+        elseif is_list(x) then
-        return "{" .. tostring(table.concat((function()
+            local ret = {}
-          local _accum_0 = { }
+            for i=1,#x do
-          local _len_0 = 1
+                ret[i] = repr(x[i])
-          for _index_0 = 1, #x do
-            local i = x[_index_0]
-            _accum_0[_len_0] = utils.repr(i)
-            _len_0 = _len_0 + 1
             end
-          return _accum_0
+            return "{"..table.concat(ret, ", ").."}"
-        end)(), ", ")) .. "}"
         else
-        return "{" .. tostring(table.concat((function()
+            local ret = {}
-          local _accum_0 = { }
-          local _len_0 = 1
             for k, v in pairs(x) do
-            _accum_0[_len_0] = "[" .. tostring(utils.repr(k)) .. "]= " .. tostring(utils.repr(v))
+                ret[#ret+1] = "["..repr(k).."]= "..repr(v)
-            _len_0 = _len_0 + 1
             end
-          return _accum_0
+            return "{"..table.concat(ret, ", ").."}"
-        end)(), ", ")) .. "}"
         end
-    elseif 'string' == _exp_0 then
+    elseif x_type == 'string' then
         if x == "\n" then
             return "'\\n'"
         elseif not x:find([["]]) and not x:find("\n") and not x:find("\\") then
@@ -60,11 +50,11 @@ utils = {
         else
             for i = 0, math.huge do
                 local eq = ("="):rep(i)
-          if not x:find("%]" .. tostring(eq) .. "%]") and not x:match(".*]" .. tostring(eq) .. "$") then
+                if not x:find("%]"..eq.."%]") and x:sub(-#eq-1, -1) ~= "]"..eq then
                     if x:sub(1, 1) == "\n" then
-              return "[" .. tostring(eq) .. "[\n" .. x .. "]" .. tostring(eq) .. "]"
+                        return "["..eq.."[\n"..x.."]"..eq.."]"
                     else
-              return "[" .. tostring(eq) .. "[" .. x .. "]" .. tostring(eq) .. "]"
+                        return "["..eq.."["..x.."]"..eq.."]"
                     end
                 end
             end
@@ -72,197 +62,158 @@ utils = {
     else
         return tostring(x)
     end
-  end,
+end
-  stringify = function(x)
+
+local function stringify(x)
     if type(x) == 'string' then
         return x
     else
-      return utils.repr(x)
+        return repr(x)
     end
-  end,
+end
-  split = function(str, sep)
+
+local function split(str, sep)
     if sep == nil then
         sep = "%s"
     end
-    local _accum_0 = { }
+    local ret = {}
-    local _len_0 = 1
+    for chunk in str:gmatch("[^"..sep.."]+") do
-    for chunk in str:gmatch("[^" .. tostring(sep) .. "]+") do
+        ret[#ret+1] = chunk
-      _accum_0[_len_0] = chunk
-      _len_0 = _len_0 + 1
     end
-    return _accum_0
+    return ret
-  end,
+end
-  remove_from_list = function(list, item)
+
-    for i, list_item in ipairs(list) do
+local function remove_from_list(list, item)
-      if list_item == item then
+    for i=1,#list do
+        if list[i] == item then
             table.remove(list, i)
             return 
         end
     end
-  end,
+end
-  accumulate = function(glue, co)
+
+local function accumulate(glue, co)
     if co == nil then
         glue, co = "", glue
     end
     local bits = { }
     for bit in coroutine.wrap(co) do
-      table.insert(bits, bit)
+        bits[#bits+1] = bit
     end
     return table.concat(bits, glue)
-  end,
-  range = function(start, stop, step)
-    if stop == nil then
-      start, stop, step = 1, start, 1
-    elseif step == nil then
-      step = 1
-    elseif step == 0 then
-      error("Range step cannot be zero.")
 end
-    return setmetatable({
+
-      start = start,
+local function nth_to_last(list, n)
-      stop = stop,
-      step = step
-    }, {
-      __ipairs = function(self)
-        local iter
-        iter = function(self, i)
-          if i <= (self.stop - self.start) / self.step then
-            return i + 1, self.start + i * self.step
-          end
-        end
-        return iter, self, 0
-      end,
-      __index = function(self, i)
-        if type(i) ~= "Number" then
-          return nil
-        end
-        if i % 1 ~= 0 then
-          return nil
-        end
-        if i <= 0 or i - 1 > (self.stop - self.start) / self.step then
-          return nil
-        end
-        return self.start + (i - 1) * self.step
-      end,
-      __len = function(self)
-        local len = (self.stop - self.start) / self.step
-        if len < 0 then
-          len = 0
-        end
-        return len
-      end
-    })
-  end,
-  nth_to_last = function(list, n)
     return list[#list - n + 1]
-  end,
+end
-  keys = function(t)
+
-    local _accum_0 = { }
+local function keys(t)
-    local _len_0 = 1
+    local ret = {}
     for k in pairs(t) do
-      _accum_0[_len_0] = k
+        ret[#ret+1] = k
-      _len_0 = _len_0 + 1
     end
-    return _accum_0
+    return ret
-  end,
+end
-  values = function(t)
+
-    local _accum_0 = { }
+local function values(t)
-    local _len_0 = 1
+    local ret = {}
     for _,v in pairs(t) do
-      _accum_0[_len_0] = v
+        ret[#ret+1] = v
-      _len_0 = _len_0 + 1
     end
-    return _accum_0
+    return ret
-  end,
-  set = function(list)
-    local _tbl_0 = { }
-    for _index_0 = 1, #list do
-      local i = list[_index_0]
-      _tbl_0[i] = true
 end
-    return _tbl_0
+
-  end,
+local function set(list)
-  sum = function(t)
+    local ret = {}
-    do
+    for i=1,#list do
+        ret[list[i]] = true
+    end
+    return ret
+end
+
+local function sum(t)
     local tot = 0
-      for _, x in pairs(t) do
+    for i=1,#t do
-        tot = tot + x
+        tot = tot + t[i]
     end
     return tot
 end
-  end,
+
-  product = function(t)
+local function product(t)
-    do
+    if #t > 5 and 0 < t[1] and t[1] < 1 then
+        local log, log_prod = math.log, 0
+        for i=1,#t do
+            log_prod = log_prod + log(t[i])
+        end
+        return math.exp(log_prod)
+    else
         local prod = 1
-      for _, x in pairs(t) do
+        for i=1,#t do
-        prod = prod * x
+            prod = prod * t[i]
         end
         return prod
     end
-  end,
-  all = function(t)
-    for _, x in pairs(t) do
-      if not x then
-        return false
 end
+
+local function all(t)
+    for i=1,#t do
+        if not t[i] then return false end
     end
     return true
-  end,
-  any = function(t)
-    for _, x in pairs(t) do
-      if x then
-        return true
 end
+
+local function any(t)
+    for i=1,#t do
+        if t[i] then return true end
     end
     return false
-  end,
+end
-  min = function(list, keyFn)
+
+local function min(list, keyFn)
     if keyFn == nil then
         keyFn = (function(x)
             return x
         end)
     end
-    assert(utils.is_list(list), "min() expects to be operating on a list")
-    do
-      local best = list[1]
     if type(keyFn) == 'table' then
         local keyTable = keyFn
         keyFn = function(k)
             return keyTable[k]
         end
     end
+    local best, bestKey = list[1], keyFn(best)
     for i = 2, #list do
-        if keyFn(list[i]) < keyFn(best) then
+        local key = keyFn(list[i])
-          best = list[i]
+        if key < bestKey then
+            best, bestKey = list[i], key
         end
     end
     return best
 end
-  end,
+
-  max = function(list, keyFn)
+local function max(list, keyFn)
     if keyFn == nil then
         keyFn = (function(x)
             return x
         end)
     end
-    assert(utils.is_list(list), "min() expects to be operating on a list")
-    do
-      local best = list[1]
     if type(keyFn) == 'table' then
         local keyTable = keyFn
         keyFn = function(k)
             return keyTable[k]
         end
     end
+    local best, bestKey = list[1], keyFn(best)
     for i = 2, #list do
-        if keyFn(list[i]) > keyFn(best) then
+        local key = keyFn(list[i])
-          best = list[i]
+        if key > bestKey then
+            best, bestKey = list[i], key
         end
     end
     return best
 end
-  end,
+
-  sort = function(list, keyFn, reverse)
+local function sort(list, keyFn, reverse)
     if keyFn == nil then
         keyFn = (function(x)
             return x
@@ -271,29 +222,20 @@ utils = {
     if reverse == nil then
         reverse = false
     end
-    assert(utils.is_list(list), "min() expects to be operating on a list")
     if type(keyFn) == 'table' then
         local keyTable = keyFn
         keyFn = function(k)
             return keyTable[k]
         end
     end
-    local comparison
+    table.sort(list, reverse
-    if reverse then
+        and (function(x,y) return keyFn(x) > keyFn(y) end)
-      comparison = (function(x, y)
+        or  (function(x,y) return keyFn(x) < keyFn(y) end))
-        return (keyFn(x) > keyFn(y))
+    return list
-      end)
-    else
-      comparison = (function(x, y)
-        return (keyFn(x) < keyFn(y))
-      end)
-    end
-    return table.sort(list, comparison)
-  end,
-  equivalent = function(x, y, depth)
-    if depth == nil then
-      depth = 1
 end
+
+local function equivalent(x, y, depth)
+    depth = depth or 1
     if x == y then
         return true
     end
@@ -306,27 +248,31 @@ utils = {
     if depth == 0 then
         return false
     end
+    local checked = {}
     for k, v in pairs(x) do
-      if not (utils.equivalent(y[k], v, depth - 1)) then
+        if not equivalent(y[k], v, depth - 1) then
             return false
         end
+        checked[k] = true
     end
     for k, v in pairs(y) do
-      if not (utils.equivalent(x[k], v, depth - 1)) then
+        if not checked[k] and not equivalent(x[k], v, depth - 1) then
             return false
         end
     end
     return true
-  end,
+end
-  key_for = function(t, value)
+
+local function key_for(t, value)
     for k, v in pairs(t) do
         if v == value then
             return k
         end
     end
     return nil
-  end,
+end
-  clamp = function(x, min, max)
+
+local function clamp(x, min, max)
     if x < min then
         return min
     elseif x > max then
@@ -334,11 +280,13 @@ utils = {
     else
         return x
     end
-  end,
+end
-  mix = function(min, max, amount)
+
+local function mix(min, max, amount)
     return (1 - amount) * min + amount * max
-  end,
+end
-  sign = function(x)
+
+local function sign(x)
     if x == 0 then
         return 0
     elseif x < 0 then
@@ -346,8 +294,9 @@ utils = {
     else
         return 1
     end
-  end,
+end
-  round = function(x, increment)
+
+local function round(x, increment)
     if increment == nil then
         increment = 1
     end
@@ -357,5 +306,9 @@ utils = {
         return math.ceil(x / increment - .5) * increment
     end
 end
-}
+
-return utils
+return {is_list=is_list, size=size, repr=repr, stringify=stringify, split=split,
+    remove_from_list=remove_from_list, accumulate=accumulate, nth_to_last=nth_to_last,
+    keys=keys, values=values, set=set, sum=sum, product=product, all=all, any=any,
+    min=min, max=max, sort=sort, equivalent=equivalent, key_for=key_for, clamp=clamp,
+    mix=mix, round=round}

utils.moon

@@ -1,178 +0,0 @@
-local utils
-utils = {
-    is_list: (t)->
-        if type(t) != 'table' then return false
-        i = 1
-        for _ in pairs(t)
-            if t[i] == nil then return false
-            i += 1
-        return true
-
-    size: (t)->
-        with n = 0
-            for _ in pairs(t) do n += 1
-
-    repr: (x)->
-        switch type(x)
-            when 'table'
-                mt = getmetatable(x)
-                if mt and mt.__tostring
-                    mt.__tostring(x)
-                elseif utils.is_list x
-                    "{#{table.concat([utils.repr(i) for i in *x], ", ")}}"
-                else
-                    "{#{table.concat(["[#{utils.repr(k)}]= #{utils.repr(v)}" for k,v in pairs x], ", ")}}"
-            when 'string'
-                if x == "\n"
-                    return "'\\n'"
-                elseif not x\find[["]] and not x\find"\n" and not x\find"\\"
-                    "\""..x.."\""
-                elseif not x\find[[']] and not x\find"\n" and not x\find"\\"
-                    "\'"..x.."\'"
-                else
-                    for i=0,math.huge
-                        eq = ("=")\rep(i)
-                        if not x\find"%]#{eq}%]" and not x\match(".*]#{eq}$")
-                            -- Stupid bullshit add an extra newline because lua discards first one if it exists
-                            if x\sub(1,1) == "\n"
-                                return "[#{eq}[\n"..x.."]#{eq}]"
-                            else
-                                return "[#{eq}["..x.."]#{eq}]"
-            else
-                tostring(x)
-    
-    stringify: (x)->
-        if type(x) == 'string' then x
-        else utils.repr(x)
-    
-    split: (str, sep="%s")->
-        [chunk for chunk in str\gmatch("[^#{sep}]+")]
-    
-    remove_from_list: (list, item)->
-        for i,list_item in ipairs(list)
-            if list_item == item
-                table.remove list, i
-                return
-    
-    accumulate: (glue, co)->
-        if co == nil then glue, co = "", glue
-        bits = {}
-        for bit in coroutine.wrap(co)
-            table.insert(bits, bit)
-        return table.concat(bits, glue)
-
-    range: (start,stop,step)->
-        if stop == nil
-            start,stop,step = 1,start,1
-        elseif step == nil
-            step = 1
-        elseif step == 0
-            error("Range step cannot be zero.")
-        return setmetatable({:start,:stop,:step}, {
-            __ipairs: =>
-                iter = (i)=>
-                    if i <= (@stop-@start)/@step
-                        return i+1, @start+i*@step
-                return iter, @, 0
-            __index: (i)=>
-                if type(i) != "Number" then return nil
-                if i % 1 != 0 then return nil
-                if i <= 0 or i-1 > (@stop-@start)/@step then return nil
-                return @start + (i-1)*@step
-            __len: =>
-                len = (@stop-@start)/@step
-                if len < 0 then len = 0
-                return len
-
-        })
-    
-    nth_to_last: (list, n) -> list[#list-n+1]
-
-    keys: (t)-> [k for k in pairs(t)]
-    values: (t)-> [v for _,v in pairs(t)]
-    set: (list)-> {i,true for i in *list}
-
-    sum: (t)->
-        with tot = 0
-            for _,x in pairs(t) do tot += x
-
-    product: (t)->
-        with prod = 1
-            for _,x in pairs(t) do prod *= x
-
-    all: (t)->
-        for _,x in pairs t
-            if not x then return false
-        return true
-
-    any: (t)->
-        for _,x in pairs t
-            if x then return true
-        return false
-
-    min: (list, keyFn=((x)->x))->
-        assert utils.is_list(list), "min() expects to be operating on a list"
-        with best = list[1]
-            if type(keyFn) == 'table'
-                keyTable = keyFn
-                keyFn = (k)->keyTable[k]
-            for i=2,#list
-                if keyFn(list[i]) < keyFn(best)
-                    best = list[i]
-    
-    max: (list, keyFn=((x)->x))->
-        assert utils.is_list(list), "min() expects to be operating on a list"
-        with best = list[1]
-            if type(keyFn) == 'table'
-                keyTable = keyFn
-                keyFn = (k)->keyTable[k]
-            for i=2,#list
-                if keyFn(list[i]) > keyFn(best)
-                    best = list[i]
-    
-    sort: (list, keyFn=((x)->x), reverse=false)->
-        assert utils.is_list(list), "min() expects to be operating on a list"
-        if type(keyFn) == 'table'
-            keyTable = keyFn
-            keyFn = (k)->keyTable[k]
-        comparison = if reverse then ((x,y)->(keyFn(x)>keyFn(y))) else ((x,y)->(keyFn(x)<keyFn(y)))
-        table.sort list, comparison
-
-    equivalent: (x,y,depth=1)->
-        if x == y then return true
-        if type(x) != type(y) then return false
-        if type(x) != 'table' then return false
-        if depth == 0 then return false
-        for k,v in pairs(x)
-            unless utils.equivalent(y[k], v, depth-1)
-                return false
-        for k,v in pairs(y)
-            unless utils.equivalent(x[k], v, depth-1)
-                return false
-        return true
-
-    key_for: (t, value)->
-        for k,v in pairs(t)
-            if v == value
-                return k
-        return nil
-
-    clamp: (x, min,max)->
-        if x < min then min
-        elseif x > max then max
-        else x
-
-    mix: (min,max, amount)->
-        (1-amount)*min + amount*max
-
-    sign: (x)->
-        if x == 0 then 0
-        elseif x < 0 then -1
-        else 1
-
-    round: (x, increment=1)->
-        if x >= 0 then math.floor(x/increment + .5)*increment
-        else math.ceil(x/increment - .5)*increment
-
-}
-return utils