On Aug 17, 2013 9:37 PM, "rosenfeld (Rodrig= o Rosenfeld Rosas)" <rr.rosas= @gmail.com> wrote:

Issue #8772 has been updated by rosenfeld (Rodrigo Rosenfeld Rosas).

I believe it would be confusing if we had anything different from:

=A0#<<: alias for merge!
=A0#|: alias for merge

I understand how reverse_merge could be useful, but I believe that any of t= he alias above behaving as reverse_merge would be confusing.

Those alias would already be useful in cases people are using reverse_merge= :

options.reverse_merge! a: 1

options =3D {a: 1} | options # not exactly the same, but usually has the sa= me effect on most well written code

I'd even be fine with #>> as an alias for reverse_merge!

options >>=3D {a: 1} # options.reverse_merge! a: 1
----------------------------------------
Feature #8772: Hash alias #| merge, and the case for Hash and Array polymor= phism
https://bugs.ruby-lang.org/issues/8772#change-41239

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee:
Category: core
Target version: current: 2.1.0

Ideally Hash and Array would be completely polymorphic in every manner in w= hich it is possible for them to be so. The reason for this is very simple. = It makes a programmer's life easier. For example, in a recent program I= was working on, I had a list of keyboard layouts.

=A0 layouts =3D [layout1, layout2, layout3]

Later I realized I wanted to identify them by a label not an index. So...
=A0 layouts =3D {:foo =3D> layout1, :bar =3D> layout2, :baz =3D> l= ayout3}

Unfortunately this broke my program in a number of places, and I had to go = through every use of `layouts` to translate what was an Array call into a H= ash call. If Array and and Hash were more polymorphic I would have only had= to adjust the places were I wanted to take advantage of the Hash. Ideally = almost nothing should have actually broken.

The achieve optimal polymorphism between Hash and Array is to treat a Hash&= #39;s keys as indexes and its values as as the values of an array. e.g.

=A0 a =3D [:a,:b,:c]
=A0 h =3D {0=3D>:a,1=3D>:b,2=3D>:c}
=A0 a.to_a =A0#=3D> [:a,:b,:c]
=A0 h.to_a =A0#=3D> [:a,:b,:c]

Of course the ship has already sailed for some methods that are not polymor= phic, in particular #each. Nonetheless it would still be wise to try to max= imize the polymorphism going forward. (Perhaps even to be willing to take a= bold leap in Ruby 3.0 to break some backward compatibility to improve upon= this.)

In the mean time, let us consider what it might mean for Hash#+ as an alias= for #merge, *if the above were so*:

=A0 ([:a,:b] + [:c,:d]).to_a =A0 =A0 =A0 =A0 =A0 =A0 =3D> [:a,:b,:c,:d]<= br> =A0 ({0=3D>:a,1=3D>:b} + {2=3D>:c,3=3D>:d}).to_a =3D> [:a,:b= ,:c,:d]

=A0 ([:a,:b] + [:a,:b]).to_a =A0 =A0 =A0 =A0 =A0 =A0 =3D> [:a,:b,:a,:b]<= br> =A0 ({0=3D>:a,1=3D>:b} + {0=3D>:a,1=3D>:b}).to_a =3D> [:a,:b= ]

Damn! So it appears that #+ isn't the right operator. Let's try #| = instead.

=A0 ([:a,:b] | [:c,:d]).to_a =A0 =A0 =A0 =A0 =A0 =A0 =3D> [:a,:b,:c,:d]<= br> =A0 ({0=3D>:a,1=3D>:b} | {2=3D>:c,3=3D>:d}).to_a =3D> [:a,:b= ,:c,:d]

=A0 ([:a,:b] | [:a,:b]).to_a =A0 =A0 =A0 =A0 =A0 =A0 =3D> [:a,:b]
=A0 ({0=3D>:a,1=3D>:b} | {0=3D>:a,1=3D>:b}).to_a =3D> [:a,:b= ]

Bingo. So I formally stand corrected. The best alias for merge is #| not #+= .

Based on this line of reasoning I formally request the Hash#| be an alias o= f Hash#merge.

P.S. Albeit, given the current state of polymorphism between Ruby's Arr= ay and Hash, and the fact that it will probably never be improved upon, I d= oubt it really matters which operator is actually used.

--
http://bugs.ruby-l= ang.org/