Crazy constant question...

pileofrogs has asked for the wisdom of the Perl Monks concerning the following question:

Greetings Monks!

This question is probably more trouble than it's worth, but it's been bugging me, so here goes:

I can create constants like so:

use constant { FOO => 1, BAR => 2 };
[download]

but if I want a way to convert the number back into a string, I need to do something that defines the same relationships again, like

my @num_to_name = qw(FOO BAR);
[download]

which allows me to do things like:

my $thing = FOO;
print "Thing = ".$num_to_name[$thing]."\n";
[download]

My problem is, I hate that I have to maintain my constant declarations and my @num_to_name list separately. If I was doing this with a large number of constants, I'd screw it up for sure.

I actually made a thing that sort of does what I want, though It's cludge-tastic and probably all wrong and unnecessarily stupid:

my @num_to_name;
BEGIN {
    @num_to_name = qw(FOO BAR);
    for my $number ( 0 .. $#things) {
        *blah = eval "*My::Package::".$things[$number];
        *blah = sub { $number };
    }
}
[download]

With that monster, $num_to_name[FOO] eq 'FOO' no matter what. It loses the inlining of use constant, which is part of what's lame about it.

Is there a way to do this that sucks less?

Thank you for your indulgence

--Pileofrogs

Comment on Crazy constant question... Select or Download Code

Replies are listed 'Best First'.
Re: Crazy constant question... by SuicideJunkie (Vicar) on Dec 15, 2010 at 20:57 UTC
XY check: Are these trying to emulate enumerated types? If not, might hashes make more sense? Could you not do something like: `my %consts = (FOO => 42, BAR => 99); my %names = reverse %consts;` [download] then make the hashes read only or base your `use constant`s on them?	[reply] [d/l] [select]
Re: Crazy constant question... by kennethk (Abbot) on Dec 15, 2010 at 21:01 UTC
Sticking an evaled use constant in a BEGIN block would seem to meet your requirement, and avoid those nasty typeglobs: `#!/usr/bin/perl use strict; use warnings; my @num_to_name; BEGIN { @num_to_name = qw(FOO BAR); eval "use constant $num_to_name[$_] => $_" for 0 .. $#num_to_name; } print "FOO-->", FOO(), "-->", $num_to_name[FOO];` [download] I've assumed your names are necessarily 1:1 and adjacent integers starting at 0 - this is what your code seems to do. You could do something with hashes instead for more flexibility.	[reply] [d/l]
Re^2: Crazy constant question... by ikegami (Patriarch) on Dec 15, 2010 at 21:08 UTC
Avoiding eval: `my @num_to_name; BEGIN { @num_to_name = qw(FOO BAR); require constant; constant->import( $num_to_name[$_] => $_ ) for 0 .. $#num_to_name; }` [download] Avoiding eval and multiple calls to import: `my @num_to_name; BEGIN { @num_to_name = qw(FOO BAR); require constant; constant->import({ map { $num_to_name[$_] => $_ } 0..$#num_to_name + }); }` [download]	[reply] [d/l] [select]
Re: Crazy constant question... by SilasTheMonk (Chaplain) on Dec 15, 2010 at 22:16 UTC
Have you considered Readonly. It allows the read only variables to be interpolated into strings and there is an XS implementation so ought to be fast. I found the syntax a little awkward at first. You have to use '=>' and not '=', which is obvious when you think what is going on, but not so obvious from first principles.	[reply]
Re: Crazy constant question... by johna (Monk) on Dec 15, 2010 at 21:22 UTC
This might work as well by inspecting the `%constant::declared hash`: `#!/usr/bin/perl use strict; use warnings; use constant { FOO => 1, BAR => 2, BAZ => 1 }; my %val_to_name; { no strict 'refs'; foreach my $con (keys(%constant::declared)) { push @{$val_to_name{$con->()}}, $con; } } my $thing = FOO; print "$thing defined by: " . join(" and ", @{$val_to_name{$thing}})." +\n";` [download] Used a HoA to allow for multiple constants having the same value.	[reply] [d/l] [select]
Re: Crazy constant question... by moritz (Cardinal) on Dec 15, 2010 at 21:23 UTC
For your information, the inlining has two conditions: the sub needs a prototype of `()`, and the content needs to be a constant. So it would have to be something like: `*thing = eval "sub () { '$value' }"` [download] Though calling import from constant is certainly the better solution. Perl 6 - second systems done right	[reply] [d/l] [select]
Re: Crazy constant question... by thargas (Deacon) on Dec 16, 2010 at 14:04 UTC
How about `dualvar` from `Scalar::Util`? This will allow you to assign both a number and a string to a scalar and you'll get the number back in numeric context and the string in string context. Sounds like it fulfills the requirements.	[reply] [d/l] [select]
Re: Crazy constant question... by AnomalousMonk (Archbishop) on Dec 16, 2010 at 14:58 UTC
Further to the suggestions of SilasTheMonk and thargas, an example. Note that numeric context must now be supplied explicitly. Also, I have no idea what this does to execution speed. Caveat Programmor. `c:\@Work\Perl>perl -wMstrict -le "use Scalar::Util qw(dualvar); use Readonly; Readonly my $foo => dualvar 42, 'FOO'; print qq{foo ($foo) = }, 0+$foo; $foo = '11'; print qq{after ro mod}; " foo (FOO) = 42 Modification of a read-only value attempted at -e line 1` [download] (Read-only modification also fails with numeric assignment.)	[reply] [d/l]
Re: Crazy constant question... by aartist (Pilgrim) on Dec 16, 2010 at 16:40 UTC
From the book "Perl Best Practices". This is the one of the reason why Readonly is better than 'constant'. `use Readonly; Readonly my $FOO => 1; Readonly my $BAR => 1; my $thing = $FOO; $Things[$thing] = 'whatever'; print $Things[$thing];` [download]	[reply] [d/l]


Clear questions and runnable code get the best and fastest answer
	PerlMonks