Version 2.0.0

- The old functionality of lume.merge() is now spread across
  lume.merge() (for tables) and lume.concat() (for arrays). Both these
  functions create new tables rather than operating in-place
- Changed lume.fn() to use lume.concat() internally

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014, rxi
+Copyright (c) 2015, rxi
 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of

README.md

@@ -38,7 +38,7 @@ lume.lerp(100, 200, .5) -- Returns 150
 ```
 
 ### lume.smooth(a, b, amount)
-Similar to `lume.lerp()` but uses cosine interpolation instead of linear
+Similar to `lume.lerp()` but uses cubic interpolation instead of linear
 interpolation.
 
 ### lume.pingpong(x)
@@ -75,7 +75,17 @@ lume.weightedchoice({ ["cat"] = 10, ["dog"] = 5, ["frog"] = 0 })
 ```
 
 ### lume.shuffle(t)
-Shuffles the values of array `t` in place, returns the array.
+Returns a shuffled copy of the array `t`.
+
+### lume.sort(t [, comp])
+Returns a copy of the array `t` with all its items sorted. If `comp` is a
+function it will be used to compare the items when sorting. If `comp` is a
+string it will be used as the key to sort the items by.
+```lua
+lume.sort({ 1, 4, 3, 2, 5 }) -- Returns { 1, 2, 3, 4, 5 }
+lume.sort({ {z=2}, {z=3}, {z=1} }, "z") -- Returns { {z=1}, {z=2}, {z=3} }
+lume.sort({ 1, 3, 2 }, function(a, b) return a > b end) -- Returns { 3, 2, 1 }
+```
 
 ### lume.array(...)
 Iterates the supplied iterator and returns an array filled with the values.
@@ -125,10 +135,8 @@ an error is raised,
 lume.reduce({1, 2, 3}, function(a, b) return a + b end) -- Returns 6
 ```
 
-### lume.set(t [, retainkeys])
-Returns a copy of the `t` table with all the duplicate values removed. If
-`retainkeys` is true the table is not treated as an array and retains its
-original keys.
+### lume.set(t)
+Returns a copy of the `t` array with all the duplicate values removed. 
 ```lua
 lume.set({2, 1, 2, "cat", "cat"}) -- Returns {1, 2, "cat"}
 ```
@@ -141,12 +149,17 @@ an array and retains its original keys.
 lume.filter({1, 2, 3, 4}, function(x) return x % 2 == 0 end) -- Returns {2, 4}
 ```
 
-### lume.merge(t, t2 [, retainkeys])
-Merges all the values from the table `t2` into `t` in place. If `retainkeys` is
-true the table is not treated as an array and retains its original keys; if `t`
-and `t2` have a conflicting key, the value from `t2` is used.
+### lume.merge(...)
+Returns a new table with all the given tables merged together. If a key exists
+in multiple tables the right-most table's value is used.
 ```lua
-lume.merge({2, 3}, {4, 5}) -- Returns {2, 3, 4, 5}
+lume.merge({a=1, b=2, c=3}, {c=8, d=9}) -- Returns {a=1, b=2, c=8, d=9}
+```
+
+### lume.concat(...)
+Returns a new array consisting of all the given arrays concatenated into one.
+```lua
+lume.concat({1, 2}, {3, 4}, {5, 6}) -- Returns {1, 2, 3, 4, 5, 6}
 ```
 
 ### lume.find(t, value)
@@ -178,6 +191,20 @@ than a string. Creates and returns a new array of the given slice.
 lume.slice({"a", "b", "c", "d", "e"}, 2, 4) -- Returns {"b", "c", "d"}
 ```
 
+### lume.first(t [, n])
+Returns the first element of an array or nil if the array is empty. If `n` is
+specificed an array of the first `n` elements is returned.
+```lua
+lume.first({"a", "b", "c"}) -- Returns "a"
+```
+
+### lume.last(t [, n])
+Returns the last element of an array or nil if the array is empty. If `n` is
+specificed an array of the last `n` elements is returned.
+```lua
+lume.last({"a", "b", "c"}) -- Returns "c"
+```
+
 ### lume.invert(t)
 Returns a copy of the table where the keys have become the values and the
 values the keys.
@@ -185,6 +212,9 @@ values the keys.
 lume.invert({a = "x", b = "y"}) -- returns {x = "a", y = "b"}
 ```
 
