[ruby-core:111989] [Ruby master Feature#19324] Enumerator.product => Enumerable#product

Issue #19324 has been updated by zverok (Victor Shepelev). Just to add a few points: 1. I don't believe "zip with all arguments the same" has really any significant usage: at least, in codebases I looked in (Ruby stdlib, Rails, Rubocop, Sidekiq, my work apps) I can't find any. BTW, the trivial case of "have array of arrays, and want to zip each row" is just `Array#transpose` 2. From the top of my head, I can't think of more methods like `product` and `zip` (that process uniformly array of arguments, and wouldn't be the same as `arguments.reduce(:method)`, like `Hash#merge` is), which, considering (1), seems to leave `product` as a rare special case, not a useful trend to start; 3. In modern Ruby, chainable `product` is trivially implemented: `arys.then { |first, *rest| first.product(*rest) }`. If, by chance, [anonymous params for blocks](https://bugs.ruby-lang.org/issues/19370) would become a thing, it would even be `arys.then { |first, *| first.product(*) }`. It might still look worse than one specialized method, though. 4. Oh, and returning to `zip`, its first argument **is** special, because it defines the size of the output: ```ruby %w[a b c].zip([1, 2], %i[x]) # => [["a", 1, :x], ["b", 2, nil], ["c", nil, nil]] [1, 2].zip(%w[a b c], %i[x]) # => [[1, "a", :x], [2, "b", nil]] %i[x].zip(%w[a b c], [1, 2]) # => [[:x, "a", 1]] ``` ...so, considering first argument as an "owner" of the operation has its semantical meaning. ---------------------------------------- Feature #19324: Enumerator.product => Enumerable#product https://bugs.ruby-lang.org/issues/19324#change-101426 * Author: zverok (Victor Shepelev) * Status: Open * Priority: Normal ---------------------------------------- I know it might be too late after introducing a feature and releasing a version, but I find `Enumerator.product` quite confusing, and can't find any justification in #18685. **Problem 1: It is `Array#product` but `Enumerator.product`** ```ruby [1, 2].product([4, 5]) # => [[1, 4], [1, 5], [2, 4], [2, 5]] # Usually, when we add methods to Enumerable/Enumerator which # already array had before, it is symmetric, say... [1, nil, 2, 3].compact #=> [1, 2, 3] [1, nil, 2, 3].lazy.compact.first(2) #=> [1, 2] # But not in this case: [1, 2].lazy.product([4, 5]).first(2) # undefined method `product' for #<Enumerator::Lazy: [1, 2]> (NoMethodError) # Because you "just" need to change it to: Enumerator.product([1, 2].lazy, [4, 5]).first(2) # => [[1, 4], [1, 5]] ``` No other method was "promoted" from Array this way And in general, I believe core methods tend to belong to the first object in the expression and not be free module methods, Elixir style. **Problem 2: It is one letter different from `Enumerator.produce`** I understand I might be biased here (as a person who proposed `produce`), and that method is not as popular (yet?) as I hoped, but still, two methods that do completely different things and differ by one letter, both being somewhat vague verbs (so it is easy to confuse them unless you did a lot of math and "product" is firmly set for set product in your head). I believe that EITHER of two problems would be concerning enough, but the combination of them seems to be a strong enough argument to make the change?.. (Maybe with graceful deprecation of module method in one next version, but, considering the Ruby 3.2 is just released, maybe vice versa, fix the problem in the next minor release?..) -- https://bugs.ruby-lang.org/