@@ -4,26 +4,26 @@ module('functional') -- Raise an error if the given object is not of the required type local function require_type(o, t) - if g.type(o) ~= t then - g.error("Required type " .. t .. " but got " .. g.type(o), 1) - end + if g.type(o) ~= t then + g.error("Required type " .. t .. " but got " .. g.type(o), 1) + end end -- Concatenates two arrays local function concat(lhs, rhs) - require_type(lhs, "table") - require_type(rhs, "table") - - local result = {} - local i = 0 - for _, a in g.ipairs({lhs, rhs}) do - for _, v in nipairs(a) do - i = i + 1 - result[i] = v - end - end - - return result + require_type(lhs, "table") + require_type(rhs, "table") + + local result = {} + local i = 0 + for _, a in g.ipairs({lhs, rhs}) do + for _, v in nipairs(a) do + i = i + 1 + result[i] = v + end + end + + return result end -- Converts the given sequence into an expression list that can be used @@ -31,16 +31,16 @@ end -- it is unwrapped. If it is a table it is passed to the given iterator -- or ipairs if no default iterator was specified. local function to_iter(sequence, default_iter) - if sequence.iter then return g.unpack(sequence) end - default_iter = default_iter or g.ipairs - return default_iter(sequence) + if sequence.iter then return g.unpack(sequence) end + default_iter = default_iter or g.ipairs + return default_iter(sequence) end -- Wraps an expression list that can be used with a [generic for][] loop. -- This wrapped list can be used as an argument to any higher-order function -- that takes a [sequence](#sequence). function wrap_iter(func, invariant, control) - return { func, invariant, control, iter = true } + return { func, invariant, control, iter = true } end -- Returns an expression list (iterator function, invariant, control variable) @@ -56,21 +56,21 @@ end -- -- Performance is O(n), though it will be slower than using ipairs. function nipairs(arr) - require_type(arr, "table") - local upper = g.table.maxn(arr) - return function(a, i) - i = i + 1 - if i <= upper then - return i, a[i] - end - end, arr, 0 + require_type(arr, "table") + local upper = g.table.maxn(arr) + return function(a, i) + i = i + 1 + if i <= upper then + return i, a[i] + end + end, arr, 0 end -- Returns the given arguments as an array with an additional field, n, which -- includes the number of elements in the array. This is helpful when the given -- argument list contains nils which termiante array iteration (with ipairs). local function to_args(...) - return { n = g.select('#', ...), ... } + return { n = g.select('#', ...), ... } end -- Returns a new table that maps each key, k, to the result of f(value) for @@ -80,30 +80,30 @@ end -- -- Example: map(f, { k1 = v1, k2 = v2, ..}) -> { k1 = f(v1), k2 = f(v2), ... } function map(func, seq) - require_type(func, "function") - require_type(seq, "table") + require_type(func, "function") + require_type(seq, "table") - local result = {} - for k, v in to_iter(seq, g.pairs) do - result[k] = func(v) - end + local result = {} + for k, v in to_iter(seq, g.pairs) do + result[k] = func(v) + end - return result + return result end -- Returns a value computed by applying a function to an accumulation value and -- each array element in turn. The evaluation is left to right. If `seq` is empty -- then the init value is returned. function reduce(func, init, seq) - require_type(func, "function") - require_type(seq, "table") + require_type(func, "function") + require_type(seq, "table") - local result = init - for _, v in to_iter(seq) do - result = func(result, v) - end + local result = init + for _, v in to_iter(seq) do + result = func(result, v) + end - return result + return result end -- Returns a a copy of `seq` sorted using `func`. This method uses the [Schwartzian @@ -113,12 +113,12 @@ end -- -- [Schwartzian Transform]: http://en.wikipedia.org/wiki/Schwartzian_transform function sort_by(func, seq) - require_type(func, "function") - require_type(seq, "table") + require_type(func, "function") + require_type(seq, "table") - local result = map(function (v) return { func(v), v } end, seq) - g.table.sort(result, function (l, r) return l[1] < r[1] end) - return map(function (v) return v[2] end, result ) + local result = map(function (v) return { func(v), v } end, seq) + g.table.sort(result, function (l, r) return l[1] < r[1] end) + return map(function (v) return v[2] end, result ) end -- Sentinel used to indicate a parameter must be filled in with partial(...). @@ -132,33 +132,33 @@ g.setmetatable(PLACEHOLDER, { __tostring = function() return "PLACEHOLDER" end } -- For example, you could create a specialization of `math.pow` that returns -- powers of 3 as follows: -- --- threeToThePowerOf = partial(math.pow, 3, placeholder) +-- threeToThePowerOf = partial(math.pow, 3, placeholder) -- -- You could then call threeToThePowerOf like this: -- --- threeToThePowerOf(2) -> 9 --- threeToThePowerOF(4) -> 81 +-- threeToThePowerOf(2) -> 9 +-- threeToThePowerOF(4) -> 81 function partial(func, ...) - require_type(func, "function") - - local args = to_args(...) - local arg_iter = wrap_iter(nipairs(args)) - if false == reduce(function(a, v) return a or (v == PLACEHOLDER) end, false, arg_iter) then - return func(g.unpack(args, 1, args.n)) - end - - return function(...) - -- TODO: make this functional - local args = copy(args) -- This prevents side-effects - local myargs = to_args(...) - for i = 1, args.n do - if args[i] == PLACEHOLDER then - args[i] = g.table.remove(myargs, 1) or PLACEHOLDER - end - end - - return partial(func, g.unpack(concat(args, myargs), 1, args.n + myargs.n)) - end + require_type(func, "function") + + local args = to_args(...) + local arg_iter = wrap_iter(nipairs(args)) + if false == reduce(function(a, v) return a or (v == PLACEHOLDER) end, false, arg_iter) then + return func(g.unpack(args, 1, args.n)) + end + + return function(...) + -- TODO: make this functional + local args = copy(args) -- This prevents side-effects + local myargs = to_args(...) + for i = 1, args.n do + if args[i] == PLACEHOLDER then + args[i] = g.table.remove(myargs, 1) or PLACEHOLDER + end + end + + return partial(func, g.unpack(concat(args, myargs), 1, args.n + myargs.n)) + end end -- Given a function, the arity for the function, and an incomplete set of @@ -167,36 +167,36 @@ end -- argument and only requires the remaining arguments. Arguments are filled -- from left to right. This is a specialization of partial(...). function curry(func, arity, ...) - require_type(func, "function") - require_type(arity, "number") + require_type(func, "function") + require_type(arity, "number") - local args = { n = g.select('#', ...), ... } - for i = args.n + 1, arity do - g.table.insert(args, PLACEHOLDER) - end + local args = { n = g.select('#', ...), ... } + for i = args.n + 1, arity do + g.table.insert(args, PLACEHOLDER) + end - return partial(func, g.unpack(args)) + return partial(func, g.unpack(args)) end -- Takes a function and a [sequence](#sequence) and returns a new array containing only values -- where `func(value)` is `true`. function filter(func, seq) - require_type(func, "function") - require_type(seq, "table") + require_type(func, "function") + require_type(seq, "table") - local result = {} - for _, v in to_iter(seq) do - if func(v) then - g.table.insert(result, v) - end - end + local result = {} + for _, v in to_iter(seq) do + if func(v) then + g.table.insert(result, v) + end + end - return result + return result end -- Returns a shallow copy of the given [sequence](#sequence) function copy(seq) - return map(function(x) return x end, seq) + return map(function(x) return x end, seq) end -- Returns a new function that when called will first write all arguments @@ -204,14 +204,14 @@ end -- `tostring(func)` as the name of this function unless `name` is defined. This -- method will use `io.stdout` unless `out` is defined. function trace(func, name, out) - local out = out or g.io.stdout - local name = name or g.tostring(func) - return function(...) - string_args = map(function(x) return g.tostring(x) end, {...}) - out:write("Entering: " .. name .. "(" .. - g.table.concat(string_args, ', ', 1, g.select('#', ...)) .. ")\n") - return func(...) - end + local out = out or g.io.stdout + local name = name or g.tostring(func) + return function(...) + string_args = map(function(x) return g.tostring(x) end, {...}) + out:write("Entering: " .. name .. "(" .. + g.table.concat(string_args, ', ', 1, g.select('#', ...)) .. ")\n") + return func(...) + end end -- Adds all public functions and variables for this module to the given environment. @@ -220,13 +220,13 @@ end -- -- A common way to use this is: `functional.add_to_env(getfenv())` function add_to_env(env, force) - force = force or false - for k, v in g.pairs(g.getfenv()) do - if not (g.string.match(k, "^_.*") or k == "add_to_env") then - if env[k] then - error("Key collision for key '" .. k .. "'", 2) - end - env[k] = v - end - end + force = force or false + for k, v in g.pairs(g.getfenv()) do + if not (g.string.match(k, "^_.*") or k == "add_to_env") then + if env[k] then + error("Key collision for key '" .. k .. "'", 2) + end + env[k] = v + end + end end functional.lua @@ -3,57 +3,57 @@ require 'functional' functional.add_to_env(getfenv()) function test_map() - local a = {} - for i = 1, 10 do a[i] = i end - map(function(x) return x * 10 end, a) + local a = {} + for i = 1, 10 do a[i] = i end + map(function(x) return x * 10 end, a) end function test_reduce() - local a = {} - for i = 1, 10 do a[i] = i end - reduce(function(t, v) return t + v end, 0, a) + local a = {} + for i = 1, 10 do a[i] = i end + reduce(function(t, v) return t + v end, 0, a) end function test_sort_by() - local a = {} - for i = 10, 1, -1 do a[i] = i end - sort_by(function(x) return x end, a) + local a = {} + for i = 10, 1, -1 do a[i] = i end + sort_by(function(x) return x end, a) end function test_partial() - local func = function(x, y) return x + y end - local partial = partial(func, 5, PLACEHOLDER) - partial(10) + local func = function(x, y) return x + y end + local partial = partial(func, 5, PLACEHOLDER) + partial(10) end function test_curry() - local func = function(x, y) return x + y end - local curried = curry(func, 2, 5) - curried(10) + local func = function(x, y) return x + y end + local curried = curry(func, 2, 5) + curried(10) end function test_filter() - local a = {} - for i = 1, 10 do a[i] = i end - filter(function(x) return x % 2 == 1 end, a) + local a = {} + for i = 1, 10 do a[i] = i end + filter(function(x) return x % 2 == 1 end, a) end function run_test(func, count) - local start = os.clock() - for i = 1, count do func() end - return os.clock() - start + local start = os.clock() + for i = 1, count do func() end + return os.clock() - start end tests = { - test_map = 100 * 1000, - test_reduce = 100 * 1000, - test_sort_by = 25 * 1000, - test_partial = 25 * 1000, - test_curry = 25 * 1000, - test_filter = 100 * 1000, + test_map = 100 * 1000, + test_reduce = 100 * 1000, + test_sort_by = 25 * 1000, + test_partial = 25 * 1000, + test_curry = 25 * 1000, + test_filter = 100 * 1000, } for test_name, count in pairs(tests) do - local result = run_test(_G[test_name], count) - print(test_name .. "(" .. count .. ")", result) + local result = run_test(_G[test_name], count) + print(test_name .. "(" .. count .. ")", result) end functional_perf.lua @@ -3,163 +3,163 @@ require 'functional' functional.add_to_env(getfenv()) function do_assert(condition, message, depth) - if not condition then - error(message, depth) - end + if not condition then + error(message, depth) + end end function assert_equals(expected, actual, depth) - depth = depth or 3 - do_assert(expected == actual, "Values do not match. Expected: " .. tostring(expected) - .. " Actual: " .. tostring(actual), depth) + depth = depth or 3 + do_assert(expected == actual, "Values do not match. Expected: " .. tostring(expected) + .. " Actual: " .. tostring(actual), depth) end function assert_array_equals(expected, actual) - assert_equals("table", type(expected), 4) - assert_equals("table", type(actual), 4) + assert_equals("table", type(expected), 4) + assert_equals("table", type(actual), 4) - local expected_arr = {} - for _, v in ipairs(expected) do table.insert(expected_arr, v) end + local expected_arr = {} + for _, v in ipairs(expected) do table.insert(expected_arr, v) end - local actual_arr = {} - for _, v in ipairs(actual) do table.insert(actual_arr, v) end + local actual_arr = {} + for _, v in ipairs(actual) do table.insert(actual_arr, v) end - assert_table_equals(expected_arr, actual_arr) + assert_table_equals(expected_arr, actual_arr) end function assert_table_equals(expected, actual) - assert_equals("table", type(expected), 4) - assert_equals("table", type(actual), 4) + assert_equals("table", type(expected), 4) + assert_equals("table", type(actual), 4) - for k, v in pairs(expected) do - do_assert(v == actual[k], "Values do not match. Key: " .. k .. " Expected: " - .. tostring(v) .. " Actual: " .. tostring(actual[k])) - end - for k, v in pairs(actual) do - do_assert(v == expected[k], "Values do not match. Key: " .. k .. " Expected: " - .. tostring(v) .. " Actual: " .. tostring(expected[k])) - end + for k, v in pairs(expected) do + do_assert(v == actual[k], "Values do not match. Key: " .. k .. " Expected: " + .. tostring(v) .. " Actual: " .. tostring(actual[k])) + end + for k, v in pairs(actual) do + do_assert(v == expected[k], "Values do not match. Key: " .. k .. " Expected: " + .. tostring(v) .. " Actual: " .. tostring(expected[k])) + end end function test_nipairs() - local a = { 1, 2, nil, 4, a = 25 } - local expected = { 1, 2, nil, 4 } + local a = { 1, 2, nil, 4, a = 25 } + local expected = { 1, 2, nil, 4 } - local visited = 0 - for k, v in nipairs(a) do - assert_equals(expected[k], v) - visited = visited + 1 - end + local visited = 0 + for k, v in nipairs(a) do + assert_equals(expected[k], v) + visited = visited + 1 + end end function test_map() - mapped = map(function(x) return x + 1 end, { 1, 2, 3, n = 4 }) - assert_array_equals({ 2, 3, 4 }, mapped) - assert_equals(5, mapped.n) + mapped = map(function(x) return x + 1 end, { 1, 2, 3, n = 4 }) + assert_array_equals({ 2, 3, 4 }, mapped) + assert_equals(5, mapped.n) end function test_map_empty() - assert_array_equals({}, map(function(x) return x + 1 end, {})) + assert_array_equals({}, map(function(x) return x + 1 end, {})) end function test_reduce() - assert_equals(16, reduce(function(t, v) return t + v end, 10, { 1, 2, 3 })) + assert_equals(16, reduce(function(t, v) return t + v end, 10, { 1, 2, 3 })) end function test_reduce_empty() - assert_equals(5, reduce(function(t, v) return t + v end, 5, {})) + assert_equals(5, reduce(function(t, v) return t + v end, 5, {})) end function test_reduce_with_nipairs() - local a = { 1, nil, 5 } - local addButResetForNil = function(t, v) - return v and t + v or 0 - end - assert_equals(5, reduce(addButResetForNil, 0, wrap_iter(nipairs(a)))) + local a = { 1, nil, 5 } + local addButResetForNil = function(t, v) + return v and t + v or 0 + end + assert_equals(5, reduce(addButResetForNil, 0, wrap_iter(nipairs(a)))) end function test_sort_by() - assert_array_equals({ 1, 2, 3}, sort_by(function(x) return x end, { 1, 3, 2 })) + assert_array_equals({ 1, 2, 3}, sort_by(function(x) return x end, { 1, 3, 2 })) end function test_sort_by_empty() - assert_array_equals({}, sort_by(function(x) return x end, {})) + assert_array_equals({}, sort_by(function(x) return x end, {})) end function test_partial() - local func = function(x, y, z) return { x, y, z } end - local partial = partial(func, PLACEHOLDER, 'b', PLACEHOLDER) - assert_equals("function", type(partial)) - assert_equals("function", type(partial('a'))) - assert_array_equals({ 'a', 'b', 'c' }, partial('a')('c')) - assert_array_equals({ 'a', 'b', 'c' }, partial('a', 'c')) + local func = function(x, y, z) return { x, y, z } end + local partial = partial(func, PLACEHOLDER, 'b', PLACEHOLDER) + assert_equals("function", type(partial)) + assert_equals("function", type(partial('a'))) + assert_array_equals({ 'a', 'b', 'c' }, partial('a')('c')) + assert_array_equals({ 'a', 'b', 'c' }, partial('a', 'c')) end function test_partial_with_nil() - local func = function(x, y) return { x, y } end - local partial = partial(func, nil, PLACEHOLDER) - assert_equals("function", type(partial)) - assert_table_equals({ nil, 'a' }, partial('a')) + local func = function(x, y) return { x, y } end + local partial = partial(func, nil, PLACEHOLDER) + assert_equals("function", type(partial)) + assert_table_equals({ nil, 'a' }, partial('a')) end function test_curry() - local func = function(x, y, z) return { x, y, z } end - local curried = curry(func, 3, 'a') - assert_equals("function", type(curried)) - assert_equals("function", type(curried('b'))) - assert_array_equals({ 'a', 'b', 'c' }, curried('b')('c')) - assert_array_equals({ 'a', 'b', 'c' }, curried('b', 'c')) + local func = function(x, y, z) return { x, y, z } end + local curried = curry(func, 3, 'a') + assert_equals("function", type(curried)) + assert_equals("function", type(curried('b'))) + assert_array_equals({ 'a', 'b', 'c' }, curried('b')('c')) + assert_array_equals({ 'a', 'b', 'c' }, curried('b', 'c')) end function test_curry_with_zero_arity() - assert_equals(5, curry(function() return 5 end, 0)) + assert_equals(5, curry(function() return 5 end, 0)) end function test_filter_none() - assert_array_equals({}, filter(function() return false end, { 1, 2, 3, 4 })) + assert_array_equals({}, filter(function() return false end, { 1, 2, 3, 4 })) end function test_filter_all() - assert_array_equals({ 1, 2, 3, 4 }, filter(function() return true end, { 1, 2, 3, 4 })) + assert_array_equals({ 1, 2, 3, 4 }, filter(function() return true end, { 1, 2, 3, 4 })) end function test_filter_even() - local even = function(x) return x % 2 == 0 end - assert_array_equals({ 2, 4 }, filter(even, { 1, 2, 3, 4 })) + local even = function(x) return x % 2 == 0 end + assert_array_equals({ 2, 4 }, filter(even, { 1, 2, 3, 4 })) end function test_copy() - local array = { 'a', 'b', 'c' } - local copy = copy(array) - assert(array ~= copy, "array and it's copy should not be the same object") - assert_array_equals(array, copy) + local array = { 'a', 'b', 'c' } + local copy = copy(array) + assert(array ~= copy, "array and it's copy should not be the same object") + assert_array_equals(array, copy) end function test_wrap_iter_example() - local array = { 'a', 'b', 'c', nil, 'e' } - local sequence = wrap_iter(nipairs(array)) - local concatenate = function(t, v) return v and t .. v or t end - local result = reduce(concatenate, "", sequence) - assert_equals("abce", result) + local array = { 'a', 'b', 'c', nil, 'e' } + local sequence = wrap_iter(nipairs(array)) + local concatenate = function(t, v) return v and t .. v or t end + local result = reduce(concatenate, "", sequence) + assert_equals("abce", result) end function test_trace() - local mock_out = { - buffer = "", - write = function (self, ...) - self.buffer = self.buffer .. ... - end - } + local mock_out = { + buffer = "", + write = function (self, ...) + self.buffer = self.buffer .. ... + end + } - local tracer = trace(function(...) end, nil, mock_out) - tracer(100, 'abc', function() end) - assert(mock_out.buffer ~= "", "Buffer should contain trace output, but it was empty") + local tracer = trace(function(...) end, nil, mock_out) + tracer(100, 'abc', function() end) + assert(mock_out.buffer ~= "", "Buffer should contain trace output, but it was empty") end -- Run the tests for test_name, test in pairs(getfenv()) do - if string.match(test_name, "test_.*") then - print(test_name) - test() - end + if string.match(test_name, "test_.*") then + print(test_name) + test() + end end functional_tests.lua 6ded479f60a9334096187e88e3171b5eedbc1611 Chris Pettitt chris@samsarin.com http://github.com/samsarin/lua-functional/commit/a8fd5b29ea099f6d21afcff7526d332e47566ad8 a8fd5b29ea099f6d21afcff7526d332e47566ad8 2008-06-15T11:59:23-07:00 2008-06-15T11:59:23-07:00 Switch to new coding style: tabs instead of spaces. 224ebdcfda6fc7ecdfd4af0a84c7fb688f38823e Chris Pettitt chris@samsarin.com