Errata

The first sentence of the 3rd paragraph ends "... even to the point that it's main implementation goes by the name Rakudo."

It should read "... that its main implementation ..." [it's --> its]

The word "it's" (with an apostrophe) is the contraction of "it is" or "it has". The word "its" (without an apostrophe) is the possessive form. In fact, not one of the possessive pronouns or adjectives in English is ever written with an apostrophe.

<aside>
Another popular error these days is to use "who's", which is the contraction of "who is" or "who has", instead of "whose", which is the relative possessive pronoun.
</aside>

Note from the Author or Editor:
Change as noted.

but a variable you use throughout a program should probably have a more descriptive name to not only remind you want [what] it does, but let other people know what it does

Note from the Author or Editor:
In the second to last line on p.30, "you want" should become "you what". This is the last sentence in the first paragraph of "Choosing Good Variable Names".

"programmers? text editor"

should be

"programmer?s text editor"

Note from the Author or Editor:
Change as noted

rule in Perl: as long you don�t change the meaning by removing the parentheses,

should be:

rule in Perl: as long _as_ you don�t change the meaning by removing the parentheses, (emphasis with underscore)

Note from the Author or Editor:
Change as noted

@array = qw( pebbles dino fred barney betty );
@removed = splice @array, 2; #remove everything after fred
# @removed is qw( fred barney betty )
# @array is qw( pebbles dino)

Shouldn't the first comment read "#remove fred and everything after" since "fred" is removed as well.?

Note from the Author or Editor:
Change as noted

On page 56, second paragraph, there's a part explaining the different results from 2*3 and 2x3 and it says "The first gives you 8" which is wrong. 2*3 is 6 I believe unless you meant 2**3 which is actually 8 but then you have to correct 2*3 to 2**3.

Note from the Author or Editor:
Change "The first gives you 8 while the second gives you 222" to "The first gives you 6 while the second gives you 222"

The * in 2*3 is numeric multiplication, while the x in <2x3> is string replication. The first
gives you 8 ....

Should be 6 instead of 8.

This error has already been reported for the pdf Format.

Note from the Author or Editor:
Change as noted

On page 65, towards the bottom, you have the sentence:

"You normally take in those sorts of statements when you�re ready to deploy
your program."

I think perhaps you meant to say "take OUT".

Note from the Author or Editor:
Change as noted

"can't open wimla: No such file or directory"

should be

"can't open wilma: No such file or directory"

Note from the Author or Editor:
Fixed in the sources

Change "zero or one arguments" to "zero or one argument".

Note from the Author or Editor:
Change as noted unless it breaks house style.

"Perl realizes that $fh is a filehandle"

should be

"Perl realizes that $rocks_fh is a filehandle"

Note from the Author or Editor:
Fixed in the sources

$hash{ bar.foo } = 1; # that's the key 'foobar'

should be:

$hash{ bar.foo } = 1; # that's the key 'barfoo'

Note from the Author or Editor:
Change as noted.

if (/\p{Digit}/) { # 411 different possible characters

should be (because of update for Perl 5.14 with Unicode Version 6.0.0):

if (/\p{Digit}/) { # 420 different possible characters

More information:
http://perldoc.perl.org/perluniprops.html
http://unicode.org/cldr/utility/list-unicodeset.jsp?a=[:General_Category=Decimal_Number:]

Note from the Author or Editor:
Update as noted.

"Even under Unicode semantics, the \s still doesn?t match the vertical tab, next line, or nonbreaking space."

That seems to be untrue in Perl 5.14:

#!/usr/bin/perl -w
use 5.014;
use charnames qw(:full);

my @chars = ("\N{LINE TABULATION}", "\N{NO-BREAK SPACE}", "\N{NEXT LINE}");
foreach (@chars) {
if (/\s/u) { # Unicode semantics explicitely by /u
printf "%s is matched\n", charnames::viacode(ord);
}
}

Result is (that is, only vertical tab is unmatched):

NO-BREAK SPACE is matched
NEXT LINE (NEL) is matched

Note from the Author or Editor:
I shouldn't have used "semantics" in the footnote because I wasn't considering the /u. The footnote really refers to the Unicode Space property.

there is:

"just like you did with /d:"

should be:

"just like you did with \d:"

Also you might consider dropping unnecessary square brackets on previous page (129), that is "/HAL-[\d]+" into "/HAL-\d+" (two occurences in code examples on that page).

Note from the Author or Editor:
Change the /d to \d, but leave the other suggestions as is.

The comment says that character class [\v\h] is the same as \p{Space} (which is true), but it also says that "it is no more than \s".

I would rather say, that it is quite opposite way: no less than \s, because \s:

- lacks vertical tab in older (pre 5.18) versions of Perl
- it's restricted to ANSI subset when /a modifier is turned on
- can be narrowed by locale modifier /l (note that \p{Space} does not care about locale)

Note from the Author or Editor:
This is true, but with the seventh edition coming out, I'll make the change there. Which is, no change.

Text is "Make a program that prints each line that has a two of the same nonwhitespace
characters next to each other."

The "a" before "two" should be removed.

Note from the Author or Editor:
Change as noted

U+0OBC is 1&#8260;4

should be:

U+00BC is 1&#8260;4

Note from the Author or Editor:
Change as noted. It should be all zeroes in that bit of code.

the pattern would look like /^(fred(barney)/

should be:

the pattern would look like /\A(fred(barney)/

Note from the Author or Editor:
Change as noted

if (/\s(\[a-zA-Z]+),/) { # capture the word between space and comma

should be (just without backslash before '['):

if (/\s([a-zA-Z]+),/) { # capture the word between space and comma

Note from the Author or Editor:
Remove slash in front of square brace.

you use \k<label:

should be:

you use \k<label>:


and, the footnote has the same issue:

A \k<label is slightly different

should be:

A \k<label> is slightly different

Note from the Author or Editor:
Change as noted

See ?Answers to Exercises? on page 306 for answers to the following exercises.

should be (also with proper hyperlink to page 308 instead of 306):

See ?Answers to Exercises? on page 308 for answers to the following exercises.

Note from the Author or Editor:
This is the link from the Chapter 8 exercises to the Chapter 7 answers. The link should be from the Chapter 8 exercises to the Chapter 8 answers, on page 308.

For example, if the input string says I
saw Wilma yesterday, the up-to-five characters are ?yest?.

should be:

For example, if the input string says I saw Wilma yesterday, the up-to-five characters are ? yest?.

Note from the Author or Editor:
Fixed in the source. Thanks.

Change "Set::Crossproduct" to "Set::CrossProduct".

Note from the Author or Editor:
Change as noted

Change "brian" to "fred".

Note from the Author or Editor:
Change as noted

print $dt->ymd(''); # 20010423

should be

print $dt->ymd(''); # 20110423

Note from the Author or Editor:
Change as noted. The year should be 2011

"In Perl, you use the unlink operator with a list of the file that you want to remove"

should be

"In Perl, you use the unlink operator with a list of the files that you want to remove"

So the comparison is $score{"fred"} <=> $score {"barney>"},

should be:

So the comparison is $score{"fred"} <=> $score {"barney"},

Note from the Author or Editor:
There's an extra > in that inline code. Remove it.

"When you finds one that does match"

should be

"When you find one that does match"

It is peculiar that this exact text appears in the previous edition without the typo.

Note from the Author or Editor:
Change as noted. Fixed in the repo.

In the paragraph starting with

"What if you have tow scalar variables? ..."

the scalar variables used in the code are called $fred and $barney. However, in the explanation following the code snippet, they are referred to as $scalar1 and $scalar2.

Note from the Author or Editor:
Change $scalar1 and $scalar2 to $fred and $barney as noted. This is in the paragraph immediately before the section heading "The given statement"

The last sentence of the last paragraph says ( underscores only for emphasis):

"Each when block reports a different way that it found Fred, starting with the _least restrictive to the most_."

Assuming that you are using the second code snippet from the following page (253), and not the first (which does not seem to have any specific order), the sentence should mention "most restrictive to the least" instead.

<aside>
Sorry if this has been already fixed from aphilipp's reports.
</aside>

Note from the Author or Editor:
Change to "least restrictive to most" as noted.

Example #1:
==========
given ( $ARGV[0] ) {
when ( 'Fred' ) { say 'Name is Fred' }
when ( /fred/i ) { say 'Name has fred in it' }
when ( /\AFred/ ) { say 'Name starts with Fred' }
default { say "I don't see a Fred" }
}

Example #2:
==========
given( $ARGV[0] ) {
when ( $_ ~~ 'Fred' ) { say 'Name is Fred' }
when ( $_ ~~ /\AFred/ ) { say 'Name starts with Fred' }
when ( $_ ~~ /fred/i ) { say 'Name has fred in it' }
default { say "I don't see a Fred" }
}

The second example is supposed to be a rewrite of the first example, with the only difference being the use of explicit smart matching. But looking carefully, one can see that the second and third when conditions are reversed. Because of this, the output from each example can be different (as shown below).

Output for Example #1:
==================
$ perl5.10.1 switch.pl Frederick
Name has fred in it

Output for Example #2:
==================
$ perl5.10.1 switch.pl Frederick
Name starts with Fred

Also, the above example code is used as the basis for further examples throughout the remainder of this chapter. So any corrections to the above mentioned code should probably be applied to the rest of the chapter.

Note from the Author or Editor:
Fixed in the sources. Thanks,

The following is the example code that corresponds to the text that is at issue:

given ( $ARGV[0] ) {
when ( $_ ~~ 'Fred' ) { say 'Name is Fred'; break }
when ( $_ ~~ /fred/i ) { say 'Name has fred in it'; break }
when ( $_ ~~ /\AFred/ ) { say 'Name starts with Fred'; break }
default { say "I don't see a Fred"; break }
}

The above code does not agree with the text. This example does not go from general to specific. It is untrue that Perl doesn?t test any of the when conditions if the argument matches /fred/i. The when condition "if the argument is exactly Fred" does in fact get checked because it is the second when block that stops the entire control structure.

As this paragraph was borrowed from the 5th edition, I suspect that it was not updated to reflect changes made to the example code. The other possibility is that some of the lines in the example code are not in the correct order (as pointed out in the errata submission for page 252).

Note from the Author or Editor:
Fixed in the sources

The "# OOPS!" comment next to the first when block should be deleted.

Note from the Author or Editor:
Fixed in the sources

Code Example #1
==============
given ( $ARGV[0] ) {
when ( $_ ~~ 'Fred' ) { say 'Name is Fred'; break }
when ( $_ ~~ /fred/i ) { say 'Name has fred in it'; break }
when ( $_ ~~ /\AFred/ ) { say 'Name starts with Fred'; break }
default { say "I don't see a Fred"; break }
}

Paragraph #1
===========
This doesn't work very well for the problem, though. Since our example goes from specific to general, if the argument matches Fred, Perl doesn't test any more of the when conditions. I don't get to check if the argument is exactly Fred because the first when block stops the entire control structure.

Code Example #2
==============
given ( $ARGV[0] ) {
when ( $_ ~~ 'Fred' ) { say 'Name is Fred'; continue }
when ( $_ ~~ /fred/i ) { say 'Name has fred in it'; continue }
when ( $_ ~~ /\AFred/ ) { say 'Name starts with Fred'; continue } # OOPS!
default { say "I don't see a Fred" }
}

Discussion
=========
The order of the when conditions in these code examples is not consistent with the other examples in this section. I assume that the order should be as follows:
when ( $_ ~~ 'Fred' )
when ( $_ ~~ /\AFred/ )
when ( $_ ~~ /fred/i )

Paragraph #1 does not seem to be well adapted since the previous edition. Previously, the order went from general to specific. Because of this, it made sense to call attention to the fact that none of the other when conditions are tested if the argument matches /fred/i. But because we are now going from specific to general, it not longer seems meaningful. For example, if the argument matches Fred, then there is no need to test any of the other when conditions since we already know that they would match.

Also, the last sentence in the paragraph #1 is no longer applicable and should probably be removed.

Note from the Author or Editor:
That's probably a good idea

Page 254 in the 7th Edition and 246 in the 6th

Line 5 in the code is

$personal_name{$a} cmp $family_name{$b} or

but it looks like it should be

$personal_name{$a} cmp $personal_name{$b} or

Note from the Author or Editor:
Yes, those should be the same hash as noted

Actually is:
when ( ! /\A-?\d+\.\d+\z/ ) { #smart

Should be:
when ( ! /\A-?\d+\.\d+\z/ ) { #dumb

Since "Negated expressions, including a negated regular expression, don?t use a smart match either." (top of Page 256)

Note from the Author or Editor:
Change as noted

The main logic in the code examples is as follows:

foreach ( @names ) {
when ( /fred/i ) { say 'Name has fred in it'; continue }
when ( /\AFred/ ) { say 'Name starts with Fred'; continue }
when ( 'Fred' ) { say 'Name is Fred'; }
default { say "I don't see a Fred" }
}

It logically makes more sense to reverse the order of the when conditions. By putting the general when condition at the bottom, we ensure that the default does not get invoked when any of the when conditions are true. This can be illustrated as follows:

foreach ( @names ) {
when ( 'Fred' ) { say 'Name is Fred'; continue }
when ( /\AFred/ ) { say 'Name starts with Fred'; continue }
when ( /fred/i ) { say 'Name has fred in it'; }
default { say "I don't see a Fred" }
}

Also, the above change would make the logic consistent with the other examples in the chapter.

Note from the Author or Editor:
That's probably a good idea.

This is the sentence:

"The pipe opens can also take more than three commands."

Change "commands" to "arguments".

Note from the Author or Editor:
Change as noted

"If the keyword eval doesn't come directly before a block of code in curly braces, as you saw for most of this section, there's no need to worry - that's the safe kind of eval."

should be

"If the keyword eval comes directly before a block of code in curly braces, as you saw for most of this section, there's no need to worry - that's the safe kind of eval."

Note from the Author or Editor:
Fixed in the source

It then goes back to @family

should be:

It then goes back to @abc

Note from the Author or Editor:
Change as noted

"It then goes back to @family to get its next element,..." should read "It then goes back to @abc to get its next element,..."

Note from the Author or Editor:
The printed book has this mistake, but my sources don't. That's odd. It's correct in the current sources.

Some of the elements of @large_array contain the undef value. Therefore the following change should be made:

a 1 dino b 2 c 3 ...

should be

a 1 dino b 2 undef c 3 ...

Note from the Author or Editor:
There should have been two spaces after the 2. I've also added a short paragraph after that output to explain it.

In the solution to Chapter 9 Exercise 2, the text refers to bareword filehandles IN and OUT. But the corresponding code uses scalar variables $in_fh and $out_fh to store the filehandles. The text should correlate with the code.

Note from the Author or Editor:
Fixed in the source.

"Once the filehandles $in and $out are opened, the real program can begin."

should be

"Once the filehandles $in_fh and $out_fh are opened, the real program can begin."

Note from the Author or Editor:
Fixed in the sources

Exercise 1 on page 201 asks to print a list of all of the modules that came with Perl 5.14. Therefore the following change should be made to the solution on page 313.

my %modules = %{ $Module::CoreList::version{5.006} };

should be

my %modules = %{ $Module::CoreList::version{5.014} };

Note from the Author or Editor:
Fixed in repo as noted.

Page 247 explains that smart matching is broken in Perl 5.10.0 and that most of the problems disappeared in Perl 5.10.1. To be consistent with the examples presented in Chapter 15, the following change should be made to the exercise solutions:

use 5.010;

should be

use 5.010001;

Note from the Author or Editor:
Fixed in sources.

sub my_usr2_handler { say 'Caught INT. Exiting.'; exit }

should be

sub my_int_handler { say 'Caught INT. Exiting.'; exit }

Note from the Author or Editor:
Fixed in the sources, thanks.

chomp(my @strings = <FILE>);

should be

chomp(my @strings = <$fh>);

Note from the Author or Editor:
Fixed in the sources.

"has a strftime subroutine the takes"

should be

"has a strftime subroutine that takes"

This is the sentence:

"In Chapter 16, we mentioned the map and grep list-processing operators."

Change "Chapter 16" to "Chapter 17".

Note from the Author or Editor:
Change as noted

"while the "yay" message should"

should be

"while the "yay" messages should"

In the right part of the image it says
SMALL LETTER A, U+00E4
It should be
SMALL LETTER A, U+0061

Note from the Author or Editor:
Change as noted

"DIAERESIS, U+00A8"

should be (because of NFD transformation):

"COMBINING DIAERESIS, U+0308"

Note from the Author or Editor:
Change as noted

Actually is:
The NFKD forms miss the compatible equivalents:

Should be:
The NFD forms miss the compatible equivalents:

Note from the Author or Editor:
Change as noted

Reading from or Writing to STDOUT or STDERR

should be:

Reading from STDIN or Writing to STDOUT or STDERR

Note from the Author or Editor:
Change as noted

/a modifier, 136

should be

/a modifier, 129, 136

Note from the Author or Editor:
The /a modifier index entry should be modified as noted.

The following should be added to the index:

readlink function, 228

Note from the Author or Editor:
Change as noted

The following should be added to the index:

/r modifier, 158

Note from the Author or Editor:
There should be an index entry for /r, as noted

Fifth Edition

should be:

Sixth Edition

Note from the Author or Editor:
Change as noted

"He was been an instructor and author"

should be

"He was an instructor and author"

Note from the Author or Editor:
In the "About the author" for brian, change "He was been" to "He was", as noted.