Definitely go for the module approach. Though not that short as I would prefer, the code below demonstrate how you could achieve the effect of "automatically" stuffing your constants into the list of exports of your module.

The code for finding the constant names in the symbol table is almost abstract and with a little effort could be migrated into a generic module, leaving your constant module lighter.

our @GLOBAL_SYMBOLS; # these are not package constants, but Perl artif
+acts
BEGIN {
    @GLOBAL_SYMBOLS = qw(BEGIN EXPORT);
}
[download]

sub is_constant {
    my $k = shift;
   return $k =~ /^[A-Z]+$/ 
       && !grep { $_ eq $k } @GLOBAL_SYMBOLS
}
[download]

Bah, use a hash, Luke! Use a hash!

our %GLOBAL_SYMBOL; # these are not package constants, but Perl artifa
+cts
BEGIN {
    %GLOBAL_SYMBOL = map { $_ => 1 } qw(BEGIN EXPORT ISA EXPORT_OK GLO
+BAL_SYMBOL);  
}
[download]

sub is_constant {
    my $k = shift;
   return $k =~ /^[A-Z_0-9]+$/
       && !$GLOBAL_SYMBOL{$k};
}
[download]

BTW did you forget to exclude @GLOBAL_SYMBOLS, by any chance? And, why not use a lexical for it?

BTW I think this functionality is generally interesting enough to deserve its own module on CPAN. Let's call it ExportAll, or something else like that. And, as the helper subs would reside in that module, they wouldn't be exported themselves.

Update: Oh no, I see you only support only upper case letters only names (which would exclude @GLOBAL_SYMBOLS). Which seems too restrictive to my taste.

Oh no, I see you only support only upper case letters only names (which would exclude @GLOBAL_SYMBOLS). Which seems too restrictive to my taste.

Don't go down on me that fast. This restriction can be lifted very easily and that's why I kept is_constant separated from push_constants. If the role of is_constant is taken by a subroutine ref, the rest is generic enough.

Here an implementation of that generic module whose idea you cherished for a moment:

Read more... (2 kB)
And then applying it to the original request of the OP:
Read more... (491 Bytes)
The user's code just says

use MyConstants;
[download]

to import the constants into the current namespace.

BTW I have not worried with @GLOBAL_SYMBOLS because it didn't match /^[A-Z]+$/ which does not accept underlines. It was an oversight, but, because of this, it was not a problem.

BTW you were right about using a hash. The grep was only for a quick-and-dirty solution.

package myfile;

use strict;
use Exporter;
our @ISA = qw(Exporter);

# Setup the variables with values
my $list = 
'our $myvar   = 42;
our $another  = 1234;
our $yascalar = 3456;';
eval $list;

$list =~ s/our (.+?)\s+= \d+;/$1/g;
our @EXPORT = split("\n", $list);

1;
[download]

In case you'd (only) use the pragma constant to declare your constants, you could use its hash %constant::declared to get the list of names to export. Something like this

Your module with the constants:

package MyConsts;

use constant {
    CONST1 => 123,
    CONST2 => 1.11,
    CONST3 => "foo",
    CONST4 => ["foo", "bar"],
};
use constant CONST5 => qw(foo bar);

use Exporter 'import';
our @EXPORT = map /([^:]+)$/, keys %constant::declared;
1;
[download]

How to make use of it:

#!/usr/bin/perl
use strict;
use warnings;
use MyConsts;

print CONST1, "\n";

# or some weirder cases (just to illustrate,
# I understand that you only need integers)
print "@{CONST4()}\n";     # -> foo bar
print "@{[CONST5]}\n";     # -> foo bar
print +(CONST5)[1], "\n";  # -> bar
[download]

use SHARED_INTEGERS;

my $calculation = $SHARED_INTEGERS::alfa * $SHARED_INTEGERS::beta;
[download]

package SHARED_INTEGERS.pm

$alfa = 123;
$beta = 456;
[download]