It doesn't do what you think it does (Perl doesn't have named formal parameters, and yes I read your mind). Prototypes cause trouble and are best avoided. But to answer your question, prototypes allow you to change Perls usual argument-passing mechanism. It is an understatement to say this is tricky. If you want to validate arguments passed in you might want to take a look at Params::Validate. Also the PBP has a few good tips on how to use subs.

HTH
Harry

cheers, si_lence

The only really good use for prototypes is the creation of syntactic sugar. Perl prototypes can let you do neat things like write your own custom grep function that you can call like this:

Prototypes can also provide limited parameter checking but there are a lot of gotchas involved. In fact, so many that the standard advice is not to use them that way. Here are two:

• There is no guarantee that parameter checking will even take place. Perl only checks parameter prototypes when a subroutine is called as a function and has no leading &. If user decides to call your subroutine like $x->foo() or MyClass::X->foo() or even &foo($x,...), then Perl will happily ignore your prototype. A subroutine author has no control over how people call his/her code, the subroutine has to be written as if there were no error checking at all.
• Even if parameter checking does take place, a prototype will only complain about bad parameters if it can't coerce the arguments you pass into good parameters. This can lead to strange and hard to track down bugs. For example, normally you would expect that foo(@someArray) would pass one parameter for each member of the array @someArray. So, for example, if @someArray=(1,2) then foo(@someArray) would be the same as passing foo(1,2)

  However, if you declare something with a prototype foo($;$) and then try to pass it foo(@someArray) or some other array, Perl will pass the size of @someArray, not the array elements. This is because the first $ of foo($;$) forces a scalar context on @someArray and an array in scalar context evaluates to its size.

Protypes can also interfere with good programming practice if you aren't careful. Passing @_ is a good way to cleanly define two almost alike subroutines. It is a lot less prone to typos than extracting all the parameters and then passing them one by one to a subroutine that takes the same parameters:

sub fooExtra {
  my $somethingExtra=shift;
  my $result=foo(@_);
  # combine $somethingExtra and $result in some way
  # and return, for example ....
  return $result + $somethingExtra;
}
[download]

But if you define foo($;$) with a prototype, the above code won't work. Instead of passing the parameters, you'll pass the size of @_, which is not at all what you wanted.

Best, beth

• Types of arguments the function can take.
• the number of arguments intended to be passed to the function.

(updated)

example:
sub NAME($$;$){...}  #mistake corrected
[download]

How would you go about inspecting the contents of a scalar to decide if it is a number using only prototypes?
That sounds like more of a job for:

confess("Parameter $n stinks") unless $param[$n] =~ /$goodRule[$n]/;
[download]


Append:
Example of extensive parameter handling:

sub buyWidgets
{
    my $numWidgets = shift;
    my $supplier = shift;
    
    #validate parameters
    unless ($numWidgets =~ /^\d+$/)
    {
        carp("'$numWidgets' is not a valid number of widgets: purchase
+ canceled\n";
        return undef; 
    }
   
    # Validate, and be flexible if possible.   Accept both "ACME" and 
+"hash(0xPtrToACME)", and even ["ACME", "Bob's Widgets", "Black Market
+"]
    if (ref($supplier) eq 'ARRAY')
    {
        my $buyCount = 0;
        foreach (@$supplier)
        {
            my $result = buyWidgets($numWidgets-$buyCount, $_);
            $buyCount += $result if defined($result);
        }
        return $buyCount;
    }
    if (ref($supplier) ne 'Supplier')
    {
        unless (exists $globalSupplierDirectory->{$supplier})
        {
            carp("Cannot buy from '$supplier': not a valid supplier\n"
+);
            return undef;
        }
        $supplier = $globalSupplierDirectory->{$supplier};
    }

    # Do stuff with the good parameters
    return $supplier->buyWidgets($numWidgets);
}
[download]

Untested, and not self-contained.