Agreed.
On Aug 17, 2013 9:37 PM, "rosenfeld (Rodrigo 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:
>
>  #<<: alias for merge!
>  #|: alias for merge
>
> I understand how reverse_merge could be useful, but I believe that any of
> the 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 = {a: 1} | options # not exactly the same, but usually has the
> same effect on most well written code
>
> I'd even be fine with #>> as an alias for reverse_merge!
>
> options >>= {a: 1} # options.reverse_merge! a: 1
> ----------------------------------------
> Feature #8772: Hash alias #| merge, and the case for Hash and Array
> polymorphism
> 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
> which 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.
>
>   layouts = [layout1, layout2, layout3]
>
> Later I realized I wanted to identify them by a label not an index. So...
>
>   layouts = {:foo => layout1, :bar => layout2, :baz => layout3}
>
> 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
> Hash 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's keys as indexes and its values as as the values of an array. e.g.
>
>   a = [:a,:b,:c]
>   h = {0=>:a,1=>:b,2=>:c}
>   a.to_a  #=> [:a,:b,:c]
>   h.to_a  #=> [:a,:b,:c]
>
> Of course the ship has already sailed for some methods that are not
> polymorphic, in particular #each. Nonetheless it would still be wise to try
> to maximize 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*:
>
>   ([:a,:b] + [:c,:d]).to_a             => [:a,:b,:c,:d]
>   ({0=>:a,1=>:b} + {2=>:c,3=>:d}).to_a => [:a,:b,:c,:d]
>
>   ([:a,:b] + [:a,:b]).to_a             => [:a,:b,:a,:b]
>   ({0=>:a,1=>:b} + {0=>:a,1=>:b}).to_a => [:a,:b]
>
> Damn! So it appears that #+ isn't the right operator. Let's try #| instead.
>
>   ([:a,:b] | [:c,:d]).to_a             => [:a,:b,:c,:d]
>   ({0=>:a,1=>:b} | {2=>:c,3=>:d}).to_a => [:a,:b,:c,:d]
>
>   ([:a,:b] | [:a,:b]).to_a             => [:a,:b]
>   ({0=>:a,1=>:b} | {0=>:a,1=>:b}).to_a => [: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
> of Hash#merge.
>
> P.S. Albeit, given the current state of polymorphism between Ruby's Array
> and Hash, and the fact that it will probably never be improved upon, I
> doubt it really matters which operator is actually used.
>
>
>
> --
> http://bugs.ruby-lang.org/
>