You're running into regular expression meta characters, like $. You want to look at perlre and use \Q...\E or quotemeta for interpreting your string as literal characters in regular expression interpolation:

my $regexp = qr/\Qsome$thing\E/;
...
if (/$regexp/) {
[download]

or alternatively

my $regexp = quotemeta('some$thing');
...
if (/$regexp/) {
[download]

With respect I don't think it is seeing $ as an RE meta-character, but interpolation is looking for a variable called $thing. My understanding is that $ only means 'end-of-text' at the end of an RE expression, unless /m is specified.
Using \Q will still fix it though.

I now realize that I only saw half of the problem. The wanted idea seems to be double-interpolation of 'some$thing' into "someTHING" by replacing the string '$thing' within $regexp with the value of the variable $thing.

Your points are close but wrong - Perl allows stuff to appear in regular expressions after the $ metacharacter. Otherwise, Perl regular expressions act like double-quoted strings and hence interpolate only once:

#!perl -wl
use strict;
my $regexp = 'some$thing';
my $thing = 'THING';

my $target = 'this is some$thing strange.';

print $regexp;
print $target;

print '$target =~ /$regexp/ ', $target =~ /$regexp/;
print '$target =~ /\Q$regexp\E/ ', $target =~ /\Q$regexp\E/;
print '$target =~ /some\$thing/ ', $target =~ /some\$thing/;
print '$target =~ /some$/ ', $target =~ /some$/;
my $eol_in_the_middle = qr/some$(?:thing)/;
print 'eol_in_the_middle ',$eol_in_the_middle;
print '$target =~ /$eol_in_the_middle/ ',$target =~ /$eol_in_the_middl
+e/;
[download]

Of course, it's kinda hard to make $eol_in_the_middle match, but you can do it by using the /m switch and changing the RE and target string a bit:

my $eol_in_the_middle2 = qr/some$(?:\s*thing)/;
my $target2 = "this is some\nthing strange.";
print '$target2 =~ /$eol_in_the_middle2/ ',$target2 =~ /$eol_in_the_mi
+ddle2/sm;
[download]

Thanks, Corion, for
- responding so quickly,
- pointing me to the relevant documentation, and
- providing the two code snippets which do the one (double interpolation by means of qr{\Q...\E}) or the other trick (single interpolation by means of quotemeta).

I'm a little astonished that obviously none of these two is the default behaviour of Perl. May I ask you (or any of the other Monks reading) to explain why exactly /$regexp/ is always false in my examples? I would really like to understand what's going on "inside" if I use neither qr{\Q...\E} nor quotemeta, i.e. for which value of $_ the condition would be true.

I first didn't understand what you want to do, but cdarke pointed me to it.

It seems you want to solve two problems:

Firstly, you want to use the value in $regexp as some kind of template which later on uses the value of $thing to replace the string $thing within some$thing. This does not happen, because regular expressions are, to Perl, more or less like double-quoted strings (see perlop, section Quotes and quote-like operators). So, your $regexp will always remain some$thing and never access the value of the variable named $thing.

\Q...\E don't do double interpolation, they do quoting, so the regex meta characters are not seen as meta characters anymore and thus don't help you with your problem.

Having double interpolation the default in Perl would be horrendous, because after double interpolation immediately follows triple interpolation whenever you're using a double-interpolated string in any string context, which would make it nearly impossible to use any modules that construct strings or regular expressions.

To solve your problem at hand, doing template-like replacement on a string, you don't want to use a variable (and its name), but a hash which contains the name/value pairs:

my $regexp = 'some$thing';
my %values = (
    'thing' => 'THING',
    # ... other value mappings
);
print $regexp;
$regexp =~ s/\$(\w+)/$values{$1}/ge;
print $regexp;
[download]

If you're still wondering, yes, it's possible to do the replacement on variables by name too, but Dominus has explained far much better why it's stupid to use a variable as a variable name.

To address your last question, the regular expression formed by $regexp = qr/some\$thing/ matches any string that contains the substring some$thing literally, that is, with a dollar sign in the middle.

my $thing = 'THING';
my $regexp = "some$thing";  # now $regexp is 'someTHING'
[download]

#!/usr/bin/perl -W
use strict;

my $thing1 = 'THING';
my $thing2 = '$thing';

sub test {
    my $regex = shift;
    local $_ = 'some thing someTHING some$thing';
    printf " %15s =~ %s", $regex, $_; 
    print " == TRUE , matched [", $&, "]" if /$regex/;
    print "\n";
}


test ( 'some$thing1' );
test ( "some$thing1" );
test ( 'some$thing2' );
test ( "some$thing2" );

test ( quotemeta 'some$thing1' );
test ( quotemeta "some$thing1" );
test ( quotemeta 'some$thing2' );
test ( quotemeta "some$thing2" );
[download]

  #!/usr/bin/perl -w
  use strict;

  print 'Please enter the RE to test: ';
  chomp( my $regexp = <STDIN> );

  print "Please enter your strings ('QUIT' to exit):\n";
  print 'regex> ';
  while ( <STDIN> ) {
    chomp;
    last if /^QUIT$/;
    if ( /$regexp/ ) {
      print "Match: |$`<$&>$'|\n";
    }
    else {
      print "No matches.\n";
    }
    print 'regex> ';
  }
[download]

  (fred|barney){3}
[download]

  \(fred\|barney\)\{3\} or   (?-xism:\(fred\|barney\)\{3\}),

01  #!/usr/bin/perl -w
02  use strict;
03  my $regexp = 'some$thing';
04  $_ = # PLEASE ENTER YOUR TEST STRING HERE
05  print "That's it!\n" if /$regexp/m;
[download]

  my $thing = 'THING';

then 'someTHING' solves the problem. That is what I meant when I wrote "double interpolation by means of qr{\Q...\E}".

Well, the simple fact is nothing can be put into $_ to get the regexp some$thing to match against it because $ is more of a placeholder metacharacter to indicate to the regex engine to make matches around EOL, it doesn't actually denote or match any character per se.

Under the popular text formats an EOL is denoted by a Carriage Return or Line Feed or both. So, is it possible to try and match an EOL sequence in a string that doesn't contain either of CR or LF or CR/LF (\r, \n, \r\n respectively)? Well, No, it's simply impossible.

You have to change your regexp to try and match an actual EOL sequence after $ like this.


my $regexp = qr/some$.thing/sm; # or even qr'some$\nthing'm
local $_ = "some\nthing";
print " matched $& " if /$regexp/;
[download]

You'll notice the use of qr//sm modifiers to get the regexp to work with multiline strings and get . to match newlines. The //sm modifiers are very important as normally, newlines aren't matched by . in regular expressions unless /s is used but we also are working with multiline strings, hence //sm, more info in perlretut.

Not all strings entered from STDIN are newline terminated, e.g. if you were in multi-line mode (via $/ = undef ) and CTRL+D (twice if preceding character wasn't a newline) was used to terminate input, no newline or any character for that matter is appended to the end of the input string.


---
perl -e '$,=$",$_=(split/\W/,$^X)[y[eval]]]+--$_],print+just,another,split,hack'er

Aaaah, what a light bulb moment - thank you, Firefly258! I was a real blockhead not to see that as an anchor $ can only match a position between two characters or "between" a character and the beginning/end of a string, just as it is with the anchors \b and \B.

I must confess I'm still not very familiar with the qr// operator (but be assured that perlretut has been pushed onto my 2do stack ;-) so I tried

   my $regexp = 'some$' . "\nthing";
[download]

and, finally, /$regexp/m matched "some\nthing".

Thanks again. You Monks are great!