Does Ruby Hash's keep a separate list of read values vs assigned values?

Question

This is related to Ruby hash default value behavior

But maybe the explanation there doesn't include this part: it seems that Ruby's Hash default value are separate whether you "read it", or see "what is set"?

One example is:

foo = Hash.new([])

foo[123].push("hi")

p foo       # => {}
p foo[123]  # => ["hi"]
p foo       # => {}

How is it that foo[123] has a value, but foo is all empty, is somewhat beyond my comprehension... the only way I can understand it is that Ruby Hash keeps a separate list for the "read" or "getter", while somehow the "internal" assigned value are different.

If one of Ruby's design principles is "to have the least amount of surprise to the programmers", then the foo is empty but foo[123] is something, is somewhat in this case, a surprise to me.

(I haven't seen that in other languages actually... if there is a case where another language has similar behavior, maybe it is easier to make a connection.)

Answer 1

Suppose `

h = Hash.new(:cat)
h[:a] = 1
h[:b] = 2
h #=> {:a=>1, :b=>2}

Now

h[:a] #=> 1
h[:b] #=> 2
h[:c] #=> :cat
h[:d] #=> :cat
h     #=> {:a=>1, :b=>2}

h = Hash.new(:cat) defines an empty hash h with a default value of :cat. This means that if h does not have a key k, h[k] will return :cat, nothing more, nothing less. As you can see above, executing h[k] does not change the hash when k is :c or :d.

On the other hand,

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

Confused? Let me write this without the syntactic sugar:

h.[]=(:d, h.[](:d))
  #=> :cat
h #=> {:a=>1, :b=>2, :d=>:cat}

The default value is returned by h.[](:d) (i.e., h[:d]) whereas Hash#[]= is an assignment method (that takes two arguments, a key and a value) to which the default does not apply.

A common use of this default is to create a counting hash:

a = [1,3,1,4,2,5,4,4]
h = Hash.new(0)
a.each { |x| h[x] = h[x] + 1 }
h #=> {1=>2, 3=>1, 4=>3, 2=>1, 5=>1}

Initially, when h is empty and x #=> 1, h[1] = h[1] + 1 will evaluate to h[1] = 0 + 1, because (since h has no key 1) h[1] on the right side of the equality is set equal to the default value of zero. The next time 1 is passed to the block (x #=> 1), x[1] = x[1] + 1, which equals x[1] = 1 + 1. This time the default value is not used because h now has a key 1.

This would normally be written (incidentally):

a.each_with_object(Hash.new(0)) { |x,h| h[x] += 1 }
  #=> {1=>2, 3=>1, 4=>3, 2=>1, 5=>1}

One generally does not want the default value to be a collection, such as an array or hash. Consider the following:

h = Hash.new([])
[1,2,3].map { |n| h[n] = h[n] }
h #=> {1=>[], 2=>[], 3=>[]}

Now observe:

h[1] << 2
h #=> {1=>[2], 2=>[2], 3=>[2]}

This is normally not the desired behaviour. It has happened because

h.map { |k,v| v.object_id }
  #=> [25886508, 25886508, 25886508]

That is, all the values are the same object, so if the value of one key is changed the values of all other keys are changed as well.

The way around this is to use a block when defining the hash:

h = Hash.new { |h,k| h[k]=[] }
[1,2,3].each { |n| h[n] = h[n] }
h #=> {1=>[], 2=>[], 3=>[]}
h[1] << 2
h #=> {1=>[2], 2=>[], 3=>[]}
h.map { |k,v| v.object_id }
  #=> [24172884, 24172872, 24172848]

When the hash h does not have a key k the block { |h,k| h[k]=[] } is executed and returns an empty array specific to that key.

Answer 2

The statement:

foo = Hash.new([])

creates a new Hash that has an empty array ([] as default value). The default value is the value returned by Hash::[] when its argument is not a key present in the hash.

The statement:

foo[123]

invokes Hash::[] and, because the hash is empty (the key 123 is not present in the hash), it returns a reference to the default value which is an object of type Array. The statement above doesn't create the 123 key in the hash.

Ruby objects are always passed and returned by reference. This means that the statement above doesn't return a copy of the default value of the hash but a reference to it.

The statement:

foo[123].push("hi")

modifies the above mentioned array. Now, the default value of the foo hash is not an empty array any more; it is the array ["hi"]. But the has is still empty; none of the above statements added some (key, value) pair to it.

How is it that foo[123] has a value

foo[123] doesn't have any value, the key 123 is not present in the hash (the hash is empty). A subsequent call to foo[123] returns a reference to the default value again and the default value now it's ["hi"]. And a call to foo[456] or foo['abc'] also returns a reference to the same default value.

Answer 3

You didn't actually change the value of key 123, you're just accessing the default value [] you provided during initialization. You can confirm this if you inspect a different value like foo[0].

If you would do this:

foo[123] = ["hi"]

you could see the new entry, because you've created a new array under the key 123.

Edit

• When you call foo[123].push("hi"), you're mutating the (default) value instead of adding a new entry.

• Calling foo[123] += ["hi"] creates a new array under the given key, replacing the previous one if it existed, which will show the behavior you desire.

Answer 4

Printing out the hash with:

p foo

only prints the values stored in the hash. It does not display the default value (or anything added to the default array).

When you execute:

p foo[123]

Because 123 does not exist, it access the default value.

If you added two values to the default value:

foo[123].push("hi")
foo[456].push("hello")

your output would be:

p foo       # => {}
p foo[123]  # => ["hi","hello"]
p foo       # => {}

Here, poo[123] does again still not exist, so it prints out the contents of the default value.