Errata

Text:
-----------
Recall the validator function from Chapter 4:

validator("arg must be a map", aMap)(42);
//=> false

The validator higher order function takes a validation predicate and returns an array of the errors encountered along the way. If the error array is empty, then there were no reported errors.
-----------
The validator function is given bottom of page 83. It takes an error string and a predicate, and returns the wrapped predicate with its message property set to the supplied error string.

The checker function, defined page 82, accepts validator functions and returns a function that returns an array of errors.

The text that follows seems to deal with validator as it is defined on p83, rather than as it is described on page 104.

Note from the Author or Editor:
The fragment "an array of the errors encountered along the way. If the error array is empty, then there were no reported errors." can be changed to "an augmented predicate useful in the operation of the checker function."

look at the following code
var array123 = [1,2,3,4,5];
for (var i = 0, l = array123.length; i < l; i++) {
doSomething(array[i]);
}

at doSomething there should be array123[i] instead of array[i]

Note from the Author or Editor:
should be array123[i]

Missing `_.toArray` around `arguments` in `cat` call of the inner anonymous function. Using _.union instead of cat would have worked with the raw arguments object.

Note from the Author or Editor:
Call _.toArray on arguments supplied to cat.

ACTUAL TEXT:
_.tap([1,2,3], note);
;; NOTE: 1,2,3
//=> [1, 2, 3]


EXPECTED TEXT:
_.tap([1,2,3], note);
// NOTE: 1,2,3
//=> [1, 2, 3]


NOTICE:
The difference is `//` vs `;;` on the second line

Note from the Author or Editor:
Whoops. Some Clojure snuck in there. Change to // NOTE: 1,2,3

ACTUAL TEXT:
"However, there is one limitation of _chain ? it's not lazy."

EXPECTED TEXT:
"However, there is one limitation of _.chain ? it's not lazy."

NOTE:
The difference in `_chain` vs `_.chain`

Note from the Author or Editor:
Change to _.chain

"That is, by using _.extend, I copy all of the methods into Hole.mix
in."

should be:

That is, by using _.extend, I copy all of the methods into Hole.prototype.

Note from the Author or Editor:
Change to Hole.prototype

The number 10000 is pushed to seed, but the _q member of instance q now has a new 1000, not 10000 as expected.

Note from the Author or Editor:
Change 1000 to 10000

The result of:

var a = repeatedly(1000, partial1(rand, 3));

Is more like {1: 327, 2: 336, 3: 337} than the result in the book which is {1: 498, 2: 502}.

Note from the Author or Editor:
Change partial1(rand, 3) to partial1(rand, 2)

The randString function will only output random lowercase ASCII characters including "q". It will not output "r", "s", "t", "u", "v", "w", "x", "y", "z". Last line on page 139 should be changed to:

var ascii = repeatedly(len, partial1(rand, 35));

Note from the Author or Editor:
Change partial1(rand, 26 to partial1(rand, 35))

The line:

# (console) Hello CoffeeScript

Should have an exclamation mark at the end of it.

Note from the Author or Editor:
# (console) Hello CoffeeScript

Should have an exclamation mark at the end of it.

Here is a more complete list of book-defined functions missing from the index:

actions, 184
cat, 39
construct, 39
curry, 95
curry2, 96
curry3, 98
doWhen, 20
fail, 9
flat, 124
note, 9
nth, 12
pipeline, 177
second, 13
splat, 2
unsplat, 2
warn, 9

Note from the Author or Editor:
Thank you. Adding all of these would be nice.

In the "Curry to the right, curry to the left" it says:

"The use of a division operation to illustrate currying works nicely because the result changes if the arguments are switched (i.e., it?s not associative)."

Indeed division is not associative, but isn't it more intuitive in this context to state about division being not commutative?

Note from the Author or Editor:
Yes, commutativity is correct.

The function that is called should be createLaunchCommand() and not createCommand()

Note from the Author or Editor:
The function that is called should be createLaunchCommand() and not createCommand()

The paragraph needs "just because a global variable holds a certain value [?] doesn't mean that when you refer to it you'll get the global value". This is incorrect: when you refer to any variable, you get its value?by definition. However, what is probably meant is: "when you use the name of a global variable, it doesn't always point to that global variable (depending on the current scope)".

Note from the Author or Editor:
Changed to be a little more clear: ...doesn't mean that when you refer to its name you'll...

There is a reference to a function "lessThan" when the actual name is "lessOrEqual":
"..., and lessThan only returns true or false, ...".

Note from the Author or Editor:
Thank you.

In the spirit of completeness, it?s worth noting that the function _.map can also take a third argument, the collection itself:


Isn't this referring to the function *supplied* to _.map?

Note from the Author or Editor:
Yes. This should refer to the function that _.map takes.

"On Speed" section - fourth code sample:

function performTask(array) {
_.each(array, function(elem) {
doSomething(array[i]);
});
}

should be

function performTask(array) {
_.each(array, function(elem) {
doSomething(elem);
});
}

(substitute "elem" for "array[i]" in call to doSomething)

Code sample output is incorrect. Text states:

[2, 3, -1, -6, 0, -108, 42, 10].sort(lessOrEqual);
//=> [100, 10, 1, 0, -1, -1, -2]

... which would be correct if the array to be sorted matched the array in the code sample on page 15 using the comparator. Either the array to be sorted should contain the values:

[100, 1, 0, 10, -1, -2, -1].sort(lessOrEqual);

or the output should be:

//=> [42, 10, 3, 2, 0, -1, -6, -108]

Text states: "A comparator is a function that takes two values and returns <1 if the first is less than the second, >1 if it is greater, and 0 if they are equal."

Should be less than or greater to zero, not one: "A comparator is a function that takes two values and returns <0 if the first is less than the second, >0 if it is greater, and 0 if they are equal."

Note from the Author or Editor:
More accuracy is better. Thank you.

The last implementation of `second` is defined as:

```
function second(a) {
return _.first(_.first(a));
}
```

Taking the first element of the first element will not return the second element. Instead, I believe the author meant:

```
function second(a) {
return _.first(_.rest(a));
}
```

The `enqueue` function defined on `Queue.prototype` uses the `+` operator to concatenate onto the end of the array `this._q`:

```
return new Queue(this._q + thing);
```

In JS, you cannot use `+` to concatenate onto arrays. Instead, you will get a string:

[1,2,3]+1 === "1,2,31"

Page 159 has a correct implementation (SaferQueue), which uses the `cat` function.

Note from the Author or Editor:
Thankfully this doesn't factor into the discussion, but in any case, the correct implementation is:

Queue.prototype = {
enqueue: function(thing) {
return new Queue(cat(this._q, [thing]));
}
};