Range Iterator

wiki

function range(from, to, step)
  step = step or 1
  return function(_, lastvalue)
    local nextvalue = lastvalue + step
    if step > 0 and nextvalue <= to or step < 0 and nextvalue >= to or
       step == 0
    then
      return nextvalue
    end
  end, nil, from - step
end

Example use:

function f() return 10, 0, -1 end

for i in range(f()) do
  print(i)
end

Update #1:

Conditionals may also be moved out of the functions: --DavidManura

function range(from, to, step)
  step = step or 1
  local f =
    step > 0 and
      function(_, lastvalue)
        local nextvalue = lastvalue + step
        if nextvalue <= to then return nextvalue end
      end or
    step < 0 and
      function(_, lastvalue)
        local nextvalue = lastvalue + step
        if nextvalue >= to then return nextvalue end
      end or
      function(_, lastvalue) return lastvalue end
  return f, nil, from - step
end

Update #2:

Here is a version that in addition to treating step as optional and optimizing the inner conditional checks, allows 1 argument calls:

-- range(a) returns an iterator from 1 to a (step = 1)
-- range(a, b) returns an iterator from a to b (step = 1)
-- range(a, b, step) returns an iterator from a to b, counting by step.
function range(a, b, step)
  if not b then
    b = a
    a = 1
  end
  step = step or 1
  local f =
    step > 0 and
      function(_, lastvalue)
        local nextvalue = lastvalue + step
        if nextvalue <= b then return nextvalue end
      end or
    step < 0 and
      function(_, lastvalue)
        local nextvalue = lastvalue + step
        if nextvalue >= b then return nextvalue end
      end or
      function(_, lastvalue) return lastvalue end
  return f, nil, a - step
end

This allows for a more compact form for simple upwards counting:

-- Prints the range of numbers 1 to 10 inclusive.
for i in range(10) do
  print(i)
end

Update #3:

Here is my take, it supports both forward and backward iteration.

The other BIG thing is that iterators (imo) _should_ return at least 2 values on each successful iteration.

Consider this:

       -- Some functions accept the returned values of generators (like ipairs())
       -- and have a predefined for loop in their body like so:
       some_function = (...) local tmp = {} for k, v in ... do tmp[k] = v end return tmp end
       some_function(ipairs({ 1, 2, 3 }) -> { 1, 2, 3 }
       some_function(range(3)) -> { 1, 2, 3 }

The actual range() definition:

       -- range(start)             returns an iterator from 1 to a (step = 1)
       -- range(start, stop)       returns an iterator from a to b (step = 1)
       -- range(start, stop, step) returns an iterator from a to b, counting by step.
       range =
           function (i, to, inc)
                if i == nil then return end -- range(--[[ no args ]]) -> return "nothing" to fail the loop in the caller

               if not to then
                   to = i 
                   i  = to == 0 and 0 or (to > 0 and 1 or -1) 
               end 

               -- we don't have to do the to == 0 check
               -- 0 -> 0 with any inc would never iterate
               inc = inc or (i < to and 1 or -1) 

               -- step back (once) before we start
               i = i - inc 

               return function () if i == to then return nil end i = i + inc return i, i end 
           end 
       

Why

I had needed a range() because I wanted to do:

        to_table(range(10)) -- would create { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }

Sure you could type a literal { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } to get the table you want, but that's not the point, it's about what having a generator like range() can let you do. It's for places where you need to provide an iterator because you can't use a numeric-for. (functional vs imperative programming?)

Elsewhere I use it to do things like this:

        -- print the sum of every cleanly-divisible-by-3 number from 1 to 100
        print(setmetatable(to_table(range(100)), { __index == 'special_table' }):remove_if(function (x) return x % 3 ~= 0 end):reduce(function (x, y) return x + y --[[ sum ]] end, 0 --[[ initial y ]]))

There are, of course, more direct ways to write this -- but let your imagination flow for a better example. :-)

Example calls:

        for i in range( 10) print(i) end -- iterate 1 to 10, increment by 1
        for i in range(-10) print(i) end -- iterate -1 to -10, decrement by 1
        for i in range(7, -2) print(i) end -- iterate 7 to -2, decrement by 1
        for i in range(3, 27, 3) print(i) end -- iterate 3 to 27, increment by 3
        for i in range(0, 1, -1) print(i) end -- iterate 0 to 1, decrementing by 1 (loop forever downward)
        for i in range() print(i) end -- error() because the call to the "returned" iterator is a nil value

-- SleepyCoder