This is documented in the POD for the 'constant' pragma:

Constants defined using this module cannot be interpolated into strings like variables.

You can work around that behavior like this:

use constant MYTEST => '.txt';
my $expression = quotemeta( MYTEST );
my $string = "test.txt";
if ( $string =~ /$expression/ ) {
    print "Match\n";
}
[download]

Another WTDI:

print "Match" if $string =~ /@{[MYTEST]}/;
[download]

@{[MYTEST]} leaves out the all-important "quotemeta". In the OP's example, the literal text to match against was ".txt", and without quotemeta, '.' will match anything, instead of dot.


Dave

"If I had my life to live over again, I'd be a plumber." -- Albert Einstein

Thanks folks! This gives me a number of different ways to solve the problem.

This node contains a similar discussion. You might find some of the info helpful...

use of constants in regex substitutions?

Constants are transformed into subroutines (at least in some cases, I'm not too familiar with them at all). So one possibility of what to do is get a subroutine call inside your regex. Looking at the perldocs for constant and perlre, I came up with this working code. It uses a highly experimental regex feature, so you probably won't want to use this. Take a look at the perlre documentation to learn more about what the (??{}) construct does. It worked for me, so here it is.

#!/usr/bin/perl -w
$|++;

use strict;
use constant EXTENSION => '.txt';

my $file = shift;
die sprintf(
  'cannot match "%s" extension in "%s"', EXTENSION, $file
) unless $file =~ /(??{EXTENSION()})\z/;
[download]

Update: I figure I'd cross this out just because you really don't want to use an experimental feature, do you? As discovered with the help of Zed_Lopez, you should really use something like this regex snippet. Or, follow perrin's advice and just use variables instead of constants :)

Constants are transformed into subroutines (at least in some cases, I'm not too familiar with them at all).

Constants created with constant.pm are indeed subs (in all cases.) They are made by aliasing the constant's name to an anonymous sub with an empty prototype the body of which is simply the supplied value. The empty prototype is a hint to perl that the sub is a candidate for inlining. In other words, you could create your own "constants" with code like

sub MY_CONSTANT () { 42 }
[download]

if you wanted.

-sauoq
"My two cents aren't worth a dime.";

i don't know what the empty prototype implies for inlining, but it also keeps the sub from swallowing arguments.

sub A () {1};
sub B {2};
print A + 1,$/;
print B + 1,$/;

__END__
prompt$ perl test.pl
2
2prompt$
[download]

without the empty prototype subs wouldn't work very well for constants.

IMO, it's the current interaction of the enclosed code with lexical vars that remains experimental. The feature is not going to go away.

See also: abigail's suggestion and Dave and Hugo's response.