Why not just combine the two into one regexp, skirting the issue entirely?

$phrase = '$foo $(bar)';
$variables = { foo => '$(bar)', bar => '$(foo)' };

$phrase =~ s/
    (?:                     # Just take the first one
        \$([a-zA-Z0-9_]+)
    )
    |                       # And alternate it with the second
    (?:
        \$\(([a-zA-Z0-9_]+)\)
    )
    /$variables->{$1||$2}/xg; # Then do the substitution for the one
                              # that matched

print $phrase; # Prints "$(bar) $(foo)"
[download]

I'm sure there's an easier and more efficient way to write this regex, but this seems like the straightforward solution. You eliminate the second pass, so you eliminate the double interpolation. This particular scheme fails if you allow a variable named '0' though, so you may need to do something else in the replacement part if this is the case.

The leading $and the middle \w are common between patterns. In fact, all that's required is to require a closing ) only when there was an opening (.

Using a less well known feature

\$ # Our '$' prefix
(?:
    # Optionally *don't* find the opening paren.
  |
    (\() # Optionally find the opening paren
)
(\w+) # The middle part is captured in $2
(?(1)\)) # Require a closing paren only if $1 matched.
[download]

Merely removing the prefix

\$ # Our '$' prefix
( # Capture into $1
    (?:
        \w+ # Plain word.
      |
        \( \w+ \) # A word with parentheses around it.
    )
)
[download]

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

You could change

(?:
  |
  ( \( )
)
[download]

to

(
  \(
)?
[download]

... unless you get queasy when you see quantifiers placed on capturing groups.

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart

Replace $1 ||$2 with $+. That'll contain the value of the last capture that actually matched. See perlvar:

The text matched by the last bracket of the last successful search pattern. This is useful if you don't know which one of a set of alternative patterns matched.

p.s. Originally I mistakingly had posted this as a followup to Re^2: How do I avoid double substitution when replacing many patterns?, now its sibling.

PS, I didn't know about $+ so I'm glad you posted that in the wrong place.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

This particular scheme fails if you allow a variable named '0' though, so you may need to do something else in the replacement part if this is the case.

Yes. In that case, your "$1||$2" would have to be "defined $1 ? $1 : $2".

perl -e '
  $f = "\$foo \$(bar) \n";
  $f =~ s/\$ (?: (\w+) | \((\w+)\) )/<$^N>/xg;
  print $f;'
[download]

The following also works - but will allow for more matching groups after the $^N.

perl -e '
  my $f = "\$foo \$(bar)";

  our $val;       # must use package global
                  # for temporization in regex

  $f =~ s{\$                        # the dollar
    (?:                             # outer altinator
      (\w+)   (?{ $val = $^N })     # match and then store
    | \((\w+) (?{ $val = $^N }) \)  # or match 2 and store
    )                               # close outer
  }{<$val>}xg; print "$f\n"'
[download]

However, Template::Toolkit is often hard to get started with and it is indeed the need for its sheer power that tends to justify the effort.

You might want to take a look at Data::Phrasebook, as this handles things a little better. Using your example the following works:

use Data::Phrasebook;
my $pb = Data::Phrasebook->new( file => 'phrases.txt' );
my $str = $pb->fetch( 'baz', {foo => '${bar}', bar => '${foo}'} );
# $str = 'foo is ${bar} and bar is ${foo}'
[download]

where phrases.txt use the default parameter substitution and looks like:

baz=foo is :foo and bar is :bar
[download]

While there is support for TT style parameter substitution, it doesn't current support a TT embeded templating system. Might be a possibility for the future, but would be a little overkill for this problem ;)