subNAME
BLOCK
subNAME
subBLOCK
subNAME
PROTO
BLOCK
subNAME
PROTO
subPROTO
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.