Slight update tweaks on perlunicode.pod.

[p5sagit/p5-mst-13.2.git] / pod / perldata.pod

diff --git a/pod/perldata.pod b/pod/perldata.pod
index 1744ff7..ffb47f0 100644 (file)
--- a/pod/perldata.pod
+++ b/pod/perldata.pod
@@ -271,11 +271,18 @@ integer formats:
     12345
     12345.67
     .23E-10             # a very small number
-    4_294_967_296       # underline for legibility
+    3.14_15_92          # a very important number
+    4_294_967_296       # underscore for legibility
     0xff                # hex
+    0xdead_beef         # more hex   
     0377                # octal
     0b011011            # binary
 
+You are allowed to use underscores (underbars) in numeric literals
+between digits for legibility.  You could, for example, group binary
+digits by threes (as for a Unix-style mode argument such as 0b110_100_100)
+or by fours (to represent nibbles, as in 0b1010_0110) or in other groups.
+
 String literals are usually delimited by either single or double
 quotes.  They work much like quotes in the standard Unix shells:
 double-quoted string literals are subject to backslash and variable
@@ -413,20 +420,20 @@ string may be either an identifier (a word), or some quoted text.  If
 quoted, the type of quotes you use determines the treatment of the
 text, just as in regular quoting.  An unquoted identifier works like
 double quotes.  There must be no space between the C<< << >> and
-the identifier.  (If you put a space it will be treated as a null
-identifier, which is valid, and matches the first empty line.)  The
-terminating string must appear by itself (unquoted and with no
-surrounding whitespace) on the terminating line.
+the identifier, unless the identifier is quoted.  (If you put a space it
+will be treated as a null identifier, which is valid, and matches the first
+empty line.)  The terminating string must appear by itself (unquoted and
+with no surrounding whitespace) on the terminating line.
 
        print <<EOF;
     The price is $Price.
     EOF
 
-       print <<"EOF";  # same as above
+       print << "EOF"; # same as above
     The price is $Price.
     EOF
 
-       print <<`EOC`;  # execute commands
+       print << `EOC`; # execute commands
     echo hi there
     echo lo there
     EOC
@@ -437,7 +444,7 @@ surrounding whitespace) on the terminating line.
     I said bar.
     bar
 
-       myfunc(<<"THIS", 23, <<'THAT');
+       myfunc(<< "THIS", 23, <<'THAT');
     Here's a line
     or two.
     THIS
@@ -478,6 +485,23 @@ you have to write
     the other 
     E 
 
+If the terminating identifier is on the last line of the program, you
+must be sure there is a newline after it; otherwise, Perl will give the
+warning B<Can't find string terminator "END" anywhere before EOF...>.
+
+Additionally, the quoting rules for the identifier are not related to
+Perl's quoting rules -- C<q()>, C<qq()>, and the like are not supported
+in place of C<''> and C<"">, and the only interpolation is for backslashing
+the quoting character:
+
+    print << "abc\"def";
+    testing...
+    abc"def
+
+Finally, quoted strings cannot span multiple lines.  The general rule is
+that the identifier must be a string literal.  Stick with that, and you
+should be safe.
+
 =head2 List value constructors
 
 List values are denoted by separating individual values by commas
@@ -541,7 +565,7 @@ interpolating an array with no elements is the same as if no
 array had been interpolated at that point.
 
 This interpolation combines with the facts that the opening
-and closing parentheses are optional (except necessary for
+and closing parentheses are optional (except when necessary for
 precedence) and lists may end with an optional comma to mean that
 multiple commas within lists are legal syntax. The list C<1,,3> is a
 concatenation of two lists, C<1,> and C<3>, the first of which ends
@@ -587,7 +611,27 @@ This is handy when you want to do a list assignment in a Boolean
 context, because most list functions return a null list when finished,
 which when assigned produces a 0, which is interpreted as FALSE.
 
-The final element may be an array or a hash:
+It's also the source of a useful idiom for executing a function or
+performing an operation in list context and then counting the number of
+return values, by assigning to an empty list and then using that
+assignment in scalar context. For example, this code:
+
+    $count = () = $string =~ /\d+/g;
+
+will place into $count the number of digit groups found in $string.
+This happens because the pattern match is in list context (since it
+is being assigned to the empty list), and will therefore return a list
+of all matching parts of the string. The list assignment in scalar
+context will translate that into the number of elements (here, the
+number of times the pattern matched) and assign that to $count. Note
+that simply using
+
+    $count = $string =~ /\d+/g;
+
+would not have worked, since a pattern match in scalar context will
+only return true or false, rather than a count of matches.
+
+The final element of a list assignment may be an array or a hash:
 
     ($a, $b, @rest) = split;
     my($a, $b, %rest) = @_;