While it is possible to do what you say that you want in Perl, it is not advisable. Please read Mark Jason Dominus' excellent Why it's stupid to `use a variable as a variable name' about it. Most likely, you do want real references or a hash instead.

So I guess you're suggesting something like:

my @bar = qw(One Two Three);
my $foo = "bar";
my %quux = ("bar", \@bar);

print "***" . $foo . "***";

foreach my $baz (@{$quux{$foo}}) {

     print $baz . "\n\n";

}
[download]

It looks like that will work, but it does mean I have to create a hash.

Think about it this way - you are asking to access some data structure (scalar, array, hash, whatever) using an arbitrary string as its name. That is the very definition of a hash.

In fact, soft references are implemented under the hood as a hash. So, it's not like you're saving anything. :-)

------
We are the carpenters and bricklayers of the Information Age.

Then there are Damian modules.... *sigh* ... that's not about being less-lazy -- that's about being on some really good drugs -- you know, there is no spoon. - flyingmoose

What you're talking about is known as "symbolic references". It won't work on lexical ("my") variables; your @bar would have to be a package (aka "global") variable.

But while symbolic refs can be done, they are strongly discouraged. Instead, consider using a hash variable:

  my %h;

  @{$h{"bar"}} = qw( One Two Three );

  $foo = "bar";

  for ( @{ $h{$foo} } ) {
[download]

I want to print the string that $foo is equal to and then print the values in the array that has the same name as what $foo is equal to. Does that help?

I think that you may have made a bad choice of string value for $foo in that some other posters think that you want to interpolate the value of $bar. Is it the case that you want two distinct and possibly unrelated values for $foo, one a string and the other an array reference? If so, I would suggest that you might have a design flaw somewhere (which a hash solution might fix), but on the off chance that you really need this, you could use overload -- though I wouldn't recommend it.

#!/usr/local/bin/perl -w
use strict;
                                                                      
+          
package ArrayOrString;
use overload
    '""'  => \&to_string;
                                                                      
+          
my $STRING_VAL = '';
                                                                      
+          
sub new {
    my ($class, $arrayref) = @_;
    die "not an array ref" unless 'ARRAY' eq ref $arrayref;
    bless $arrayref, $class;
}
                                                                      
+          
sub string {
    shift;
    $STRING_VAL = shift if @_;
    return $STRING_VAL;
}
                                                                      
+          
sub to_string {
    return $STRING_VAL;
}
                                                                      
+          
package main;
                                                                      
+          
my @bar = qw(one two three);
my $foo = ArrayOrString->new(\@bar);
$foo->string('bar');
print "*** $foo ***\n";
                                                                      
+          
foreach my $baz (@$foo) {
    print "Val: $baz \n";
}
[download]

Update: Whoops! I see your reply to dragonchild. You want soft references and that's a bad idea. Ignore my neat code, it doesn't do what you want, though it does what I said it does :)

This is Cool, Ovid. I wish I could give more than just a ++ to your answer. Thanks.

my @bar = qw(One Two Three);
my $foo = "bar";

print "***" . $foo . "***\n";

my($baz);
foreach $baz (@bar) {

     print $baz. "\n";

}
[download]

Without arguing the merits of symbolic reference (merits they say... what merits?), this will do it.

#!/usr/bin/perl
our @bar = qw(One Two Three);
my $foo = "bar";


print "***" . $foo . "***\n";

foreach  (@$foo) {

     print $_ . "\n";

}
[download]