+### lume.keys(t)
+Returns an array containing each key of the table.
+
 ### lume.clone(t)
 Returns a shallow copy of the table `t`.
 
@@ -208,6 +238,32 @@ f() -- Prints "Hello"
 f() -- Does nothing
 ```
 
+### lume.memoize(fn)
+Returns a wrapper function to `fn` where the results for any given set of
+arguments are cached. `lume.memoize()` is useful when used on functions with
+slow-running computations.
+```lua
+fib = lume.memoize(function(n) return n < 2 and n or fib(n-1) + fib(n-2) end)
+```
+
+### lume.combine(...)
+Creates a wrapper function which calls each supplied argument in the order they
+were passed to `lume.combine()`; nil arguments are ignored. The wrapper
+function passes its own arguments to each of its wrapped functions when it is
+called.
+```lua
+local f = lume.combine(function(a, b) print(a + b) end,
+                       function(a, b) print(a * b) end)
+f(3, 4) -- Prints "7" then "12" on a new line
+```
+
+### lume.call(fn, ...)
+Calls the given function with the provided arguments and returns its values. If
+`fn` is `nil` then no action is performed and the function returns `nil`.
+```lua
+lume.call(print, "Hello world") -- Prints "Hello world"
+```
+
 ### lume.time(fn, ...)
 Inserts the arguments into function `fn` and calls it. Returns the time in
 seconds the function `fn` took to execute followed by `fn`'s returned values.
@@ -215,16 +271,6 @@ seconds the function `fn` took to execute followed by `fn`'s returned values.
 lume.time(function(x) return x end, "hello") -- Returns 0, "hello"
 ```
 
-### lume.combine(...)
-Creates a wrapper function which calls each supplied argument in the order they
-were passed to `lume.combine`. The wrapper function passes its own arguments to
-each of its wrapped functions when it is called.
-```lua
-local f = lume.combine(function(a, b) print(a + b) end,
-                       function(a, b) print(a * b) end)
-f(3, 4) -- Prints "7" then "12" on a new line
-```
-
 ### lume.lambda(str)
 Takes a string lambda and returns a function. `str` should be a list of
 comma-separated parameters, followed by `->`, followed by the expression which
@@ -268,6 +314,15 @@ instead of whitespace.
 lume.trim("  Hello  ") -- Returns "Hello"
 ```
 
+### lume.wordwrap(str [, limit])
+Returns `str` wrapped to `limit` number of characters per line, by default
+`limit` is `72`. `limit` can also be a function which when passed a string,
+returns `true` if it is too long for a single line.
+```lua
+-- Returns "Hello world\nThis is a\nshort string"
+lume.wordwrap("Hello world. This is a short string", 14)
+```
+
 ### lume.format(str [, vars])
 Returns a formatted string. The values of keys in the table `vars` can be
 inserted into the string by using the form `"{key}"` in `str`; numerical keys
@@ -306,6 +361,17 @@ lume.hotswap("lume") -- Reloads the lume module
 assert(lume.hotswap("inexistant_module")) -- Raises an error
 ```
 
+### lume.ripairs(t)
+Performs the same function as `ipairs()` but iterates in reverse; this allows
+the removal of items from the table during iteration without any items being
+skipped.
+```lua
+-- Prints "3->c", "2->b" and "1->a" on separate lines
+for i, v in lume.ripairs({ "a", "b", "c" }) do
+  print(i .. "->" .. v)
+end
+```
+
 ### lume.rgba(color)
 Takes the 32bit integer `color` argument and returns 4 numbers, one for each
 channel, with a range of 0 - 255. The returned values can be used as the
