perl 5.003_01: pod/perllol.pod

[perl5.git] / pod / perllol.pod

diff --git a/pod/perllol.pod b/pod/perllol.pod
index 4b58bee..a1e8a2d 100644 (file)
--- a/pod/perllol.pod
+++ b/pod/perllol.pod
@@ -1,8 +1,10 @@
-=head1 TITLE
+=head1 NAME
 
 perlLoL - Manipulating Lists of Lists in Perl
 
-=head1 Declaration and Access
+=head1 DESCRIPTION
+
+=head1 Declaration and Access of Lists of Lists
 
 The simplest thing to build is a list of lists (sometimes called an array
 of arrays).  It's reasonably easy to understand, and almost everything
@@ -53,7 +55,7 @@ instead of having to write these:
 
 Well, that's because the rule is that on adjacent brackets only (whether
 square or curly), you are free to omit the pointer dereferencing array.
-But you need not do so for the very first one if it's a scalar containing
+But you cannot do so for the very first one if it's a scalar containing
 a reference, which means that $ref_to_LoL always needs it.
 
 =head1 Growing Your Own
@@ -126,7 +128,7 @@ or even just
        $LoL[$i] = [ split ' ', <> ];
     } 
 
-You should in general be leary of using potential list functions
+You should in general be leery of using potential list functions
 in a scalar context without explicitly stating such.  
 This would be clearer to the casual reader:
 
@@ -241,7 +243,7 @@ Hm... that's still a bit ugly.  How about this:
 
 =head1 Slices
 
-If you want to get at a slide (part of a row) in a multidimensional
+If you want to get at a slice (part of a row) in a multidimensional
 array, you're going to have to do some fancy subscripting.  That's
 because while we have a nice synonym for single elements via the
 pointer arrow for dereferencing, no such convenience exists for slices.
@@ -300,48 +302,6 @@ If I were you, I'd put that in a function:
     } 
 
 
-=head1 Passing Arguments
-
-One place where a list of lists crops up is when you pass
-in several list references to a function.  Consider:
-
-    @tailings = popmany ( \@a, \@b, \@c, \@d );
-
-    sub popmany {
-       my $aref;
-       my @retlist = ();
-       foreach $aref ( @_ ) {
-           push @retlist, pop @$aref;
-       } 
-       return @retlist;
-    } 
-
-This function was designed to pop off the last element from each of
-its arguments and return those in a list.  In this function, 
-you can think of @_ as a list of lists.
-
-Just as a side note, what happens if the function is called with the
-"wrong" types of arguments?  Normally nothing, but in the case of
-references, we can be a bit pickier.  This isn't detectable at
-compile-time (yet--Larry does have a prototype prototype in the works for
-5.002), but you could check it at run time using the ref() function.
-
-    use Carp;
-    for $i ( 0 .. $#_) {
-       if (ref($_[$i]) ne 'ARRAY') {
-           confess "popmany: arg $i not an array reference\n";
-       }
-    } 
-
-However, that's not usually necessary unless you want to trap it.  It's
-also dubious in that it would fail on a real array references blessed into
-its own class (an object).  But since you're all going to be using
-C<strict refs>, it would raise an exception anyway even without the die.
-
-This will matter more to you later on when you start building up 
-more complex data structures that all aren't woven of the same 
-cloth, so to speak.
-
 =head1 SEE ALSO
 
 perldata(1), perlref(1), perldsc(1)