No Keys, nor other hash methods on multidimensional hash

(Xeno Campanoli) #1

Okay, I'm taking the example I got last week for multi-dimensional hashes, and
I don't have access to any Hash methods:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call }
pHash['1']['a'] = "one"
p pHash.keys

I run this and get the result:

...undefined method `keys' for ... (NoMethodError)

Do I need to dereference or something, or is this just something that doesn't
work after all?

Sincerely, Xeno Campanoli, Ruby neophyte and general paraphernalian.

(David A. Black) #2

Hi --

···

On Tue, 23 Aug 2005, Xeno Campanoli wrote:

Okay, I'm taking the example I got last week for multi-dimensional hashes, and
I don't have access to any Hash methods:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call }
pHash['1']['a'] = "one"
p pHash.keys

I run this and get the result:

...undefined method `keys' for ... (NoMethodError)

Do I need to dereference or something, or is this just something that doesn't
work after all?

Try this:

   hash_lambda = lambda { Hash.new {|h,k| h[k] = hash_lambda.call } }
   hash = hash_lambda[]
   hash['1']['a'] = "one"
   p hash.keys

David

--
David A. Black
dblack@wobblini.net

(Martin DeMello) #3

lambda creates an anonymous function, which in this case returns a hash.
hash_factory might have been a better variable name:

hash_factory = lambda { Hash.new {|h,k| h[k] = hash_factory.call }}

How it works: Hash.new {|h,k| block} creates a new hash, and calls the
block whenever the hash is called with a nonexistent key. h and k, the
two parameters passed to the block, are the hash itself and the key you
tried to look up.

lambda {Hash.new} creates an anonymous function that returns a hash. The
clever part here is that we capture a reference to the function we're
defining, and pass that reference into the block we pass to the hash
(this all works because lambdas are lazily evaluated). So now every time
we call the hash with a missing key, the hash_factory is called again
and generates a new autovivifying hash to store as the value.

Here's how you use it:

hash = hash_factory.call
hash[1][2][3] #=> nil, but the hash will now have the keys

martin

···

Xeno Campanoli <xeno@eskimo.com> wrote:

Okay, I'm taking the example I got last week for multi-dimensional hashes, and
I don't have access to any Hash methods:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call }

(Bill Kelly) #4

Hi,

Okay, I'm taking the example I got last week for multi-dimensional hashes, and
I don't have access to any Hash methods:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call }
pHash['1']['a'] = "one"
p pHash.keys

I run this and get the result:

...undefined method `keys' for ... (NoMethodError)

Do I need to dereference or something, or is this just something that doesn't
work after all?

pHash isn't the hash-of-hashes itself, it's a Proc object
that knows how to create such a hash.

in irb:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

=> #<Proc:0x02dc4960@(irb):1>

pHash.class # we can see its class is Proc

=> Proc

pHash.call # if we call the Proc, it does its job and creates the hash

=> {}

pHash[] # this is just a synonym for pHash.call

=> {}

I guess one could look at "pHash" as a factory that creates
an auto-vivifying hash.

Regards,

Bill

···

From: "Xeno Campanoli" <xeno@eskimo.com>

(Florian Gross) #5

Xeno Campanoli wrote:

Okay, I'm taking the example I got last week for multi-dimensional hashes, and
I don't have access to any Hash methods:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call }
pHash['1']['a'] = "one"
p pHash.keys

I run this and get the result:

...undefined method `keys' for ... (NoMethodError)

Try this one instead:

hash_proc = lambda { |hash, key| hash[key] = Hash.new(&hash_proc) }
hash = Hash.new(&hash_proc)

irb(main):003:0> hash[5][4][3][2][1] = 0
=> 0
irb(main):004:0> hash.keys
=> [5]
irb(main):005:0> hash
=> {5=>{4=>{3=>{2=>{1=>0}}}}}

Or if you're a fan of the y combinator:

class Proc
   def self.y(&block)
     result = lambda { |*args| block.call(result, *args) }
   end
end

Hash.new(&Proc.y { |p, h, k| h[k] = Hash.new(&p) })

(Gavin Kistner) #6

To be clear, what Bill is saying is that you need to use pHash.call to
create your hash, and call the Hash methods on that. Like so:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['L']['a'] = "one"
p uberhash.keys #=> ["L"]
p uberhash['L'].keys #=> ["a"]
p uberhash['L'].values #=> ["one"]

(W. James) #7

Phrogz wrote:

