use strict;
use warnings;
use feature 'say';

my @arr  = ();
my $ref1 = \@arr;
my $ref2 = $ref1;

push @arr, "Hello";

# To access an array or hash via the reference
# we need to use a pointy arrow...
say $ref1->[0];  # says "Hello"
say $ref2->[0];  # says "Hello" again

# We use an @{...} to "dereference" an array ref.
# That is, to treat it like an array. 
push @{$ref1}, "World";

say $arr[1];     # says "World"
say $ref2->[1];  # says "World" again

# The dereferencing syntax can be interpolated into
# strings.
say "@{$ref2}";    # says "Hello World"

my %h = ();

# You can't store an array in a hash because hash
# values are always scalars.
$h{foo} = @arr;  # an array in scalar context
                 # evaluates to its length.
                 # This stores "2" in the hash.

# But you can store a reference, because a reference
# is a hash.
$h{bar} = $ref1;

# Let's print that "Hello" string again, via the hash.
say $h{bar}->[0];  # says "Hello"

# Now let's take a reference to that hash.
my $ref3 = \%h;

# We can also print "Hello" via the hash reference
say $ref3->{bar}->[0];  # says "Hello"

# When you've got a big chain of pointy arrows to
# navigate through references, you only need the
# first one.
say $ref3->{bar}[0];    # says "Hello"

# Here's something a little advanced. We'll
# assign a reference to a localized glob.
our %h2;
local *h2 = $ref3;

# Now %h2 (which is a real hash, not a reference to
# a hash) is an ALIAS for %h.
say $h2{foo};   # says "2"

delete $h2{foo};   # also deletes $h{foo}.