Errata

The subsection "Implicit Function Parameters" should be a subsection of "Implicits", not at the same level as "Implicits".

Note from the Author or Editor:
The formatting should be changed in subsequent printings and editions

The comment that begins with // ERROR: contains text from the previous example. This line should read "//ERROR: Won't compile: List[Nothing] return type inferred for makeList"

The location reference is not accurate, and should have been:

"Views and View Bounds" on page 264

Note from the Author or Editor:
Technically, the reference is to the enclosing section, but this suggestion does narrow the reference down to the actual subsection, so we should change it. Thanks for the suggestion.

The location reference is not accurate, and should have been:

"Type Projections" on page 279

Note from the Author or Editor:
Good catch. Thanks for pointing this out.

"The second expression is equivalent to list.::(a)" is wrong. The a needs to be quoted: list.::('a')

Note from the Author or Editor:
Yes, the quotes around "a" got dropped in the production of the book.

"The only difference that a do-while checks to see if ..."

should probably read

"The only difference is that a do-while checks to see if ..."

Note from the Author or Editor:
The missing "is" is required.

The example should read

for (i <- 1 until 10)

Note from the Author or Editor:
Good catch. Thanks!
For subsequent editions and printings, change the "0" to "1" in the 2nd to last paragraph. The example earlier on the page (the "do-while-script.scala") is correct.

"This should paint a clearer picture of how Scala's internal libraries compose to form easy-to-use language constructs."

should probably read

"This should paint a clearer picture of how Scala's internal libraries are composed to form easy-to-use language constructs."

Note from the Author or Editor:
Yes, I like this suggested wording better.

Correction: I thought some more about what this text is actually intended to mean and the original wording is correct, if not completely clear. The meaning is that you can compose behavior easily using Scala library and language constructs. That is, they are good "building blocks". I suggest this rewording:

"This should paint a clearer picture of how Scala allows you to compose behavior from easy-to-use language constructs and internal libraries."

Under version 2.8.0.Beta1-prerelease, there are deprecation warnings with the source code.

The following runs without warning:
// code-examples/Rounding/enumeration-script.scala

object Breed extends Enumeration {
val doberman = Value("Doberman Pinscher")
val yorkie = Value("Yorkshire Terrier")
val scottie = Value("Scottish Terrier")
val dane = Value("Great Dane")
val portie = Value("Portuguese Water Dog")
}

// print a list of breeds and their IDs
println("ID\tBreed")
for (breed <- Breed.values) println(breed.id + "\t" + breed)

// print a list of Terrier breeds
println("\nJust Terriers:")
Breed.values.filter(_.toString.endsWith("Terrier")).foreach(println)

Note from the Author or Editor:
Yes, apparently this is an API change in 2.8. If you run the script with "scala -deprecation ...", you'll see the warnings in more detail (I wish this flag was on by default). You have to use "for (breed <- Breed.values)" instead of "for (breed <- Breed)" and similarly, "Breed.values.filter" instead of "Breed.filter" to eliminate the warnings. However, the values method isn't available in 2.7.X.

"ButtonCountObserverSpec" should probably read "ButtonObserverSpec".

It is written, "ButtonObserverSpec" in the downloaded code.

Note from the Author or Editor:
Correct, the references in the text (not the code listing) should say ButtonObserverSpec.

The description of overloading can be interpreted to mean that functions whose only difference is in the type of the returned value can be overloaded.

Note from the Author or Editor:
Thanks for pointing this out. Yes, the paragraph could be interpreted that way, which is wrong. It would be good to add an extra sentence, perhaps in parentheses, like this:
"(If the return types are different, the list of parameters must also be different.)"

Also, the word "type" should be dropped in the phrase "The signature includes the *type* name, ..."

"The signature includes the type name, the list of parameters with types, and the method's return value."

It should probably have read as:

"The signature includes the type name, the list of parameters with types, and the method's return type."

Note from the Author or Editor:
Yes, the last word should be "type".

