Convert tabs in indentation to spaces.
authorShlomi Fish <shlomif@shlomifish.org>
Tue, 20 Jan 2015 14:15:49 +0000 (16:15 +0200)
committerJames E Keenan <jkeenan@cpan.org>
Fri, 23 Jan 2015 01:13:15 +0000 (20:13 -0500)
This is so it will display correctly with every tab-step/tab-size.

pod/perldsc.pod

index c5f53d8..6da0477 100644 (file)
@@ -9,12 +9,12 @@ Perl lets us have complex data structures.  You can write something like
 this and all of a sudden, you'd have an array with three dimensions!
 
     for $x (1 .. 10) {
-       for $y (1 .. 10) {
-           for $z (1 .. 10) {
-               $AoA[$x][$y][$z] =
-                   $x ** $y + $z;
-           }
-       }
+        for $y (1 .. 10) {
+            for $z (1 .. 10) {
+                $AoA[$x][$y][$z] =
+                    $x ** $y + $z;
+            }
+        }
     }
 
 Alas, however simple this may appear, underneath it's a much more
@@ -85,10 +85,10 @@ level.  It's just that you can I<use> it as though it were a
 two-dimensional one.  This is actually the way almost all C
 multidimensional arrays work as well.
 
-    $array[7][12]                      # array of arrays
-    $array[7]{string}                  # array of hashes
-    $hash{string}[7]                   # hash of arrays
-    $hash{string}{'another string'}    # hash of hashes
+    $array[7][12]                       # array of arrays
+    $array[7]{string}                   # array of hashes
+    $hash{string}[7]                    # hash of arrays
+    $hash{string}{'another string'}     # hash of hashes
 
 Now, because the top level contains only references, if you try to print
 out your array in with a simple print() function, you'll get something
@@ -116,8 +116,8 @@ repeatedly.  Here's the case where you just get the count instead
 of a nested array:
 
     for $i (1..10) {
-       @array = somefunc($i);
-       $AoA[$i] = @array;      # WRONG!
+        @array = somefunc($i);
+        $AoA[$i] = @array;      # WRONG!
     }
 
 That's just the simple case of assigning an array to a scalar and getting
@@ -125,16 +125,16 @@ its element count.  If that's what you really and truly want, then you
 might do well to consider being a tad more explicit about it, like this:
 
     for $i (1..10) {
-       @array = somefunc($i);
-       $counts[$i] = scalar @array;
+        @array = somefunc($i);
+        $counts[$i] = scalar @array;
     }
 
 Here's the case of taking a reference to the same memory location
 again and again:
 
     for $i (1..10) {
-       @array = somefunc($i);
-       $AoA[$i] = \@array;     # WRONG!
+        @array = somefunc($i);
+        $AoA[$i] = \@array;     # WRONG!
     }
 
 So, what's the big problem with that?  It looks right, doesn't it?
@@ -148,12 +148,12 @@ the following C program:
 
     #include <pwd.h>
     main() {
-       struct passwd *getpwnam(), *rp, *dp;
-       rp = getpwnam("root");
-       dp = getpwnam("daemon");
+        struct passwd *getpwnam(), *rp, *dp;
+        rp = getpwnam("root");
+        dp = getpwnam("daemon");
 
-       printf("daemon name is %s\nroot name is %s\n",
-               dp->pw_name, rp->pw_name);
+        printf("daemon name is %s\nroot name is %s\n",
+                dp->pw_name, rp->pw_name);
     }
 
 Which will print
@@ -169,8 +169,8 @@ broken code fragments:
 X<[]> X<{}>
 
     for $i (1..10) {
-       @array = somefunc($i);
-       $AoA[$i] = [ @array ];
+        @array = somefunc($i);
+        $AoA[$i] = [ @array ];
     }
 
 The square brackets make a reference to a new array with a I<copy>
@@ -181,8 +181,8 @@ Note that this will produce something similar, but it's
 much harder to read:
 
     for $i (1..10) {
-       @array = 0 .. $i;
-       @{$AoA[$i]} = @array;
+        @array = 0 .. $i;
+        @{$AoA[$i]} = @array;
     }
 
 Is it the same?  Well, maybe so--and maybe not.  The subtle difference
@@ -235,9 +235,9 @@ do the right thing behind the scenes.
 
 In summary:
 
