--[[
---------------------------------------------------------------------------------
-- Iterating primitives
---------------------------------------------------------------------------------
Base functions to work on stateful lua iterators.
Function that creates iterators, like "pair" and "ipair", but stateful unlike them
-- May be building a duplicate of https://www.wikidata.org/wiki/Module:Luafun
--]]
local p = {}
----------------------------------------
-- Copied From Luafun
local methods = {} -- collects the methods to append to an iterator object
local register_method = (function(module, methods)
return function(name, func)
module[name] = func
methods[name] = func
end
end)(p, methods)
-- the metatable for an iterator object
local iterator_mt = {
-- usually called by for-in loop
__call = function(self, param, state)
return self.gen(param, state)
end;
__tostring = function(self)
return '<generator>'
end;
-- add all exported methods
__index = methods;
}
-- used to change an iterator function to an iterator objects to allow to attach methods to an iterator
local wrap = function(gen, param, state)
return setmetatable({
gen = gen,
param = param,
state = state
}, iterator_mt), param, state
end
p.wrap = wrap
local method0 = function(fun)
return function(self)
return fun(self.gen, self.param, self.state)
end
end
local methodn = function(fun)
return function(self, ...)
return fun(self.gen, ...)
end
end
--------------------------------------------------------
-- iterator constructor. Transforms an iterator over a sequence of values in
-- an iterator on the result of the "value_constructor" function applied to the initial values
-- (a kind of an equivalent of the functional "map" function that works on iterator instead of list)
-- this iterator works on values and ignore the keys
local function map(it, transformation)
assert(it, "map : no iterator provided")
return wrap(
function()
local val = it()
if val then return transformation(val) end
end
)
end
register_method("map", map)
-- like "map" except it works on pairs of values (usually key/val pairs)
-- this iterator works on pairs
local function pair_map(it, transformation)
assert(it, "pair_map : no iterator provided")
return wrap(
function()
local i, val = it()
if i then return transformation(i, val) end
end
)
end
register_method("pair_map",pair_map)
-- iterates on the values of another iterators and yield only the values that pass the criteria
-- (a kind of an equivalent of the functional "filter" function that works on iterator instead of list)
-- this iterator works on values
local function filter(it, criteria)
assert(it, "filter : no iterator provided")
assert(type(criteria)=="function", "no criteria provided")
return wrap(
function()
local val = it()
while val and not(criteria(val)) do
val = it()
end
return val
end
)
end
register_method("filter", filter)
-- pair version of the previous function
--this iterators works on pairs
local function pair_filter(it, criteria)
assert(it, "pair_filter : no iterator provided")
return wrap(
function()
local i, val = it()
while val and not(criteria(i, val)) do
i, val = it()
end
return i, val
end
)
end
register_method("pair_filter", pair_filter)
--creates a value only iterator from a "pair" one, yielding only the "keys" (first item of the pair)
--this iterators works on pairs
local function select_keys(it)
assert(it, "select_keys : no iterator provided")
return wrap(
function()
local i, val = it()
return i
end
)
end
register_method("select_keys", select_keys)
--creates a value only iterator from a "pair" one, yielding only the "values" (second item of the pair)
--this iterators works on pairs
local function select_vals(it)
assert(it, "pair_vals : no iterator provided")
return wrap(
function()
local i, val = it()
return val
end
)
end
p.select_vals = select_vals
-- create a stateful iterators that iterates on the values of a table
-- (from the stateless standard "pairs" iterator on tables)
local function on_vals(tabl)
local _f, _s, _v = pairs(tabl)
return wrap(
function()
if _s then
local i, res = _f(_s, _v)
_v = i
if not res then _s = nil end
return res
end
end
)
end
p.on_vals = on_vals
-- create a stateful iterators that iterates over the keys of a table
-- (from the stateless standard "pairs" iterator on tables)
local function on_pairs(tabl)
local _f, _s, _v = pairs(tabl)
return --wrap(
function()
if _s then
local i, res = _f(_s, _v)
_v = i
if not res then _s = nil end
return i, res
end
end
--)
end
p.on_pairs = on_pairs
-- equivalent of the "join" operation, with join({{"a"},{},{"b","c"}}) = {"a","b","c"}
-- for iterators.
-- if the parameter "it" is an iterator that yields {"a"} ; then {} ; then {"b","c"}
-- and "creator" is a function that creates an iterator that yields "b" then "c" from the table {"b","c"}
-- the "flatten"-ing of this parameter will yield "a" then "b" then "c"
local function flatten(it, creator)
assert(it, "flatten : no iterator provided")
assert(creator, "flatten : no iterator creator provided")
local main_val = it()
if main_val then
local sub_it = creator(main_val)
return wrap(
function()
if main_val then
local val = nil
while not val and main_val do
if sub_it then
val = sub_it()
end
if not val then
main_val = it()
if not main_val then return end
sub_it = creator(main_val)
end
end
return val
end
end
)
else
return wrap(function () return nil end)
end
end
register_method("flatten", flatten)
-- equivalent of list concatenation for iterators
local chain = function (it1, it2)
return wrap(
function()
local res = it1() or it2()
return res
end
)
end
register_method("chain", chain)
-- creates an iterator on a single value
p.singleton = function (val)
local iterated
return wrap(function()
if not iterated then
iterated = true
return val
end
end)
end
local function fold(it, acc, init)
local accum = init
for res in it do
accum = acc(res, accum)
end
return accum
end
register_method("fold", fold)
local function totable(it)
return fold(
it,
function (val, tabl)
table.insert(tabl, val)
return tabl
end,
{}
)
end
register_method("totable", totable)
function p.range(start_i, end_i, step)
local i = nil
step = step or 1
assert(step ~= 0)
local direction = step/math.abs(step)
return wrap(function()
if not i then
i = start_i
else
i = i + step
end
if i * direction < end_i * direction then
return i
else
return
end
end)
end
--------------------------------------------------------------------------------
-- TESTING FUNCTIONS
--------------------------------------------------------------------------------
function p.execute(iterator)
for x in iterator do
mw.log(x)
end
end
function p.execute_pair(iterator)
for x, y in iterator do
mw.log(x, y)
end
end
return p
Belgekirina modulê[biafirîne]