It may help to know what the const pragma does. It simply creates functions (subs) that are constant. A sub prototyped with () is defined to take no arguments and is then in-lined. Here's an evil method I wrote but never used in live code that may help you dig a little further:

sub const_override
{
    my $name = shift;
    my $pkg;

    if ($name =~ /^(.*)::([^:]+)$/)
    {
        $pkg = $1;
        $name = $2;
    }
    else
    {
        $pkg = caller;
    }

    no strict 'refs';

    if (!defined(*{"${pkg}::$name"}))
    {
        croak "A constant named '${pkg}::$name' has not been defined."
+;
    }

    carp "Constant override for ${pkg}::$name not in BEGIN block may f
+ail"
      if (defined($^S));

    local $SIG{__WARN__} = sub
    {
        warn @_ if (join(" ", @_) !~ /Constant subroutine .* redefined
+/);
    };

    if (@_ == 1)
    {
        my $scalar = $_[0];
        *{"${pkg}::$name"} = sub () { $scalar };
    }
    elsif (@_)
    {
        my @list = @_;
        *{"${pkg}::$name"} = sub () { @list };
    }
    else
    {
        my $set;
        *{"${pkg}::$name"} = sub () { };
    }
}
[download]

Devel::Constants. Let me know if it doesn't do everything you want.

Just call the function by name. Constants are functions so... it just works. No eval necessary.

sub dump_consts {

    print "SINS list: @{[SINS]}\n\n";

    no strict 'refs';
    local $, = ' ';
    for my $const (keys %constant::declared) {
        print $const, $const -> (), "\n";
    }
}
__DATA__
SINS list: pride envy gluttony lust anger greed sloth

main::CLOUD 9
main::SINS pride envy gluttony lust anger greed sloth
main::HELL system admin
[download]

Seeking Green geeks in Minnesota

Hi dio,

I have to apologize for this long delay until giving feedback, but I only come round here so seldomly.

Your hint was absolutely right. I should have had a look at the source of constant.pm (by invoking perldoc with the -m switch) to realize that the constants are only inlined subs.

Regards

use Devel::Symdump;
use strict;
use warnings;

use constant   SINS  => qw(pride envy gluttony lust anger greed sloth)
+;

my $dS = Devel::Symdump->new(__PACKAGE__);

local $\="\n";

print " here are some constants (prototype '')";

for my $f( $dS->functions ) {

    my $p = prototype $f;
    print $f if defined $p and $p eq '';
}

__END__
 here are some constants (prototype '')
main::SINS
[download]

MJD says you can't just make shit up and expect the computer to know what you mean, retardo! ** The Third rule of perl club is a statement of fact: pod is sexy.

Unfortunately your snippet will report subroutines that aren't constants as constants. Try adding

  my $foo = 1;
  sub foo () { $foo++ }
[download]

ihb

I know (that can only be determined through constant.pm like you know). You should've mentioned the fact that I completely missed the question.

update: you see me saying you in italycs like that, imagine i'm nodding at you as I say it, mmkay.

Also, chromatic also likes the Devel:: namespace ;)

MJD says you can't just make shit up and expect the computer to know what you mean, retardo! ** The Third rule of perl club is a statement of fact: pod is sexy.

  sub dump_consts_in_current_package {
    no strict 'refs';
    printf "%s => %s\n", $_, join ', ', $_->()
      foreach grep $_ =~ ('^' . __PACKAGE__ . '::'), keys %constant::d
+eclared;
  }
[download]

A brief explanation of the code. Constants are special subroutines, check out perlsub, but can still be called as any other subroutine. I choose to treat it as a symbolic reference, and dereference it immediately with the arrow notation; see perlref. To get only the current package's constants I use grep() to filter out those that begin with the current package's name. The perhaps unusual pattern is nothing but an expression that's later interpreted as a pattern.

That's it. :)

(As a side-note: The grep() above won't be slow because of the "special" pattern. __PACKAGE__ is compile-time so a constant will be folded in, and two constants concatenated is optimized to be just one constant. This in combination with that identical patterns at the same place won't recompile makes this not impose any overhead. You could interpolate __PACKAGE__ and use the o modifier to make the pattern compile at program compile-time. (Update: If I interpolate it won't be precompiled anyway... so the only thing gained by using the o modifier is that reinterpolation won't occure.) But the o modifier doesn't work in activeperl, at least not my activeperl, so I never use it. (Update: Clarification per request: With the o modifier I mean the "compile only once" modifier you can put on pattern quote ops, like m/PATTERN/o.)

/o doesn't make the pattern compile at perl's compile time. It just means that when the expression is used and compiled it keeps the result instead of throwing away the compiled form. It doesn't imply that the regex itself is compiled at any particular time.

---

Seeking Green geeks in Minnesota

I'm sorry, I was obviously smoking. I didn't mean that /o makes the pattern compile at program compile-time. The idea was to make perl do precompilation (at compile-time) by making it a match operator instead of an expression. (Perl precompiles constant patterns.) The /o was supposed to make sure that the pattern wasn't recompiled. But how I managed to perform this logic I don't understand myself. Because if I interpolate, precompilation can't occure anyway. And the /o is close to totally unnecessary, since the pattern will be the same and the optimization I mentioned myself about identical patterns will kick in. So the only thing saved is interpolation time.