Show Me Your References

Randal L. Schwartz

I spend a lot of time (perhaps some would say "far too much") on chat channels helping out Perl beginners, and even the occasional expert. One of the things that still amazes me is the absolute gibberish that people come up with while trying to construct references and then dereference them. It's like they just stomp on the top row of the keyboard and then hand that to Perl and say "here, interpret this".

So, I thought that this month I'd go "back to the basics" and review the standard forms of creating references, and then using those references by dereferencing them.

The first thing to understand about a reference is that it fits wherever a scalar fits, except as the key of a hash. So we can put a reference into a scalar variable, or as an element of a list, or as a value within an array or a hash. We can also pass those lists containing references to and from subroutines. Packages like Storable and Data::Dumper can take complex bundles that include references and safely serialize and restore them.

One way to create a reference is to put a backslash in front of an existing variable or subroutine name. For example, I can create scalar, array, hash, and subroutine references from existing things, like so:

my $scalar_ref = \$scalar;
my $array_ref = \@array;
my $hash_ref = \%hash;
my $code_ref = \&marine;
            

These references could also have been placed immediately as elements into an array or hash:

my @refs = (\$scalar, \@array, \%hash, \&marine);
my %ref_map = (
  scalar => \$scalar,
  array => \@array,
  hash => \%hash,
  code => \&marine,
);

I can also create a reference to an anonymous array, hash, or subroutine using the anonymous constructor syntax, like so:

my $array_ref = [3, 4, 5];
my $hash_ref = { first => 'Randal', last => 'Schwartz', \
  login => 'merlyn' };
my $code_ref = sub { my $sum = 0; $sum += $_ for @_; return $sum };

To access the original item, I need to dereference the reference to it. In the case of a scalar, array, or hash, a dereference lets me get at the variable to get or set its value. In the case of a code ref, dereferencing generally invokes the corresponding subroutine.

To begin, let's look at the canonical rule of dereferencing that will always work regardless of how the reference is obtained. We start by taking the syntax as if references aren't involved, such as $some_array[$element]. We then take the name of the item out and replace it with curly braces around the expression that gives us a reference. The simplest example is scalar access. Start with a scalar variable:

$scalar = 42;  # update
print $scalar; # access

${$scalar_ref} = 42;  # update via $scalar_ref
print ${$scalar_ref}; # access via $scalar_ref 
${$refs[0]} = 42;   # update via $refs[0]
print ${$refs[0]};  # access via $refs[0]
${$ref_map{scalar}} = 42;   # update via $ref_map{scalar}
print ${$ref_map{scalar}};  # access via $ref_map{scalar}

@array           # entire array
$array[$index]   # single element of array
@array[@indices] # array slice
$#array          # index of last array element

@{$array_ref}           # entire array
${$array_ref}[$index]   # single element of array 
@{$array_ref}[@indices] # array slice
$#{$array_ref}          # index of last array element

@{$refs[1]}           # entire array
${$refs[1]}[$index]   # single element of array
@{$refs[1]}[@indices] # array slice
$#{$refs[1]}          # index of last array element

@{$ref_map{array}}           # entire array
${$ref_map{array}}[$index]   # single element of array
@{$ref_map{array}}[@indices] # array slice
$#{$ref_map{array}}          # index of last array element

Continuing on, the hash also has a number of access forms:

%hash        # entire hash
$hash{$key}  # single element of hash
@hash{@keys} # hash slice

%{$hash_ref}        # entire hash
${$hash_ref}{$key}  # single element of hash
@{$hash_ref}{@keys} # hash slice

%{$refs[2]}        # entire hash
${$refs[2]}{$key}  # single element of hash
@{$refs[2]}{@keys} # hash slice 

%{$ref_map{hash}}        # entire hash 
${$ref_map{hash}}{$key}  # single element of hash 
@{$ref_map{hash}}{@keys} # hash slice

Finally, for code ref dereferencing, we're invoking the subroutine. For the purpose of constructing the canonical form, we'll pretend that subroutine invocations without an ampersand are forbidden:

&marine        # invoke subroutine passing current @_
&marine()      # invoke subroutine with no arguments
&marine(@args) # invoke subroutine passing @args

&{$code_ref}        # invoke subroutine passing current @_ 
&{$code_ref}()      # invoke subroutine with no arguments
&{$code_ref}(@args) # invoke subroutine passing @args 

&{$refs[3]}         # invoke subroutine passing current @_
&{$refs[3]}()       # invoke subroutine with no arguments 
&{$refs[3]}(@args)  # invoke subroutine passing @args 

&{$ref_map{code}}        # invoke subroutine passing current @_ 
&{$ref_map{code}}()      # invoke subroutine with no arguments 
&{$ref_map{code}}(@args) # invoke subroutine passing @args 

Luckily, there are a few syntax optimizations that actually end up applying about 90% of the time. For example, you can remove any curly braces you introduced for dereferencing as long as the only thing inside the braces is a simple scalar (not array or hash element, or complex expression). That simplifies some of the items above to the following forms:

$$scalar_ref = 42;  # update via $scalar_ref 
print $$scalar_ref; # access via $scalar_ref 

@$array_ref           # entire array 
$$array_ref[$index]   # single element of array 
@$array_ref[@indices] # array slice 
$#$array_ref          # index of last array element 

%$hash_ref        # entire hash 
$$hash_ref{$key}  # single element of hash 
@$hash_ref{@keys} # hash slice 

&$code_ref        # invoke subroutine passing current @_ 
&$code_ref()      # invoke subroutine with no arguments 
&$code_ref(@args) # invoke subroutine passing @args 
     

${ UGLY_ARRAY_REF_EXPRESSION }[$index]  # canonical form for               
                                        # array element
UGLY_ARRAY_REF_EXPRESSION->[$index]     # arrow form for array              
                                        # element

${ UGLY_HASH_REF_EXPRESSION }{$key}     # canonical form for hash element

UGLY_HASH_REF_EXPRESSION->{$index}      # arrow form for hash element

${ UGLY_CODE_REF_EXPRESSION }(@args) # canonical form for code                  
                                     # invocation
UGLY_CODE_REF_EXPRESSION->(@args)    # arrow form for code     
                                     # invocation

${$hash_map{code}}(@args) # canonical form
$hash_map{code}->(@args)  # arrow form

${$refs[1]}[$index] # canonical form
$refs[1]->[$index]  # arrow form
$refs[1][$index]    # reduced arrow form
 
${$ref_map{hash}}{$key} # canonical form
$ref_map{hash}->{$key}  # arrow form
$ref_map{hash}{$key}    # reduced arrow form 

$hash_map{code}(@args)  # reduced arrow form

Randal L. Schwartz is a two-decade veteran of the software industry -- skilled in software design, system administration, security, technical writing, and training. He has coauthored the "must-have" standards: Programming Perl, Learning Perl, Learning Perl for Win32 Systems, and Effective Perl Programming. He's also a frequent contributor to the Perl newsgroups, and has moderated comp.lang.perl.announce since its inception. Since 1985, Randal has owned and operated Stonehenge Consulting Services, Inc.