my %patterns = ( 123 => [ 1, 2, 3 ],
                 312 => [ 3, 1, 2 ] );
@matches = $string =~ /regexp/;
$string = join "", @matches[ @{ $patterns{$patternkey} } ];
[download]

my %patterns = ( 123 => [0,1,2],
                 312 => [2,1,0] );

my @matches = $string =~ m/$some_pattern/;
return join '', @matches[@{$patterns{$patternkey}}];
[download]

I would recommend using another way than interpolation to do what you want, but it can still be a fun exercise.

If you don't want to exercise and really need the functionality, look at String::Interpolate.

To show how to do what you tried to do, for educational purposes:

# Use something more sophisticated which escapes properly.
sub quote { qq!"$_[0]"! }

my ($x, $y, $z) = qw/ X Y Z /;
my $str = 'Foo $x bar $y baz $z';
print $str;              # Foo $x bar $y baz $z
print quote($str);       # "Foo $x bar $y baz $z"
print eval quote(str);   # Foo X bar Y baz Z
[download]

ihb

You can do away with the hash completely by passing the order as a list rather than a string.

#! perl -slw
use strict;

sub munge { 
    my( $str, $regex ) = ( shift, shift );
    my @matches = ( undef, $str =~ $regex );
    return join'', @matches[ @_ ];
}

print munge( 
    'one_two_three', 
    '^([^_]+)_([^_]+)_([^_]+)$', 
    2, 1, 3 
);
__END__
[10:24:12.59] P:\test>junk
twoonethree
[download]

You could also allow for referencing the whole match as 0 with:

    $str =~ $regex;
    my @matches = map substr( $str, $-[$_], $+[$_] - $-[$_] ), 0..$#-;
[download]

my $newstring = munge_string( 'one_two_three', '312' );
print $newstring;

sub munge_string {
    $_ = $_[1]; split /[^a-zA-Z]+/, $_[0];
    s/(\d)/$_[$1-1]/g; return $_;
}
[download]

Thank you all for your responses. gaal and Arunbear's suggestion to save the matches in an array and then stringify them later looks like the best option (at least for now). Some of the patterns contain other (non-captured) text, so I'll have to use something a bit trickier than just taking a slice, but the overall idea should work fine.

ihb's recommendation of String::Interpolate is definitely one I'll file away for later, and the quote/eval example clearly showed what I was missing in my initial attempts. I like the code provided by BrowserUk and Fletch, as it is more generalizable than what I have now, but one of my goals is to keep the formats of the returned strings encapsulated in the function itself. That way if one of the formats is changed I only have to update the values in the hash, rather than track down every call that uses that specific format and update each one individually. TedPride's solution is a clever use of split, but unfortunately the variety of input data is such that coming up with a generalizable split would be difficult.

In summary, I think I'll start by throwing the captured values into an array and then using indices to access them, rather than trying to interpolate $1, etc directly. Thanks again for all of the creative (and better yet, functional!) examples. I've definitely got a good start now, but if any alternative ideas come to mind, I'd love to hear them!