lightweigt coroutine for iterator?

[codehz]

Since closure is in plan, I think it is possible to support a lightware coroutine?

I mean, transform this function

function iter(val: integer): iterator(integer) <iterator>
local state = 0
-- use while for simplicity, it could be a for loop
while state < val do
yield(state) -- or another keyword
state = state + 1
end
end

to

local iter_state = @record{ step: integer, state: integer, val: integer }

local function iter_impl(state: *iter_state): (boolean, integer)
  switch state.step
  case 0 then
    state.state = 0
    if state.state < state.val then
      state.step = 1
      return true, state.state
    end
    state.step = -1
    return false, integer()
  case 1 then
    state.state = state.state + 1
    if state.state < state.val then
      return true, state.state
    end
    state.step = -1
    return false, integer()
  else
    panic("invalid state")
  end
end

local function iter(val: integer): (function(state: *iter_state): (boolean, integer), iter_state)
  return iter_impl, { step = 0, val = val }
end

local fn, state = iter(5)

print(fn(state))
print(fn(state))
print(fn(state))
print(fn(state))
print(fn(state))
print(fn(state))

-- maybe used in for loop? not possible for now
-- for val in iter(5) do print(val) end

why perfer this approach since we already have the stackful coroutine?

to make iterator easier without add too much runtime cost.
the state record generation should be able to share same logic in future closure implemention, the only challenge is how to transform loop and other control flow to this style

[edubart]

This is already supported, Nelua supports for in in the same style of Lua iterators, check the overview and for in documentation. For implementation examples you could look iterators module, there ipairs and pairs iterators are implemented, and here is what you wanted I think:

local function iter(max: integer): (auto, integer, integer)
  local function iter_next(max: integer, i: integer): (boolean, integer)
    i = i + 1
    if i >= max then
      return false, 0
    end
    return true, i
  end
  return iter_next, max, -1
end

for i in iter(10) do
  print(i) -- outputs: 0 1 2 3 4 5 6 7 8 9
end

You can also embed a more complex state inside the iterator, check hashmap_iteratorT inside hashmap module for example of that.

In the compiler sources, the for in does just some AST transformation under the hood and is lightweight.

[codehz]

The idea in here is the transform yield to switch based coroutine, not about the iterator.

[edubart]

Oh right, I got it, you can probably do this with some AST transformations like for in does, will think about a PoC for this later.