Errata

In this example below from ?Clojure Programming? (2012) in the second part of Example 3-7, the Clojure function `take` would be a lot better than `drop`, as `drop` forces the interpreter into an infinite operation. Without this correction to `take`, the `iterate` just keeps going until the computer user kills the process manually.

Existing:

(->> (iterate step #{[2 0] [2 1] [2 2] [1 2] [0 1]})
(drop 8)
first
(populate (empty-board 6 6))
pprint)

(->> (iterate step #{[2 0] [2 1] [2 2] [1 2] [0 1]})
(take 8)
first
(populate (empty-board 6 6))
pprint)

The regex to split camel case doesn't work for numbers.

The following fails:
(camel->keyword "fooBar1Bar2")

Instead use the following regex::
#"(?<=[a-z0-9])(?=[A-Z])"

The example code did not work until I made a minor modification to it. Here's a sample session:

user=> (into {} (for [[k v] (group-by :artist playlist)] [k (summarize v)]))
{"The White Stripes" " / / ", "Papas Fritas" " / / ", "PJ Harvey" " / / ", "Mardi Gras BB" " / / "}
user=> (into {} (for [[k v] (group-by :artist playlist)] [k (map summarize v)]))
{"The White Stripes" ("Elephant / The White Stripes / 2003"), "Papas Fritas" ("Helioself / Papas Fritas / 1997" "Buildings and Grounds / Papas Fritas / 2000"), "PJ Harvey" ("Stories from the City, Stories from the Sea / PJ Harvey / 2000"), "Mardi Gras BB" ("Zen Rodeo / Mardi Gras BB / 2002")}
user=>

One difference between the sample code from the book, and the code as I've typed it initially, is that I needed to specify ":artist", whereas the book left "key-fn" unspecified. But I needed to do this to get a concrete working example.

The original neighbours function is used within example 3-7 without mentioning that no boundary checking is performed, and therefore off-grid locations may be included in the result, e.g.

(def blinker #{[0 0][0 1][0 2]})
;;#'user/blinker
(def blinker-game (iterate step blinker))
;;#'user/blinker-game
;;(defn blink [n] (pprint (-> blinker-game (nth n))))
;;#'user/blink
(blink 1)
#{[1 1] [-1 1] [0 1]}

This does not affect the glider pattern as set-up in the book, but shouldn't it be mentioned (or accounted for) nevertheless?

Thanks for a great book..

As shown in the hex-grid diagram at https://www.dropbox.com/s/ywm8np2wbk0dr8d/hex-1.png (from `user> (hex-neighbours [2 3])`), the `hex-neighbors` function for Life-like automaton H.B2/S34 (with a hexagonal grid) should be implemented as:

(defn hex-neighbours
[[x y]]
(for [dx [-1 0 1] dy (if (zero? dx) [-1 1] [1 0])]
[(+ dx x) (+ dy y)]))

The above hex-neighbors function yields the correct neighbors, shown in green at the diagram linked above.

Instead, the current implementation from the book yields the neighbors marked in red on the diagram linked above:

(defn hex-neighbours
[[x y]]
(for [dx [-1 0 1] dy (if (zero? dx) [-2 2] [-1 1])]
[(+ dx x) (+ dy y)]))

because the latter function computes three neighbors that are off-by-one in their 'y' value.

"49. A branch is a node that *may* have children: a branch can have no children."
→ "49. A branch is a node that *must* have children: a branch can't have no children."

http://clojure.org/refs says "All reads of Refs will see a consistent snapshot of the 'Ref world' as of the starting point of the transaction (its 'read point')."

It explicitly states that a transaction's point of reading all refs is at the start of the transaction.

However, Figure 4-2 makes it look as if t1 would succeed if t1 modified ref 'a' after t2 committed, and the third paragraph on page 184 adds to the confusion.

The paragraph reads "The unique semantic of alter is that, when the transaction is to be committed, the value of the ref outside of the transaction must be the same as it was prior to the first in-transaction application of alter. Otherwise, the transaction is restarted from the
beginning with the new observed values of the refs involved."

From the figure and the paragraph, I was led to think the value of the ref outside of the transaction must be the same as the one right before the first in-transaction application of alter, which causes a big trouble for the function, 'heal'.

(defn heal
[healer target]
(dosync
(let [aid (min (* (rand 0.1) (:mana @healer))
(- (:max-health @target) (:health @target)))]
(when (pos? aid)
(commute healer update-in [:mana] - (max 5 (/ aid 5)))
(alter target update-in [:health] + aid)))))

If the value of 'target' changed between the time it was read for the calculation of 'aid' and the time alter was invoked in the transaction, alter wouldn't cause the transaction to retry, but validator could throw exception due to exceeding max health.

You should modify Figure4-2 and the paragraph to not confuse readers.

The link to Library Coding Standards is outdated and should be: http://dev.clojure.org/display/community/Library+Coding+Standards (instead of http://dev.clojure.org/display/design/Library+Coding+Standards).

“This is because the data structures are persistent, an implementation technique where collections reuse internal structure to minimize the number of operations needed to represent altered versions of an instance of a collection while ensuring that all versions of a collection will maintain the same efficiency guarantees.”

Maybe I misread the sentence above incorrectly, but it sounds like it implies that persistent data structures imply re-use, which is misleading. In fact persistence is just a property of preserving data structures upon modification.

Even though this is besides the point of demonstrating the usefulness of implementation maps with this excellent example, there are three issues with (def abstract-matrix-impl ...):

1) A compile error due to the use of 'y' free variable (instead of '%' as required by an anon. fn) on the 5th line

2) The representation of :rows and :cols is the opposite of what is previously done by (extend-protocol Matrix Point...) on pp. 280-281:

(cols (Point. 10 20)) yields
=> ((10) (20))
as opposed to the expected
=> ((10 20))
and vice versa for (rows p)

3) This is minor, but we probably want vectors as opposed to generic seqs, e.g. [[10 20]] vs ((10 20))?

The following seems to fix all of the above:

(def abstract-matrix-impl
{:cols (fn [pt]
(let [[h w] (dims pt)]
(-> (fn [x] (-> (map #(lookup pt x %) (range 0 w)) vec))
(map (range 0 h))
vec)))
:rows (fn [pt]
(-> (apply map vector (cols pt)) vec))})

Thanks for a great book!

Maze example in Ch 3 has a casting issue:

Exception in thread "main" java.lang.ClassCastException: clojure.lang.LazySeq cannot be cast to clojure.lang.IFn
at user$grid.invoke(maze.clj:22)

(defn grid
[w h]
(set concat(
(for [i (range (dec w)) j (range h)] #{[i j]
[(inc i) j]})
(for [i (range w) j (range (dec h))] #{[i j]
[i (inc j)]}))))

Where line 22 is the first for loop above.

The example code for the project on github also doesn't include this particular example - it supplies source code for the first example of the chapter, Conway's Game of Life, but then stops.

I think the mentions of BigInteger should instead be BigInt.

I believe the parameters for the modulo function are switched in the following invocation:

(palette (mod (dec (count palette)) (inc escape-iter)))

It should instead read:

(palette (mod (inc escape-iter) (dec (count palette))))

so that we get x modulo the size of the palette

The line should be:

chain.runChain("data123");

instead of:

chain.run("data123");

The run method does not exist for the FooProcessor class or its parent class.