This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
More changes to perlretut
authorFather Chrysostomos <sprout@cpan.org>
Mon, 7 Mar 2011 06:28:47 +0000 (22:28 -0800)
committerFather Chrysostomos <sprout@cpan.org>
Mon, 7 Mar 2011 06:30:41 +0000 (22:30 -0800)
Mostly minor punctuation changes, but also:

• Some of the ‘new’ features are no longer new.
• Explain that \Q\L\U only apply to literal regexps, not interpolated
  ones.
• The charnames pragma is not required for \p
• The section on [:POSIX:] char classes was still explaining 5.6.

pod/perlretut.pod

index 2e3ae39..efc7f04 100644 (file)
@@ -1830,7 +1830,7 @@ too often on a hike, but when we are stuck, they can be invaluable.
 
 What follows are the more advanced, less used, or sometimes esoteric
 capabilities of Perl regexps.  In Part 2, we will assume you are
-comfortable with the basics and concentrate on the new features.
+comfortable with the basics and concentrate on the advanced features.
 
 =head2 More on characters, strings, and character classes
 
@@ -1871,12 +1871,16 @@ instance,
 It does not protect C<$> or C<@>, so that variables can still be
 substituted.
 
+C<\Q>, C<\L>, C<\U> and C<\E> are actually part of the syntax of regular
+expression I<literals>, and are not part of regexp syntax proper.  So they
+do not work in interpolated patterns.
+
 With the advent of 5.6.0, Perl regexps can handle more than just the
 standard ASCII character set.  Perl now supports I<Unicode>, a standard
 for representing the alphabets from virtually all of the world's written
 languages, and a host of symbols.  Perl's text strings are Unicode strings, so
 they can contain characters with a value (codepoint or character number) higher
-than 255
+than 255.
 
 What does this mean for regexps? Well, regexp users don't need to know
 much about Perl's internal representation of strings.  But they do need
@@ -1884,8 +1888,8 @@ to know 1) how to represent Unicode characters in a regexp and 2) that
 a matching operation will treat the string to be searched as a sequence
 of characters, not bytes.  The answer to 1) is that Unicode characters
 greater than C<chr(255)> are represented using the C<\x{hex}> notation, because
-\x hex (without curly braces) doesn't go further than 255.  (Starting in Perl
-5.14) if you're an octal fan, you can also use C<\o{oct}>.
+\x hex (without curly braces) doesn't go further than 255.  Starting in Perl
+5.14, if you're an octal fan, you can also use C<\o{oct}>.
 
     /\x{263a}/;  # match a Unicode smiley face :)
 
@@ -1963,14 +1967,14 @@ traditional Unicode classes:
     IsWord           /^[LMN]/ || $code eq "005F"
     IsXDigit         $code =~ /^00(3[0-9]|[46][1-6])$/
 
-You can also use the official Unicode class names with the C<\p> and
-C<\P>, like C<\p{L}> for Unicode 'letters', or C<\p{Lu}> for uppercase
+You can also use the official Unicode class names with C<\p> and
+C<\P>, like C<\p{L}> for Unicode 'letters', C<\p{Lu}> for uppercase
 letters, or C<\P{Nd}> for non-digits.  If a C<name> is just one
 letter, the braces can be dropped.  For instance, C<\pM> is the
 character class of Unicode 'marks', for example accent marks.
 For the full list see L<perlunicode>.
 
-The Unicode has also been separated into various sets of characters
+Unicode has also been separated into various sets of characters
 which you can test with C<\p{...}> (in) and C<\P{...}> (not in).
 To test whether a character is (or is not) an element of a script
 you would use the script name, for example C<\p{Latin}>, C<\p{Greek}>,
@@ -2001,27 +2005,26 @@ as in the word Angstrom.
 For the full and latest information about Unicode see the latest
 Unicode standard, or the Unicode Consortium's website L<http://www.unicode.org>
 
-As if all those classes weren't enough, Perl also defines POSIX style
+As if all those classes weren't enough, Perl also defines POSIX-style
 character classes.  These have the form C<[:name:]>, with C<name> the
 name of the POSIX class.  The POSIX classes are C<alpha>, C<alnum>,
 C<ascii>, C<cntrl>, C<digit>, C<graph>, C<lower>, C<print>, C<punct>,
 C<space>, C<upper>, and C<xdigit>, and two extensions, C<word> (a Perl
-extension to match C<\w>), and C<blank> (a GNU extension).  If C<utf8>
-is being used, then these classes are defined the same as their
+extension to match C<\w>), and C<blank> (a GNU extension).  If
+Unicode is enabled (see C<perlunicode/The "Unicode Bug">),
+then these classes are defined the same as their
 corresponding Perl Unicode classes: C<[:upper:]> is the same as
-C<\p{IsUpper}>, etc.  The POSIX character classes, however, don't
-require using C<utf8>.  The C<[:digit:]>, C<[:word:]>, and
+C<\p{IsUpper}>, etc.  The C<[:digit:]>, C<[:word:]>, and
 C<[:space:]> correspond to the familiar C<\d>, C<\w>, and C<\s>
 character classes.  To negate a POSIX class, put a C<^> in front of
-the name, so that, e.g., C<[:^digit:]> corresponds to C<\D> and under
-C<utf8>, C<\P{IsDigit}>.  The Unicode and POSIX character classes can
+the name, so that, e.g., C<[:^digit:]> corresponds to C<\D> and, under
+Unicode, C<\P{IsDigit}>.  The Unicode and POSIX character classes can
 be used just like C<\d>, with the exception that POSIX character
 classes can only be used inside of a character class:
 
     /\s+[abc[:digit:]xyz]\s*/;  # match a,b,c,x,y,z, or a digit
     /^=item\s[[:digit:]]/;      # match '=item',
                                 # followed by a space and a digit
-    use charnames ":full";
     /\s+[abc\p{IsDigit}xyz]\s+/;  # match a,b,c,x,y,z, or a digit
     /^=item\s\p{IsDigit}/;        # match '=item',
                                   # followed by a space and a digit