This is due to the way that map does aliasing (it's essentially using a for() loop). What's happening is that the aref is being used in l-value context, and therefore is being auto-vivified into existence.

In your latter example, you're attempting to use the aref directly in r-value context, which is why it generates the error (because no auto-vivification happens).

You can simplify your test to use for(), and you'll get the same result as with map():

use warnings;
use strict;

my $x;

for (@{ $x }){
    print "$_\n";
}
[download]

...no output. To visually see that $x was auto-vivified as an array reference, you can use the ref() function:

my $x;
my @a = map $_, @{ $x };

print ref $x;
[download]

Output:

ARRAY
[download]

Disclaimer: taken verbatim from one of my previous StackOverflow answers.

Haven't done a ton of research yet, but think the answer is the same as in Array dereference in foreach(): map probably provides lvalue context to the list it is iterating over (because it allows modification of the original items of the list via $_), and autovivification happens in lvalue context. Further somewhat related reading:

• Autovivification Oddity
• Why doesn't this die with "Can't use an undefined value as an ARRAY reference"?"

Update: stevieb beat me to it :-)

stevieb beat me to it :-)

By only mere seconds bud ;)

use strict;
use warnings;
use Data::Dumper; 

my $this_key = "NOT_IN_HASH";
my $hash_ref = {};

my @items;

@items = map { $_->{value} } @{$hash_ref->{$this_key}};

print Dumper \@items;

my @x;
foreach (@{$hash_ref->{$this_key}})  # loop does not execute
                                     # because array is empty
{
   print "loop is looping\n";  #This doesn't ever print !
   push @x, $_->{value};
}

print Dumper \@x;

my @nothing;
print Dumper \@nothing;

__END__
Prints:
$VAR1 = [];  #print Dumper \@items;
$VAR1 = [];  #print Dumper \@x;
$VAR1 = [];  #print Dumper \@nothing;
[download]