See also:

• Params::Check (Core module since 5.10)
• Params::Validate
• Perl Best Practices, chapter 9 (Subroutines)

> Params::Check (Core module since 5.10)

wow, thanks for listing this one...

(...someone should start a thread about the most unknown core moduls...)

Cheers Rolf

Seconding the thanks for this reply. Not only some solid modules, I am now integrating Params::Check into large swaths of my code to increase their resilience to silliness and loving that it is a built-in.

But the reason I'm replying again - I took a peek at Perl Best Practices and found it extremely useful for a Perl programmer who is still finding his coding style (me). Picked up a copy as a desk reference =)

^{Strange things are afoot at the Circle-K.}

I did, however, encounter a snag with this method. I have to check for existence of the key within the referenced hash before attempting to access it otherwise Perl warns me about accessing an uninitialized value if the argument was not set by the user

If the caller doesn't pass the values you expect, you'll get a warning in the traditional style too:

$ perl -wE 'sub f { my ($v) = @_; say $v }; f()'
Use of uninitialized value $v in say at -e line 1.

$
[download]

In the end the level of checking you want to do is a matter of style, and intended audience.

In Perl 5 code I usually only check the arguments where I suspect the subs might get called wrongly. In Perl 6 I just write the signatures as expressive as possible, and let the compiler and runtime do the checking for me.

and other references given in that thread.

UPDATE: see also

Thanks guys, great suggestions, +1

Spent some time looking at Params::Check - seems perfect for what I want.

Aside from the fact that I'll have to define templates for all my subs, but I'm sure that I can come up with some way to dynamically create templates. Even still, it's easier than handwriting the logic myself.

On a related note, I was trying to sort using different comparison code blocks which are passed as args (within the hashref model above) to subs:

#! perl -w 

use strict;
use Params::Check qw(check last_error);

my $verbose = 1;

my_func( { test_block => sub {$b cmp $a} } );

sub my_func {
   my $sort_function;
   my $tmpl = {
      test_block => {
         required => 1,
         defined => 1, 
         default => sub {$a cmp $b}, 
         strict_type => 1, 
         store => \$sort_function}
   };
   check($tmpl, shift, $verbose) 
           or warn ('problem with check: ' . Params::Check::last_error
+());
   my @stuff = qw(foo bie bletch a z);
   @stuff = sort $sort_function @stuff;
   print join "\n", @stuff;
}
[download]

Took a bit of tinkering to figure out how all that needed to be written to work properly so I thought it might be helpful to somebody if I posted it up here as well.

Thanks again, brothers.

Personally, I go with passing in hash refs most of the time, or shifting off when I only have a single parameter. And in all cases, I just deal with undefs as appropriate. Which sometimes means don't do anything about them - I want the fatal warning (I enable fatal warnings, too, did I forget to mention that?). If it's optional, I use the defined-or operator, // to use either the value or a default:

sub say_hello
{
  my $opts = shift;
  my $hello_sub = $opts->{hello_sub} // sub { my $o = shift; say "hell
+o, ", $o->{who} // 'world' };

  $hello_sub->($opts);
}

say_hello(); # says "hello, world"
say_hello({ who => 'temporal'}); # says "hello, temporal"
say_hello({ hello_sub => sub { my $o = shift; say "wazzup, ", $o->{zup
+} // 'homie' }, zup => 'bro' }); # says "wazzup, bro"
[download]

I don't check parameters. Almost ever. I've been bitten by too many tools trying to be too smart about their inputs, but when I feed them objects with string overloading or filehandles that aren't files and they fail just because the author didn't realise how automorphic perl variables can be, it gets annoying. Don't assume that the person calling your code is less smart than you. Carp if you have to, but it might just work if you try.

There is another approach to this problem: prototyping.

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

#prototyped to explicitly state acceptable arguments

sub addstuff($$$);

my $D=4;
my $E=3;
my $F=2;

#gives error if too few or too many arguments
#(or arguements of wrong type)

my $result = addstuff $D, $E, $F;

print $result."\n";

#prototyped to match

sub addstuff($$$){
        my $A=shift;
        my $B=shift;
        my $C=shift;
        return $A+$B+$C;
}
[download]

#prototyped to explicitly state acceptable arguments

sub addstuff($$$);

...

#gives error if too few or too many arguments
#(or arguements of wrong type)
[download]

OTOH:

>perl -wMstrict -le
"my @ra = (99 .. 199);
 ;;
 sub S ($$$) {
   my $A = shift;  my $B = shift;  my $C = shift;
   ;;
   return $A + $B + $C;
   }
 ;;
 print S 1, 2, @ra;
"
104
[download]

Maybe better read Far More than Everything You've Ever Wanted to Know about Prototypes in Perl -- by Tom Christiansen first, then generally avoid prototypes.

Thanks AnomalousMonk, I am following your advice and already seeing some issues that I'll run into with using Perl's prototyping such as it is.

'Enjoyable light reading' indeed, protist! Maybe just enjoyable ;)

^{Strange things are afoot at the Circle-K.}

Cool, didn't know that Perl supported function prototyping. Looks a bit quicker and dirtier than using Params::Check - fewer filtering options, no default values, etc.

I am gravitating towards creating a separate file which would contain all of my function prototypes and then I would require that in my module. My module has quite a few functions so this might be the easiest way to keep track of them all and have a single point of change rather than having to track down all that template-building legwork within the subroutines themselves that Params::Check requires.

Not quite as legible, though. And to heed the docs warning, I could get into trouble writing prototypes for already written functions. So I'll have to do a little checking to make sure I'm not doing anything too silly with how arguments are being passed and unpacked.

Anyway, thanks for pointing this out protist =)

^{Strange things are afoot at the Circle-K.}

Before you decide to go this route, read Far More than Everything You've Ever Wanted to Know about Prototypes in Perl -- by Tom Christiansen carefully.
لսႽ† ᥲᥒ⚪⟊Ⴙᘓᖇ Ꮅᘓᖇ⎱ Ⴙᥲ𝇋ƙᘓᖇ

Cool, didn't know that Perl supported function prototyping.

It doesn't. It's more like 'function argument context prototyping'. Please read the highly recommended Far More Than...

You are welcome. :)