| local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local ipairs = _tl_compat and _tl_compat.ipairs or ipairs; local math = _tl_compat and _tl_compat.math or math; local table = _tl_compat and _tl_compat.table or table; local _tl_table_unpack = unpack or table.unpack; local type = type |
|
|
| local fun = {} |
|
|
|
|
| function fun.concat(xs, ys) |
| 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, v) |
| for _, x in ipairs(xs) do |
| if v == x then |
| return true |
| end |
| end |
| return false |
| end |
|
|
| function fun.map(xs, f) |
| local rs = {} |
| for i = 1, #xs do |
| rs[i] = f(xs[i]) |
| end |
| return rs |
| end |
|
|
| function fun.filter(xs, f) |
| 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.reverse_in(t) |
| 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(t, f) |
| table.sort(t, f) |
| return t |
| end |
|
|
| function fun.flip(f) |
| return function(a, b) |
| return f(b, a) |
| end |
| end |
|
|
| function fun.find(xs, f) |
| if type(xs) == "table" then |
| for _, x in ipairs(xs) do |
| local r = f(x) |
| if r then |
| return r |
| end |
| end |
| else |
| for x in xs do |
| local r = f(x) |
| if r then |
| return r |
| end |
| end |
| end |
| end |
|
|
|
|
| function fun.partial(f, ...) |
| local n = select("#", ...) |
| if n == 1 then |
| local a = ... |
| return function(...) |
| return f(a, ...) |
| end |
| elseif n == 2 then |
| local a, b = ... |
| return function(...) |
| return f(a, b, ...) |
| end |
| else |
| local pargs = { n = n, ... } |
| return function(...) |
| 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(_tl_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(a) |
| if memory[a] then |
| if memory[a] == NIL then |
| return nil, errors[a] |
| end |
| return memory[a] |
| end |
| local ret1, ret2 = fn(a) |
| if ret1 then |
| memory[a] = ret1 |
| else |
| memory[a] = NIL |
| errors[a] = ret2 |
| end |
| return ret1, ret2 |
| end |
| end |
|
|
| return fun |
|
|