"We mentioned companion objects briefly in Chapter 1, and we discussed
the Pair example from the Scala library in Chapter 2."

I guess "Pair" should be "Tuple". There was no Pair in Chapter2,
except the usage in the sample code during the discussion about the
Tuple .

Note from the Author or Editor:
Yes, we didn't really "discuss" Pair in chapter two, just showed it as an alternative was of defining a Tuple2. I would rephrase " and we discussed the Pair example from the Scala library in Chapter 2" as "and in Chapter 2, we briefly mentioned Pair as an alternative name for a tuple with two elements."

"First, recall that if a class (or a type referring to a class) and an
object are declared in the same file, in the same package, and with
the same name, they are called a companion class (or companion type)
and a companion object, respectively."

I guess "recall that if a class" should probably be "call a class". I
found this paragraph to be confusing because you "recall" the
companion class (or object) without having explained about it before.
Though you have referred to the name by examples, there was no
definition ever.

Note from the Author or Editor:
I found the reference to companion objects on page 19, but it doesn't really explain what they are. So, the text on 126 should not use the misleading word "recall". It would be better for this sentence to begin: "First, if a class (or a type referring to a class) and..."

The "Widget" in the regular expressions should start with a lower case "w" to be consistent with the toString method from the Widget class.

Note from the Author or Editor:
Yes, lowercase "w" would be better.

The example code should be implicit-conversions-resolution2.sc instead of implicit-conversions-resolution.sc. The difference between two example is:

implicit def overridingConversion(s: String): Foo = Foo("Boo: "+s)

Note from the Author or Editor:
Please upgrade to the latest edition.

I believe the !! is a typo and it should just be !. I through it was weird that you glossed over a new operator without explanation, but then couldn't find it anywhere in the scala api docs.

Note from the Author or Editor:
The wording is not clear in this paragraph. There really is a !! method that returns a Future object that can be queried for the reply, as described in the text. The sentence should be reworded to say:

"If you send a message to an Actor with the !! method, rather than the ! method, it will return a future. A variant of this method allows you ...".

The line "import payroll.dsl.rules_" should have a period between "rules" and "_".

"[BNF]" should probably be changed to "[EBNF]"

In the line "returns the string ... We're done!", the parser output should have been "(("Buck Trends"~(2~weeks))~List())".

