[Summary view] [Print] [Text view]

   1  =head1 NAME
   2  X<reference> X<pointer> X<data structure> X<structure> X<struct>
   3  
   4  perlref - Perl references and nested data structures
   5  
   6  =head1 NOTE
   7  
   8  This is complete documentation about all aspects of references.
   9  For a shorter, tutorial introduction to just the essential features,
  10  see L<perlreftut>.
  11  
  12  =head1 DESCRIPTION
  13  
  14  Before release 5 of Perl it was difficult to represent complex data
  15  structures, because all references had to be symbolic--and even then
  16  it was difficult to refer to a variable instead of a symbol table entry.
  17  Perl now not only makes it easier to use symbolic references to variables,
  18  but also lets you have "hard" references to any piece of data or code.
  19  Any scalar may hold a hard reference.  Because arrays and hashes contain
  20  scalars, you can now easily build arrays of arrays, arrays of hashes,
  21  hashes of arrays, arrays of hashes of functions, and so on.
  22  
  23  Hard references are smart--they keep track of reference counts for you,
  24  automatically freeing the thing referred to when its reference count goes
  25  to zero.  (Reference counts for values in self-referential or
  26  cyclic data structures may not go to zero without a little help; see
  27  L<perlobj/"Two-Phased Garbage Collection"> for a detailed explanation.)
  28  If that thing happens to be an object, the object is destructed.  See
  29  L<perlobj> for more about objects.  (In a sense, everything in Perl is an
  30  object, but we usually reserve the word for references to objects that
  31  have been officially "blessed" into a class package.)
  32  
  33  Symbolic references are names of variables or other objects, just as a
  34  symbolic link in a Unix filesystem contains merely the name of a file.
  35  The C<*glob> notation is something of a symbolic reference.  (Symbolic
  36  references are sometimes called "soft references", but please don't call
  37  them that; references are confusing enough without useless synonyms.)
  38  X<reference, symbolic> X<reference, soft>
  39  X<symbolic reference> X<soft reference>
  40  
  41  In contrast, hard references are more like hard links in a Unix file
  42  system: They are used to access an underlying object without concern for
  43  what its (other) name is.  When the word "reference" is used without an
  44  adjective, as in the following paragraph, it is usually talking about a
  45  hard reference.
  46  X<reference, hard> X<hard reference>
  47  
  48  References are easy to use in Perl.  There is just one overriding
  49  principle: Perl does no implicit referencing or dereferencing.  When a
  50  scalar is holding a reference, it always behaves as a simple scalar.  It
  51  doesn't magically start being an array or hash or subroutine; you have to
  52  tell it explicitly to do so, by dereferencing it.
  53  
  54  =head2 Making References
  55  X<reference, creation> X<referencing>
  56  
  57  References can be created in several ways.
  58  
  59  =over 4
  60  
  61  =item 1.
  62  X<\> X<backslash>
  63  
  64  By using the backslash operator on a variable, subroutine, or value.
  65  (This works much like the & (address-of) operator in C.)  
  66  This typically creates I<another> reference to a variable, because
  67  there's already a reference to the variable in the symbol table.  But
  68  the symbol table reference might go away, and you'll still have the
  69  reference that the backslash returned.  Here are some examples:
  70  
  71      $scalarref = \$foo;
  72      $arrayref  = \@ARGV;
  73      $hashref   = \%ENV;
  74      $coderef   = \&handler;
  75      $globref   = \*foo;
  76  
  77  It isn't possible to create a true reference to an IO handle (filehandle
  78  or dirhandle) using the backslash operator.  The most you can get is a
  79  reference to a typeglob, which is actually a complete symbol table entry.
  80  But see the explanation of the C<*foo{THING}> syntax below.  However,
  81  you can still use type globs and globrefs as though they were IO handles.
  82  
  83  =item 2.
  84  X<array, anonymous> X<[> X<[]> X<square bracket>
  85  X<bracket, square> X<arrayref> X<array reference> X<reference, array>
  86  
  87  A reference to an anonymous array can be created using square
  88  brackets:
  89  
  90      $arrayref = [1, 2, ['a', 'b', 'c']];
  91  
  92  Here we've created a reference to an anonymous array of three elements
  93  whose final element is itself a reference to another anonymous array of three
  94  elements.  (The multidimensional syntax described later can be used to
  95  access this.  For example, after the above, C<< $arrayref->[2][1] >> would have
  96  the value "b".)
  97  
  98  Taking a reference to an enumerated list is not the same
  99  as using square brackets--instead it's the same as creating
 100  a list of references!
 101  
 102      @list = (\$a, \@b, \%c);
 103      @list = \($a, @b, %c);    # same thing!
 104  
 105  As a special case, C<\(@foo)> returns a list of references to the contents
 106  of C<@foo>, not a reference to C<@foo> itself.  Likewise for C<%foo>,
 107  except that the key references are to copies (since the keys are just
 108  strings rather than full-fledged scalars).
 109  
 110  =item 3.
 111  X<hash, anonymous> X<{> X<{}> X<curly bracket>
 112  X<bracket, curly> X<brace> X<hashref> X<hash reference> X<reference, hash>
 113  
 114  A reference to an anonymous hash can be created using curly
 115  brackets:
 116  
 117      $hashref = {
 118      'Adam'  => 'Eve',
 119      'Clyde' => 'Bonnie',
 120      };
 121  
 122  Anonymous hash and array composers like these can be intermixed freely to
 123  produce as complicated a structure as you want.  The multidimensional
 124  syntax described below works for these too.  The values above are
 125  literals, but variables and expressions would work just as well, because
 126  assignment operators in Perl (even within local() or my()) are executable
 127  statements, not compile-time declarations.
 128  
 129  Because curly brackets (braces) are used for several other things
 130  including BLOCKs, you may occasionally have to disambiguate braces at the
 131  beginning of a statement by putting a C<+> or a C<return> in front so
 132  that Perl realizes the opening brace isn't starting a BLOCK.  The economy and
 133  mnemonic value of using curlies is deemed worth this occasional extra
 134  hassle.
 135  
 136  For example, if you wanted a function to make a new hash and return a
 137  reference to it, you have these options:
 138  
 139      sub hashem {        { @_ } }   # silently wrong
 140      sub hashem {       +{ @_ } }   # ok
 141      sub hashem { return { @_ } }   # ok
 142  
 143  On the other hand, if you want the other meaning, you can do this:
 144  
 145      sub showem {        { @_ } }   # ambiguous (currently ok, but may change)
 146      sub showem {       {; @_ } }   # ok
 147      sub showem { { return @_ } }   # ok
 148  
 149  The leading C<+{> and C<{;> always serve to disambiguate
 150  the expression to mean either the HASH reference, or the BLOCK.
 151  
 152  =item 4.
 153  X<subroutine, anonymous> X<subroutine, reference> X<reference, subroutine>
 154  X<scope, lexical> X<closure> X<lexical> X<lexical scope>
 155  
 156  A reference to an anonymous subroutine can be created by using
 157  C<sub> without a subname:
 158  
 159      $coderef = sub { print "Boink!\n" };
 160  
 161  Note the semicolon.  Except for the code
 162  inside not being immediately executed, a C<sub {}> is not so much a
 163  declaration as it is an operator, like C<do{}> or C<eval{}>.  (However, no
 164  matter how many times you execute that particular line (unless you're in an
 165  C<eval("...")>), $coderef will still have a reference to the I<same>
 166  anonymous subroutine.)
 167  
 168  Anonymous subroutines act as closures with respect to my() variables,
 169  that is, variables lexically visible within the current scope.  Closure
 170  is a notion out of the Lisp world that says if you define an anonymous
 171  function in a particular lexical context, it pretends to run in that
 172  context even when it's called outside the context.
 173  
 174  In human terms, it's a funny way of passing arguments to a subroutine when
 175  you define it as well as when you call it.  It's useful for setting up
 176  little bits of code to run later, such as callbacks.  You can even
 177  do object-oriented stuff with it, though Perl already provides a different
 178  mechanism to do that--see L<perlobj>.
 179  
 180  You might also think of closure as a way to write a subroutine
 181  template without using eval().  Here's a small example of how
 182  closures work:
 183  
 184      sub newprint {
 185      my $x = shift;
 186      return sub { my $y = shift; print "$x, $y!\n"; };
 187      }
 188      $h = newprint("Howdy");
 189      $g = newprint("Greetings");
 190  
 191      # Time passes...
 192  
 193      &$h("world");
 194      &$g("earthlings");
 195  
 196  This prints
 197  
 198      Howdy, world!
 199      Greetings, earthlings!
 200  
 201  Note particularly that $x continues to refer to the value passed
 202  into newprint() I<despite> "my $x" having gone out of scope by the
 203  time the anonymous subroutine runs.  That's what a closure is all
 204  about.
 205  
 206  This applies only to lexical variables, by the way.  Dynamic variables
 207  continue to work as they have always worked.  Closure is not something
 208  that most Perl programmers need trouble themselves about to begin with.
 209  
 210  =item 5.
 211  X<constructor> X<new>
 212  
 213  References are often returned by special subroutines called constructors.  Perl
 214  objects are just references to a special type of object that happens to know
 215  which package it's associated with.  Constructors are just special subroutines
 216  that know how to create that association.  They do so by starting with an
 217  ordinary reference, and it remains an ordinary reference even while it's also
 218  being an object.  Constructors are often named C<new()>.  You I<can> call them
 219  indirectly:
 220  
 221      $objref = new Doggie( Tail => 'short', Ears => 'long' );
 222  
 223  But that can produce ambiguous syntax in certain cases, so it's often
 224  better to use the direct method invocation approach:
 225  
 226      $objref   = Doggie->new(Tail => 'short', Ears => 'long');
 227  
 228      use Term::Cap;
 229      $terminal = Term::Cap->Tgetent( { OSPEED => 9600 });
 230  
 231      use Tk;
 232      $main    = MainWindow->new();
 233      $menubar = $main->Frame(-relief              => "raised",
 234                              -borderwidth         => 2)
 235  
 236  =item 6.
 237  X<autovivification>
 238  
 239  References of the appropriate type can spring into existence if you
 240  dereference them in a context that assumes they exist.  Because we haven't
 241  talked about dereferencing yet, we can't show you any examples yet.
 242  
 243  =item 7.
 244  X<*foo{THING}> X<*>
 245  
 246  A reference can be created by using a special syntax, lovingly known as
 247  the *foo{THING} syntax.  *foo{THING} returns a reference to the THING
 248  slot in *foo (which is the symbol table entry which holds everything
 249  known as foo).
 250  
 251      $scalarref = *foo{SCALAR};
 252      $arrayref  = *ARGV{ARRAY};
 253      $hashref   = *ENV{HASH};
 254      $coderef   = *handler{CODE};
 255      $ioref     = *STDIN{IO};
 256      $globref   = *foo{GLOB};
 257      $formatref = *foo{FORMAT};
 258  
 259  All of these are self-explanatory except for C<*foo{IO}>.  It returns
 260  the IO handle, used for file handles (L<perlfunc/open>), sockets
 261  (L<perlfunc/socket> and L<perlfunc/socketpair>), and directory
 262  handles (L<perlfunc/opendir>).  For compatibility with previous
 263  versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>, though it
 264  is deprecated as of 5.8.0.  If deprecation warnings are in effect, it will warn
 265  of its use.
 266  
 267  C<*foo{THING}> returns undef if that particular THING hasn't been used yet,
 268  except in the case of scalars.  C<*foo{SCALAR}> returns a reference to an
 269  anonymous scalar if $foo hasn't been used yet.  This might change in a
 270  future release.
 271  
 272  C<*foo{IO}> is an alternative to the C<*HANDLE> mechanism given in
 273  L<perldata/"Typeglobs and Filehandles"> for passing filehandles
 274  into or out of subroutines, or storing into larger data structures.
 275  Its disadvantage is that it won't create a new filehandle for you.
 276  Its advantage is that you have less risk of clobbering more than
 277  you want to with a typeglob assignment.  (It still conflates file
 278  and directory handles, though.)  However, if you assign the incoming
 279  value to a scalar instead of a typeglob as we do in the examples
 280  below, there's no risk of that happening.
 281  
 282      splutter(*STDOUT);        # pass the whole glob
 283      splutter(*STDOUT{IO});    # pass both file and dir handles
 284  
 285      sub splutter {
 286      my $fh = shift;
 287      print $fh "her um well a hmmm\n";
 288      }
 289  
 290      $rec = get_rec(*STDIN);    # pass the whole glob
 291      $rec = get_rec(*STDIN{IO}); # pass both file and dir handles
 292  
 293      sub get_rec {
 294      my $fh = shift;
 295      return scalar <$fh>;
 296      }
 297  
 298  =back
 299  
 300  =head2 Using References
 301  X<reference, use> X<dereferencing> X<dereference>
 302  
 303  That's it for creating references.  By now you're probably dying to
 304  know how to use references to get back to your long-lost data.  There
 305  are several basic methods.
 306  
 307  =over 4
 308  
 309  =item 1.
 310  
 311  Anywhere you'd put an identifier (or chain of identifiers) as part
 312  of a variable or subroutine name, you can replace the identifier with
 313  a simple scalar variable containing a reference of the correct type:
 314  
 315      $bar = $$scalarref;
 316      push(@$arrayref, $filename);
 317      $$arrayref[0] = "January";
 318      $$hashref{"KEY"} = "VALUE";
 319      &$coderef(1,2,3);
 320      print $globref "output\n";
 321  
 322  It's important to understand that we are specifically I<not> dereferencing
 323  C<$arrayref[0]> or C<$hashref{"KEY"}> there.  The dereference of the
 324  scalar variable happens I<before> it does any key lookups.  Anything more
 325  complicated than a simple scalar variable must use methods 2 or 3 below.
 326  However, a "simple scalar" includes an identifier that itself uses method
 327  1 recursively.  Therefore, the following prints "howdy".
 328  
 329      $refrefref = \\\"howdy";
 330      print $$$$refrefref;
 331  
 332  =item 2.
 333  
 334  Anywhere you'd put an identifier (or chain of identifiers) as part of a
 335  variable or subroutine name, you can replace the identifier with a
 336  BLOCK returning a reference of the correct type.  In other words, the
 337  previous examples could be written like this:
 338  
 339      $bar = ${$scalarref};
 340      push(@{$arrayref}, $filename);
 341      ${$arrayref}[0] = "January";
 342      ${$hashref}{"KEY"} = "VALUE";
 343      &{$coderef}(1,2,3);
 344      $globref->print("output\n");  # iff IO::Handle is loaded
 345  
 346  Admittedly, it's a little silly to use the curlies in this case, but
 347  the BLOCK can contain any arbitrary expression, in particular,
 348  subscripted expressions:
 349  
 350      &{ $dispatch{$index} }(1,2,3);    # call correct routine
 351  
 352  Because of being able to omit the curlies for the simple case of C<$$x>,
 353  people often make the mistake of viewing the dereferencing symbols as
 354  proper operators, and wonder about their precedence.  If they were,
 355  though, you could use parentheses instead of braces.  That's not the case.
 356  Consider the difference below; case 0 is a short-hand version of case 1,
 357  I<not> case 2:
 358  
 359      $$hashref{"KEY"}   = "VALUE";    # CASE 0
 360      ${$hashref}{"KEY"} = "VALUE";    # CASE 1
 361      ${$hashref{"KEY"}} = "VALUE";    # CASE 2
 362      ${$hashref->{"KEY"}} = "VALUE";    # CASE 3
 363  
 364  Case 2 is also deceptive in that you're accessing a variable
 365  called %hashref, not dereferencing through $hashref to the hash
 366  it's presumably referencing.  That would be case 3.
 367  
 368  =item 3.
 369  
 370  Subroutine calls and lookups of individual array elements arise often
 371  enough that it gets cumbersome to use method 2.  As a form of
 372  syntactic sugar, the examples for method 2 may be written:
 373  
 374      $arrayref->[0] = "January";   # Array element
 375      $hashref->{"KEY"} = "VALUE";  # Hash element
 376      $coderef->(1,2,3);            # Subroutine call
 377  
 378  The left side of the arrow can be any expression returning a reference,
 379  including a previous dereference.  Note that C<$array[$x]> is I<not> the
 380  same thing as C<< $array->[$x] >> here:
 381  
 382      $array[$x]->{"foo"}->[0] = "January";
 383  
 384  This is one of the cases we mentioned earlier in which references could
 385  spring into existence when in an lvalue context.  Before this
 386  statement, C<$array[$x]> may have been undefined.  If so, it's
 387  automatically defined with a hash reference so that we can look up
 388  C<{"foo"}> in it.  Likewise C<< $array[$x]->{"foo"} >> will automatically get
 389  defined with an array reference so that we can look up C<[0]> in it.
 390  This process is called I<autovivification>.
 391  
 392  One more thing here.  The arrow is optional I<between> brackets
 393  subscripts, so you can shrink the above down to
 394  
 395      $array[$x]{"foo"}[0] = "January";
 396  
 397  Which, in the degenerate case of using only ordinary arrays, gives you
 398  multidimensional arrays just like C's:
 399  
 400      $score[$x][$y][$z] += 42;
 401  
 402  Well, okay, not entirely like C's arrays, actually.  C doesn't know how
 403  to grow its arrays on demand.  Perl does.
 404  
 405  =item 4.
 406  
 407  If a reference happens to be a reference to an object, then there are
 408  probably methods to access the things referred to, and you should probably
 409  stick to those methods unless you're in the class package that defines the
 410  object's methods.  In other words, be nice, and don't violate the object's
 411  encapsulation without a very good reason.  Perl does not enforce
 412  encapsulation.  We are not totalitarians here.  We do expect some basic
 413  civility though.
 414  
 415  =back
 416  
 417  Using a string or number as a reference produces a symbolic reference,
 418  as explained above.  Using a reference as a number produces an
 419  integer representing its storage location in memory.  The only
 420  useful thing to be done with this is to compare two references
 421  numerically to see whether they refer to the same location.
 422  X<reference, numeric context>
 423  
 424      if ($ref1 == $ref2) {  # cheap numeric compare of references
 425      print "refs 1 and 2 refer to the same thing\n";
 426      }
 427  
 428  Using a reference as a string produces both its referent's type,
 429  including any package blessing as described in L<perlobj>, as well
 430  as the numeric address expressed in hex.  The ref() operator returns
 431  just the type of thing the reference is pointing to, without the
 432  address.  See L<perlfunc/ref> for details and examples of its use.
 433  X<reference, string context>
 434  
 435  The bless() operator may be used to associate the object a reference
 436  points to with a package functioning as an object class.  See L<perlobj>.
 437  
 438  A typeglob may be dereferenced the same way a reference can, because
 439  the dereference syntax always indicates the type of reference desired.
 440  So C<${*foo}> and C<${\$foo}> both indicate the same scalar variable.
 441  
 442  Here's a trick for interpolating a subroutine call into a string:
 443  
 444      print "My sub returned @{[mysub(1,2,3)]} that time.\n";
 445  
 446  The way it works is that when the C<@{...}> is seen in the double-quoted
 447  string, it's evaluated as a block.  The block creates a reference to an
 448  anonymous array containing the results of the call to C<mysub(1,2,3)>.  So
 449  the whole block returns a reference to an array, which is then
 450  dereferenced by C<@{...}> and stuck into the double-quoted string. This
 451  chicanery is also useful for arbitrary expressions:
 452  
 453      print "That yields @{[$n + 5]} widgets\n";
 454  
 455  Similarly, an expression that returns a reference to a scalar can be
 456  dereferenced via C<${...}>. Thus, the above expression may be written
 457  as:
 458  
 459      print "That yields ${\($n + 5)} widgets\n";
 460  
 461  =head2 Symbolic references
 462  X<reference, symbolic> X<reference, soft>
 463  X<symbolic reference> X<soft reference>
 464  
 465  We said that references spring into existence as necessary if they are
 466  undefined, but we didn't say what happens if a value used as a
 467  reference is already defined, but I<isn't> a hard reference.  If you
 468  use it as a reference, it'll be treated as a symbolic
 469  reference.  That is, the value of the scalar is taken to be the I<name>
 470  of a variable, rather than a direct link to a (possibly) anonymous
 471  value.
 472  
 473  People frequently expect it to work like this.  So it does.
 474  
 475      $name = "foo";
 476      $$name = 1;            # Sets $foo
 477      ${$name} = 2;        # Sets $foo
 478      ${$name x 2} = 3;        # Sets $foofoo
 479      $name->[0] = 4;        # Sets $foo[0]
 480      @$name = ();        # Clears @foo
 481      &$name();            # Calls &foo() (as in Perl 4)
 482      $pack = "THAT";
 483      ${"$pack}::$name"} = 5;    # Sets $THAT::foo without eval
 484  
 485  This is powerful, and slightly dangerous, in that it's possible
 486  to intend (with the utmost sincerity) to use a hard reference, and
 487  accidentally use a symbolic reference instead.  To protect against
 488  that, you can say
 489  
 490      use strict 'refs';
 491  
 492  and then only hard references will be allowed for the rest of the enclosing
 493  block.  An inner block may countermand that with
 494  
 495      no strict 'refs';
 496  
 497  Only package variables (globals, even if localized) are visible to
 498  symbolic references.  Lexical variables (declared with my()) aren't in
 499  a symbol table, and thus are invisible to this mechanism.  For example:
 500  
 501      local $value = 10;
 502      $ref = "value";
 503      {
 504      my $value = 20;
 505      print $$ref;
 506      }
 507  
 508  This will still print 10, not 20.  Remember that local() affects package
 509  variables, which are all "global" to the package.
 510  
 511  =head2 Not-so-symbolic references
 512  
 513  A new feature contributing to readability in perl version 5.001 is that the
 514  brackets around a symbolic reference behave more like quotes, just as they
 515  always have within a string.  That is,
 516  
 517      $push = "pop on ";
 518      print "$push}over";
 519  
 520  has always meant to print "pop on over", even though push is
 521  a reserved word.  This has been generalized to work the same outside
 522  of quotes, so that
 523  
 524      print $push} . "over";
 525  
 526  and even
 527  
 528      print ${ push } . "over";
 529  
 530  will have the same effect.  (This would have been a syntax error in
 531  Perl 5.000, though Perl 4 allowed it in the spaceless form.)  This
 532  construct is I<not> considered to be a symbolic reference when you're
 533  using strict refs:
 534  
 535      use strict 'refs';
 536      ${ bareword };    # Okay, means $bareword.
 537      ${ "bareword" };    # Error, symbolic reference.
 538  
 539  Similarly, because of all the subscripting that is done using single
 540  words, we've applied the same rule to any bareword that is used for
 541  subscripting a hash.  So now, instead of writing
 542  
 543      $array{ "aaa" }{ "bbb" }{ "ccc" }
 544  
 545  you can write just
 546  
 547      $array{ aaa }{ bbb }{ ccc }
 548  
 549  and not worry about whether the subscripts are reserved words.  In the
 550  rare event that you do wish to do something like
 551  
 552      $array{ shift }
 553  
 554  you can force interpretation as a reserved word by adding anything that
 555  makes it more than a bareword:
 556  
 557      $array{ shift() }
 558      $array{ +shift }
 559      $array{ shift @_ }
 560  
 561  The C<use warnings> pragma or the B<-w> switch will warn you if it
 562  interprets a reserved word as a string.
 563  But it will no longer warn you about using lowercase words, because the
 564  string is effectively quoted.
 565  
 566  =head2 Pseudo-hashes: Using an array as a hash
 567  X<pseudo-hash> X<pseudo hash> X<pseudohash>
 568  
 569  Pseudo-hashes have been removed from Perl.  The 'fields' pragma
 570  remains available.
 571  
 572  =head2 Function Templates
 573  X<scope, lexical> X<closure> X<lexical> X<lexical scope>
 574  X<subroutine, nested> X<sub, nested> X<subroutine, local> X<sub, local>
 575  
 576  As explained above, an anonymous function with access to the lexical
 577  variables visible when that function was compiled, creates a closure.  It
 578  retains access to those variables even though it doesn't get run until
 579  later, such as in a signal handler or a Tk callback.
 580  
 581  Using a closure as a function template allows us to generate many functions
 582  that act similarly.  Suppose you wanted functions named after the colors
 583  that generated HTML font changes for the various colors:
 584  
 585      print "Be ", red("careful"), "with that ", green("light");
 586  
 587  The red() and green() functions would be similar.  To create these,
 588  we'll assign a closure to a typeglob of the name of the function we're
 589  trying to build.  
 590  
 591      @colors = qw(red blue green yellow orange purple violet);
 592      for my $name (@colors) {
 593          no strict 'refs';    # allow symbol table manipulation
 594          *$name = *{uc $name} = sub { "<FONT COLOR='$name'>@_</FONT>" };
 595      } 
 596  
 597  Now all those different functions appear to exist independently.  You can
 598  call red(), RED(), blue(), BLUE(), green(), etc.  This technique saves on
 599  both compile time and memory use, and is less error-prone as well, since
 600  syntax checks happen at compile time.  It's critical that any variables in
 601  the anonymous subroutine be lexicals in order to create a proper closure.
 602  That's the reasons for the C<my> on the loop iteration variable.
 603  
 604  This is one of the only places where giving a prototype to a closure makes
 605  much sense.  If you wanted to impose scalar context on the arguments of
 606  these functions (probably not a wise idea for this particular example),
 607  you could have written it this way instead:
 608  
 609      *$name = sub ($) { "<FONT COLOR='$name'>$_[0]</FONT>" };
 610  
 611  However, since prototype checking happens at compile time, the assignment
 612  above happens too late to be of much use.  You could address this by
 613  putting the whole loop of assignments within a BEGIN block, forcing it
 614  to occur during compilation.
 615  
 616  Access to lexicals that change over time--like those in the C<for> loop
 617  above, basically aliases to elements from the surrounding lexical scopes--
 618  only works with anonymous subs, not with named subroutines. Generally
 619  said, named subroutines do not nest properly and should only be declared
 620  in the main package scope.
 621  
 622  This is because named subroutines are created at compile time so their
 623  lexical variables get assigned to the parent lexicals from the first
 624  execution of the parent block. If a parent scope is entered a second
 625  time, its lexicals are created again, while the nested subs still
 626  reference the old ones.
 627  
 628  Anonymous subroutines get to capture each time you execute the C<sub>
 629  operator, as they are created on the fly. If you are accustomed to using
 630  nested subroutines in other programming languages with their own private
 631  variables, you'll have to work at it a bit in Perl.  The intuitive coding
 632  of this type of thing incurs mysterious warnings about "will not stay
 633  shared" due to the reasons explained above. 
 634  For example, this won't work:
 635  
 636      sub outer {
 637          my $x = $_[0] + 35;
 638          sub inner { return $x * 19 }   # WRONG
 639          return $x + inner();
 640      }
 641  
 642  A work-around is the following:
 643  
 644      sub outer {
 645          my $x = $_[0] + 35;
 646          local *inner = sub { return $x * 19 };
 647          return $x + inner();
 648      }
 649  
 650  Now inner() can only be called from within outer(), because of the
 651  temporary assignments of the anonymous subroutine. But when it does,
 652  it has normal access to the lexical variable $x from the scope of
 653  outer() at the time outer is invoked.
 654  
 655  This has the interesting effect of creating a function local to another
 656  function, something not normally supported in Perl.
 657  
 658  =head1 WARNING
 659  X<reference, string context> X<reference, use as hash key>
 660  
 661  You may not (usefully) use a reference as the key to a hash.  It will be
 662  converted into a string:
 663  
 664      $x{ \$a } = $a;
 665  
 666  If you try to dereference the key, it won't do a hard dereference, and
 667  you won't accomplish what you're attempting.  You might want to do something
 668  more like
 669  
 670      $r = \@a;
 671      $x{ $r } = $r;
 672  
 673  And then at least you can use the values(), which will be
 674  real refs, instead of the keys(), which won't.
 675  
 676  The standard Tie::RefHash module provides a convenient workaround to this.
 677  
 678  =head1 SEE ALSO
 679  
 680  Besides the obvious documents, source code can be instructive.
 681  Some pathological examples of the use of references can be found
 682  in the F<t/op/ref.t> regression test in the Perl source directory.
 683  
 684  See also L<perldsc> and L<perllol> for how to use references to create
 685  complex data structures, and L<perltoot>, L<perlobj>, and L<perlbot>
 686  for how to use them to create objects.