Thanks for the hint. Looks interesting.

Your code is fine. Anonymous subroutines might take more memory than named ones if they close on lexical variables, so if you create many (*many*) instances of them you might start feeling the difference, but in this case, you won't.

One thing you can do to earn a few style points but mainly to maximize your use of Getopt::Long is to use a hash. For one thing, it allows you to pass a simple hashref so that you don't end up doing any ugly $main::opt_foo business when you're trying to access your options from another class. And it also makes it easy to have default options.

my %opts = ( 'foo' => 'default_value',
             'bar' => 'another_default_value',
             'baz' => 'yet_another' ); 

GetOptions( \%opts, override, default, values, here);

My::Class->method( \%opts );

# ... elsewhere in your code ...

package My::Class;

  my $class    = shift;
  my $opts_ref = shift;

  ...
[download]

Also, if you're going to use an anonymous sub for help, it reads a little better if you do:

   'h|help'   => sub { help() },
[download]

Also worth a mention simply because I think it's nifty, Getopt::Long has an auto_help option. If you throw some POD in your code (specifically a SYNOPSIS section), turning auto_help on will automatically display that section.

use Getopt::Long qw/:config auto_help/;

...

=pod

=head1 SYNOPSIS

some help text...

=cut

...
[download]

--
"A long habit of not thinking a thing wrong, gives it a superficial appearance of being right." -- Thomas Paine
naChoZ

I didn't understand the "hashy" part of GetOpt::Long yet, but it sounds good to me.

Regarding the

'h|help'   => sub { help() },
[download]

part, I don't get the point. What's the advantage over:

'h|help'   => \&help,
[download]

That way is fine also. I tend to shy away from &'s in general out of personal preference.

I just like...

'h|help' => sub { help() },

...

sub help { ... }
[download]

better than...

'h|help' => \&help,

...

my $help = sub { ... }
[download]

--
"A long habit of not thinking a thing wrong, gives it a superficial appearance of being right." -- Thomas Paine
naChoZ

I have no problems with the anonymous sub. I do take issue, though, with the list of scalars for options. I much prefer to use a hash to keep things in one place.

But hang on! If you mispell a scalar, the compiler will bark at you. If you mispell a hash key, the runtime will autovivify it for you. Hmm.

But that's ok too, because what I really prefer doing is hiding it all away in a scope, and declaring subs as The Only Way of retrieving values. Admittedly, you still don't get a compile time error, but it will blow up at runtime if you get things worng. My template looks something like:

{
    use Getopt::Long;
    my %opt;
    GetOptions (
        \%opt,
        qw/ verbose! file:s debug+ help/
    ) || die sub { print <<END_OF_HELP;
$0: you blew it! Switches are as follows:
    --help | -h  this help screen
...
END_OF_HELP
    }
    sub debug   { exists $opt{debug} ? $opt{debug} : 0 }
    sub verbose { exists $opt{verbose} ? 1 : 0 }
    sub file    {
        if( not exists $opt{f} ) {
            ''
        }
        elsif( not defined $opt{f} ) {
            '/etc/passwd'
        }
        else {
            $opt{f}
        }
    }
}
[download]

The sub file lets you distinguish between an argument that is absent (return an empty string), present, but with no value (return a fixed name) or present with a value (return the value).

Since the %opt hash isn't available outside the scope, the program can't (accidentally or on purpose) modify the contents. This may be construed as a feature.

GetOptions(\%runconfig,
       "load=s"          => \&loadAttributeDescriptions,
       "loadconfig=s"    => \&loadconfig,
       "dumpconfig=s"    => \$dumpconfig,
       "tables=s"        => \$tables,
       "prec:i"          => \$precision,
       "decorate"        => \$decorate,
       "i=s@",           # include a nominal field.
       "arff",           # arff file [data mining]
       "max:i",          # examine file to this length
       "quiet",          # do not spit out csv
       "filter=s"        => \&addfilter,
       "cp=s"            => \&addcp, # array of [ant [ dependents ] ] 
       "cptformat=s",    # cp table format
       "prune",          # get rid of 0 info columns 
       "help"            => \$help,
       "man"             => \$man
       ) or pod2usage(-verbose=>1) && exit(1);
[download]

cptplus.pl --cp="charm|perlmonk,cyberpunk,neovictorian"
[download]

sub addcp{
    my $cpstring = $_[1];
    $cpstring =~ s/^([A-Za-z\-\_0-9]+)\|//;
    my $antecedent = $1 || return;
    my @dependents = split(/,/, $cpstring);
    my @cptrequest = ($antecedent, \@dependents);
    push @{$runconfig{"cp"}},(\@cptrequest);
}
[download]

To cut it short you mean: "It gets confusing if you overuse these anonymous subs", right?

I do not intend to use any other sub than help as anonymous. I love to have the help text at the very beginning of my scripts, because you see the help as soon as you look into the script.

use strict;
use Getopt::Long;
use Pod::Usage;

my $verbose = 0;
my %opts = ('verbose' => \$verbose);
GetOptions(\%opts,     ## throw our options into a hash
  "infile=s",          ## incoming mbox file
  "offset=i",          ## seek position (in bytes)
  "logfile=s",         ## file to log into
  "onerun!",           ## only read the first message
  "maxrun|max=i",      ## maximum number of messages to read
  "verbose+",          ## set verbosity level
  "finduser!",         ## attempt to perform user lookup.
  "nslookup!",         ## attempt to perform nslookup for zone ... slo
+w
  "help|?",            ## prints usage message.
  "man",               ## prints entire POD.
) or pod2usage(0);
pod2usage(-verbose => 2) if exists $opts{man};
pod2usage(-verbose => 1) if exists $opts{help};
pod2usage(-msg     => "missing infile: --help for more information",
          -verbose => 0) unless exists $opts{infile};

etc, etc
[download]

I don't have much to say myself, because others have done so before me:

• The Dynamic Duo --or-- Holy Getopt::Long, Pod::UsageMan!
• GetOpt::Long usage style

You might want to peruse Super Search next time before posting a question like this… :-)

Also, I'd advise against using a hash with Getopt::Long. It looks tidier, but you lose the advantage of strictures — the only clue that you misspelt a hash key is odd behaviour from the script. Instead, use my variables (and declare them in-place, as per above link), and use strict, so that Perl will find your typos for you.

I'd love to use Super Search for questions like this. But tell me: If you were in my shoes? What would you have searched for? I had no clue what to search. Please show me what I would have found and how it should have answered my question.

Cutting and pasting the title of the OP itself turns up useful nodes like 241367.