Hash pointing to reference of itself!

Hey!

Supposed I want have a hash, with one key always holding the value of
another key. Is this possible without referencing outside the hash
closure? Forgive my lack of understanding of ruby internals.

Cheers!

On Wed, Apr 27, 2011 at 9:06 PM, Peter E.
[email protected]wrote:

You can’t do that, that would require variables being able to point to
other
variables.

You could, however, fake it by creating your own hash which allows this
functionality, as shown below. It just has an internal hash that allows
keys
to refer to other keys, then when you request one, it follows the chain
of
referrals until it arrives at an end point, and gives you back that key.
While this is a bit interesting, it is more likely that whatever you are
trying to do is not the Ruby way of solving your problem. Are you coming
from a language like C++ where you have direct access to pointers and
references? You might be trying to write Ruby like it is that other
language. Perhaps if you tell us more about your use case, we can offer
a
solution that is better than “this technically does what you are
requesting”.

class RHash

def initialize
@data = Hash.new
@references = Hash.new
end

def
return nil unless in_reference_chain? key
@data[actual key]
end

def []=(key,value)
@data[actual key] = value
end

def refer(references)
references.each do |from, to|
reference_chain from, to
@data.delete from if orphaned? from
end
end

private

def orphaned?(from)
@references[from] != from
end

def in_reference_chain?(key)
@references.has_key? key
end

def reference_chain(from, to=from)
@references[from] = to
end

def actual(key)
reference_chain key unless in_reference_chain? key
referenced = @references[key]
return referenced if referenced == key
return actual referenced
end
end

h = RHash.new
h[:foo] # => nil
h[:foo] = 5
h[:foo] # => 5

h[:bar] # => nil
h.refer :bar => :foo
h[:bar] # => 5
h[:foo] = 6
h[:bar] # => 6

h # => #<RHash:0x00000100852b58 @data={:foo=>6},
@references={:foo=>:foo,
:bar=>:foo}>
h.refer :foo => :baz
h # => #<RHash:0x00000100852b58 @data={}, @references={:foo=>:baz,
:bar=>:foo}>

h[:baz] = 12
h[:foo] # => 12
h[:bar] # => 12
h[:baz] # => 12

h[:foo] = 40
h[:foo] # => 40
h[:bar] # => 40
h[:baz] # => 40

h.refer :foo => :foo
h # => #<RHash:0x00000100852b58 @data={:baz=>40},
@references={:foo=>:foo,
:bar=>:foo, :baz=>:baz}>
h[:foo] # => nil
h[:bar] # => nil
h[:baz] # => 40

h[“garlic”] = “vampire”
h.refer :foo => ‘garlic’, :bar => :baz
h[:foo] # => “vampire”
h[‘garlic’] # => “vampire”
h[:bar] # => 40
h[:baz] # => 40

note: if you decide you actually want to use this code, let me know, and
I’ll give you the “test suite” I used while writing it.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs