In other programming experience I had developed the opinion that protypes were a good thing as they provide usage enforcement

I know many monks, myself included, only use prototypes to get subs to look like builtins, especially passing a bare block as the first argument (as in grep { ... }) or an array ref (as in splice @arr). They're ok occasionally for this kind of syntactic sugar, but they're not as useful as you'd think for actually enforcing parameters. As I said, read that article if you haven't read it yet, otherwise read it again ;)

blokhead

That article really helps.
I certainly was NOT accomplishing what I thought.

Thanks

The only use I've had for a prototype in my career, was with the share() subroutine in my forks module. That subroutine should be passed a single scalar, array or hash, but receive the appropriate reference as the parameter (without flattening). Take this example:

sub foo (\[$@%]) { print "received a $_[0]\n" }

foo( $a );
foo( @a );
foo( %a );
[download]

received a SCALAR(0x107c84)
received a ARRAY(0x107d44)
received a HASH(0x107d68)

On the other hand, I know of people who use prototypes on subroutines that are intended to be called as methods purely for the documentational value.

Hope this helps.

Liz

sub handler ($$) {
    my ($self,$r);
    # yadda yadda
}
[download]

But other than that, i never use prototypes.

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

This odd use of prototypes is being replaced by the method attribute in mod_perl 2.

Here's something to read: Far More Than Everything You've Ever Wanted to Know about Prototypes in Perl.

I try not to use it in Perl partly because it gives you the false impression of security. While it enforces certain context/number of arguments, for some reason a lot of people I know tend to not validate their input if you have a function prototype. Which is really bad, especially when you try to make the transition from procedural to OO Perl, where no prototype check is done.

Plus it's really damn annoying when something like this compiles:

   sub foo($) {
     ...
   }
   foo(@bar); # = foo( scalar( @bar ) ). argh.
[download]

I'd rather stick with Params::Validate

This is about the only way I ever use them - to get a function that does not need parens and behaves like an inbuilt

sub strip($);

my $str = '
   begone
   leading
   whitespace
';

print strip $str, "   ->this is extra stuff";

sub strip ($) {
    my $str = shift;
    $str =~ s/^\s+//gm;
  $str;
}
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

In other programming experience I had developed the opinion that protypes were a good thing as they provide usage enforcement.

That may work for other languages, but forcing a programmer to jump to certain hoops isn't very Perlish. If you prefer bondage programming (and I don't mean this negatively, in fact, I think most people, and that includes most people currently programming Perl, are better off using a bondage language instead of Perl), you shouldn't use Perl, but say, Java or Python.

Having said that, the only times I use prototypes is to change how function calls are being parsed. So, I use it to create function that take blocks are arguments, or to create unary functions. Or to autoreference arrays and hashes.

Abigail

Theres some good discussion on the subject in an older thread: When to use Prototypes?