evan_tech

Lua's approach to iterators is to have a function that returns a function (a closure); it then calls that second function repeatedly until it returns nil. I quite like this pattern because it bundles the iteration code and the state up together in a nice package:

function zero_to(n)
    local a = -1
    return function ()
        a = a + 1
        if a > n then return nil end
        return a
    end
end

But then, I'm well known as being overly fond of closures. I'm often told I use closures too much — especially by people that don't understand them :). If you combine it with Lua's coroutines you can end up with a generator pattern (with all the yeilding) if you like that sort of thing, though this is a feature of the runtime library and not of the language itself.

I love the idea of lazy lists because it always seemed like such a hack to expose to the programmer the distinction between an iterator and a list. Of course, you describe in your last paragraph why it's often desirable to have it explicit.

for @list.kv -> $index, $value { ... }

@new <== gather {
    for @old.kv -> $i, $v {
        take $k if $v == 3;
    }
}

Python

1. Python uses generators to simulate lazy lists, and most Python iterators nowadays use generators.



2. 
   In Python you'll write code like:
   elems = []; for e in tree.preorder(): elems.append(e)

   
   

   Nuh-uh, no fucking way, in Python you'll write code like elems = list(tree.preorder()). I love both Haskell and Python, but for god's sake at least try to know what you're talking about before criticizing it




3. What if I want each index as I go? [...] zip [0..] (preorder tree)
   gives you a list (or equivalently an iterator) of pairs of </code>(index, element)</code>.

   
   

   And Python has the enumerate function which goes exactly that (give it an enumerable and it returns a generator of (index, element) pairs), and you can recreate it with a combination of itertools.count and itertools.izip or zip e.g. zip(count(), ["foo","bar","baz"]) returns [(0, 'foo'), (1, 'bar'), (2, 'baz')] (izip does something similar but it returns a generator, so izip(count(), ["foo","bar","baz"]) perfectly replicates the behaviour of enumerate(["foo","bar","baz"])




4. For more complicated control flow, like skipping certain elements, you can fall back on referring to the iterator explicitly like you do in [...] Python</code>

   
   

   Uh what? Since when does anyone explicitely refer to iterator objects in Python?




5. A reverse iterator over every other element from a tree with the elements numbered in preorder is then just
   reverse (everyOther (zip [0..] (preorder tree))).

   
   

   reversed(filter(everyOther, enumerate(tree.preorder()))) # you'll note that my everyOther function here is merely a predicate, it doesn't do the filtering even though you could trivially create one that does it.

   
   

   Or, to look more like the Haskell code, reversed(filter(everyOther, zip(count(), tree.preorder())))

Laziness is an evaluation order