Question

Lets say I have some “object” that I’ve defined elsewhere. Maybe it represents a set of items, but is more complex than a simple table. Whatever it may be, it would be logical to iterate over it.

As such, it has a iterator method defined. So I can write this:

local myObject = AbstractObject:new()

for obj in myObject:iterator() do
    obj:foo()
end

What I’m wondering is if there is some metamethod trickery that I can do, which will allow me to write this:

local myObject = AbstractObject:new()

for obj in myObject do
    obj:foo()
end

So is there?

Answer 1

One slight change to your example would make the semantics a lot less painful:

local myObject = AbstractObject:new()

for obj in myObject() do
    obj:foo()
end

That way, you can use a metatable to define the __call metamethod to return myObject:interator(), with code that looks something like this in AbstractObject:new():

setmetatable(newobject, {__call = function() return newobject:iterator() end})

---

Without the iterator construction, you’ll be effectively reusing a single iterator for multiple iterations, which means you’ll need to keep the iterator state in the object/creation closure, and reset it after it finishes so the next call will restart the iteration again. If you really want to do this, the best solution would really be to write something for the specific iteration implementation, but this would perform the generic iteration:

local iterator

--table.pack is planned for 5.2
local pack = table.pack or function(...)
  local t = {...}
  t.n = select('#',...)
  return t
end

--in 5.1 unpack isn't in table
local unpack = table.unpack or unpack

function metamethods.__call(...)
  if not iterator then
    iterator = newobject:iterator()
  end

  local returns = pack(iterator(...))

  if returns[1] == nil then
    --iteration is finished: next call will restart iteration
    iterator = nil
  end
  return unpack(returns, 1, returns.n)
end

Again: This should really be adjusted to fit your use case.