- Hermes - : create

2021-10-16T12:14:17Z

create

Nouvelle page

--[[
---------------------------------------------------------------------------------
-- 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

Module:Iterateurs - Historique des versions

- Hermes - : create