I find it helps to add a little white space and remove the "extra" set of () that aren't required for push:

push @{$genes{$r[0]}{$r[1]}{$r[2]}}, $r[3];
[download]

genes must be a hash because it's being accessed using{} and it contains a series of nested hashes because there is a chain of {}{}: {$r[0]}{$r[1]}{$r[2]}. r is an array which you can tell because it's being accessed using []. The @{} wrapper around the genes access turns an array reference into an array (that's what the @ is about).

So the whole thing pushes the fourth element of @r into an array stored in a hash stored in a hash stored in %genes.

Ok thanks a ton.. so let me clarify to see if I get it... in this situation based on what you said :

 
 foreach my $key1 ( sort keys %genes ) {
     print "\t". scalar (keys %{$genes{$key1}}) . "\t";
          foreach my $key2 ( sort keys %{$genes{$key1}} ) { etc....
[download]

I am printing the number of hash keys at the $gene{$r4} level...... and the %{} is a wrapper that turns a hash reference into a hash? ( as opposed to above where its an @ ref into an @. So changing that reference to an actual hash allows me to see the true values of the keys ( or in this instance the number of them because of the scalar command) rather then seeing the hash reference? If the wrapper were not to be there and I tried to access a deeper level in the hash rather then just printing the values at that level, it wouldn't work because the values themselves don't store the information for the overall nested structure (thats what the refs are for) ..correct?

OK, there is an array @r somewhere in scope. It has at least four elements. For simplicity, let's assume...

my @r = ('a', 'b', 'c', 'd');
[download]

Thus your original code can be rewritten as:

push @{ $genes{'a'}{'b'}{'c'} }, 'd';
[download]

Which means that %genes is a hash; $genes{'a'} is one of the items in the hash, and the value of $genes{'a'} is itself a hashref. Similarly, the value of $genes{'a'}{'b'} is also a hashref, and $genes{'a'}{'b'}{'c'} is an arrayref.

And here we're pushing 'd' onto the array referenced by $genes{'a'}{'b'}{'c'}.

So overall, your code is pushing the value of $r[3] onto an array, which is referenced by the value corresponding to key $r[2] in a hash, which is referenced by the value corresponding to key $r[1] in a hash, which is referenced by $genes{ $r[0] } which itself is a single value from the hash %genes.

You could say %gene is a hash of hashes of hashes of arrays, though of course when you have a tree structure like that, perhaps not all branches are symmetrical. If $r[0] took a different value, then perhaps we might consider %gene to be a hash of file handles.

@{ $genes{$r[0]}{$r[1]}{$r[2]} }
[download]

is short for

@{ $genes{$r[0]}->{$r[1]}->{$r[2]} }
[download]

which is equivalent to

@{ ${ ${ $genes{$r[0]} }{$r[1]} }{$r[2]} }
[download]

There are two notations for dereferencing.

• The embedded* notation (${ $array }[4]) can be used to dereference anything that can be deferenced, but it's a bit clunky.

• The arrow notation ($array->[4]) is cleaner, but it can only be used for some forms of dereferencing.

There's no arrow equivalent for @{ $array }, so using push @{ ... }, $r[3] was necessary.

* — I just made up that name. I don't know of any existing name for it.