util and fun

6 files changed, 151 insertions, 36 deletions

diff --git a/src/luarocks/build.lua b/src/luarocks/build.lua
index 56e5ebd4..c294b98e 100644
--- a/src/luarocks/build.lua
+++ b/src/luarocks/build.lua
@@ -14,7 +14,7 @@ local repos = require("luarocks.repos")
 local writer = require("luarocks.manif.writer")
 local deplocks = require("luarocks.deplocks")
 
-build.opts = util.opts_table("build.opts", {
+build.opts = util.opts_table("build.opts", { --WORK
    need_to_fetch = "boolean",
    minimal_mode = "boolean",
    deps_mode = "string",
diff --git a/src/luarocks/cmd/install.lua b/src/luarocks/cmd/install.lua
index c3b5f811..4f27e471 100644
--- a/src/luarocks/cmd/install.lua
+++ b/src/luarocks/cmd/install.lua
@@ -54,7 +54,7 @@ function install.add_to_parser(parser)
    parser:flag("--sign"):hidden(true)
 end
 
-install.opts = util.opts_table("install.opts", {
+install.opts = util.opts_table("install.opts", { --WORK
    namespace = "string?",
    keep = "boolean",
    force = "boolean",
diff --git a/src/luarocks/core/util.lua b/src/luarocks/core/util.lua
index f72f1ec6..8cd2d25e 100644
--- a/src/luarocks/core/util.lua
+++ b/src/luarocks/core/util.lua
@@ -9,10 +9,9 @@ local util = {Ordering = {}, }
 
 
 
-local dir_sep = package.config:sub(1, 1)
-
 
 
+local dir_sep = package.config:sub(1, 1)
 
 
 
diff --git a/src/luarocks/fun.tl b/src/luarocks/fun.tl
new file mode 100644
index 00000000..f52e059d
--- /dev/null
+++ b/src/luarocks/fun.tl
@@ -0,0 +1,148 @@
+
+--- A set of basic functional utilities
+local record fun
+end
+
+function fun.concat(xs: {any}, ys: {any}): {any} --? not generic becuse lua suports differnt types in one array
+   local rs = {}
+   local n = #xs
+   for i = 1, n do
+      rs[i] = xs[i]
+   end
+   for i = 1, #ys do
+      rs[i + n] = ys[i]
+   end
+   return rs
+end
+
+function fun.contains(xs: {any}, v: any): boolean --? same logic as above fine?
+   for _, x in ipairs(xs) do
+      if v == x then
+         return true
+      end
+   end
+   return false
+end
+
+function fun.map<K, V>(xs: {K}, f: function(K): V): {V} --? right
+   local rs = {}
+   for i = 1, #xs do
+      rs[i] = f(xs[i])
+   end
+   return rs
+end
+
+function fun.filter<K>(xs: {K}, f: function): {K}
+   local rs = {}
+   for i = 1, #xs do
+      local v = xs[i]
+      if f(v) then
+         rs[#rs+1] = v
+      end
+   end
+   return rs
+end
+
+function fun.traverse<K, V>(t: {K}, f: function(K): V): {V} --? right or {any} | any
+   return fun.map(t, function(x: K): V
+      -- return x is table and fun.traverse(x, f) or f(x) --? 
+      if x is {any} then
+         fun.traverse(x, f)
+      else
+         f(x)
+      end
+   end)
+end
+
+function fun.reverse_in(t: {any}): {any}
+   for i = 1, math.floor(#t/2) do
+      local m, n = i, #t - i + 1
+      local a, b = t[m], t[n]
+      t[m] = b
+      t[n] = a
+   end
+   return t
+end
+
+function fun.sort_in<K>(t: {K}, f: table.SortFunction<K>): {K}
+   table.sort(t, f)
+   return t
+end
+
+function fun.flip<K, V, S>(f: function(K, V): S): function(V, K): S
+   return function(a: V, b: K): S
+      return f(b, a)
+   end
+end
+
+function fun.find(xs: function | {any}, f: function): any
+   if xs is function then
+      for v in xs do
+         local x = f(v)
+         if x then
+            return x
+         end
+      end
+   elseif xs is {any} then
+      for _, v in ipairs(xs) do
+         local x = f(v)
+         if x then
+            return x
+         end
+      end
+   end
+end
+
+function fun.partial<K>(f: (function(...: any): K), ...: any): (function(...: any): K)
+   local n = select("#", ...)
+   if n == 1 then
+      local a = ...
+      return function(...): K
+         return f(a, ...)
+      end
+   elseif n == 2 then
+      local a, b = ...
+      return function(...): K
+         return f(a, b, ...)
+      end
+   else
+      local pargs = { n = n, ... }
+      return function(...): K
+         local m = select("#", ...)
+         local fargs = { ... }
+         local args = {}
+         for i = 1, n do
+            args[i] = pargs[i]
+         end
+         for i = 1, m do
+            args[i+n] = fargs[i]
+         end
+         return f(table.unpack(args, 1, n+m))
+      end
+   end
+end
+
+function fun.memoize(fn)
+   local memory = setmetatable({}, { __mode = "k" })
+   local errors = setmetatable({}, { __mode = "k" })
+   local NIL = {}
+   return function(arg)
+      if memory[arg] then
+         if memory[arg] == NIL then
+            return nil, errors[arg]
+         end
+         return memory[arg]
+      end
+      local ret1, ret2 = fn(arg)
+      if ret1 ~= nil then
+         memory[arg] = ret1
+      else
+         memory[arg] = NIL
+         errors[arg] = ret2
+      end
+      return ret1, ret2
+   end
+end
+
+return fun
+--? look for wrong/missing generics usage
\ No newline at end of file
diff --git a/src/luarocks/util.lua b/src/luarocks/util-original.lua
index de9157fc..de9157fc 100644
--- a/src/luarocks/util.lua
+++ b/src/luarocks/util-original.lua
diff --git a/src/luarocks/util.tl b/src/luarocks/util.tl
index 505584a0..aa04a3f3 100644
--- a/src/luarocks/util.tl
+++ b/src/luarocks/util.tl
@@ -548,38 +548,6 @@ do
       }
    end
 end
-
-function util.opts_table(type_name: string, valid_opts: {string: string}): function({string : string}): {string : string}
-   local opts_mt: metatable<{string : string}> = {
-      -- type: function(): string --!
-   }
-
-   opts_mt.__index = opts_mt
-
-   function opts_mt.type(): string --!
-      return type_name
-   end
-
-   return function(opts: {string: string}): {string: string}
-      for k, v in pairs(opts) do
-         local tv = type(v)
-         if not valid_opts[k] then
-            error("invalid option: "..k)
-         end
-         local vo, optional = valid_opts[k]:match("^(.-)(%??)$")
-         if not (tv == vo or (optional == "?" and tv == nil)) then
-            error("invalid type option: "..k.." - got "..tv..", expected "..vo)
-         end
-      end
-      for k, v in pairs(valid_opts) do
-         if (not v:find("?", 1, true)) and opts[k] == nil then
-            error("missing option: "..k)
-         end
-      end
-      return setmetatable(opts, opts_mt)
-   end
-end
-
 --- Return a table of modules that are already provided by the VM, which
 -- can be specified as dependencies without having to install an actual rock.
 -- @param rockspec (optional) a rockspec table, so that rockspec format