Module:Enum

-- awawa local libraryUtil = require('libraryUtil') local checkType = libraryUtil.checkType local checkTypeMulti = libraryUtil.checkTypeMulti local p = {} p.__index = p

setmetatable(p, {	__call = function(_, enum)		return p.new(enum)	end })

function p.__tostring(enum) local dumpObject = require('Module:Logger').dumpObject setmetatable(enum, nil) return dumpObject(enum, {clean=true, collapseLimit=100}) end

function p.__concat(lhs, rhs) if type(lhs) == 'table' and type(rhs) == 'table' then return p.insert(lhs, rhs) else return tostring(lhs) .. tostring(rhs) end end

function p.__unm(enum) return p.map(enum, function(x) return -x end) end

local function mathTemplate(lhs, rhs, funName, fun) checkTypeMulti('Module:Enum.' .. funName, 1, lhs, {'number', 'table'}) checkTypeMulti('Module:Enum.' .. funName, 2, rhs, {'number', 'table'}) local res = setmetatable({}, getmetatable(lhs) or getmetatable(rhs))

if type(lhs) == 'number' or type(rhs) == 'number' then local scalar, vector if type(lhs) == 'number' then scalar = lhs vector = rhs else scalar = rhs vector = lhs end

for i = 1, #vector do			res[i] = fun(vector[i], scalar) end else assert(#lhs == #rhs, 'Tables are not equal length') for i = 1, #lhs do			res[i] = fun(lhs[i], rhs[i]) end end

return res end

function p.__add(lhs, rhs) return mathTemplate(lhs, rhs, '__add', function(x, y) return x + y end) end

function p.__sub(lhs, rhs) return mathTemplate(lhs, rhs, '__sub', function(x, y) return x - y end) end

function p.__mul(lhs, rhs) return mathTemplate(lhs, rhs, '__mul', function(x, y) return x * y end) end

function p.__div(lhs, rhs) return mathTemplate(lhs, rhs, '__div', function(x, y) return x / y end) end

function p.__pow(lhs, rhs) return mathTemplate(lhs, rhs, '__pow', function(x, y) return x ^ y end) end

