Remove obsolete stuffs

bin/cmder/vendor/clink-completions/modules/funclib.lua

@@ -0,0 +1,100 @@
+
+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