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

Issue #19324 has been updated by duerst (Martin D=FCrst).





Thinking about this a bit more, I guess both the "first argument is special=
" (A) and the "all arguments are the same" (B) have use cases. There's prob=
ably a third one, which is "all arguments are already in an array" (C). (B)=
 and (C) are only one splat/[] away from each other; (A) is clearly a bit f=
arther off from the other two, see `array_of_arrays.first.product(*array_of=
_arrays.drop(1))` above.



Making a distinction by using the difference between method with receiver a=
nd class method is one way to accommodate these use cases, but I think it w=
ould be more Ruby-like if receivers where used in both cases and the distin=
ction were made by method name. So as an example, we could have: `a.zip(b, =
c)` and `[a,b,c].multi_zip`. `multi_zip` here is only one possible name, th=
ere may be better ones. This solution would allow method chaining, which is=
 important for good Ruby style.



----------------------------------------

Feature #19324: Enumerator.product =3D> Enumerable#product

https://bugs.ruby-lang.org/issues/19324#change-101415



* Author: zverok (Victor Shepelev)

* Status: Open

* Priority: Normal

----------------------------------------

I know it might be too late after introducing a feature and releasing a ver=
sion, but I find `Enumerator.product` quite confusing, and can't find any j=
ustification in #18685.



**Problem 1: It is `Array#product` but `Enumerator.product`**



```ruby

[1, 2].product([4, 5])

# =3D> [[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 #=3D> [1, 2, 3]

[1, nil, 2, 3].lazy.compact.first(2) #=3D> [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)

# =3D> [[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 i=
n 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`), a=
nd 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 so=
mewhat vague verbs (so it is easy to confuse them unless you did a lot of m=
ath and "product" is firmly set for set product in your head).



I believe that EITHER of two problems would be concerning enough, but the c=
ombination of them seems to be a strong enough argument to make the change?=
.. (Maybe with graceful deprecation of module method in one next version, b=
ut, considering the Ruby 3.2 is just released, maybe vice versa, fix the pr=
oblem in the next minor release?..)









--=20

https://bugs.ruby-lang.org/

 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-c=
ore.ml.ruby-lang.org/