You can't print "@${a}\n" because you don't have an array reference named 'a'. This works:

my $a = \@{$h{a}};
print "@${a}\n"; # or just "@$a\n";
[download]

And the outer curlies in "@{$h{a}}\n" surround an array reference. Reading it inside-out, you have a hash key $h{a} whose value is an anonymous array. To print that value, you dereference it with @{}.

One reason you can't say "@${a}\n" is because you forgot the letter h, so that gets read as interpolating the dereferenced variable $a into the string. If instead you consider what you likely meant to type, "@$h{a}\n", the order of operations is problematic -- the array dereference @ gets applied before the hash access, so perl is looking for a nonexistant scalar $h. See perlreftut.

strict and warnings tells you as much for both these errors. Please read Use strict warnings and diagnostics or die.

perl -le '%x=(y=>"a"); $a="Z";print ${$x{y}}'
[download]

If 'use strict' were in effect for the one-liner above, it would die with the error: "Can't use string ("a") as a SCALAR ref while "strict refs" in use at -e line 1." Of course, there are cases where curlies are useful, even with strictures in effect, for referring to chunks of data structures -- e.g.:

use strict;
my %hoa = ( foo => [0, 1], bar => [2, 3] );
for ( keys %hoa ) {
   print " $_  contains: @{$hoa{$_}}\n";
}
[download]

It's not that you "can't say" something like @${a} (you can, provided you don't 'use strict') -- it's just that this doesn't do what you thought it would do. (What did you think it would do?) What it actually does is treat the predefined global variable "$a" as a reference to an array, and tries to dereference it so as to return the array. If 'strict refs' is in effect, this is an illegal operation; in the absence of 'strict refs', if $a was not assigned an array reference as its value, you'll just get (undefined) instead of an array.

why the curly braces surrounding the array

So, in your case, the $h{a} gives you an array reference. To dereference it, use the sigil-block syntax, with $h{a} as the block content. So, the result is: @{$h{a}}.

Note that you write @$h{a}, Perl considers this a short-hand for @{$h}{a}. This would try to (array)dereference $h, and to (hash)index the result, causing a run-time error.

use strict;
use warnings;

my %h = ('a', ['A', 'B'], 'b', 'B','a b', 'A B');

print join('-', keys %h) . "\n\n";

print join('-', values %h) . "\n\n";

print "@{$h{'a'}}\n\n";

print "$_ => $h{$_}\n" for keys %h;
print "\n";

use Data::Dumper;
print Dumper(\%h);
[download]

Output:

a-a b-b

ARRAY(0x1801180)-A B-B

A B

a => ARRAY(0x1801180)
a b => A B
b => B

$VAR1 = {
          'a' => [
                   'A',
                   'B'
                 ],
          'a b' => 'A B',
          'b' => 'B'
        };
[download]

Note that hashes do not retain order, so the elements may display in a different order from the order you defined them.

Personally, I prefer this format if I'm creating a hash, just makes things a lot more clear:

my %h = ( 'a' => ['A', 'B'], 'b' => 'B', 'a b' => 'A B' );

Why can't I say: print "@${a}\n";

I don't know. You should be able to, and I can.

$ perl -wE'$a = [1,2,3]; say "@${a}";'
1 2 3
[download]

What do you get? Perhaps $a didn't contain a reference to an array when you tried it?

Also, why the curly braces surrounding the array (@{..})

In general, they're optional. In @{ $h{a} }, they override precendence.

@$h{a}
=> @{$h}{a}
=> A hash slice that expects $h to be a reference to a hash.

@{ $h{a} }
=> @{$h}{a}
=> An array dereference that expects $h{a} to return an array ref.
[download]

See Tutorials: References quick reference

$ cat /tmp/foo
my %foo =
('a'   => [ 'A','B' ],
 'b'   => 'B',
 'a b' => 'A B'
);

my @foo = %foo;
my $foo = \@foo;

print( "list: [@foo]\n",
       "listref deref: [@$foo]\n",
     );

__DATA__
list: [a ARRAY(0x1f12d48) a b A B b B]
listref deref: [a ARRAY(0x1f12d48) a b A B b B]
[download]

nit: There's no such thing as a reference to a list in Perl. Your so-called listrefs are array references.