During Day 2 of Io the reader is suddenly told to "Think of doMessage as somewhat like Ruby's eval". eval however was never mentioned any where in the Ruby section an far as I could see. Which can cause readers to stumble a bit. The explanation of what eval is follows in the next sentence, but it's a bit weird to suddenly learn eval first after you are told to think of something else as eval.

The examples of functions with associated code blocks (e.g. "in_case_of_emergency") shows the named block defined before the function. This will not work; the block needs to come afterward, e.g.

def foo
...code goes here...
yield
...more code...
end

foo do
...code that runs when we call yield
end
--Steven

In the 3rd paragraph of the "I Won’t Be Your Programming Reference" section, "I will walk you through examples in each languages" should be "I will walk you through examples in each language".--Dan Parson

You list the "logical operators" | and & as behaving more or less like || and && but without shortcutting.

This is incorrect. | and & are the bitwise operators and the only reason they can behave somewhat like || and && in some circumstances is due to the specific types you have been comparing and how they have these operators implemented.

It is misleading not to specifically refer to these as the bitwise operators.--Oliver Hookins

In the check out code of Duck Typing when discussing the type system the example
>>a = ['100', 100.0] returns ["100", 100.0] not ['100', 100.0]--IshtarIS

You describe "methods that test" as those that end in a question mark. I think you can be clearer than that about this Ruby idiom.

Specifically, methods that are expected to return a boolean are expected to end in a question mark. You could probably combine the description to include both ideas - testing something and the expectation of a boolean return value.--Oliver Hookins

The attr keyword defines an instance variable. Several versions exist. The most common are attr (defining an instance variable and a method of the same name to access it)…

Presumably this should be attr_reader rather than attr?--Vincent Bray

The first paragraph says "Create a list like this" then shows the method 'list'.

Then there's a paragraph explaining that there's a shortcut method 'list', which we've already seen.

The first code example should probably use 'toDos := List clone' then append values.--Michael Bannister

In "What We Learned in Day 3" for Io (Chapter 3), it states "Next, we built an XML generator that used /method_missing/ to print XML elements." however it was Io's /forward/ that was used, and while a previous heading was called "Io's missing_method" (p.67) and went on to say "You can use the /forward/ message in the same way that you would use Ruby's /missing_missing/" (p.68) it seems a mistake to still refer to the Ruby construct in the Io summary. --Ciarán

> "The coroutines differed from concurrency in languages like Ruby, C, and Java because threads could only change their own state, leading to a more predictable and understandable concurrency model and less of a need for blocking states that become bottlenecks."

This sentence is confusing. Coroutines are compared to threads, which are "leading to a more predictable and understandable concurrency model …" (?), but a few sections back it was said that threads are harder to use and debug (true).
* Is that quoted part related to coroutines?
* Or it seems that "actors" should be used instead of "threads" there, which is also confirmed in the Actors section on p.74.
* Is it possible to rephrase the sentence?

Thanks.--eugene

When you call `postOffice messageTarget` it should report back the `postOffice` object memory address: `Object_0x100444b38`. It currently reports `Object_0x1004ce658`, which is incorrect.--Marc Soda

In the prolog example, map.pl, there is:
different(Mississippi, Alabama),
...
different(Alabama, Mississippi)
...

Isn't that redundant?--Arjen Dijkstra

