You could turn the problem around and instead of returning references to results pass in references to where you want the results stored.

sub foo {
  my( $s, $a, $s1, $a2 ) = @_;
  ${$s} = 42;
  @{ $a } = 0..5
  ${$s1} = sin( 1 );
  @{ $a2 } = qw( yadda yadda yadda );
  return;
}

foo( \$a, \@b, \$c, \@d );
[download]

Update: Oop, left off making scalars references as well

I like this approach because it allows for some nice sanity checking too (I know it is only 1 array_ref, but it is the principle)

sub get_my_list
{
  my $array_ref = $_;
  if( &some_other_func() ){
    @{$array_ref} = qw( Yadda yAdda yaDda );
    return 1;
  }
  return 0;
}

if( get_my_list(\@array) ){
  print 'I got this array: '.join(',',@array);
}else{
  print 'Failed';
}
[download]

But leading back to your original question, my initial thoughts would also be to use a hash_ref. Your scalar-array data pattern lends itself well to a hash. And if the hash key (scalar) is a key to a particular function that you wish to perform on the array then your method becomes easily scalable.

<a href="http://www.graq.co.uk">Graq</a>

Saying my @array = @tmparray actually allocates new memory and makes a (shallow) copy of the data. Sometimes this is what you want, but in those cases it does make sense to actually say so explicitly. If you don't need a copy, and are just looking for convenience, access the elements as $arrayref->[0] and so on. True, this looks different from $array[0], but that's because it is different.

[...]

Okay, okay, if you're *sure* you want to do this, here's how to create an alias of the referenced data (-:

$arrayref = [ qw/A B C D/ ];
{
    no strict "vars";
    *array_alias = $arrayref;
}
print $array_alias[0];
[download]

Also, there's not any harm in leaving them as references and using them that way (unless you really hate typing -> and prefixing it with @ as appropriate).

The following is an abstraction that shows a way to do what you want. It will handle "... a lot of values ..." and can be extended (e.g. you could add support for hashrefs at some later time).

[ ~/tmp ] $ cat return_multi_refs 
# return_multi_refs

use strict;
use warnings;

use constant REF_SYM_MAP => {
    ''      => ['$', '', ''],
    SCALAR  => ['$', '${', '}'],
    ARRAY   => ['@', '@{', '}'],
};

my $rh_params = subroutine();

spawn_vars($rh_params);

{
    no strict qw(vars);
    no warnings qw(once);

    print "scalar1 [$scalar1]\nscalar2 [$scalar2]\nscalar3 [$scalar3]\
+n",
            "array1[1] [$array1[1]]\narray2[2] [$array2[2]]\n";
}

exit;

sub subroutine
{
    my @array1 = ( qw(a b c ) );
    my $ra_array2 = [ qw(x y z) ];
    my $scalar2 = 'Scalar the Second';
    my $scalar3 = 'Scalar the Third';

    my %params = (
        scalar1 => 'Scalar the First',
        array1  => \@array1,
        scalar2 => \$scalar2,
        array2  => $ra_array2,
        scalar3 => $scalar3,

    );

    return \%params;
}


sub spawn_vars
{
    eval join '', map {(
            REF_SYM_MAP->{ref($_[0]->{$_})}[0], __PACKAGE__, '::', $_,
+ ' = ',
            REF_SYM_MAP->{ref($_[0]->{$_})}[1], '$_[0]->{', $_, '}',
            REF_SYM_MAP->{ref($_[0]->{$_})}[2], ';',
    )} keys(%{$_[0]});
    die $@ if $@;
}
[download]

Test output:

[ ~/tmp ] $ perl return_multi_refs 
scalar1 [Scalar the First]
scalar2 [Scalar the Second]
scalar3 [Scalar the Third]
array1[1]  [b]
array2[2]  [z]
[ ~/tmp ] $
[download]

sub f { return \'hello', [1..3], { a => b }, \&f }
local (*a, *b, *c, *g) = foo();
# $a, @b, %c, and &g are now defined.
[download]