Does Ruby have a way to return a reference, similar to PHP?

Question

In PHP I can use & to assign the reference of a variable to another variable as seen in the first code snippet below.

See PHP "Returning References" documentation for some more context... http://www.php.net/manual/en/language.references.return.php

PHP Code:

<?php
  $tree = array();
  $tree["branch"] = array();
  $tree["branch"]["leaf"] = "green";

  echo '$tree: ';
  var_dump($tree);

  $branch = &$tree["branch"];

  $branch = "total replacement!";

  echo '$tree: ';
  var_dump($tree);
?>

PHP's output:

$tree: array(1) {
  ["branch"]=>
  array(1) {
    ["leaf"]=>
    string(5) "green"
  }
}
$tree: array(1) {
  ["branch"]=>
  &string(18) "total replacement!"
}

Trying to do this in Ruby I did:

tree = {}
tree["branch"] = {}
tree["branch"]["leaf"] = "green"

puts "tree: #{tree.inspect}"

branch = tree["branch"]

branch = "total replacement!"

puts "tree: #{tree.inspect}"

Which output:

tree: {"branch"=>{"leaf"=>"green"}}
tree: {"branch"=>{"leaf"=>"green"}}

Now, while this straight assignment does not work in Ruby, modification of the object does:

Ruby Code (Continued):

branch["lead"] = "red"
puts "tree: #{tree.inspect}"

Ruby's Output:

tree: {"branch"=>{"leaf"=>"red"}}

So, I'm left wondering if there is a way to find the "parent" of an object so that I might modify it like I've done with branch["leaf"].

Author Edit:

While one can't change a hash reference to any other variable through assignment (e.g., x = y), one can modify the existing object through its methods. Using this approach one can pseudo-assign a new hash to the branch variable using .replace() as seen below...

Replacement Instead of Assignment:

tree = {}
tree["branch"] = {}
tree["branch"]["leaf"] = "green"

puts "tree: #{tree.inspect}"

branch = tree["branch"]

branch.replace({"leaf" => "red", "twig" => "brown"})

puts "tree: #{tree.inspect}"

Output:

tree: {"branch"=>{"leaf"=>"green"}}
tree: {"branch"=>{"leaf"=>"red", "twig"=>"brown"}}

Answer 1

A Variable Can Store a Key

Rather than trying to use indirect references or Kernel#eval, the Ruby way is to use a variable or expression to store or define the key you need. This isn't quite the same as your PHP code, but you can certainly use Ruby's native Hash methods to find the key for a given value.

Finding the Key You Want

I'm left wondering if there is a way to find the "parent" of an object so that I might modify it like I've done with branch["leaf"].

Consider the nature of a hash: each key in a hash must be unique, although keys for nested hashes can be the same as a key in a parent or sibling hash. For example:

# Keys for nested hashes can be the same.
tree = {
  branch1: { leaf: 'green' },
  branch2: { leaf: 'red'   },
}
#=> {:branch1=>{:leaf=>"green"}, :branch2=>{:leaf=>"red"}}

# Duplicate keys; last one "wins."
tree = {
  branch: { leaf: 'green' },
  branch: { leaf: 'red'   },
}
#=> {:branch=>{:leaf=>"red"}

On the bright side, that means that any given level of your hash will have exactly one key that matches what you want. There are any number of ways to find it. One example is using Hash#rassoc to return the key you want:

tree.rassoc( {leaf: 'red'} ).first
#=> :branch2

Other methods like #select, #each_pair, and so forth may also be useful, depending on your needs and the semantics of what you're trying to express.

Using the Key Name

Once you have the key, you can use that key to modify the associated value for that key. For example:

tree = {
  branch1: { leaf: 'green' },
  branch2: { leaf: 'red'   },
}
key = tree.rassoc( {leaf: 'red'} ).first
tree[key] = { leaf: 'blue' }
tree
#=> {:branch1=>{:leaf=>"green"}, :branch2=>{:leaf=>"blue"}}

Answer 2

For starters, Ruby is pass by reference. Think of it this way - this line:

branch = tree["branch"]

is creating a second reference to the underlying hash you created here:

tree["branch"] = {}

Those references are the:

1. local branch variable.
2. hash value in the tree hash for key branch.

By assigning a different value to the local variable branch, you're removing one reference, e.g. you're changing the reference holder not the reference itself. In Ruby you wouldn't expect the reference in the hash to change when a totally separate reference changed.

Some objects support operations that allow you to update them in-place, hashes for instance, but there is no facility I'm aware of to perform cascading reference changes like you're describing (e.g. change all references to an object to some other object).