@@ -324,6 +390,11 @@ lume.chain({1, 2, 3, 4})
   :map(function(x) return -x end)
   :result() -- Returns { -2, -4 }
 ```
+The table returned by the `lume` module, when called, acts in the same manner
+as calling `lume.chain()`.
+```lua
+lume({1, 2, 3}):each(print) -- Prints 1, 2 then 3 on separate lines
+```
 
 
 ## License

lume.lua

@@ -1,13 +1,13 @@
 --
 -- lume
 --
--- Copyright (c) 2014, rxi
+-- Copyright (c) 2015, rxi
 --
 -- This library is free software; you can redistribute it and/or modify it
 -- under the terms of the MIT license. See LICENSE for details.
 --
 
-local lume = { _version = "1.3.1" }
+local lume = { _version = "2.0.0" }
 
 local pairs, ipairs = pairs, ipairs
 local type, assert, unpack = type, assert, unpack or table.unpack
@@ -16,11 +16,18 @@ local math_floor = math.floor
 local math_ceil = math.ceil
 local math_random = math.random
 local math_cos = math.cos
-local math_atan2 = math.atan2
+local math_atan2 = math.atan2 or math.atan
 local math_sqrt = math.sqrt
 local math_abs = math.abs
 local math_pi = math.pi
 
+local noop = function()
+end
+
+local identity = function(x)
+  return x
+end
+
 local patternescape = function(str)
   return str:gsub("[%(%)%.%%%+%-%*%?%[%]%^%$]", "%%%1")
 end
@@ -30,7 +37,41 @@ local absindex = function(len, i)
 end
 
 local iscallable = function(x)
-  return type(x) == "function" or getmetatable(x).__call ~= nil
+  if type(x) == "function" then return true end
+  local mt = getmetatable(x)
+  return mt and mt.__call ~= nil
+end
+
+local isarray = function(x)
+  return (x and x[1]) and true or false
+end
+
+local iternil = function()
+  return noop
+end
+
+local getiter = function(x)
+  if x == nil then
+    return iternil
+  elseif isarray(x) then
+    return ipairs
+  else
+    return pairs
+  end
+end
+
+local iteratee = function(x)
+  if x == nil then return identity end
+  if iscallable(x) then return x end
+  if type(x) == "table" then
+    return function(z)
+      for k, v in pairs(x) do
+        if z[k] ~= v then return false end
+      end
+      return true
+    end
+  end
+  return function(z) return z[x] end
 end
 
 
@@ -57,7 +98,8 @@ end
 
 
 function lume.smooth(a, b, amount)
-  local m = (1 - math_cos(lume.clamp(amount, 0, 1) * math_pi)) / 2
+  local t = lume.clamp(amount, 0, 1)
+  local m = t * t * (3 - 2 * t)
   return a + (b - a) * m
 end
 
@@ -108,41 +150,64 @@ end
 
 
 function lume.shuffle(t)
+  local rtn = {}
   for i = 1, #t do
-    local r = math_random(#t)
-    t[i], t[r] = t[r], t[i]
+    local r = math_random(i)
+    if r ~= i then
+      rtn[i] = rtn[r]
+    end
+    rtn[r] = t[i]
   end
-  return t
+  return rtn
+end
+
+
+function lume.sort(t, comp)
+  local rtn = lume.clone(t)
+  if comp then
+    if type(comp) == "string" then
+      table.sort(rtn, function(a, b) return a[comp] < b[comp] end)
+    else
+      table.sort(rtn, comp)
+    end
+  else
+    table.sort(rtn)
+  end
+  return rtn
 end
 
 
 function lume.array(...)
   local t = {}
-  for x in unpack({...}) do t[#t + 1] = x end
+  for x in ... do t[#t + 1] = x end
   return t
 end
 
 
 function lume.each(t, fn, ...)
+  local iter = getiter(t)
   if type(fn) == "string" then
-    for _, v in pairs(t) do v[fn](v, ...) end
+    for _, v in iter(t) do v[fn](v, ...) end
   else
-    for _, v in pairs(t) do fn(v, ...) end
+    for _, v in iter(t) do fn(v, ...) end
   end
   return t
 end
 
 
 function lume.map(t, fn)
-  local rtn = {} 
-  for k, v in pairs(t) do rtn[k] = fn(v) end
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  local rtn = {}
+  for k, v in iter(t) do rtn[k] = fn(v) end
   return rtn
 end
 
 
 function lume.all(t, fn)
-  fn = fn or function(x) return x end
-  for k, v in pairs(t) do
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if not fn(v) then return false end
   end
   return true
@@ -150,8 +215,9 @@ end
 
 
 function lume.any(t, fn)
-  fn = fn or function(x) return x end
-  for k, v in pairs(t) do
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if fn(v) then return true end
   end
   return false
@@ -166,34 +232,55 @@ function lume.reduce(t, fn, first)
 end
 
 
-function lume.set(t, retainkeys)
+function lume.set(t)
   local rtn = {}
-  for k, v in pairs(lume.invert(t)) do 
-    rtn[retainkeys and v or (#rtn + 1)] = k
+  for k, v in pairs(lume.invert(t)) do
+    rtn[#rtn + 1] = k
   end
   return rtn
 end
 
 
 function lume.filter(t, fn, retainkeys)
+  fn = iteratee(fn)
+  local iter = getiter(t)
   local rtn = {}
-  for k, v in pairs(t) do
+  for k, v in iter(t) do
     if fn(v) then rtn[retainkeys and k or (#rtn + 1)] = v end
   end
   return rtn
 end
 
 
-function lume.merge(t, t2, retainkeys)
-  for k, v in pairs(t2) do
-    t[retainkeys and k or (#t + 1)] = v
+function lume.merge(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    local iter = getiter(t)
+    for k, v in iter(t) do
+      rtn[k] = v
+    end
   end
-  return t
+  return rtn
+end
+
+
+function lume.concat(...)
+  local rtn = {}
+  for i = 1, select("#", ...) do
+    local t = select(i, ...)
+    local iter = getiter(t)
+    for k, v in iter(t) do
+      rtn[#rtn + 1] = v
+    end
+  end
+  return rtn
 end
 
 
 function lume.find(t, value)
-  for k, v in pairs(t) do
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if v == value then return k end
   end
   return nil
@@ -201,7 +288,9 @@ end
 
 
 function lume.match(t, fn)
-  for k, v in pairs(t) do
+  fn = iteratee(fn)
+  local iter = getiter(t)
+  for k, v in iter(t) do
     if fn(v) then return v, k end
   end
   return nil
@@ -210,12 +299,17 @@ end
 
 function lume.count(t, fn)
   local count = 0
+  local iter = getiter(t)
   if fn then
-    for k, v in pairs(t) do
+    fn = iteratee(fn)
+    for k, v in iter(t) do
       if fn(v) then count = count + 1 end
     end
   else
-    for k in pairs(t) do count = count + 1 end
+    if isarray(t) then
+      return #t
+    end
+    for k in iter(t) do count = count + 1 end
   end
   return count
 end
@@ -232,6 +326,18 @@ function lume.slice(t, i, j)
 end
 
 
+function lume.first(t, n)
+  if not n then return t[1] end
+  return lume.slice(t, 1, n)
+end
+
+
+function lume.last(t, n)
+  if not n then return t[#t] end
+  return lume.slice(t, -n, -1)
+end
+
+
 function lume.invert(t)
   local rtn = {}
   for k, v in pairs(t) do rtn[v] = k end
@@ -239,6 +345,14 @@ function lume.invert(t)
 end
 
 
+function lume.keys(t)
+  local rtn = {}
+  local iter = getiter(t)
+  for k, v in iter(t) do rtn[#rtn + 1] = k end
+  return rtn
+end
+
+
 function lume.clone(t)
   local rtn = {}
   for k, v in pairs(t) do rtn[k] = v end
@@ -248,10 +362,10 @@ end
 
 function lume.fn(fn, ...)
   assert(iscallable(fn), "expected a function as the first argument")
-  local args = {...}
+  local args = { ... }
   return function(...)
-    local a = lume.merge(lume.clone(args), {...})
-    return fn(unpack(a)) 
+    local a = lume.concat(args, { ... })
+    return fn(unpack(a))
   end
 end
 
@@ -267,22 +381,53 @@ function lume.once(fn, ...)
 end
 
 
-function lume.time(fn, ...)
-  local start = os.clock()
-  local rtn = {fn(...)}
-  return (os.clock() - start), unpack(rtn)
+local memoize_fnkey = {}
+local memoize_nil = {}
+
+function lume.memoize(fn)
+  local cache = {}
+  return function(...)
+    local c = cache
+    for i = 1, select("#", ...) do
+      local a = select(i, ...) or memoize_nil
+      c[a] = c[a] or {}
+      c = c[a]
+    end
+    c[memoize_fnkey] = c[memoize_fnkey] or {fn(...)}
+    return unpack(c[memoize_fnkey])
+  end
 end
 
 
 function lume.combine(...)
-  local funcs = {...}
-  assert(lume.all(funcs, iscallable), "expected all arguments to be functions")
+  local funcs = {}
+  for i = 1, select("#", ...) do
+    local fn = select(i, ...)
+    if fn ~= nil then
+      assert(iscallable(fn), "expected a function or nil")
+      funcs[#funcs + 1] = fn
+    end
+  end
   return function(...)
     for _, f in ipairs(funcs) do f(...) end
   end
 end
 
 
+function lume.call(fn, ...)
+  if fn then
+    return fn(...)
+  end
+end
+
+
+function lume.time(fn, ...)
+  local start = os.clock()
+  local rtn = {fn(...)}
+  return (os.clock() - start), unpack(rtn)
+end
+
+
 local lambda_cache = {}
 
 function lume.lambda(str)
@@ -335,10 +480,36 @@ function lume.trim(str, chars)
 end
 
 
+function lume.wordwrap(str, limit)
+  limit = limit or 72
+  local check
+  if type(limit) == "number" then
+    check = function(str) return #str >= limit end
+  else
+    check = limit
+  end
+  local rtn = {}
+  for j, line in ipairs(lume.split(str, "\n")) do
+    local str
+    for i, word in ipairs(lume.split(line)) do
+      local s = (str and (str .. " ") or "") .. word
+      if check(s) then
+        rtn[#rtn + 1] = str
+        str = word
+      else
+        str = s
+      end
+    end
+    rtn[#rtn + 1] = str
+  end
+  return table.concat(rtn, "\n")
+end
+
+
 function lume.format(str, vars)
   if not vars then return str end
-  local f = function(x) 
-    return tostring(vars[x] or vars[tonumber(x)] or "{" .. x .. "}") 
+  local f = function(x)
+    return tostring(vars[x] or vars[tonumber(x)] or "{" .. x .. "}")
   end
   return (str:gsub("{(.-)}", f))
 end
@@ -349,7 +520,9 @@ function lume.trace(...)
   local t = { "[" .. info.short_src .. ":" .. info.currentline .. "]" }
   for i = 1, select("#", ...) do
     local x = select(i, ...)
-    x = (type(x) == "number") and lume.round(x, .01) or (x or "nil")
+    if type(x) == "number" then
+      x = string.format("%g", lume.round(x, .01))
+    end
     t[#t + 1] = tostring(x)
   end
   print(table.concat(t, " "))
@@ -375,7 +548,7 @@ function lume.hotswap(modname)
   local oldglobal = lume.clone(_G)
   local updated = {}
   local function update(old, new)
-    if updated[old] then return end 
+    if updated[old] then return end
     updated[old] = true
     local oldmt, newmt = getmetatable(old), getmetatable(new)
     if oldmt and newmt then update(oldmt, newmt) end
@@ -395,7 +568,7 @@ function lume.hotswap(modname)
     local newmod = require(modname)
     if type(oldmod) == "table" then update(oldmod, newmod) end
     for k, v in pairs(oldglobal) do
-      if v ~= _G[k] and type(v) == "table" then 
+      if v ~= _G[k] and type(v) == "table" then
         update(v, _G[k])
         _G[k] = v
       end
@@ -407,10 +580,24 @@ function lume.hotswap(modname)
 end
 
 
+local ripairs_iter = function(t, i)
+  i = i - 1
+  local v = t[i]
+  if v then return i, v end
+end
+
+function lume.ripairs(t)
+  if t == nil then
+    return noop
+  end
+  return ripairs_iter, t, (#t + 1)
+end
+
+
 function lume.rgba(color)
-  local a = math_floor((color / 2 ^ 24) % 256)
-  local r = math_floor((color / 2 ^ 16) % 256)
-  local g = math_floor((color / 2 ^ 08) % 256)
+  local a = math_floor((color / 16777216) % 256)
+  local r = math_floor((color /    65536) % 256)
+  local g = math_floor((color /      256) % 256)
   local b = math_floor((color) % 256)
   return r, g, b, a
 end
@@ -430,5 +617,11 @@ function lume.chain(value)
   return setmetatable({ _value = value }, chain_mt)
 end
 
+setmetatable(lume,  {
+  __call = function(t, ...)
+    return lume.chain(...)
+  end
+})
+
 
 return lume

test/test_lume.lua

@@ -109,12 +109,24 @@ end
 -- lume.shuffle
 tests["lume.shuffle"] = function()
   local t = {1, 2, 3, 4, 5}
-  lume.shuffle(t)
+  t = lume.shuffle(t)
   table.sort(t)
   testeq( t,                {1, 2, 3, 4, 5} )
   testeq( lume.shuffle({}), {}              )
 end
 
+-- lume.sort
+tests["lume.sort"] = function()
+  local t = { 1, 5, 2, 4, 3 }
+  local fn = function(a, b) return a > b end
+  testeq( t == lume.sort(t), false             )
+  testeq( lume.sort(t),      { 1, 2, 3, 4, 5 } )
+  testeq( lume.sort(t, fn),  { 5, 4, 3, 2, 1 } )
+  testeq( t,                 { 1, 5, 2, 4, 3 } )
+  local t = { { id = 2 }, { id = 3 }, { id = 1 } }
+  testeq( lume.sort(t, "id"), { { id = 1 }, { id = 2 }, { id = 3 } })
+end
+
 -- lume.array
 tests["lume.array"] = function()
   local t = lume.array(pairs({a=0, b=0, c=0}))
@@ -141,6 +153,8 @@ end
 tests["lume.map"] = function()
   testeq( lume.map({1, 2, 3}, function(x) return x * 2 end), {2, 4, 6} )
   testeq( lume.map({a=2,b=3}, function(x) return x * 2 end), {a=4,b=6} )
+  local t = {{ id = 10 }, { id = 20 }, { id = 30 }}
+  testeq( lume.map(t, "id"), { 10, 20, 30 })
 end
 
 -- lume.all
@@ -149,6 +163,10 @@ tests["lume.all"] = function()
   testeq( lume.all({true, true, true, true}),                         true  )
   testeq( lume.all({2, 3, 4, 5}, function(x) return x % 2 == 0 end),  false )
   testeq( lume.all({2, 4, 6, 8}, function(x) return x % 2 == 0 end),  true  )
+  testeq( lume.all({{ x = 1 }, {}, { x = 3 }}, "x"),                  false )
+  testeq( lume.all({{ x = 1 }, { x = 2 }, { x = 3 }}, "x"),           true  )
+  testeq( lume.all({{ x = 1 }, { x = 2 }, { x = 3 }}, { x = 2 }),     false )
+  testeq( lume.all({{ x = 2 }, { x = 2 }, { x = 2 }}, { x = 2 }),     true  )
 end
 
 -- lume.any
@@ -157,6 +175,9 @@ tests["lume.any"] = function()
   testeq( lume.any({false, false, false}),                            false )
   testeq( lume.any({2, 3, 4, 5}, function(x) return x % 2 == 0 end),  true  )
   testeq( lume.any({1, 3, 5, 7}, function(x) return x % 2 == 0 end),  false )
+  local t = {{ id = 10 }, { id = 20 }, { id = 30 }}
+  testeq( lume.any(t, { id = 10 }), true  )
+  testeq( lume.any(t, { id = 40 }), false )
 end
 
 -- lume.reduce
@@ -189,12 +210,23 @@ tests["lume.filter"] = function()
   testeq( t, {2, 4} )
   local t = lume.filter({a=1, b=2, c=3}, function(x) return x == 2 end, true) 
   testeq( t, {b=2} )
+  local t = lume.filter({{ x=1, y=1 }, { x=2, y=2 }, { x=1, y=3 }}, { x = 1 })
+  testeq( t, {{ x=1, y=1 }, {x=1, y=3}} )
 end
 
 -- lume.merge
 tests["lume.merge"] = function()
-  testeq( lume.merge({1, 2, 3}, {8, 9, 0}),         {1, 2, 3, 8, 9, 0}  )
-  testeq( lume.merge({a=1, b=2}, {b=3, c=4}, true), {a=1, b=3, c=4}     )
+  testeq( lume.merge(),                       {}              )
+  testeq( lume.merge({x=1, y=2}),             {x=1, y=2}      )
+  testeq( lume.merge({a=1, b=2}, {b=3, c=4}), {a=1, b=3, c=4} )
+end
+
+-- lume.concat
+tests["lume.concat"] = function()
+  testeq( lume.concat(nil),                            {}                    )
+  testeq( lume.concat({1, 2, 3}),                      {1, 2, 3}             )
+  testeq( lume.concat({1, 2, 3}, {4, 5, 6}),           {1, 2, 3, 4, 5, 6}    )
+  testeq( lume.concat({1, 2, 3}, {4, 5, 6}, nil, {7}), {1, 2, 3, 4, 5, 6, 7} )
 end
 
 -- lume.find
@@ -208,6 +240,7 @@ end
 tests["lume.match"] = function()
   local t = { "a", "b", "c", "d" }
   local t2 = { a = 1, b = 2, c = 3, d = 4 }
+  local t3 = { {x=1, y=2}, {x=3, y=4}, {x=5, y=6} }
   local v, k = lume.match(t, function(x) return x > "c" end)
   testeq( v, "d"  )
   testeq( k, 4    )
@@ -220,6 +253,8 @@ tests["lume.match"] = function()
   local v, k = lume.match(t2, function(x) return x > 5 end)
   testeq( v, nil  )
   testeq( k, nil  )
+  local v, k = lume.match(t3, { x = 3, y = 4 })
+  testeq( k, 2    )
 end
 
 -- lume.count
@@ -229,6 +264,10 @@ tests["lume.count"] = function()
   testeq( lume.count(t, function(x) return x % 2 == 0 end ), 3 )
   local a = { 5, 6, 7, 8, 9 }
   testeq( lume.count(a), #a )
+  local t = { { n = 20 }, { n = 30 }, { n = 40 }, { n = 20 } }
+  testeq( lume.count(t, { n = 20 }),  2 )
+  testeq( lume.count(t, { n = 30 }),  1 )
+  testeq( lume.count(t, { n = 50 }),  0 )
 end
 
 -- lume.slice
@@ -248,14 +287,40 @@ tests["lume.slice"] = function()
   testeq( lume.slice({"a", "b", "c", "d", "e"}, -3, 900), {"c", "d", "e"} )
 end
 
+-- lume.first
+tests["lume.first"] = function()
+  local t = { "a", "b", "c", "d", "e" }
+  testeq( lume.first(t),    "a"           )
+  testeq( lume.first(t, 1), { "a" }       )
+  testeq( lume.first(t, 2), { "a", "b" }  )  
+end
+
+-- lume.last
+tests["lume.last"] = function()
+  local t = { "a", "b", "c", "d", "e" }
+  testeq( lume.last(t),     "e"           )
+  testeq( lume.last(t, 1),  { "e" }       )
+  testeq( lume.last(t, 2),  { "d", "e" }  )  
+end
+
 -- lume.invert
-tests["lume_invert"] = function()
+tests["lume.invert"] = function()
   testeq( lume.invert({}),                        {}                  )
   testeq( lume.invert{a = "x", b = "y"},          {x = "a", y = "b"}  )
   testeq( lume.invert{a = 1, b = 2},              {"a", "b"}          )
   testeq( lume.invert(lume.invert{a = 1, b = 2}), {a = 1, b = 2}      )
 end
 
+-- lume.keys
+tests["lume.keys"] = function()
+  testeq( lume.keys({}), {} )
+  local t = lume.keys({ aaa = 1, bbb = 2, ccc = 3 }) 
+  table.sort(t)
+  testeq( t, {"aaa", "bbb", "ccc"} ) 
+  local t = lume.keys({ "x", "x", "x" })
+  testeq( t, {1, 2, 3} )
+end
+
 -- lume.clone
 tests["lume.clone"] = function()
   local t = {6, 7, 4, 5}
@@ -279,11 +344,18 @@ tests["lume.once"] = function()
   tester.test.error( lume.once, 123 )
 end
 
--- lume.time
-tests["lume.time"] = function()
-  local t, a, b, c = lume.time(function(x) return 50, 60, x end, 70)
-  testeq( type(t),    "number"      )
-  testeq( {a, b, c},  {50, 60, 70}  )
+-- lume.memoize
+tests["lume.memoize"] = function()
+  local f = lume.memoize(
+    function(a, b, c)
+      return tostring(a) .. tostring(b) .. tostring(c)
+    end)
+  testeq( f("hello", nil, 15),  "hellonil15"  )
+  testeq( f("hello", nil, 15),  "hellonil15"  )
+  testeq( f(),                  "nilnilnil"   )
+  testeq( f(),                  "nilnilnil"   )
+  local f2 = lume.memoize(function() end)
+  testeq( f2(), nil )
 end
 
 -- lume.combine
@@ -294,6 +366,25 @@ tests["lume.combine"] = function()
   local fn = lume.combine(a, b)
   fn(10, 20)
   testeq( acc, 230 )
+  acc = 0
+  fn = lume.combine(nil, a, nil, b, nil)
+  fn(10, 20)
+  testeq( acc, 230 )
+end
+
+-- lume.call
+tests["lume.call"] = function()
+  local add = function(a, b) return a + b end
+  testeq( lume.call(),              nil )
+  testeq( lume.call(nil, 1, 2, 3),  nil )
+  testeq( lume.call(add, 1, 2),     3   )
+end
+
+-- lume.time
+tests["lume.time"] = function()
+  local t, a, b, c = lume.time(function(x) return 50, 60, x end, 70)
+  testeq( type(t),    "number"      )
+  testeq( {a, b, c},  {50, 60, 70}  )
 end
 
 -- lume.lambda
@@ -340,6 +431,16 @@ tests["lume.trim"] = function()
   testeq( lume.trim("^.hello world]^", "^.]"),  "hello world"   )
 end
 
+-- lume.wordwrap
+tests["lume.wordwrap"] = function()
+  local str = "A small string with some words and then some more words"
+  local b = "A small string with\nsome words and then\nsome more words"
+  local fn = function(str) return #str >= 20 end
+  testeq( lume.wordwrap(str),     str )
+  testeq( lume.wordwrap(str, 20), b   )
+  testeq( lume.wordwrap(str, fn), b   )
+end
+
 -- lume.format
 tests["lume.format"] = function()
   local str = lume.format("a {a} in a {b}", {a = "mouse", b = "house"})
@@ -385,6 +486,18 @@ tests["lume.hotswap"] = function()
   testeq( type(err),  "string"  )
 end
 
+-- lume.ripairs
+tests["lume.ripairs"] = function()
+  local t = { "a", "b", "c" }
+  local r = {}
+  for i, v in lume.ripairs(t) do
+    table.insert(r, { i, v })
+  end
+  testeq( r, { { 3, "c" }, { 2, "b" }, { 1, "a" } })
+  for i, v in lume.ripairs(nil) do
+  end
+end
+
 -- lume.rgba
 tests["lume.rgba"] = function()
   local r, g, b, a = lume.rgba(0x12345678)
@@ -399,6 +512,8 @@ tests["lume.chain"] = function()
   local t = lume.chain({1, 2}):map(function(x) return x * 2 end):result() 
   testeq( t, { 2, 4 } )
   testeq( lume.chain(10):result(), 10 )
+  local t = lume({1, 2}):map(function(x) return x * 2 end):result()
+  testeq( t, { 2, 4 } )
 end