Lambda the Ultimate

Also, I think a comparison with some of the Smalltalk control structures would have been interesting. The Sather upTo iterator seems like Smalltalk's to message, for example.

Otherwise you have a problem impelmenting different iteration policies. It is also a question of coupling.

This isssue is discussed in the GoF book, IIRC. Also in some of Robert Martin's papers.

I'm not sure what you mean by "policy"; I am assuming that you're referring to something like in-order vs. post-order traversals for trees. In this case, one could simply add extra traversal methods, so that a Tree collection would implement, say, "nextElementInPostOrder" in addition to a plain "nextElement."

Also, by having an external iterator class holding on to a collection's element, it could create garbage collection problems, where an item is retained after it is needed.

This isssue is discussed in the GoF book, IIRC. Also in some of Robert Martin's papers.

Remember that iteration in the normal sense is just one aspect of the concept of coroutines. In my mind, coroutines are more like of sink if data, wherein data can be retrieved in sequential fashion. That sink can be a simple sequence of values within a list (array, collection), or it can be a the next item in a function (an infinite list). The bottom line in coroutines is that you can get late evaluation of terms (lazy evaluation).

Although you can achieve coroutines in a number of languages, it seems to me that the languages with the best implementation are Icon (generators), Sather (coroutines), and Haskell (lazy evaluation.

Perhaps the most interesting aspect is how the concepts of generators, coroutines and lazy evaluation are inexorably intertwined. If you get one of the three, then you invariably can get the other two.

One interesting thing that I noted from reading Betrand Meyer is that coroutines were done very well in Simula. Intersting that Sather is a takeoff on the concept of coroutines, but never officially accepted by Meyer in the Eiffel language.

Speaking of Sather, what's up? I was hoping that GNU taking over the project would spring it forward, but last I checked it hasn't made a whole lot of progress. Not that Eiffel really needs a spinoff language, but Sather has been interesting in it's own right.

Sather iterators were inspired by CLU iterators

One wouldn't want you to remain CLUless, so here is an example (from A Brief Introduction to CLU by Guttag):

set[t] = cluster is create, insert, member, elems, equal
   rep = array[t]
   create = proc() retrurns (cvt)
      return rep$new())
      end create
   ...
   elems = iter (s:cvt) yields (t)
     for e: t in rep$elems(s) do yield(e) end
     end elems
   equal = proc (s1: set, s2: set) returns (bool)
     if rep$size(down(s1)) ~= rep$size(down(s2)) then 
      return (false) end
     for e: t in elems(s1) do
       if ~member(s2, e) then return(false) end
     end
     return(true)
    end equal
end set

I know this is a simple example. I am not a CLU expert. The Sather paper above goes into more details about the capabilities of CLU iterators (as compare to the Sather variety).