To be clear, what Bill is saying is that you need to use pHash.call to
create your hash, and call the Hash methods on that. Like so:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['L']['a'] = "one"
p uberhash.keys #=> ["L"]
p uberhash['L'].keys #=> ["a"]
p uberhash['L'].values #=> ["one"]

How would you test to see if this exists?

h[9][8][7][6][5][4][3][2][1]

(David A. Black) #8

Hi --

···

On Tue, 23 Aug 2005, William James wrote:

Phrogz wrote:

To be clear, what Bill is saying is that you need to use pHash.call to
create your hash, and call the Hash methods on that. Like so:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['L']['a'] = "one"
p uberhash.keys #=> ["L"]
p uberhash['L'].keys #=> ["a"]
p uberhash['L'].values #=> ["one"]

How would you test to see if this exists?

h[9][8][7][6][5][4][3][2][1]

I think it exists as soon as you refer to it. (I thought that's the
whole point :slight_smile: But if you didn't want that to happen I guess you
could do:

   if h[9][8][7][6][5][4][3][2].has_key?(1) ...

David

--
David A. Black
dblack@wobblini.net

(W. James) #9

William James wrote:

Phrogz wrote:
> To be clear, what Bill is saying is that you need to use pHash.call to
> create your hash, and call the Hash methods on that. Like so:
>
> pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }
>
> uberhash = pHash.call
>
> uberhash['L']['a'] = "one"
> p uberhash.keys #=> ["L"]
> p uberhash['L'].keys #=> ["a"]
> p uberhash['L'].values #=> ["one"]

How would you test to see if this exists?

h[9][8][7][6][5][4][3][2][1]

Here's one way, but it doesn't seem efficient:

···

------------------------------------------------------------------
class Hash
  def has( *subs )
    h=self
    subs.each{|x|
      return false unless h.key?(x)
      h=h[x]
    }
    true
  end
end

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['a']['b']['c']='The crux.'
p uberhash.has('a','b','c')
p uberhash.has('a','b','x')
p uberhash
------------------------------------------------------------------

Output:

true
false
{"a"=>{"b"=>{"c"=>"The crux."}}}

Note that the hash wasn't changed by the check for the
nonexistent key.

By the way, here's how Awk effortlessly handles multidimensional
associative arrays (hashes):
   a['foo','bar']
is equivalent to
   a['foo' SUBSEP 'bar']
The keys are merely joined using a character that won't be found
in the keys.

(W. James) #10

David A. Black wrote:

Hi --

> Phrogz wrote:
>> To be clear, what Bill is saying is that you need to use pHash.call to
>> create your hash, and call the Hash methods on that. Like so:
>>
>> pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }
>>
>> uberhash = pHash.call
>>
>> uberhash['L']['a'] = "one"
>> p uberhash.keys #=> ["L"]
>> p uberhash['L'].keys #=> ["a"]
>> p uberhash['L'].values #=> ["one"]
>
> How would you test to see if this exists?
>
> h[9][8][7][6][5][4][3][2][1]

