101 lines
3.4 KiB
Lua
101 lines
3.4 KiB
Lua
|
|
local exports = {}
|
|
|
|
--- Implementation of table.filter function. Applies filter function to each
|
|
-- element of table and returns a new table with values for which filter
|
|
-- returns 'true'.
|
|
--
|
|
-- @param tbl a table to filter. Default is an empty table.
|
|
-- @param filter function that accepts an element of table, specified in the
|
|
-- first argument and returns either 'true' or 'false'. If not specified,
|
|
-- then default function is used that returns its argument.
|
|
--
|
|
-- @return a new table with values that are not filtered out by 'filter' function.
|
|
exports.filter = function (tbl, filter)
|
|
if not tbl then return {} end
|
|
if not filter then filter = function(v) return v end end
|
|
local ret = {}
|
|
for _,v in ipairs(tbl) do
|
|
if filter(v) then table.insert(ret, v) end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
--- Implementation of table.map function. Applies filter function to each
|
|
-- element of table and returns a new table with values returned by mapper
|
|
-- function.
|
|
--
|
|
-- @param tbl a table to filter. Default is an empty table.
|
|
-- @param map_func function that accepts an element of table, specified in the
|
|
-- first argument and returns a new value for resultant table. If not
|
|
-- specified, then 'map' function returns it input table.
|
|
--
|
|
-- @return a new table with values produced by 'map_func'.
|
|
exports.map = function (tbl, map_func)
|
|
assert(tbl == nil or type(tbl) == "table",
|
|
"First argument must be either table or nil")
|
|
|
|
assert(map_func == nil or type(map_func) == "function",
|
|
"Second argument must be either function or nil")
|
|
|
|
if tbl == nil then return {} end
|
|
if not map_func then return tbl end
|
|
local ret = {}
|
|
for _,v in ipairs(tbl) do
|
|
table.insert(ret, map_func(v))
|
|
end
|
|
return ret
|
|
end
|
|
|
|
--- Implementation of table.reduce function. Iterates through table and calls
|
|
-- 'func' function passing an accumulator and an entry from the original
|
|
-- table. The result of table is stored in accumulator and passed to next
|
|
-- 'func' call.
|
|
--
|
|
-- @param accum an accumulator, initial value that will be passed to first
|
|
-- 'func' call.
|
|
-- @param tbl a table to reduce. Default is an empty table.
|
|
-- @param func function that accepts two params: an accumulator and an element
|
|
-- of table, specified in the first argument and returns a new value for
|
|
-- accumulator.
|
|
--
|
|
-- @return a resultant accumulator value.
|
|
exports.reduce = function (accum, tbl, func)
|
|
assert(type(func) == "function",
|
|
"Third argument must be a function")
|
|
|
|
if not tbl then return accum end
|
|
for _,v in ipairs(tbl) do
|
|
accum = func(accum, v)
|
|
end
|
|
return accum
|
|
end
|
|
|
|
--- Concatenates any number of input values into one table. If input parameter is
|
|
-- a table then its values is copied to the end of resultant table. If the
|
|
-- parameter is single value, then it is appended to the resultant table. If
|
|
-- the input value is 'nil', then it is omitted.
|
|
--
|
|
-- @return a result of concatenation. The result is always a table.
|
|
exports.concat = function (...)
|
|
local input = {...}
|
|
local ret = {}
|
|
local i = 1
|
|
|
|
while i <= #input do
|
|
local arg = input[i]
|
|
if type(arg) == 'table' then
|
|
for _,v in ipairs(arg) do
|
|
table.insert(ret, v)
|
|
end
|
|
elseif arg ~= nil then
|
|
table.insert(ret, arg)
|
|
end
|
|
i = i + 1
|
|
end
|
|
|
|
return ret
|
|
end
|
|
|
|
return exports
|