Readonly may help.

Alternatives to Readonly, since it is unmaintained ( rt://Readonly ) and slow ( without Readonly::XS )
• Attribute::Constant, a wrapper around Data::Lock
• Const::Fast

If you want to continue using constant, and you want to interpolate within a string, the only way I know of is using the array interpolations:

use constant SOME_CONSTANT => 'the value';
print "This is @{[SOME_CONSTANT]}\n";
[download]

Within a hash key, treat it as a sub:

$h{&SOME_CONSTANT} = 'hash value';
[download]

For string interpolation you may also use scalar context

print "This is ${\SOME_CONSTANT}\n";
[download]

With a hash key you can also disambiguate a constant with parens

$h{(SOME_CONSTANT)}
[download]

"use constant" is useful for debug statements and levels. In recent versions of Perl, if the compiler can see say "if DEBUG_LEVEL3" and if knows that DEBUG_LEVEL3 is false, that statement will not even be compiled. This can result in a significant performance increase where there are lots of detailed "debug" print statements within an inner loop.

Other than that, I think use constant is pretty worthless. I normally use a 'C' style $ALL_UPPER_CASE for constants and as a matter of programming discipline, never use something like that as a lvalue.

I guess that was a long winded way of saying: I agree, but think about constant for debug flags when you have a lot of them or they are in performance critical sections of code.

One way to deal with this in Perl is to say have a .ini file. Stick these "magic" definitions like "MAX_RECS_PER_LINE = 8" in that file. Parsing a .ini file can get to be a pretty big deal in 'C'. In Perl, this is easy as there are a number of "config" modules that do that. At times I have built a "front-end" module that uses some flavor of the configuration .ini modules.

Anyway one possibility is to have say $MAX_RECS_PER_LINE as a program variable and you ask the config module (really a mini read only DB in simple case) what MAX_RECS_PER_LINE means.

*SOME_CONSTANT = \ 'the value';
[download]

$h{$SOME_CONSTANT};

print "$SOME_CONSTANT\n";
[download]

$SOME_CONSTANT = 'new value';
[download]

This is documented in perlmod under "Symbol Tables".

Small problem is that these are package variables (not 'my'-able). Under 'use strict' U have to 'our' them. In case U want the freedom to choose between package or lexical, I use this:

use CONSTANT;

CONSTANT my $E     => 2.73,
         my $PI    => 3.14,
         my $CREDO =>   'The dream of the slave is...to become master 
+and have slaves';

# Oops! Wrong CREDO ;)
$CREDO = 'In $$$ we trust!'; # will ERROR out ;)

# and U can:
print "I still believe that '$CREDO!'\n";

#where

package CONSTANT;
use Carp;
use Exporter;
use Tie::Scalar;
@ISA = qw(Tie::StdScalar Exporter);
@EXPORT = qw(CONSTANT);

# sub CONSTANT {my $i=0;tie $_[$i++],__PACKAGE__,$_[$i++] while $i<@_}
sub CONSTANT {tie $_[$.++],__PACKAGE__,$_[$.++] while $. < @_}
# If you want to know if something is tied somewhere ;)
# sub REF {@_ > 1 ? '' : ref tied $_[0] || ref $_[0]}
sub STORE {confess "constants are READ ONLY!"};
1;

vess
[download]