From: "trans (Thomas Sawyer)" Date: 2013-08-18T22:07:26+09:00 Subject: [ruby-core:56722] [ruby-trunk - Feature #8772] Hash alias #| merge, and the case for Hash and Array polymorphism Issue #8772 has been updated by trans (Thomas Sawyer). =begin Allowing Hash#<< to take a key-value pair, i.e. [:a,1], provides useful polymorphism between hash and associative arrays. And that's because in Ruby the way it represents a key-value pair is via a two-element array. We see this when use `Hash.each { |q| .. }`, q is an array pair. So for example: h = {:a=>1, :b=>2} i = [] obj.inject(i) do |q, j| j << q end => [[:a,1], [:b,2]] i = {} h.inject(i) do |q, j| j << q end => {:a=>1, :b=>2} We were able to use the same routine regardless of whether `i` is an array or a hash. And notice that Hash#to_a produces the associative array. _.to_a #=> [[:a,1], [:b,2]] Without this polymorphism, we would have to write more complex code to handle an array vs a hash case. But by simpling allowing #<< to handle key-value pairs, we get a lot more bang for our coding buck. =end ---------------------------------------- Feature #8772: Hash alias #| merge, and the case for Hash and Array polymorphism https://bugs.ruby-lang.org/issues/8772#change-41251 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/