Issue #8772 has been updated by fuadksd (Fuad Saud).


Just pinging. Any more ideas on this matter?
----------------------------------------
Feature #8772: Hash alias #| merge, and the case for Hash and Array polymorphism
https://bugs.ruby-lang.org/issues/8772#change-42459

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


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/