Perl Cd Bookshelf [Electronic resources] نسخه متنی

10.11.1. Problem

Perl has something of a prototype facility, but it isn't what you're
thinking. Perl's function prototypes are more like a context coercion
used to write functions that behave like some Perl built-ins, such as
push and pop.

Manually checking the validity of a function's arguments can't happen
until runtime. If you make sure the function is declared before it is
used, you can tickle the compiler into using a very limited form of
prototype checking. But don't confuse Perl's function prototypes with
those found in any other language.

A Perl function prototype is zero or more spaces, backslashes, or
type characters enclosed in parentheses after the subroutine
definition or name. A backslashed type symbol means that the argument
is passed by reference, and the argument in that position must start
with that type character.

A prototype can impose context on the prototyped function's
arguments. This is done when Perl compiles your program. But this
does not always mean that Perl checks the number or type of
arguments; since a scalar prototype is like inserting a
scalar in front of just one argument, sometimes an
implicit conversion occurs instead. For example, if Perl sees
func(3, 5) for a function
prototyped as sub func
($), it will stop with a compile-time error. But
if it sees func(@array) with the same prototype,
it will merely put @array into scalar context
instead of complaining that you passed an array, but it wanted a
scalar.

This is so important that it bears repeating: don't use Perl
prototypes expecting the compiler to check type and number of
arguments for you. It does a little bit of that, sometimes, but
mostly it's about helping you type less, and sometimes to emulate the
calling and parsing conventions of built-in functions.

The other common use of prototypes is to give the convenient
pass-without-flattening behavior of built-in functions like
push and shift. When you call
push as push(@array,
1, 2, 3) the
function gets a reference to
@array instead of the actual array. This is
accomplished by backslashing the @ character in
the prototype:

sub mypush (\@@) {
my $array_ref = my @remainder = @_;
# ...
}

The \@ in the prototype says "require the first
argument to begin with an @ character, and pass it
by reference." The second @ says "the rest of the
arguments are a (possibly empty) list." A backslash in a prototype
requires that the argument actually begin with the literal type
character, which can sometimes be annoying. You can't even use the
conditional ?: construct to pick which array to
pass:

mypush( $x > 10 ? @a : @b, 3, 5 ); # WRONG

Instead, you must play games with references:

mypush( @{ $x > 10 ? \@a : \@b }, 3, 5 ); # RIGHT (but ugly)