-    $AoA[$i] = [ @array ];     # usually best
-    $AoA[$i] = \@array;                # perilous; just how my() was that array?
-    @{ $AoA[$i] } = @array;    # way too tricky for most programmers
+    $AoA[$i] = [ @array ];      # usually best
+    $AoA[$i] = \@array;         # perilous; just how my() was that array?
+    @{ $AoA[$i] } = @array;     # way too tricky for most programmers
 
 
 =head1 CAVEAT ON PRECEDENCE
@@ -247,8 +247,8 @@ Speaking of things like C<@{$AoA[$i]}>, the following are actually the
 same thing:
 X<< -> >>
 
-    $aref->[2][2]      # clear
-    $$aref[2][2]       # confusing
+    $aref->[2][2]       # clear
+    $$aref[2][2]        # confusing
 
 That's because Perl's precedence rules on its five prefix dereferencers
 (which look like someone swearing: C<$ @ * % &>) make them bind more
@@ -279,9 +279,9 @@ also disallow accidental "symbolic dereferencing".  Therefore if you'd done
 this:
 
     my $aref = [
-       [ "fred", "barney", "pebbles", "bambam", "dino", ],
-       [ "homer", "bart", "marge", "maggie", ],
-       [ "george", "jane", "elroy", "judy", ],
+        [ "fred", "barney", "pebbles", "bambam", "dino", ],
+        [ "homer", "bart", "marge", "maggie", ],
+        [ "george", "jane", "elroy", "judy", ],
     ];
 
     print $aref[2][2];
@@ -304,21 +304,21 @@ For example, given the assignment to $AoA above, here's the debugger output:
     DB<1> x $AoA
     $AoA = ARRAY(0x13b5a0)
        0  ARRAY(0x1f0a24)
-         0  'fred'
-         1  'barney'
-         2  'pebbles'
-         3  'bambam'
-         4  'dino'
+          0  'fred'
+          1  'barney'
+          2  'pebbles'
+          3  'bambam'
+          4  'dino'
        1  ARRAY(0x13b558)
-         0  'homer'
-         1  'bart'
-         2  'marge'
-         3  'maggie'
+          0  'homer'
+          1  'bart'
+          2  'marge'
+          3  'maggie'
        2  ARRAY(0x13b540)
-         0  'george'
-         1  'jane'
-         2  'elroy'
-         3  'judy'
+          0  'george'
+          1  'jane'
+          2  'elroy'
+          3  'judy'
 
 =head1 CODE EXAMPLES
 
@@ -454,10 +454,10 @@ X<hash of arrays> X<HoA>
 
  # print the whole thing sorted by number of members and name
  foreach $family ( sort {
-                           @{$HoA{$b}} <=> @{$HoA{$a}}
-                                       ||
-                                   $a cmp $b
-           } keys %HoA )
+                            @{$HoA{$b}} <=> @{$HoA{$a}}
+                                        ||
+                                    $a cmp $b
+            } keys %HoA )
  {
      print "$family: ", join(", ", sort @{ $HoA{$family} }), "\n";
  }
@@ -560,19 +560,19 @@ X<hash of hashes> X<HoH>
 
  %HoH = (
         flintstones => {
-               lead      => "fred",
-               pal       => "barney",
+                lead      => "fred",
+                pal       => "barney",
         },
         jetsons     => {
-               lead      => "george",
-               wife      => "jane",
-               "his boy" => "elroy",
+                lead      => "george",
+                wife      => "jane",
+                "his boy" => "elroy",
         },
         simpsons    => {
-               lead      => "homer",
-               wife      => "marge",
-               kid       => "bart",
-       },
+                lead      => "homer",
+                wife      => "marge",
+                kid       => "bart",
+        },
  );
 
 =head2 Generation of a HASH OF HASHES
@@ -681,12 +681,12 @@ Here's a sample showing how to create and use a record whose fields are of
 many different sorts:
 
      $rec = {
-        TEXT      => $string,
-        SEQUENCE  => [ @old_values ],
-        LOOKUP    => { %some_table },
-        THATCODE  => \&some_function,
-        THISCODE  => sub { $_[0] ** $_[1] },
-        HANDLE    => \*STDOUT,
+         TEXT      => $string,
+         SEQUENCE  => [ @old_values ],
+         LOOKUP    => { %some_table },
+         THATCODE  => \&some_function,
+         THISCODE  => sub { $_[0] ** $_[1] },
+         HANDLE    => \*STDOUT,
      };
 
      print $rec->{TEXT};