function p.__lt(lhs, rhs) for i = 1, math.min(#lhs, #rhs) do		if lhs[i] >= rhs[i] then return false end end return true end

function p.__le(lhs, rhs) for i = 1, math.min(#lhs, #rhs) do		if lhs[i] > rhs[i] then return false end end return true end

function p.__eq(lhs, rhs) if #lhs ~= #rhs then return false end for i = 1, #lhs do		if lhs[i] ~= rhs[i] then return false end end return true end

function p.all(enum, fn, clone) checkType('Module:Enum.all', 1, enum, 'table') checkType('Module:Enum.all', 2, fn, 'function', true) checkType('Module:Enum.all', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end fn = fn or function(item) return item end local i = 1 while enum[i] ~= nil do		if not fn(enum[i], i) then return false end i = i + 1 end return true end

function p.any(enum, fn, clone) checkType('Module:Enum.any', 1, enum, 'table') checkType('Module:Enum.any', 2, fn, 'function', true) checkType('Module:Enum.any', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end fn = fn or function(item) return item end local i = 1 while enum[i] ~= nil do		if fn(enum[i], i) then return true end i = i + 1 end return false end

function p.contains(enum, elem, clone) checkType('Module:Enum.contains', 1, enum, 'table') checkType('Module:Enum.contains', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum); elem = mw.clone(elem) end return p.any(enum, function(item) return item == elem end) end

function p.each(enum, fn, clone) checkType('Module:Enum.each', 1, enum, 'table') checkType('Module:Enum.each', 2, fn, 'function') checkType('Module:Enum.each', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end local i = 1 while enum[i] ~= nil do		fn(enum[i], i)		i = i + 1 end end

function p.filter(enum, fn, clone) checkType('Module:Enum.filter', 1, enum, 'table') checkType('Module:Enum.filter', 2, fn, 'function', true) checkType('Module:Enum.filter', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end fn = fn or function(item) return item end local r = setmetatable({}, getmetatable(enum)) local len = 0 local i = 1 while enum[i] ~= nil do		if fn(enum[i], i) then len = len + 1 r[len] = enum[i] end i = i + 1 end return r end

function p.find(enum, fn, default, clone) checkType('Module:Enum.find', 1, enum, 'table') checkType('Module:Enum.find', 2, fn, 'function') checkType('Module:Enum.find', 4, clone, 'boolean', true) if clone then enum = mw.clone(enum); default = mw.clone(default) end local i = 1 while enum[i] ~= nil do		if fn(enum[i], i) then return enum[i], i		end i = i + 1 end return default end

function p.find_index(enum, fn, default, clone) checkType('Module:Enum.find_index', 1, enum, 'table') checkType('Module:Enum.find_index', 2, fn, 'function') checkType('Module:Enum.find_index', 4, clone, 'boolean', true) if clone then enum = mw.clone(enum); default = mw.clone(default) end fn = fn or function(item) return item end local i = 1 while enum[i] ~= nil do		if fn(enum[i], i) then return i		end i = i + 1 end return default end

function p.newIncrementor(start, step) checkType('Module:Enum.newIncrementor', 1, start, 'number', true) checkType('Module:Enum.newIncrementor', 2, step, 'number', true) step = step or 1 local n = (start or 1) - step local obj = {} return setmetatable(obj, {		__call = function n = n + step return n end,		__tostring = function return n end,		__index = function return n end,		__newindex = function(self, k, v)			if k == 'step' and type(v) == 'number' then				step = v			elseif type(v) == 'number' then				n = v			end		end,		__concat = function(x, y) return tostring(x) .. tostring(y) end	}) end

function p.intersect(enum1, enum2, clone) checkType('Module:Enum.intersect', 1, enum1, 'table') checkType('Module:Enum.intersect', 2, enum2, 'table') checkType('Module:Enum.intersect', 3, clone, 'boolean', true) if clone then enum1 = mw.clone(enum1); enum2 = mw.clone(enum2) end local enum2Elements = {} local res = setmetatable({}, getmetatable(enum1) or getmetatable(enum2)) local len = 0 p.each(enum2, function(item) enum2Elements[item] = true end) p.each(enum1, function(item)		if enum2Elements[item] then			len = len + 1			res[len] = item		end	end) return res end

function p.intersects(enum1, enum2, clone) checkType('Module:Enum.intersects', 1, enum1, 'table') checkType('Module:Enum.intersects', 2, enum2, 'table') checkType('Module:Enum.intersects', 3, clone, 'boolean', true) if clone then enum1 = mw.clone(enum1); enum2 = mw.clone(enum2) end local small = {} local large if #enum1 <= #enum2 then p.each(enum1, function(item) small[item] = true end) large = enum2 else p.each(enum2, function(item) small[item] = true end) large = enum1 end return p.any(large, function(item) return small[item] end) end

function p.insert(enum1, enum2, index, clone) checkType('Module:Enum.insert', 1, enum1, 'table') checkType('Module:Enum.insert', 2, enum2, 'table') checkType('Module:Enum.insert', 3, index, 'number', true) checkType('Module:Enum.insert', 4, clone, 'boolean', true) if clone then enum1 = mw.clone(enum1); enum2 = mw.clone(enum2) end local len1 = #enum1 local len2 = #enum2 index = index or (len1 + 1) local res = setmetatable({}, getmetatable(enum1) or getmetatable(enum2))

for i = 1, (len1 + len2) do		if i < index then res[i] = enum1[i] elseif i < (index + len2) then res[i] = enum2[i - index + 1] else res[i] = enum1[i - len2] end end

return res end

function p.map(enum, fn, clone) checkType('Module:Enum.map', 1, enum, 'table') checkType('Module:Enum.map', 2, fn, 'function') checkType('Module:Enum.map', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end local len = 0 local r = setmetatable({}, getmetatable(enum)) local i = 1 while enum[i] ~= nil do		local tmp = fn(enum[i], i)		if tmp ~= nil then len = len + 1 r[len] = tmp end i = i + 1 end return r end

function p.max_by(enum, fn, clone) checkType('Module:Enum.max_by', 1, enum, 'table') checkType('Module:Enum.max_by', 2, fn, 'function') checkType('Module:Enum.max_by', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end return unpack(p.reduce(enum, function(new, old) local y = fn(new) return y > old[2] and {new, y} or old end, {enum[1], -math.huge})) end

function p.new(enum) for _, v in pairs(enum) do		if type(v) == 'table' then p.new(v) end end

if getmetatable(enum) == nil then setmetatable(enum, p)	end

return enum end

function p.range(start, stop, step) checkType('Module:Enum.range', 1, start, 'number') checkType('Module:Enum.range', 2, stop, 'number', true) checkType('Module:Enum.range', 3, step, 'number', true) local array = setmetatable({}, p)	local len = 0 if not stop then stop = start start = 1 end for i = start, stop, step or 1 do		len = len + 1 array[len] = i	end return array end

function p.reduce(enum, fn, accumulator, clone) checkType('Module:Enum.reduce', 1, enum, 'table') checkType('Module:Enum.reduce', 2, fn, 'function') checkType('Module:Enum.reduce', 4, clone, 'boolean', true) if clone then enum = mw.clone(enum); accumulator = mw.clone(accumulator) end local acc = accumulator local i = 1 while enum[i] ~= nil do		if i == 1 and not accumulator then acc = enum[i] else acc = fn(enum[i], acc) end i = i + 1 end return acc end

function p.reject(enum, fn, clone) checkType('Module:Enum.reject', 1, enum, 'table') checkTypeMulti('Module:Enum.reject', 2, fn, {'function', 'table', 'nil'}) checkType('Module:Enum.reject', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end fn = fn or function(item) return item end local r = setmetatable({}, getmetatable(enum)) local len = 0 if type(fn) == 'function' then local i = 1 while enum[i] ~= nil do			if not fn(enum[i], i) then len = len + 1 r[len] = enum[i] end i = i + 1 end else local rejectMap = {} p.each(fn, function(item) rejectMap[item] = true end) local i = 1 while enum[i] ~= nil do			if not rejectMap[enum[i]] then len = len + 1 r[len] = enum[i] end i = i + 1 end end return r end

function p.rep(val, n, clone) checkType('Module:Enum.rep', 2, n, 'number') checkType('Module:Enum.reject', 3, clone, 'boolean', true) if clone then val = mw.clone(val) end local r = setmetatable({}, p)	for i = 1, n do		r[i] = val end return r end

function p.scan(enum, fn, accumulator, clone) checkType('Module:Enum.scan', 1, enum, 'table') checkType('Module:Enum.scan', 2, fn, 'function') checkType('Module:Enum.scan', 4, clone, 'boolean', true) if clone then enum = mw.clone(enum); accumulator = mw.clone(accumulator) end local acc = accumulator local r = setmetatable({}, getmetatable(enum)) local i = 1 while enum[i] ~= nil do		if i == 1 and not accumulator then acc = enum[i] else acc = fn(enum[i], acc) end r[i] = acc i = i + 1 end return r end

function p.slice(enum, start, finish, clone) checkType('Module:Enum.slice', 1, enum, 'table') checkType('Module:Enum.slice', 2, start, 'number', true) checkType('Module:Enum.slice', 3, finish, 'number', true) checkType('Module:Enum.slice', 4, clone, 'boolean', true) if clone then enum = mw.clone(enum) end start = start or 1 finish = finish or #enum local r = setmetatable({}, getmetatable(enum)) local len = 0 for i = start, finish do		len = len + 1 r[len] = enum[i] end return r end

function p.split(enum, count, clone) checkType('Module:Enum.split', 1, enum, 'table') checkType('Module:Enum.split', 2, count, 'number') checkType('Module:Enum.split', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end if #enum < count then return enum, {} elseif count < 1 then return {}, enum end

local x = setmetatable({}, getmetatable(enum)) local y = setmetatable({}, getmetatable(enum))

for i = 1, #enum do		table.insert(i <= count and x or y, enum[i]) end return x, y end

function p.sum(enum, clone) checkType('Module:Enum.sum', 1, enum, 'table') checkType('Module:Enum.sum', 2, clone, 'boolean', true) if clone then enum = mw.clone(enum) end return p.reduce(enum, function(x, y) return x + y end) end

function p.take(enum, count, clone) checkType('Module:Enum.take', 1, enum, 'table') checkType('Module:Enum.take', 2, count, 'number') checkType('Module:Enum.take', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end local x, _ = p.split(enum, count) return x end

function p.take_every(enum, n, clone) checkType('Module:Enum.take_every', 1, enum, 'table') checkType('Module:Enum.take_every', 2, n, 'number') checkType('Module:Enum.take_every', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end local r = setmetatable({}, getmetatable(enum)) local len = 0 local i = 1 while enum[i] ~= nil do		if (i - 1) % n == 0 then len = len + 1 r[len] = enum[i] end i = i + 1 end return r end

function p.unique(enum, fn, clone) checkType('Module:Enum.unique', 1, enum, 'table') checkType('Module:Enum.unique', 2, fn, 'function', true) checkType('Module:Enum.unique', 3, clone, 'boolean', true) if clone then enum = mw.clone(enum) end fn = fn or function(item) return item end local r = setmetatable({}, getmetatable(enum)) local len = 0 local hash = {} local i = 1 while enum[i] ~= nil do		local id = fn(enum[i]) if not hash[id] then len = len + 1 r[len] = enum[i] hash[id] = true end i = i + 1 end return r end

function p.zip(enums, clone) checkType('Module:Enum.zip', 1, enums, 'table') checkType('Module:Enum.zip', 2, clone, 'boolean', true) if clone then enums = mw.clone(enums) end local r = setmetatable({}, getmetatable(enums)) local _, longest = p.max_by(enums, function(enum) return #enum end) for i = 1, longest do		local q = {} for j = 1, #enums do			table.insert(q, enums[j][i]) end table.insert(r, q)	end return r end

return p --