The definition of the friend rule works for very simple queries, but gives unexpected results when querying with an unbound variable (e.g. asking "who is the friend of wallace?":

?- [user].

|: likes(wallace,cheese).
|: likes(grommit,cheese).
|: likes(wendolene,sheep).
|: friend(X,Y):- \+(X = Y),likes(X,Z),likes(Y,Z).
|: % user://1 compiled 0.01 sec, 1,720 bytes
true.

?- friend(wallace,grommit).
true.

?- friend(wallace,X).
false.

This is because the "\+(X = Y)" clause comes before the X and Y variables are bound to possible values by the "likes" statements. If the order of the clauses is changed, the query works:

?- [user].

|: likes(wallace,cheese).
|: likes(grommit,cheese).
|: likes(wendolene,sheep).
|: friend(X,Y):- likes(X,Z),likes(Y,Z),\+(X = Y).
|: % user://2 compiled 0.01 sec, 480 bytes
true.

?- friend(wallace,grommit).
true.

?- friend(wallace,X).
X = grommit ;
false.

These examples use SWI Prolog, but I received the same results with GNU Prolog.--Rob

In the Prolog code for map.pl on page 83, since the three colours are defined as being different through symmetric relations, there seems to be an unneeded line of code in the rule for coloring:

different(Alabama, Mississippini),

It's the only instance of a symmetrically relational subgoal in the rule, all others having been omitted.--Ciarán

Typo with foreach->forEach; "we iterate through the phone numbers in the list with forEach" should be "we iterate through the phone numbers in the list with foreach".--Ben Moon

In the explanation of the concatenate example
<code>
concatenate([], List, List).
concatenate([Head|Tail1], List, [Head|Tail2]) :-
concatenate(Tail1, List, Tail2).
</code>
you talk about List1, List2 and List3 which refers to
<code>concatenate(List1, List2, List3)</code> mentioned earlier. This is for the poor beginner, who tries to understand the logic way of doing things for the first time, extremely confusing. Would be better to either have a consistent naming or a completely different one.

Otherwise: thank you for this very valuable book!--Martin

In section "Classes in Scala": class Person(firstName: String, lastName: String) doesn't result in a class with firstName and lastName attributes, as the text says. It merely results in a class whose constructor takes two arguments but doesn't do anything with them.

To get attributes, "val" must be added in from of the two parameters. Otherwise readers will be confused that they cannot access the supposed attributes if they experiment with the example:

scala> class Person(firstName: String, lastName: String)
defined class Person

scala> val gump = new Person("Forrest", "Gump")
gump: Person = Person@43900f17

scala> gump.firstName
<console>:10: error: value firstName is not a member of Person
gump.firstName
^

with val though:

scala> class Person(val firstName: String, val lastName: String)
defined class Person

scala> val gump = new Person("Forrest", "Gump")
gump: Person = Person@707cdc58

scala> gump.firstName
res1: String = Forrest--Robin

def turnRight() {
bearing = (bearing + 1) % directions.size
inform("right")
}

Should be:
def turnRight() {
bearing = (bearing + (directions.size + 1)) % directions.size
inform("right")
}--Eric T.

In scala/employee.scala: Using "override val" for the name attribute in Employee is not necessary. It's easier to write it like this:

class Employee(name: String, val number: Int) extends Person(name) {
...
}

This results in the Employee constructor taking the names as an argument and passing it on to Person, where it will live as a field.

If you use override val, it results in an override of the public getter method, which is not necessary as Person already provides that.

The same thing for scala/nice.scala, this way is much better:

class Character(name: String) extends Person(name) with Nice--Robin

In scala/employee.scala: "id():String" isn't recommended style, the colon should always be followed by a space. It's right most of the time, but it's not consistent (it looks unclean).

Other examples of missing space after colon is in scala/nice.scala, on page 151. Maybe other places, but I'm not yet as far :).--Robin

In the description of the sort example it is said "that will yield a case-insensitive sort".
This is not true as the comparison is only performed on the first character of each word--Norbert Müller

(Note that the page# is a guess based on other submissions since I'm reading the Kindle version.)

Under "What We Learned in Day 2", in the fourth paragraph, the second sentence reads:

"We also used count, isEmpty, and first methods for obvious purposes."

I looked manually and searched via the search function, but could find no example of a method named "first" being used.--Glenn

Inconsistent formatting and syntax highlighting
Code example not prefaced with "scala >" prompt

val hobbits = Set("frodo", "samwise", "pippin")
should be
scala> val hobbits = Set("frodo", "samwise", "pippin")

In getPageSizeConcurrently() 'actor' is used but not explained. I guessed that it's a factory method in Actor (since that's a new import not found in the 'kids' example on p.157) that creates an instance of Actor with the code block argument as the act() method and calling start on it...
--Ajit Dingankar

In the first paragraph of the Scala subsection titled "Concurrency" (bottom of the page numbered 167 on the page in the PDF --- my reader thinks it's page 163), you've a sentence "Often, the actor uses a pattern matcher to detect the message and perform the appropriate message." I think the last word should be "action". Also, "classify" might be more appropriate than "detect", but that's a minor preference.

Thanks for writing the book!--Conrad Hughes

4 + "string".
"Unlike Scala, there's no coercion between strings and ints."

Yes, but the example is misleading since + doesn't concatenate strings, e.g.
"4" + "string".
yields the same exception.--Jerry Morrison

{comic_strip, {name, "Calvin and Hobbes"}, {character, "Spaceman Spiff"}}.
"We've represented a hash for a comic strip."
...
"If you are used to Ruby or Java-style hashes, it may seem strange to have the initial atom ..."

The code shows a way to represent key-value associations but I don't think there's any hashing going on here. The order of key-value pairs matters and a key may appear multiple times. Can it look up values by key?

The initial atom is a simple way to indicate type information (what Scala does with case classes) and indeed it doesn't fit the hash table concept.--Jerry Morrison

Clojure: Under the Booleans and Expressions section, you give an example of
(= 1 1.0)
and in the example, it evaluates to true. When I run the example on my machine, it evaluates to false. --Brad Cantin

The definition of left and right function on SimpleCompass can be improved by omitting the redundant SimpleCompass creation. At least as of Clojure 1.6.0 (which I am using), the functions could be simply "(left [_] (turn bearing 3))"

In "you’ll define a higher-order function with the fn function", "higher-order" should be "anonymous". Using "fn" always defines an anonymous function which may or may not be higher order. Higher-order function may also be defined using "defn". In fact your example using fn is not higher-order.--art gittleman

Section: Infinite Sequences and take

Perhaps it's a language change in Clojure 1.3, but the fib-pair example as written gets an ArithmeticException integer overflow. Starting iterate with [1N 1N] gets it to happily use BigInt values.

BTW there's no need to map first over all the iterated values -- it's enough to take the first of the nth pair -- but maybe you wrote it that way to demonstrate that map works on infinite sequences.

Is it typical Clojure code to compute one more fibonacci number than needed vs. returning the second element of the previous fib-pair?--Jerry Morrison

On line 4-5
(SomeType.arg) means fire the constructor for SimpleCompass, binding arg to the first parameter.

should be

(SomeType.arg) means fire the constructor for SomeType, binding arg to the first parameter.
--Norbert Müller

Generating the 500th Fibonacci number using the following code:

(nth (map first (iterate fib-pair [1 1])) 500)

will not work, since the integer values will overflow. You get an error like this:

ArithmeticException integer overflow clojure.lang.Numbers.throwIntOverflow (Numbers.java:1388)

In order to successfully generate the number, the BigInt type must be explicit with [1N 1N] as the initial values:

user=> (nth (map first (iterate fib-pair [1N 1N])) 500)
225591516161936330872512695036072072046011324913758190588638866418474627738686883405015987052796968498626N

This is using Clojure 1.5.1 on Java 1.6--Oliver Hookins

"We grab n elements from the infinite sequence (iterate inc 1). Then we take n of them and multiply them together with apply *."

There seems to be a redundancy between these two sentences - we "grab n elements" and THEN "take n of them"? The inner function is not grabbing n of anything, it is starting generation of infinite elements lazily, and the only time we start limiting this is at "take n".--Oliver Hookins

One of the titles used in "Working with Atoms" does not match. "Seven Languages" becomes "Seven Languages in Seven Weeks".

user=> (swap! top-sellers conj {:title "Seven Languages", :author "Tate"})
[{:title "Seven Languages in Seven Weeks", :author "Tate"}]
--Christophe Verre

You have written:
---
You can verify that entering (String. "new string") into the repl returns the new string "new string".
---

Entering that text into the repl does absolutely nothing to verify that it actually returns a new string, as it just returns the string in question.

Perhaps you could add some more code to make it a bit more clear, for example:

user=> (identical? "new string" "new string")
true
user=> (identical? (String. "new string") "new string")
false
--Oliver Hookin

This page says:

"[...] if/then/else statement"

and later:

"In Haskell, if is a function"

Both are wrong -- 'if/then/else' is an expression with special syntactic support. --Matt Fenwick

"[...] use the let function [...]"

let is not a function.

"in Haskell, let binds a variable to a function"

'function' should be replaced by 'value', as is shown in the following example.--Matt Fenwick

foldl1 only takes a function and a list. The example in the middle of the page provides 0 as an initial value to foldl1. Removing the zero makes the example work.--Eric Andres

There is a discrepancy between the two implementations of the Fibonacci sequence on pages 262-263 of the UK edition.

The 1st fib implementation prints out the nth Fibonacci number like a zero based array (write out the 1st 10 numbers starting with a 0). For example fib 10 returns 89, which is the 11th Fibonacci number. The 'x' in the fibTuple is the correct fibonacci number though.--Tom Kealy

"Haskell includes first-class ranges and some syntactic sugar to support them"

Ranges are not first-class, they're just sugar for calls to functions from the Enum typeclass.--Matt Fenwick

Two issues [page 276-277]
The composition operator [pg276] is misused; "foo(bar x)" would be "(foo . bar) x". "(foo x).(bar x)" can be written "(foo <*> bar) x" using applicatives, but that goes beyond the scope of the section.

Second, the starter 'monad' example [pg277] is also applicitive functor-ish rather than monad-ish. '>>==' and 'rtn' are typed 'Position a -> Position a'; to be monadic they must be type 'a -> Position a'

Evaluation in a 'do' block is enforced by composition, but it is not the same as stringing functions together with the compose operator; if "(bar . foo) x" is valid for a monadic x, then the equivalent bind would be "return x >>= foo . return >>= bar . return".--Ryan Domigan

Instead of
"foldl1 (+) 0 [1 .. 3]"
it should either read
"foldl (+) 0 [1 .. 3]"
or
"foldl1 (+) [1 .. 3]"

Anyway, it might be a good idea to shortly discuss the difference between foldr/foldl and foldr1/foldl1 or leave out the latter version. IMO this difference is not related to the application of an operator, e.g. (+), in contrast to an anonymous function.--Kay-Uwe Kirstein

Wrong order of arguments in 'foldl (\x carryOver -> carryOver + x) 0 [1 .. 10]'

The order and the following explanation would be correct for foldr but has to be reversed for foldl.

(Of course, it does not really matter for this particular function. Replace 'x' with '2 * x' to see the difference).

at the top of the page:

"the types that each statement returns"

Those are expressions, not statements. Also, expressions do not return types.--Matt Fenwick

"That means that the type Boolean will have a single value, either True or False."

I think I get what this is saying, but it's confusing, and taken literally is wrong -- the type Boolean has two values.--Matt Fenwick

No one knows what is being asked in the Lazy sequence problem. It specifies function composition where the functions to work with have int -> [int] types.

"Haskell allows us to chain let expressions together and express the final form in an in statement."

The example doesn't show chained let expressions -- it shows a single let expression.

There is no such thing as an 'in statement'. That is part of the syntax of let expressions.--Matt Fenwick

"Monads let you simulate program state."

Many monads have nothing to do with state. This seems to imply that monads are only/best for stateful patterns.

"do syntax allows programs in the imperative style."

'Do syntax' also allows non-imperative programs when working with other monads. Also, such programs can always be written without 'do syntax'.

A monad has "a type constructor that's based on some type of container."
(p. 290) "type that can hold a value"

Many people (myself included) find this intuitive explanation actually makes it harder to grok monads. The problem is that some monads act like containers, and some don't.--Matt Fenwick

"return wraps up a function into a monad"

'return :: Monad m => a -> m a'. It injects any value, not just functions, into the monad.

">>= unwraps a function"

Same thing.--Matt Fenwick

As mentioned in the 2nd monad law, "m >>= return = m". However, both the treasureMap example on p. 291 and the last example on p. 294 make the mistake of using "m >>= return" instead of simply "m".

If return needs to be demonstrated, it should be a useful example.--Matt Fenwick

Just is not a type. It is a function of type ':: a -> Maybe a'.

The examples at the top of the page are confusing. They should probably be:

Prelude> Just "some string" :: Maybe String
...
Prelude> Nothing :: Maybe String
...

This shows that there can either be a value or not. However, "Just Nothing" is of a totally different type than 'Just "some string"'.

"The bind is also easy. For Nothing, it returns a function returning Nothing. For Just x, it returns a function returning x."

The Maybe implementation of >>= does not return a function.--Matt Fenwick

"The fully polymorphic template system"

The type system is not a template system. Although there is something separate and unrelated called Template Haskell.--Matt Fenwick

You say "... class will be much more difficult to debug because Ruby can no longer tell when a method is missing. We would definitely want strong error checking to make sure it was accepting valid Roman numerals."

But, adding a line such as

return super if (!name.to_s.match(/[IVXLC]+$/))

first thing in the method_missing definition, Ruby will be able to handle the missing methods just fine.

The problem of finding the definition of the methods remains, of course.

I'd personally strip the quoted lines from that paragraph and add them as an introduction to an exercise to find the return super if cannot_handle_method idiom.--Vinko

Figure 2.1 is correct but to make it consistent with the code you show, the three blue boxes on the left should be moved down with the left arrow coming from Fixnum, not Numeric. Then add an Object box above Numeric with an up arrow showing the inheritance.--art gittleman

In the chapters about Prolog, tuples and list are mentioned.

1. Prolog does not have a real tuple type, and especially not a constant access one.
2. It is not true that lists and tuples are "containers" respectively of variable and fixed size.

In Prolog there is a binary left associative term constructor ,/2 which is what is used to build things which look as tuples:

?- (1, (2, (3, 4))) = (1, 2, 3, 4).
true.

?- (((1, 2), 3), 4) = (1, 2, 3, 4).
false.

In fact, what looks like a tuple is simply a nested term, not different from lists. Things are slightly more complicated as there is a ,/2 predicate which represents the logical conjunction of two predicates:

?- (true, false).
false.

?- (true, true).
true.

The list functor is '.'.

?- .(3, []) = [3].
true.

The usual [...] syntax is just syntactic sugar.

Essentially a list is not a "mutable size container" (lists are essentially immutable[0]).
It is just a cons list, like in Scheme. Simply the pair constructor is . and not cons.

?- ','(3, 4) = (3, 4).
true.

The 'term' syntax can be used essentially to bypass usual precedence rules which would make the desugared version ,(3, 4) a syntax error.

Since in Prolog it is possible to use any functor (including ',') to build terms of arbitrary arity, it is correct to write:

?- X = ','(3, 4, 5).
X = ','(3, 4, 5).

However, that is *not* a tuple type:

?- ','(3, 4, 5) = (3, 4, 5).
false.

Because (1, (2, (3, 4))) = (1, 2, 3, 4).

----
[0] In some sense it can be "modified" because if we have variables we can "extend" the list through unification if the last term is a variable
(this is also the basis for difference lists). Same applies to tuples, though.

?- (1, A) = (1, 2, 3).
A = (2, 3).

--Enrico Franchi

The Fibonacci sequence is defined with the 0th element as 0. The definition on page 171, as another_fib, starts with the 0th element as 1.--Tyler Bindon

Immediately after mentioning Erlang is tail recursion optimized, two recursive examples are given - factorial and fibonacci. But neither of them are implemented in a tail recursive fashion. This could be confusing. --Martin Leech

In Hackers and Painters, Graham chronicles a start-up that leveraged produc- tivity with Lisp to achieve productivity that no other vendors could match.

should probably be:

In Hackers and Painters, Graham chronicles a start-up that leveraged Lisp to achieve productivity that no other vendors could match.--Julian Ceipek

The Fibonacci sequence is defined with the 0th element as 0. The definition on page 250, as fib, starts with the 0th element as 1. This gives different results from the alternative definition on page 251 where the 0th element is 0.--Tyler Bindon