stream.lua

function stream(input)
  -- Local functions
  -- local function _fn()
  local function _concat(str)
    local data = input._data
    for k, v in pairs(str) do
      data[k] = v
    end
    return _stream(data)
  end

  local function _distinct(input,func)
    func = func or (function(v) return v end)
    local data = {}
    for k1, v1 in pairs(input._data) do
      local notExist = true
      for k2, v2 in pairs(data) do
        if k1 ~= k2 and func(v1) == func(v2) then
          exist = false
          break
        end
      end
      if notExist then
        data[k1] = v1
      end
    end
    return _stream(data)
  end

  local function _filter(input,func)
    local data = {}
    for k, v in pairs(input._data) do
      if func(v) then
        data[k] = v
      end
    end
    return _stream(data)
  end

  local function _limit(input,n)
    local counter = 0
    local data = {}
    for k, v in pairs(input._data) do
      if counter < n then
        data[k] = v
        counter = counter + 1
        if counter == n then
          break
        end
      end
    end
    return _stream(data)
  end

  local function _map(input,func)
    local data = {}
    for k, v in pairs(input._data) do
      data[k] = func(v, k)
    end
    return _stream(data)
  end

  local function _skip(input,n)
    local counter = 0
    local data = {}
    for k, v in pairs(input._data) do
      if counter % n == 0 then
        data[k] = v
      end
      counter = counter + 1
    end
    return _stream(data)
  end

  local function _sort(input,comp)
    local data = input._data
    table.sort(data, comp)
    return _stream(data)
  end

  local function _split(input,func)
    local data1, data2 = {}
    for k, v in pairs(input._data) do
      if func(v, k) then
        data1[k] = v
      else
        data2[k] = v
      end
    end
    return _stream(data1), _stream(data2)
  end

  local function _allmatch(input,func)
    for k, v in pairs(input._data) do
      if func(v, k) == false then
        return false
      end
    end
    return true
  end

  local function _anymatch(input,func)
    for k, v in pairs(input._data) do
      if func(v, k) then
        return true
      end
    end
    return false
  end

  local function _collect(input,coll)
    return coll(input._data)
  end

  local function _count(input)
    return #input._data
  end

  local function _foreach(input,func)
    for k, v in pairs(input._data) do
      func(v, k)
    end
  end

  local function _max(input,func)
    local maxk = nil
    for k, v in pairs(input._data) do
      if maxk == nil then
        maxk = k
      else
        maxk = func(v, input._data[maxk], k, maxk)
      end
    end
    return maxk, input._data[maxk]
  end

  local function _min(input,func)
    local mink = nil
    for k, v in pairs(input._data) do
      if mink == nil then
        mink = k
      else
        mink = func(v, input._data[mink], k, mink)
      end
      return mink, input._data[mink]
    end
  end

  local function _nonematch(input,func)
    for k, v in pairs(input._data) do
      if func(v, k) then
        return false
      end
    end
    return true
  end

  local function _reduce(input,init,op)
    local result = init
    for k, v in pairs(input._data) do
      result = op(result, v, k)
    end
    return result
  end

  local function _toArray(input)
    local result = input._data
    return result
  end

  local function _stream(input)
    local result = {
      _stream = true,
      _data = input._data or input,
      -- Intermediate Operations
      concat = function(str) return _concat(input,str) end,
      distinct = function(func) return _distinct(input,func) end,
      filter = function(func) return _filter(input,func) end,
      limit = function(n) return _limit(input,n) end,
      map = function(func) return _map(input,func) end,
      skip = function(n) return _skip(input,n) end,
      sort = function(func) return _sort(input,func) end,
      split = function(func) return _split(input,func) end,
      -- Terminal Operations
      allmatch = function(func) return _allmatch(input,func) end,
      anymatch = function(func) return _anymatch(input,func) end,
      collect = function(coll) return _collect(input,coll) end,
      count = function() return _count(input) end,
      foreach = function(func) return _foreach(input,func) end,
      max = function(func) return _max(input,func) end,
      min = function(func) return _min(input,func) end,
      nonematch = function(func) return _nonematch(input,func) end,
      reduce = function(init,op) return _reduce(input,init,op) end,
      toArray = function() return _toArray(input) end
    }
    return result
  end

  if input == nil then
    error("input must be of type table, but was nil")
  elseif type(input) ~= "table" then
    error("input must be of type table, but was a "..type(input)..": "..input)
  end
  return _stream(input)
end

table.stream = stream