return \(%x, %y, %z)

but if your goal is to modify these hashes, why don't you operate on the references without returning them?

use strict;
use warnings;
use Data::Dump;

my %x = ( a  => "red");
my %y = ( b  => "green");
my %z = ( c  => "black");

sub modfifyHash {
    my ($x, $y, $z) = @_;
    $x->{a} = "circle";
    $y->{b} = "square";
    $z->{c} = "rectangle";
    return;
}


dd \(%x, %y, %z);

modfifyHash( \(%x, %y, %z) );

dd \(%x, %y, %z);
[download]

now tested!

({ a => "red" }, { b => "green" }, { c => "black" })
({ a => "circle" }, { b => "square" }, { c => "rectangle" })
[download]

update

added tested version

Is there a reason why you don't work directly on the hashrefs ?

use Data::Dumper;

my %x = ("a"  => "red");
my %y = ("b"  => "green");

modifyHash( \(%x, %y) );

sub modifyHash
{
  my ($x, $y) = @_;
  $x->{a} = "circle";
  $x->{b} = "square";
}

print Dumper ( \(%x, %y) );
[download]

use Data::Dumper;

my %coords = (
  x => { a => "Red" },
  y => { b => "Green" }
);

modifyHash(\%coords);

sub modifyHash
{
  my ($c,) = @_;
  $c->{x}{a} = "circle";
  $c->{y}{b} = "square";
}

print Dumper \%coords;
[download]

Hi Anonymous,

Others have already pointed out you can just edit the hashes through the references directly, and that seems like the way to go in your case. Just to explain why your second two examples don't work: Arrays or hashes on the left hand side of a my (...) = ... assignment only make sense as the last item being assigned to, because they slurp up all the remaining values from the right hand side.

That means when you write my (%x, %y, %z) = ..., then the hash %x will slurp up all the values assigned to it:

$ perl -wMstrict -MData::Dumper -le 'my (%x,%y) = (1,2,3,4); print Dum
+per(\%x,\%y)'
$VAR1 = {
          '1' => 2,
          '3' => 4
        };
$VAR2 = {};
[download]

Also, be aware that my %copy = %hash; only makes a shallow copy, so if %hash contains values which are references to other data, then those will reference the same data structures - which may not be what you want. If you want deep copies, Storable's dclone or Clone may be able to help you there.

And just for completeness, here's one ("elegant"?) way to make the shallow copies:

use warnings;
use strict;
use Data::Dump 'pp';

my %x = ("a"  => "red");
my %y = ("b"  => "green");
my %z = ("c"  => "black");

pp \%x, \%y, \%z;
my ($r1, $r2, $r3) = modfifyHash(\%x, \%y, \%z);
pp $r1, $r2, $r3;
pp \%x, \%y, \%z; # these remain unmodified

sub modfifyHash {
    #my ($x, $y, $z) = @_; # this would modify the original hashes
    my ($x, $y, $z) = map { { %{ $_ } } } @_;
    #                       ^ ^  ^
    #                       | |  for each argument
    #                       | dereference as hash
    #                       make new hash reference (shallow copy!)
    $x->{a} = "circle";
    $y->{b} = "square";
    $z->{c} = "rectangle";
    return $x, $y, $z;
}

__END__

({ a => "red" }, { b => "green" }, { c => "black" })
({ a => "circle" }, { b => "square" }, { c => "rectangle" })
({ a => "red" }, { b => "green" }, { c => "black" })
[download]

Although I would second Eily's suggestion that it might be a good idea to combine the hashes into one.

Hope this helps,
-- Hauke D

my $x = {"a"  => "red"};
my $y = {"b"  => "green"};
my $z = {"c"  => "black"};

my ($new_x, $new_y, $new_z) = &modfifyHash($x, $y, $z);

# original $x is unchanged, $new_x has new value
print "\$x->{a} = $x->{a}\t\$new_x->{a} = $new_x->{a}\n";

sub modfifyHash {
    my ($x, $y, $z) = @_;
    # If we don't want to modify the originals,
    # then make a shallow copy for each
    $_ = { %$_ } for $x,$y,$z;
    
    $x->{ "a" } = "circle";
    $y->{ "b" } = "square";
    $z->{ "c" } = "rectangle";
    return($x, $y, $z)
}
[download]

As of perl 5.22 you can also use refaliasing. In your specific example - where you want to modify the input hashes - you might do as follows:

#!/usr/bin/env perl
use strict;
use warnings;
use Data::Dumper;

use 5.024;
use feature 'refaliasing';
no warnings 'experimental::refaliasing';

my %x = ("a"  => "red");
my %y = ("b"  => "green");
my %z = ("c"  => "black");

modfifyHash(\(%x, %y, %z));

say Dumper \(%x, %y, %z);

sub modfifyHash {
   \my (%x, %y, %z) = @_;
   $x{ "a" } = "circle";
   $y{ "b" } = "square";
   $z{ "c" } = "rectangle";
}

__END__
$VAR1 = {
          'a' => 'circle'
        };
$VAR2 = {
          'b' => 'square'
        };
$VAR3 = {
          'c' => 'rectangle'
        };
[download]

use strict;
use warnings;
use Data::Dump;

my %x = ( a  => "red");
my %y = ( b  => "green");
my %z = ( c  => "black");

sub assign {
   my (%x, %y, %z) = ( %{$_[0]}, %{$_[1]}, %{$_[2]} );
   dd  \(%x, %y, %z);
}
[download]

I'll post later a more elegant but significantly slower solution

UPDATE:

I was wondering what trick you used to prevent the flattened list to go into the first hash only. Looks like there's none:

$VAR1 = {
          'c' => 'black',
          'a' => 'red',
          'b' => 'green'
        };
$VAR2 = {};
$VAR3 = {};
[download]

oops you are right, I had various outputs from Data::Dump and only saw what I expected to see... :-/

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}

as compensation an even less elegant (read uglier) attempt for a one liner:

sub assign {
   %$_ = %{shift @_} for \ (my (%a, %b, %c));
   dd ["assign", \(%a, %b, %c) ];
}
assign( \(%x, %y, %z));
[download]

Cheers Rolf
_{(addicted to the Perl Programming Language and ☆☆☆☆ :)
Je suis Charlie!}