CODEWITHSUNDEEP
ruby
artemave
artemave

Reputation: 6946

ruby hash autovivification (facets)

Here is a clever trick to enable hash autovivification in ruby (taken from facets):

  # File lib/core/facets/hash/autonew.rb, line 19
  def self.autonew(*args)
    leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
    new(*args,&leet)
  end

Although it works (of course), I find it really frustrating that I can't figure out how this two liner does what it does.

leet is put as a default value. So that then just accessing h['new_key'] somehow brings it up and creates 'new_key' => {}

Now, I'd expect h['new_key'] returning default value object as opposed to evaluating it. That is, 'new_key' => {} is not automatically created. So how does leet actually get called? Especially with two parameters?

Upvotes: 8

Views: 2816

Answers (3)

Brian K
Brian K

Reputation: 114

Alternatively, you might consider my xkeys gem. It's a module that you can use to extend arrays or hashes to facilitate nested access.

If you look for something that doesn't exist yet, you get a nil value (or another value or an exception if you prefer) without creating anything by looking. It can also append to the end of arrays.

You can opt to autovivify either hashes or arrays for integer keys (but just once for the entire structure).

Upvotes: 0

Peter Wagenet
Peter Wagenet

Reputation: 5056

It's also worth noting that this code can be made into a one-liner as follows:

def self.autonew(*args)
  new(*args){|hsh, key| hsh[key] = Hash.new(&hsh.default_proc) }
end

The call to Hash#default_proc returns the proc that was used to create the parent, so we have a nice recursive setup here.

I talk about a similar case to this on my blog.

Upvotes: 8

mikej
mikej

Reputation: 66313

The standard new method for Hash accepts a block. This block is called in the event of trying to access a key in the Hash which does not exist. The block is passed the Hash itself and the key that was requested (the two parameters) and should return the value that should be returned for the requested key.

You will notice that the leet lambda does 2 things. It returns a new Hash with leet itself as the block for handling defaults. This is the behaviour which allows autonew to work for Hashes of arbitrary depth. It also assigns this new Hash to hsh[key] so that next time you request the same key you will get the existing Hash rather than a new one being created.

Upvotes: 18

Related Questions