I think it exists as soon as you refer to it. (I thought that's the
whole point :slight_smile: But if you didn't want that to happen I guess you
could do:

   if h[9][8][7][6][5][4][3][2].has_key?(1) ...

It's not the whole point. One needs to be able to check
to see if an entry exists without changing the hash.

irb(main):002:0> h=pHash.call
=> {}
irb(main):003:0> h['foo']=999
=> 999
irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
'ok';end
=> nil
irb(main):006:0> p h
{"foo"=>999, 9=>{8=>{7=>{6=>{5=>{4=>{3=>{2=>{}}}}}}}}}

Even lowly Awk can easily do this.

···

On Tue, 23 Aug 2005, William James wrote:

-------------------------------------------------
BEGIN {
  a[9,8,7,6,5,4,3,2,1] = "yes"
  if ( (9,8,7,6,5,4,3,2,1) in a )
    print "o.k."
  if ( (0,8,7,6,5,4,3,2,1) in a )
    print "not o.k."
  if ( (0,8,7,6,5,4,3,2) in a )
    print "not o.k."
  print length(a)
}
-------------------------------------------------
Output:

o.k.
1

(David A. Black) #11

Hi --

···

On Tue, 23 Aug 2005, William James wrote:

By the way, here's how Awk effortlessly handles multidimensional
associative arrays (hashes):
  a['foo','bar']
is equivalent to
  a['foo' SUBSEP 'bar']
The keys are merely joined using a character that won't be found
in the keys.

Am I right that the keys can only be scalar values?

David

--
David A. Black
dblack@wobblini.net

(David A. Black) #12

Hi --

···

On Tue, 23 Aug 2005, William James wrote:

David A. Black wrote:

Hi --

On Tue, 23 Aug 2005, William James wrote:

Phrogz wrote:

To be clear, what Bill is saying is that you need to use pHash.call to
create your hash, and call the Hash methods on that. Like so:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['L']['a'] = "one"
p uberhash.keys #=> ["L"]
p uberhash['L'].keys #=> ["a"]
p uberhash['L'].values #=> ["one"]

How would you test to see if this exists?

h[9][8][7][6][5][4][3][2][1]

I think it exists as soon as you refer to it. (I thought that's the
whole point :slight_smile: But if you didn't want that to happen I guess you
could do:

   if h[9][8][7][6][5][4][3][2].has_key?(1) ...

It's not the whole point. One needs to be able to check
to see if an entry exists without changing the hash.

irb(main):002:0> h=pHash.call
=> {}
irb(main):003:0> h['foo']=999
=> 999
irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
'ok';end

I can't tell if you're saying the has_key? thing was the right
solution or that it wasn't :slight_smile: The creation of the intermediate
hashes is desired, right?

David

--
David A. Black
dblack@wobblini.net

(James Edward Gray II) #13

I'm not sure what you're trying to show here???

You called has_key?() on the last Hash. It did not add that key to the Hash, just as you said it shouldn't. The other Hashes were autovivified along the way, because you wrote code to make it so. I would be disappointed if any of the above had behaved differently and I know at least Perl has identical behavior.

That said, if you want an object that can check many levels deep without creating the upper levels, you can surely code one up with little effort.

James Edward Gray II

···

On Aug 22, 2005, at 5:26 PM, William James wrote:

It's not the whole point. One needs to be able to check
to see if an entry exists without changing the hash.

irb(main):002:0> h=pHash.call
=> {}
irb(main):003:0> h['foo']=999
=> 999
irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
'ok';end
=> nil
irb(main):006:0> p h
{"foo"=>999, 9=>{8=>{7=>{6=>{5=>{4=>{3=>{2=>{}}}}}}}}}

(Brian Schröder) #14

Ruby does what you ask it to do. Just as an example I took my
autovivifying array example and converted it into an auto-hash.

class AutoHash < Hash
  def initialize(*args)
    super()
    @update, @update_index = args[0][:update], args[0][:update_key]
unless args.empty?
  end
  
  def [](k)
    if self.has_key?k
      super(k)
    else
      AutoHash.new(:update => self, :update_key => k)
    end
  end

  def []=(k, v)
    @update[@update_index] = self if @update and @update_index
    super
  end
end

a = AutoHash.new
a[1][2][3] = 12
p a
a[2][3][4]
p a
a[1][-2][1] = "Negative"
p a
p a[4][5][6].has_key? 7
p a

Does this do what you think you need.

As a sidenote, I never felt the need for auto-hashes nor auto-arrays.
Ruby just makes it so simple to write clean code with specialized
container-classes for the job, that this was never neccessary. Anyway,
it was a nice exercise, so thanks for the challenge.

Brian

···

On 23/08/05, William James <w_a_x_man@yahoo.com> wrote:

David A. Black wrote:
> Hi --
>
> On Tue, 23 Aug 2005, William James wrote:
>
> > Phrogz wrote:
> >> To be clear, what Bill is saying is that you need to use pHash.call to
> >> create your hash, and call the Hash methods on that. Like so:
> >>
> >> pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }
> >>
> >> uberhash = pHash.call
> >>
> >> uberhash['L']['a'] = "one"
> >> p uberhash.keys #=> ["L"]
> >> p uberhash['L'].keys #=> ["a"]
> >> p uberhash['L'].values #=> ["one"]
> >
> > How would you test to see if this exists?
> >
> > h[9][8][7][6][5][4][3][2][1]
>
> I think it exists as soon as you refer to it. (I thought that's the
> whole point :slight_smile: But if you didn't want that to happen I guess you
> could do:
>
> if h[9][8][7][6][5][4][3][2].has_key?(1) ...

It's not the whole point. One needs to be able to check
to see if an entry exists without changing the hash.

irb(main):002:0> h=pHash.call
=> {}
irb(main):003:0> h['foo']=999
=> 999
irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
'ok';end
=> nil
irb(main):006:0> p h
{"foo"=>999, 9=>{8=>{7=>{6=>{5=>{4=>{3=>{2=>{}}}}}}}}}

Even lowly Awk can easily do this.
-------------------------------------------------
BEGIN {
  a[9,8,7,6,5,4,3,2,1] = "yes"
  if ( (9,8,7,6,5,4,3,2,1) in a )
    print "o.k."
  if ( (0,8,7,6,5,4,3,2,1) in a )
    print "not o.k."
  if ( (0,8,7,6,5,4,3,2) in a )
    print "not o.k."
  print length(a)
}
-------------------------------------------------
Output:

o.k.
1

--
http://ruby.brian-schroeder.de/

Stringed instrument chords: http://chordlist.brian-schroeder.de/

(W. James) #15

David A. Black wrote:

Hi --

> David A. Black wrote:
>> Hi --
>>
>>
>>> Phrogz wrote:
>>>> To be clear, what Bill is saying is that you need to use pHash.call to
>>>> create your hash, and call the Hash methods on that. Like so:
>>>>
>>>> pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }
>>>>
>>>> uberhash = pHash.call
>>>>
>>>> uberhash['L']['a'] = "one"
>>>> p uberhash.keys #=> ["L"]
>>>> p uberhash['L'].keys #=> ["a"]
>>>> p uberhash['L'].values #=> ["one"]
>>>
>>> How would you test to see if this exists?
>>>
>>> h[9][8][7][6][5][4][3][2][1]
>>
>> I think it exists as soon as you refer to it. (I thought that's the
>> whole point :slight_smile: But if you didn't want that to happen I guess you
>> could do:
>>
>> if h[9][8][7][6][5][4][3][2].has_key?(1) ...
>
> It's not the whole point. One needs to be able to check
> to see if an entry exists without changing the hash.
>
> irb(main):002:0> h=pHash.call
> => {}
> irb(main):003:0> h['foo']=999
> => 999
> irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
> 'ok';end

I can't tell if you're saying the has_key? thing was the right
solution or that it wasn't :slight_smile: The creation of the intermediate
hashes is desired, right?

Quote:
One needs to be able to check to see if an entry exists without
changing the hash.

Creating intermediate hashes changes the hash.

Therefore, it wasn't the right solution.

The Awk example shows that Awk can perform this check without
altering the hash in any way whatsoever, just as h.key?('foo')
doesn't alter the hash. Having to alter the hash whenever you
check for the existence of a key would be extremely crude and
ineffecient.

···

On Tue, 23 Aug 2005, William James wrote:
>> On Tue, 23 Aug 2005, William James wrote:

(David A. Black) #16

It wasn't clear to me which hash you meant. I interpreted it as
......[2], and checking its keys was a way of checking the existence
of the entry without changing the hash (i.e., *that* hash).

I do think the original impetus for this whole thing was the creation
of a hash that automatically filled in with hashes in the face of
h[1][2][3].... It's probably significantly harder to make a hash that
does that sometimes, but not always, as it were. I haven't tried it
yet though.

David

···

On Tue, 23 Aug 2005, William James wrote:

David A. Black wrote:

Hi --

On Tue, 23 Aug 2005, William James wrote:

David A. Black wrote:

Hi --

On Tue, 23 Aug 2005, William James wrote:

Phrogz wrote:

To be clear, what Bill is saying is that you need to use pHash.call to
create your hash, and call the Hash methods on that. Like so:

pHash = lambda { Hash.new {|h,k| h[k] = pHash.call } }

uberhash = pHash.call

uberhash['L']['a'] = "one"
p uberhash.keys #=> ["L"]
p uberhash['L'].keys #=> ["a"]
p uberhash['L'].values #=> ["one"]

How would you test to see if this exists?

h[9][8][7][6][5][4][3][2][1]

I think it exists as soon as you refer to it. (I thought that's the
whole point :slight_smile: But if you didn't want that to happen I guess you
could do:

   if h[9][8][7][6][5][4][3][2].has_key?(1) ...

It's not the whole point. One needs to be able to check
to see if an entry exists without changing the hash.

irb(main):002:0> h=pHash.call
=> {}
irb(main):003:0> h['foo']=999
=> 999
irb(main):005:0> if h[9][8][7][6][5][4][3][2].has_key?(1) then puts
'ok';end

I can't tell if you're saying the has_key? thing was the right
solution or that it wasn't :slight_smile: The creation of the intermediate
hashes is desired, right?

Quote:
One needs to be able to check to see if an entry exists without
changing the hash.

Creating intermediate hashes changes the hash.

Therefore, it wasn't the right solution.

--
David A. Black
dblack@wobblini.net