One liner nested hash creation in Ruby? (I come from Perl)

Question

I am a Perl person and I have made Hashes like this for a while:

my %date;

#Assume the scalars are called with 'my' earlier

$date{$month}{$day}{$hours}{$min}{$sec}++

Now I am learning Ruby and I have so far found that using this tree is the way to do many keys and a value. Is there any way to use the simple format that I use with Perl using one line?

 @date = {                                                                                                                                                                      
        month => {                                                                                                                                                                 
          day => {                                                                                                                                                                 
           hours => {                                                                                                                                                              
              min => {                                                                                                                                                             
                sec => 1                                                                                                                                                           
              }                                                                                                                                                                    
            }                                                                                                                                                                      
          }                                                                                                                                                                        
        }                                                                                                                                                                                                                                                                                                                                                     
      }                   

Answer 1

Unfortunately, there is no simple, practical way. A Ruby equivalent would be an ugly, ugly beast like:

((((@date[month] ||= {})[day] ||= {})[hours] ||= {})[min] ||= {})[sec] = 1

There is a way to assign default values for missing keys in hashes, though:

@date = Hash.new { |hash, key| hash[key] = {} }

# @date[:month] is set to a new, empty hash because the key is missing.
@date[:month][:day] = 1

Unfortunately this does not work recursively.

...unless you create it yourself; hooray for Ruby!

class Hash
  def self.recursive
    new { |hash, key| hash[key] = recursive }
  end
end

@date = Hash.recursive
@date[month][day][hours][min][sec] = 1
# @date now equals {month=>{day=>{hours=>{min=>{sec=>1}}}}}

Keep in mind, though, that all unset values are now {} rather than nil.

Answer 2

Here's a couple of options similar to the answer given by @molf but without the monkey patch.

Using a factory method:

  def hash_tree
    Hash.new do |hash, key|
      hash[key] = hash_tree
    end
  end

  @date = hash_tree
  @date[month][day][hours][min][sec] = 1

With a custom class:

  class HashTree < Hash
    def initialize
      super do |hash, key|
        hash[key] = HashTree.new
      end
    end
  end

  @date = HashTree.new
  @date[month][day][hours][min][sec] = 1

Answer 3

Compared to the lambda expression given above, this is simpler and also in one line:

Hash.new {|h,k| h[k] = Hash.new(&h.default_proc) }

Answer 4

->f{f[f]}[->f{Hash.new{|h,k|h[k]=f[f]}}]

Obviously.

Answer 5

Using symbols seemed to work:

ree-1.8.7-2009.10 > @date = {:month =>{:day => {:hours => {:min => {:sec => 1 } } } } }
 => {:month=>{:day=>{:hours=>{:min=>{:sec=>1}}}}} 

I can then retrieve the val like this:

ree-1.8.7-2009.10 > @date[:month][:day]
 => {:hours=>{:min=>{:sec=>1}}}

Answer 6

It doesn't look like Ruby can do autovivification from the start, but you can easily add in that functionality. A search for "ruby autovivification" on Google gives:

http://t-a-w.blogspot.com/2006/07/autovivification-in-ruby.html

Which contains a decent example of how to create a hash that will work the way you are looking for.

ruby hash autovivification (facets) might also be helpful.

Answer 7

You can use the Facets gem's Hash.autonew to do the same thing as the recursive function given in Molf's answer.

Answer 8

1) Refinements

You can use the Ruby Refinements instead of Monkey Patching.

It is way more secure than MonkeyPatching the entire Hash class and the usage part is still fancy

Setup ‍

# Use Hash.dynamic_keys to create keys dynamically on a Hash
module HashDynamicKeysRefinements
  refine Hash.singleton_class do
    def dynamic_keys
      new { |hash, key| hash[key] = dynamic_keys }
    end
  end
end

Usage

using HashDynamicKeysRefinements

dynamic_hash = Hash.dynamic_keys

dynamic_hash[:where][:requests][:id] = 3

dynamic_hash
=> {:where=>{:requests=>{:id=>3}}}

2) New Class

Or you can create a new class to implement this feature on the Hash class, the usage part is also awesome.

Setup ‍

• /lib/hash_dynamic.rb

# Enables dynamic keys creation on a Hash
#   query = Hash.dynamic_keys
#   query[:where][:requests][:id] = 3
#   puts query
#     {:where=>{:requests=>{:id=>3}}}
class HashDynamic < Hash
  def self.new
    Hash.new { |hash, key| hash[key] = new }
  end
end

Usage

require 'hash_dynamic.rb'

dynamic_hash = HashDynamic.new

dynamic_hash[:a][:b][:c] = 5

dynamic_hash
=> {:a=>{:b=>{:c=>5}}}