Qfyilyi

My current Perl package export feels long (snippet below). And yes, it's better to type all that just once in one place so my many Perl scripts can accesss it all with just:

use Funx;  

Still I was just hoping there would be an easy way to export everything with less typing.

package Funx;

#use strict;

use warnings;

use DBI;



use Exporter;

our @ISA    = 'Exporter';

our @EXPORT = qw(pdone dbstart dbstop dbc dbcdata numnums $SUCCESS $NOFILE 

$COPYFAIL $SOXFAIL $CURLFAIL $OPENFAIL $APPRUNNING $RAWDBEXIISTS $DBCREATEERR $DBCONNECTERR $TMPFILEERR $DBWRITEERR $INVALIDUSER $DBLOCKERR $DBUNLOCKERR WERR);



our $SUCCESS        =   0;

our $NOFILE         =   1;

our $COPYFAIL       =   2;

our $SOXFAIL        =   3;

our $CURLFAIL       =   4;

our $OPENFAIL       =   5;

our $APPRUNNING     =   6;

our $RAWDBEXIISTS   =   7;

our $DBCREATEERR    =   8;

our $DBCONNECTERR   =   9;

our $TMPFILEERR     =   10;

our $DBWRITEERR     =   11;

our $INVALIDUSER    =   12;

our $DBLOCKERR      =   13;

our $DBUNLOCKERR    =   14;

use constant WERR => 100;  

If you used constants instead of variables,

package Funx;



use strict;

use warnings;



use constant qw( );

use Exporter qw( import );



BEGIN {

    my %error_codes = (

        FUNX_SUCCESS      =>   0,

        FUNX_NOFILE       =>   1,

        FUNX_COPYFAIL     =>   2,

        FUNX_SOXFAIL      =>   3,

        FUNX_CURLFAIL     =>   4,

        FUNX_OPENFAIL     =>   5,

        FUNX_APPRUNNING   =>   6,

        FUNX_RAWDBEXIISTS =>   7,

        FUNX_DBCREATEERR  =>   8,

        FUNX_DBCONNECTERR =>   9,

        FUNX_TMPFILEERR   =>  10,

        FUNX_DBWRITEERR   =>  11,

        FUNX_INVALIDUSER  =>  12,

        FUNX_DBLOCKERR    =>  13,

        FUNX_DBUNLOCKERR  =>  14,

        FUNX_WERR         => 100,

    );



    constant->import(%error_codes);



    my @syms = keys(%error_codes);

    our @EXPORT_OK = @syms;

    our %EXPORT_TAGS = ( ALL => @syms, ERROR_CODES => @syms );

}

On top of addressing the issue you raised, the above

• Fixes the polluting of the user's namespace. Don't dump a bunch of symbols into other namespaces by default!


• Fixes the poor names that could conflict with other modules. You think you're the only module that has a code for SUCCESS?


• Fixes the polluting of your module's @ISA. Funx is not a subclass of Exporter.

Usage:

use Funx;                                 # Imports nothing.

use Funx qw( );                           # Imports nothing.

use Funx qw( :ERROR_CODES );              # Imports error codes.

use Funx qw( :ALL );                      # Imports error codes.

use Funx qw( FUNX_SUCCESS FUNX_NOFILE );  # Imports specific error codes.

You can use source filter to add some custom preprocessing.

Example:

package MyExport;



use Filter::Util::Call;



sub import {

    my ($type) = @_;

    my ($ref) = ;

    filter_add(bless $ref);

}



sub filter {

    my ($self) = @_;

    my ($status);



    if (($status = filter_read()) > 0) {

        s/^(.*)s+exports+(S+)(.*)$/push @EXPORT, '$2'; $1 $2 $3/;

    }



    $status;

}



1;

Usage:

...

use MyExport;

use Exporter;

our @ISA    = 'Exporter';

our @EXPORT;

...

our export $SUCCESS = 0;

...

Note that this implementation may be buggy. Basically s/^(.*)s+exports+(S+)(.*)$/push @EXPORT, '$2'; $1 $2 $3/; regexp turns lines like

our export $SUCCESS = 0;

into

push @EXPORT, '$SUCCESS'; our $SUCCESS = 0;