The correct output is shown near the top of the preceding page (#238). But the 7th line from the bottom (on page 238 itself) also has the same typo.

Note from the Author or Editor:
Yes, this appears to be a formatting error that occurred when generating the PDF from our original text. So the line with "... We're done!" should have (("Buck Trends"~(2~weeks))~List()). And the same (...) expression should appear at the end of the 3rd paragraph from the bottom of page 238.

The output of the script should be shown after the script, so the discussion in the subsequent paragraphs makes more sense without expecting the user to run the script beforehand. The following text should appear after the example and before the next paragraph, which begins: "WhichList tries to determine the type of list passed in...":

This script prints the following output:

List[Int]
List[Double]
List[String]
List[???]
List[???]
List[???]

"AbbrevList (...) is an abstract trait" -> it is an abstract class.

Note from the Author or Editor:
Correct, it should be "class", not "trait"

The paragraph is (eliding some parts):

The type parameter means ``B is lower bounded ... view bound of B <% Node[B]. As we saw...

The ``B should be an opening double quote, followed by B and the sentence should end with the close double quote:

The type parameter means "B is lower bounded ... view bound of B <% Node[B]." As we saw...

This paragraph refers to an example later in the chapter as if it already appeared at some earlier point in the chapter. The paragraph should read as follows:

We can also use type bounds when we declare or refine the declaration of abstract types. We will see a simple example later in this chapter in "Type Projections" on page 279 where we have a declaration type t <: AnyRef. That is, t has an upper type bound (superclass) of AnyRef. AnyVal types aren't allowed.

The phrase "You can use abstract types as method arguments and return values within a function" is not precise enough. It should say "You can use abstract types as the types of method arguments and the return values of functions."

Note from the Author or Editor:
The suggested rewording should be used in future editions.

Shouldn't the first "with" in the following line of code be "extends" instead?

trait App with Persistence with Midtier with UI {

Note from the Author or Editor:
Yes, the first "with" should be "extends". Thanks for the catch.

Remove the phrase "on the JVM" from the first sentence, which begins: "If you compile this with the -unchecked flag on the JVM, you'll get warnings..."

It says "JNDI" and "JDNI". One of those is a typo ;)

Note from the Author or Editor:
OOPS! Should be "JNDI"

example-script.scala:3: error: expected class or object definition
def printMessage(msg: Message) = {
^
example-script.scala:7: error: expected class or object definition
printMessage(new Message("Must compile this script with scalac -Xscript <name>!"))
^
two errors found
-------
The compilation errors should occur in line 5 and 9.
Maybe this output might have been captured with the code before adding "// code-examples/..." filename comment.

Note from the Author or Editor:
Thanks. Your theory about why the numbers are wrong is correct ;)

"Instead, you have invoke the Other..."
should probably read
"Instead, you have to invoke the Other..."

Note from the Author or Editor:
Thanks for finding this typo!

"ScalaCheck ([ScalaCheckTool] is a Scala port of the innovative Haskell QuickCheck ([QuickCheck]) tool that supports..."
should probably read
"ScalaCheck ([ScalaCheckTool]) is a Scala port of the innovative Haskell QuickCheck ([QuickCheck]) tool that supports..."
i.e. The closing parensis for "([ScalaCheckTool]" is missing.

Note from the Author or Editor:
Thanks for pointing out this typo.

"The toD function just converts an Int to a Double by dividing by 0.1."
should probably read
"The toD function just converts an Int to a Double by multiplying by 0.1.",
as the corresponding code is "def toD(i: Int) = i * .1".

Note from the Author or Editor:
Doh! Yes, it's multiplication.

"Two more [_Fc_]specify[_/Fc_] classes assert that..."
should probably read
"Two more [_Fc_]specify[_/Fc_] clauses assert that..."
as they are not classes but clauses.

Note from the Author or Editor:
Yes, this is correct. Thanks!

Is the last line of p. 382 and the first line of p. 383 a formatting error? It seems like half the URL is duplicated.

Note from the Author or Editor:
Actually, it looks correct to me. It would have been nice if the <beans> tag wasn't split across too pages.

"The constructor tag specifies that ..."
should probably read
"The constructor-arg tag specifies that ..."
as the example XML contains constructor-arg tag and works fine.

Note from the Author or Editor:
Good catch. Thanks!

"... SMR (see [SMRa] and ([SMRb])."
should probably read
"... SMR (see [SMRa] and [SMRb])."
as an extra open parenthesis exists before [SMRb].

Note from the Author or Editor:
Yes, thanks for the catch.

"That is, each nonterminal can appear by itself on the lefthand side of the production the specifies it"

should be


"That is, each nonterminal can appear by itself on the lefthand side of the production that the specifies it"

Note from the Author or Editor:
Correct, replace the last "the" with "that":

"... of the production that specifies it"

"FunctionN[-T1, T2, ..., TN, +R]" should be "FunctionN[-T1, -T2, ..., -TN, +R]", as not only T1 but all arguments need contravariance.
For example, the definition for N = 11 is following.
trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R]

Note from the Author or Editor:
Great catch. As described in the bug report, all the "T" types need a minus sign in front of them.

The font style of "Actor model of concurrency" is italic except the first "A". Probably all of these characters might be in italic.

Note from the Author or Editor:
Yes, it appears the "A" isn't italicized. Thanks for pointing this out.

"except for the lack of constructor parameters and auxiliary parameters"
should probably read
"except for the lack of constructor parameters and auxiliary constructors",
as it might mean that the object has no constructors, and the term "auxiliary parameters" does not occur anywhere else.

Note from the Author or Editor:
Doh! Yes, it should be "constructors", not "parameters". Thanks for the catch.