The community has been building a Ruby 1.9 compatibility tip list on  
my blog.  While most of the changes are good, a pattern is emerging:   numerable#zip was damaged in the translation.  The short story is:

* Making Enumerable#zip() return and Enumerable::Enumerator when  
called without a block hid a very useful return value that was already  n place.  Now we typically need `enum.zip(.to_a` to get the  
expected results.
* Beyond being less attractive, Enumerable::Enumerator is quite a bit  lower.  It looks like `enum.zip(.to_a` in 1.9 is about 12 times  
slower than a straight `enum.zip(` in Ruby 1.8.
* Making Enumerable#zip() stop at the length of the shortest  
Enumerable among the receiver and arguments really hurt its  
usefulness.  It now discards data and it's hard for us to prevent  
that, since we need to lengthen all short Enumerable objects we plan  
to use before the call.  The Ruby 1.8 system of limiting the result  
set to the size of the receiver was much more powerful, in my  
opinion.  We could find the longest or shortest Enumerable to get the  ength we wanted, filter out the `nil` containing groups it inserted,  r trim the size of the Enumerable objects involved (easier than  
expanding them).

So, I'm making a plea for restoring Enumerable#zip() to the cool  
iterator we all know and love:

* Can we restore the Array return value?  We can still use  
`enum_for(:zip, ` when needed.  This fits in with the other  
iterators that have a useful return value like all?(), any?(),  
count(), drop(), inject()/reduce(), none?(), one?(), sort(), and take().
* Can we revert to the 1.8 behavior of setting the result set length  
to the length of the receiver and adding `nil` objects for shorter  
Enumerable arguments?  That seems to give us a lot more control over  
the end result.

Thanks for listening.

James Edward Gray II