X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperlref.pod;h=07b2f8272fa38c075538a9ff6cec434d19a17b39;hb=3f7c398ef4badd9c6ec5b40ea29141484c160f63;hp=08a2b42aee6d893b882bcfc162f719e27c1c25cc;hpb=e0478e5a74c23ab803d1f4136ac0e84a68ba9ecf;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perlref.pod b/pod/perlref.pod index 08a2b42..07b2f82 100644 --- a/pod/perlref.pod +++ b/pod/perlref.pod @@ -31,7 +31,7 @@ have been officially "blessed" into a class package.) Symbolic references are names of variables or other objects, just as a symbolic link in a Unix filesystem contains merely the name of a file. -The C<*glob> notation is something of a of symbolic reference. (Symbolic +The C<*glob> notation is something of a symbolic reference. (Symbolic references are sometimes called "soft references", but please don't call them that; references are confusing enough without useless synonyms.) @@ -84,7 +84,7 @@ brackets: Here we've created a reference to an anonymous array of three elements whose final element is itself a reference to another anonymous array of three elements. (The multidimensional syntax described later can be used to -access this. For example, after the above, C<$arrayref-E[2][1]> would have +access this. For example, after the above, C<< $arrayref->[2][1] >> would have the value "b".) Taking a reference to an enumerated list is not the same @@ -243,7 +243,9 @@ All of these are self-explanatory except for C<*foo{IO}>. It returns the IO handle, used for file handles (L), sockets (L and L), and directory handles (L). For compatibility with previous -versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>. +versions of Perl, C<*foo{FILEHANDLE}> is a synonym for C<*foo{IO}>, though it +is deprecated as of 5.8.0. If deprecation warnings are in effect, it will warn +of its use. C<*foo{THING}> returns undef if that particular THING hasn't been used yet, except in the case of scalars. C<*foo{SCALAR}> returns a reference to an @@ -357,7 +359,7 @@ syntactic sugar, the examples for method 2 may be written: The left side of the arrow can be any expression returning a reference, including a previous dereference. Note that C<$array[$x]> is I the -same thing as C<$array-E[$x]> here: +same thing as C<< $array->[$x] >> here: $array[$x]->{"foo"}->[0] = "January"; @@ -365,7 +367,7 @@ This is one of the cases we mentioned earlier in which references could spring into existence when in an lvalue context. Before this statement, C<$array[$x]> may have been undefined. If so, it's automatically defined with a hash reference so that we can look up -C<{"foo"}> in it. Likewise C<$array[$x]-E{"foo"}> will automatically get +C<{"foo"}> in it. Likewise C<< $array[$x]->{"foo"} >> will automatically get defined with an array reference so that we can look up C<[0]> in it. This process is called I. @@ -528,66 +530,22 @@ makes it more than a bareword: $array{ +shift } $array{ shift @_ } -The B<-w> switch will warn you if it interprets a reserved word as a string. +The C pragma or the B<-w> switch will warn you if it +interprets a reserved word as a string. But it will no longer warn you about using lowercase words, because the string is effectively quoted. =head2 Pseudo-hashes: Using an array as a hash -B: This section describes an experimental feature. Details may -change without notice in future versions. - -Beginning with release 5.005 of Perl, you may use an array reference -in some contexts that would normally require a hash reference. This -allows you to access array elements using symbolic names, as if they -were fields in a structure. - -For this to work, the array must contain extra information. The first -element of the array has to be a hash reference that maps field names -to array indices. Here is an example: - - $struct = [{foo => 1, bar => 2}, "FOO", "BAR"]; - - $struct->{foo}; # same as $struct->[1], i.e. "FOO" - $struct->{bar}; # same as $struct->[2], i.e. "BAR" - - keys %$struct; # will return ("foo", "bar") in some order - values %$struct; # will return ("FOO", "BAR") in same some order - - while (my($k,$v) = each %$struct) { - print "$k => $v\n"; - } - -Perl will raise an exception if you try to delete keys from a pseudo-hash -or try to access nonexistent fields. For better performance, Perl can also -do the translation from field names to array indices at compile time for -typed object references. See L. - -There are two ways to check for the existance of a key in a -pseudo-hash. The first is to use exists(). This checks to see if the -given field has been used yet. It acts this way to match the behavior -of a regular hash. For instance: - - $phash = [{foo =>, bar => 2, pants => 3}, 'FOO']; - $phash->{pants} = undef; - - exists $phash->{foo}; # true, 'foo' was set in the declaration - exists $phash->{bar}; # false, 'bar' has not been used. - exists $phash->{pants}; # true, your 'pants' have been touched - -The second is to use exists() on the hash reference sitting in the -first array element. This checks to see if the given key is a valid -field in the pseudo-hash. - - exists $phash->[0]{pants}; # true, 'pants' is a valid field - exists $phash->[0]{shoes}; # false, 'shoes' can't be used +Pseudo-hashes have been removed from Perl. The 'fields' pragma +remains available. =head2 Function Templates -As explained above, a closure is an anonymous function with access to the -lexical variables visible when that function was compiled. It retains -access to those variables even though it doesn't get run until later, -such as in a signal handler or a Tk callback. +As explained above, an anonymous function with access to the lexical +variables visible when that function was compiled, creates a closure. It +retains access to those variables even though it doesn't get run until +later, such as in a signal handler or a Tk callback. Using a closure as a function template allows us to generate many functions that act similarly. Suppose you wanted functions named after the colors @@ -627,11 +585,13 @@ to occur during compilation. Access to lexicals that change over type--like those in the C loop above--only works with closures, not general subroutines. In the general case, then, named subroutines do not nest properly, although anonymous -ones do. If you are accustomed to using nested subroutines in other -programming languages with their own private variables, you'll have to -work at it a bit in Perl. The intuitive coding of this type of thing -incurs mysterious warnings about ``will not stay shared''. For example, -this won't work: +ones do. Thus is because named subroutines are created (and capture any +outer lexicals) only once at compile time, whereas anonymous subroutines +get to capture each time you execute the 'sub' operator. If you are +accustomed to using nested subroutines in other programming languages with +their own private variables, you'll have to work at it a bit in Perl. The +intuitive coding of this type of thing incurs mysterious warnings about +``will not stay shared''. For example, this won't work: sub outer { my $x = $_[0] + 35;