Module:FunList

Documentation for this module may be created at Module:FunList/doc

local funlist = {}
funlist.__index = funlist

-- Constructor
function funlist.new(tbl)
    assert(type(tbl) == 'table')
    assert(tbl ~= nil)

    local self = setmetatable({}, funlist)
	self.mytable = tbl
	return self
end

-- Private functions.
local function getElementAtIndex(tbl, index)
	assert(tonumber(index))
	local ix = tonumber(index)
	local i = 0
	if ix >= 0 then
		for _, v in pairs(tbl) do
			i = i + 1
			if i == ix then
				return true, v
			end
		end
	end
	
	return false, nil
end

-- Public functions
-- Determines whether all elements of a sequence satisfy a condition.
function funlist:all(predicate)
	assert(predicate)
	for _, v in pairs(self.mytable) do
		if predicate(v) == false then
			return false
		end
	end
	return true	
end

-- Determines whether any element of a sequence exists or satisfies a condition.
function funlist:any(predicate)
	if predicate then
		for _, v in pairs(self.mytable) do
			if predicate(v) == true then
				return true
			end
		end
	else
		for _, _ in pairs(self.mytable) do
			return true
		end
	end
	return false
end

-- Appends a value to the end of the sequence.
function funlist:append(item)
	assert(item)
	table.insert(self.mytable, item)
	
	return self
end

-- Determines whether a sequence contains a specified element.
function funlist:contains(item)
	assert(item)
	for _, v in pairs(self.mytable) do
		if self:isEqual(v, item) == true then
			return true
		end
	end
	return false
end

-- Returns the number of elements in a sequence.
function funlist:count()
	local count = 0
	for _, _ in pairs(self.mytable) do
		count = count + 1
	end
	return count
end

-- Returns the element at a specified index in a sequence.
function funlist:itemAt(index)
	local found, item = getElementAtIndex(self.mytable, index)
	if found == true then
		return item
	end
	
	error('Index out of range')
end

-- Returns the element at a specified index in a sequence or a default value if the index is out of range.
function funlist:itemAtOrDefault(index, defaultItem)
	local found, item = getElementAtIndex(self.mytable, index)
	if found == true then
		return item
	end
	return defaultItem
end

-- Returns the first element of a sequence.
function funlist:first()
	for _, v in pairs(self.mytable) do
		return v
	end
	error('No items in sequence.')
end

-- Returns the first element of a sequence, or a default value if no element is found.
function funlist:firstOrDefault(defaultItem)
	for _, v in pairs(self.mytable) do
		return v
	end
	return defaultItem
end

-- Returns the last element of a sequence.
function funlist:last()
	if self:any() == false then
		error('Sequence contains no items.')
	end
	local last = nil
	for _, v in pairs(self.mytable) do
		last = v
	end
	return last
end

-- Returns the last element of a sequence, or a default value if no element is found.
function funlist:lastOrDefault(defaultItem)
	if self:any() == false then
		return defaultItem
	end
	local last = nil
	for _, v in pairs(self.mytable) do
		last = v
	end
	return last
end

-- Returns the maximum value in a sequence of values.
function funlist:max()
	local h = self:first()
	for _, v in pairs(self.mytable) do
		local num = tonumber(v)
		if num == nil then error('Value is NaN') end
		if v > h then h = v end
	end
	return h
end

-- Returns the minimum value in a sequence of values.
function funlist:min()
	local l = self:first()
	for _, v in pairs(self.mytable) do
		local num = tonumber(v)
		if num == nil then error('Value is NaN') end
		if v < l then l = v end
	end
	return l
end

-- Adds elements from one sequence to the other.
function funlist:concat(tbl)
	assert(type(tbl) == 'table')
    for _, v in pairs(tbl) do
    	table.insert(self.mytable, v)
    end
    return self
end

-- Adds elements from one sequence to the other by key.
function funlist:join(tbl)
	assert(type(tbl) == 'table')
	for k, v in pairs(tbl) do
		self.mytable[k] = v
	end
	return self
end

function funlist:sort()
	table.sort(self.mytable)
	return self
end

function funlist:sortBy(selector)
	assert(selector)
	local sortFunc = function(left, right)
		return selector(left) < selector(right)
	end
	table.sort(self.mytable, sortFunc)
	return self
end

function funlist:sortByDecending(selector)
	assert(selector)
	local sortFunc = function(left, right)
		return selector(left) > selector(right)
	end
	table.sort(self.mytable, sortFunc)
	return self	
end

-- Helper function to check if objects are equal.
function funlist.isEqual(obj1, obj2)
	local type1 = type(obj1)
    local type2 = type(obj2)

    if type1 ~= type2 then
        return false
    end

    if type1 == "number" or type1 == "string" or type1 == "boolean" then
        return obj1 == obj2
    elseif type1 == "table" then
        if #obj1 ~= #obj2 then
            return false
        end
        for k, v in pairs(obj1) do
            if not isEqual(v, obj2[k]) then
                return false
            end
        end
        return true
    else
        return obj1 == obj2
    end
end

return funlist