Yukihiro Matsumoto wrote:
> |1. A new method, Array.combine  (needs a better name for general use).
> |   It takes entries from two (or many) arrays and combines them.
> |   (like a combination of Array.zip, fetch, and map)
> 

I don't think we need another method for this. This sounds like the 
domain of Enumerable#map (at least as far as how map works in lisp and 
python).

Is there anything about map that prevents it from being extended to 
accept 0 or more enumerables as parameters, then a block?

According to this rationale:

>   * the best name for the behavior.

map

>   * whether it takes only one argument or any number of arguments.

0 or more. (Much more powerful, and we don't have to give up anything 
about only taking one arg to support taking many)

>   * whether "multiplication" should be the default.

If by "default" you mean "when no block is passed", as I see it, the 
default should be identical or similar to zip.

in python, map with multiple lists and no function returns a list with 
the length of the largest list, each element being a list of the 
elements at its index in the lists passed in, None is used for elements 
that don't exist in the other lists.

I like python's behavior, but I think in the case of ruby, using the 
length of the receiver better matches expected behavior than using a 
length from one of the parameters.

(on the other hand, using the longest length makes it more useful in 
that it differs from zip, and it seems more useful in most cases)