You convert an AoH into an H in P::RD the same way you would anywhere else. Convert each hash into a list, combine the lists, and create a hash from the combined list.

    test: expr(s) /^\Z/
        { { map %$_, @{$item{"expr(s)"}} } }
[download]

That's a lot of curlies X_X

Update: Changed map { %$_ } to map %$_, to remove a pair of curlies.

Hmm, here's one way:

...
   test: expr(s) /^\Z/
        {
        my %hash;
        
        @hash{keys %$_} = values %$_ for @{$item{"expr(s)"}};
        return \%hash;
        }
...
[download]

Prints:

$HASH1 = {
           x => 1,
           y => 2,
           z => 3
         };
[download]

Is there anything "better"?

I know you just copied the OP, but return \%hash; should be just \%hash.

His return $item{"expr(s)"} should be just $item{"expr(s)"}.

P::RD actions (i.e. code blocks in curlies) are placed in a do, not a sub. Since return shouldn't be used to exit a do, return shouldn't be used to exit a P::RD action.

#!/usr/bin/perl
use Data::Dumper;

$var = [
            { x => 1 },
            { y => 2 },
            { z => 3 }
          ];


my %res;
foreach my $v (@{$var}) {
     my ($k) = keys %$v;
     $res{$k} = $v->{$k};
}
print Dumper \%res;
[download]

e.g.

{ map %$_, @$array }
[download]

use Parse::RecDescent;
use Data::Dumper;

my $Hash = {};

my $grammar = q{
    test: expr(s) /^\Z/

    expr: name '=' /\d+/
        {
            main::AddToHash($item{name}, $item[-1]);
        }

    name: /\w+/
    };

my $parser = new Parse::RecDescent ($grammar);
$parser->test ("x = 1\ny = 2\nz = 3");

sub AddToHash {
    my $szVar = shift;
    $Hash->{$szVar} = shift;
}

print Dumper ($Hash);
[download]

That breaks the ability to easily PreCompile (which is rather major) because the user must provide AddHash and the user must be main::. Breaking encapsulation in this fashion also prevents more than one instance of the parser from being used at a time. Fix:

use strict;
use warnings;

use Parse::RecDescent ();
use Data::Dumper qw( Dumper );

my $grammar = <<'__END_OF_GRAMMAR__';

   {
      use strict;
      use warnings;
   }

   test : <rulevar: local %data >
        | expr(s) /^\Z/ { \%data }

   expr : name '=' /\d+/
          { $data{ $item{name} } = $item[-1]; 1 }

   name : /\w+/

__END_OF_GRAMMAR__

my $parser = new Parse::RecDescent($grammar) or die;
my $data = $parser->test("x = 1 y = 2 z = 3") or die;
print Dumper $data;
[download]

( Note: I prefer the solution I posted last night because it doesn't break if backtracking occurs like this one and this one's parent do. )

Ok, but actually I would use this and maybe put the MyParser package to a different file (but not everybody like OO):

package MyParser;

use constant DEBUG => 1;

use strict;
use base qw(Parse::RecDescent);
use Data::Dumper;

sub new {
    print "MyParser->new(@_)\n" if (DEBUG);
    my ($class, $szGrammar, $szCode) = @_;

    my $this;
    eval {
        $this = $class->SUPER::new($szGrammar);
    };
    if ($@) {
        print $@;
        $this = {};
        bless $this, $class;
    }
    else {
        # Start parsing code
        $this->test($szCode);
        return $this;
    }
}

sub AddToHash {
    print "MyParser->AddToHash(@_)\n" if (DEBUG);
    my ($this, $szVar, $szValue) = @_;

    $this->{Result}->{$szVar} = $szValue;
}

sub GetResult {
    print "MyParser->GetResult(@_)\n" if (DEBUG);
    my ($this) = @_;

    return $this->{Result};
}

sub DumpResult {
    print "MyParser->DumpResult(@_)\n" if (DEBUG);
    my ($this) = @_;

    print Dumper($this->{Result});
}


package main;


my $szGrammar = q{
    test: expr(s) /^\Z/

    expr: name '=' /\d+/
        {
            $thisparser->AddToHash($item{name}, $item[-1]);
        }

    name: /\w+/
    };

my $szCode = "x = 1\ny = 2\nz = 3";

my $hParser = MyParser->new($szGrammar, $szCode);
$hParser->DumpResult();
[download]

Andre