sub
NAME
BLOCK
sub
NAME
sub
BLOCK
sub
NAME
PROTO
BLOCK
sub
NAME
PROTO
sub
PROTO
BLOCK
The first two of these are not really operators, but rather they
declare the existence of named subroutines, which is why the
syntax includes a
NAME
, after all. (As declarations, they
return no value.) The first one additionally defines the
subroutine with a
BLOCK
, which contains the code for the
subroutine. The second one (the one without the
BLOCK
) is
just a forward declaration, that is, a declaration that introduces the
subroutine name without defining it, with the expectation that the real
definition will come later. (This is useful because the parser treats a
word specially if it knows it's a user-defined subroutine. You can call
such a subroutine as if it were a list operator, for instance.)
The third form really
is
an operator, in that it can be
used within expressions to generate an anonymous subroutine at run-time. (More
specifically, it returns a reference to an anonymous subroutine, since you can't
talk about something anonymous without some kind of reference to it.) If the
anonymous subroutine refers to any lexical variables declared outside its
BLOCK
, it functions as a
closure
, which means that different calls to the same
sub
operator will do the bookkeeping necessary to
keep the correct "version" of each such lexical variable in sight for the life
of the closure, even if the original scope of the lexical variable has been
destroyed.
The final three forms are identical to the first three, except that they
also supply a prototype that lets you specify how calls to your
subroutine should be parsed and analyzed, so you can make your
routines act more like some of Perl's built-in functions. See
"Subroutines" in
Chapter 2
and "Anonymous Subroutines" in
Chapter 4
for more details.