Errata

The footnote describes "I-Structures, a concept from an early Parallel Haskell variant called pH."

In fact I-Structures date to pH's predecessor Id (c.f. http://ecommons.library.cornell.edu/handle/1813/6650) . I would perhaps change the footnote to describe "a concept from Id, an implicitly parallel functional language developed at MIT"

Note from the Author or Editor:
The suggestion is correct.

when trying to compile with ghc 7.6.3
Preprocessing executable 'fwaccel' for parconc-examples-0.3...
[1 of 1] Compiling Main ( fwaccel.hs, dist/build/fwaccel/fwaccel-tmp/Main.o )

fwaccel.hs:44:14: Not in scope: `A.min'

i know this was tested with a previous version but there was talk about keeping sources up to date

Note from the Author or Editor:
I've uploaded 0.3.2 with the fix for this.

Says ?Chapters 4, 5, 6, and pass:[ 14 cover frameworks that were developed in the last few years.?

Note from the Author or Editor:
Delete "pass:["

the listing containing evalPair is titled "strat.hs", but it should be "strat2.hs".
I'm using parconc-examples 0.3.4.

Note from the Author or Editor:
Correct - at the top of page 33, "strat.hs" should be "strat2.hs".

Module name should be Control.Applicative instead of Control.Monad.Applicative.

Note from the Author or Editor:
Well spotted, it should indeed be Control.Applicative.

If I am correct, the θ is anti-clockwise as postive and y-axis direction is bottom up(I think this is what in DevIL, not top down), then the rotation formula should be(Note the minus):

x' = - y sin θ + x cos θ
y' = y cos θ + x sin θ

And this also match the code(which view theta as the angle that rotate the new point back to old point, so image will rotate clockwise).

Note from the Author or Editor:
Correct, there is a missing minus sign. Rearranging the formulae to match the code, they should read:

x' = x cos \theta - y sin \theta
y' = x sin \theta + y cos \theta

where \theta is the Greek theta symbol.

In:

"The result is a DIM2 value in the Haskell world, so we can pattern match against Z:.x:.y to extract the x and y values, both of type Exp Int"

"Z:.x:.y" should read "Z:.y:.x"

In "ghc -O2 fwaccel.hs -threaded" and "./fwaccel 2000 +RTS -s", replace "fwaccel" with "fwaccel-gpu" to agree with the GitHub example file as well as with the leading paragraph "A version of the shortest paths program that has this is in fwaccel-gpu.hs".

(Thanks for the awesome book & code!)

Note from the Author or Editor:
Correct - in the two command lines mentioned, "fwaccel" should be "fwaccel-gpu".

The implementation of "finally" has wrong types: the last line can't be "after" which is of type "IO b".

Code from the book:
===========
finally :: IO a -> IO b -> IO a
finally io after = do
io `onException` after
after

Fixed:
===========
finally :: IO a -> IO b -> IO a
finally io after = do
r <- io `onException` after
after
return r

Note from the Author or Editor:
Correct: the definition of finally on page 150 should read

finally :: IO a -> IO b -> IO a
finally io after = do
r <- io `onException` after
after
return r

The implementation of "problem" uses "throw" but should use "throwIO", in accordance with the recommendation at the top of page 150.

Note from the Author or Editor:
Yes, I agree throwIO would be better than throw here.

Incorrect filename "code/tmvar.hs". It should be just "tmvar.hs".

Note from the Author or Editor:
On page 182, the filename for the first code sample should be "tmvar.hs", not "code/tmvar.hs".

Defining withAsync using bracket leaves the asynchronous thread in a masked state (prevailing from bracket). The Async library codes withAsync by hand using mask, so produces a different result. Concretely, on my machine:

import Control.Concurrent.Async
import Control.Exception

wa :: IO a -> (Async a -> IO b) -> IO b
wa io inner = bracket (async io) cancel inner

test :: IO ()
test = do
wa (getMaskingState >>= putStrLn.show) $ \a -> wait a
withAsync (getMaskingState >>= putStrLn.show) $ \a -> wait a

produces:

MaskedInterruptible
Unmasked

as output. I'm assuming this is not the intended semantics.

Note from the Author or Editor:
Yes, this is a good point. A correct definition of withAsync would be:

withAsync :: IO a -> (Async a -> IO b) -> IO b
withAsync io cont = do
var <- newEmptyTMVarIO
mask $ \restore -> do
t <- forkIO (try (restore io) >>= atomically . putTMVar var)
let a = Async t var
restore (cont a) `finally` cancel a

a) Missing space between "forM_" and "ps".
b) Missing description of this line in the following list.

Note from the Author or Editor:
Unfortunately this mistake was accidentally introduced late in the production cycle while fixing some problems with syntax highlighting.

* There should be a space between forM_ and ps
* Point (3) should be (4), and (4) should be (5)
* Point (3) should read "Send the Ping message to each of the subprocesses"

In this sentence:

"A typed channel consists of two ports, a SendPort and a ReceivePort. Messages are sent to the SendPort by sendChannel and received from the ReceivePort using receiveChannel"

"sendChannel" should be "sendChan"
"receiveChannel" should be "receiveChan"

The last sentence of second from last paragraph say that "remote" framework explicitly disallow it, maybe should be "distributed-process" framework.

Note from the Author or Editor:
On page 256, second last paragraph, the text "So the remote framework explicitly disallows it" should read "So the distributed-process framework explicitly disallows it".