[ruby-core:56624] [ruby-trunk - Feature #8772] Hash alias #| merge, and the case for Hash and Array polymorphism

Issue #8772 has been updated by trans (Thomas Sawyer).


Actually I think #<< is good too. But it's definition needs to be a bit more flexible than just merge. That's because it needs to do this:

  h = {}
  h << [:a,1]
  h << [:b,2]
  h  #=> {:a=>1, :b=>2}

Which is very useful polymorphically. Aagain, following a polymorphic principle, this too can be derived. 

Nonetheless, there should be no problem with it also supporting single entry hashes:

  h = {}
  h << {:a => 1}
  h << {:b => 2}
  h  #=> {:a=>1, :b=>2}

And by its very nature that means

  h = {}
  h << {:a => 1, :b => 2}
  h  #=> {:a=>1, :b=>2}

works just fine too.

So, yea +1 for #<<. But it is not the exact same thing as #merge, or even #merge!.

----------------------------------------
Feature #8772: Hash alias #| merge, and the case for Hash and Array polymorphism
https://bugs.ruby-lang.org/issues/8772#change-41162

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/