In the third paragraph it says "nor can it turn an a into a b". While this is correct, it certainly irrelevant for fst. It should probably read "nor can it turn a b into an a", because fst's result type is a.

It's rare that a variable name is so non-descriptive that anyone would consider it an error, but in this case the variable name 'cities' is such a poor choice of a variable name in this code:

ghci> let cities = Book 173 "Use of Weapons" ["Iain M. Banks"]

I think it should be considered an error. Naming a Book 'cities' is so out of place that it rattles the reader's confidence in the authors.

It's mentioned again on p. 56 in the 3rd code example.

When the following example, on page 57, is entered, using GHCI, the error message shown below is issued...
A fix to get rid of this error worked but then a subsequent error occurs...see the following once again:

--original code:
-- ch03/Nullable.hs
data Maybe a = Just a
| Nothing

someBool = Just True
--someBool = Main.Just True

someString = Just "somethng"
--someString = Main.Just "somethng"
********************************************************************
if this is loaded -- see following load command and error msg:
ghci>:load ch03/nullable
[1 of 1] Compiling Main ( ch03\nullable.hs, interpreted )

ch03\nullable.hs:5:11:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude

ch03\nullable.hs:8:13:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude
Failed, modules loaded: none.
ghci>
*********************************************************************
If the following correction is made, the load is successful - however, the example in the third paragraph now fails:
-- ch03/Nullable.hs
data Maybe a = Just a
| Nothing

--someBool = Just True
someBool = Main.Just True

--someString = Just "somethng"
someString = Main.Just "somethng"

**********************************************************************
ghci>:load ch03/nullable
[1 of 1] Compiling Main ( ch03\nullable.hs, interpreted )
Ok, modules loaded: Main.
ghci>
**********************************************************************

Now the following error msg is encountered:
ghci>Just 1.5

<interactive>:1:0:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude

When the following example, on page 57, is entered, using GHCI, the error message shown below is issued...
A fix to get rid of this error worked but then a subsequent error occurs...see the following once again:

--original code:
-- ch03/Nullable.hs
data Maybe a = Just a
| Nothing

someBool = Just True
--someBool = Main.Just True

someString = Just "somethng"
--someString = Main.Just "somethng"
********************************************************************
if this is loaded -- see following load command and error msg:
ghci>:load ch03/nullable
[1 of 1] Compiling Main ( ch03\nullable.hs, interpreted )

ch03\nullable.hs:5:11:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude

ch03\nullable.hs:8:13:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude
Failed, modules loaded: none.
ghci>
*********************************************************************
If the following correction is made, the load is successful - however, the example in the third paragraph now fails:
-- ch03/Nullable.hs
data Maybe a = Just a
| Nothing

--someBool = Just True
someBool = Main.Just True

--someString = Just "somethng"
someString = Main.Just "somethng"

**********************************************************************
ghci>:load ch03/nullable
[1 of 1] Compiling Main ( ch03\nullable.hs, interpreted )
Ok, modules loaded: Main.
ghci>
**********************************************************************

Now the following error msg is encountered:
ghci>Just 1.5

<interactive>:1:0:
Ambiguous occurrence `Just'
It could refer to either `Main.Just', defined at ch03\nullable.hs:2:15
or `Prelude.Just', imported from Prelude

The code at the top of p. 62 produces the curious result that if you call:

lend 200 201

which is interpreted as: you want to borrow $200 and your current balance is $201, then the result is:

Just 1

which is interpreted as: you were approved for the loan, and your new balance is $1.

On the other hand, if you call

lend 50 99

which means you want to borrow $50 and your current balance is $99, then the result is:

Nothing

which means you were turned down for the loan. Furthermore, if you call

lend 200 150

which means you want to borrow $200 and your current balance is $150, the result is:

Just (-50)

Uhmm...that sounds like the kind of lending that plunged the world's financial system into a crisis.

For anyone starting a bank, they might want to use the following code instead:

lend amount balance = let reserve = 100
newBalance = balance - amount
in

if ***newBalance*** < reserve
then Nothing
else Just newBalance


Also, I think there is a problem with the following sentence, which appears on the bottom of the previous page(p. 61), and which describes the code:

"We meet a money reserve of at least 100, and we return our new balance after subtracting the amount we have loaned:

Should 'meet' be 'need'?

I think "Interact.hs" and "./Interact" are intended to be "InteractWith.hs" and "./InteractWith" for consistency or vice versa.

Even better, I think, would be changing these to "Copy.hs" and "./Copy" (or "copy" or even just "cp".) These names provide indication of what the program actually does. It is odd to type "./InteractWith" when copying a file. Also changing to "Copy" would make the naming more parallel with the sensibly named "FixLines" in the next section.

The 3rd code sample uses the executable "./Interact" while it was compiled as "InteractWith" in the 2nd code sample.

Note: on p. 71 the comment in the code sample says
-- file: ch04/InteractWith.hs
-- Save this in a source file, e.g. Interact.hs
which might have to do with the confusion. I'd suggest to drop the second comment line.

asInt_either should have signature

asInt_either :: String -> Either ErrorMessage Int

"Partial function application is named currying, ..." I think this is incorrect. Currying and partial function application are different things. It would be good to disentangle them here.

This function probably should be named "nest" instead of "fill".

After showing how to install packages globally with

$ runghc Setup configure

it goes on to mention that "To install it into our home directory and our personal package database, we must provide a little more information:" but then just moves on to the next step without saying what "more information" is. According to the online version at

http://book.realworldhaskell.org/read/writing-a-library-working-with-json-data.html

the missing command is

$ runghc Setup configure --prefix=$HOME --user

The example is incorrect:

data CannotShow = CannotShow
deriving (Show)

-- will not compile, since CannotShow is not an instance of Show
data CannotDeriveShow = CannotDeriveShow CannotShow
deriving (Show)

This will compile nicely, however. I think the deriving (Show) declaration in CannotShow should be removed to correctly illustrate the problem.

It says
"This means that our attempt to use simpleFind will list directories ending in .c as well as files with the same extension."

But even if you apply (\p -> True)to list all the files, the result of simpleFind actually doesn't contain any directory names. Because for the directory part, it will only recursively list it.

The line

let path' = path </> name

in the definition of walk does not append the correct path when traversing down a subdirectory due to the fact that "path" actually holds the value submitted to foldTree.
path should actually be subpath (from the scope of the fold-function).

A quick fix would be:

foldTree ...
where
fold ...
where
walk ...
let path' = subpath </> name

"(==>) lets us chain two Parse values together". From the type signature, it looks as the second is not a Parse value (Parse a) but a function yielding a Parse value (a -> Parse b).

When talking about HPC, it mentions running "ghc -fhpc Run.hs --make", which works correctly, unless you've compiled the other modules without -fhpc first. A note should be added telling to user to delete all .hi and .o files in the directory. (When these steps are not taken, results like the following are found:

100% expressions used (0/0)
100% boolean coverage (0/0)
100% guards (0/0)
100% 'if' conditions (0/0)
100% qualifiers (0/0)
100% alternatives used (0/0)
100% local declarations used (0/0)
100% top-level declarations used (0/0)

)

It looks to me as if this definition of foldA1 will use the first element of "a" twice -- once as the seed ("a ! fst (bounds a)") and once when foldA accesses it as the first member of its copy of a.

Surely this list comprehension is going to give you a cross product, not a zip? i.e. of srl and digits both have N elements, the first two expressions on the page will give a list of N pairs, but the third will give a list of N^2 pairs.

The second rule is given as

-- file: ch15/MonadPlus.hs
v >> == mzero

however, it should be

v >> mzero == mzero

The example runs "(fst . runSupply next) `fmap` randomsIO" twice to demonstrate that different random numbers are supplied each time. Instead, though, it gives on both invocations an error about 'next' being ambiguous, either from Supply or from System.Random. This contradicts the given code which explicitly hides the one from System.Random, so only the one from Supply should be visible.

In order to force the sort to take place, you suggest evaluating the length of the sorted list. That works for the sort functions that you use, but is not a general solution. For instance, calculating the length of a list sorted using the following function does not evaluate its elements:

import List

sort' :: (Ord a) => [a] -> [a]
sort' xs = [ select i xs | i <- [0..length xs-1] ]
where
select 0 xs = minimum xs
select (n+1) xs = select n (delete (select 0 xs) xs)


*Main> sort' [10,9..1]
[1,2,3,4,5,6,7,8,9,10]
*Main> length (sort' [undefined,undefined])
2

I must admit that this is a very inefficient and imperative sort function, but my point is show that the proposed solution is not general enough. Wouldn't it be better to use force as you already do in the generation of the initial list?

"We include -fvia-C here mainly to show how to compile using this option:" (cabal code here....)

The problem is the "cabal code" does not mention "-fvia-C" at all. Perhaps if the line ended in a "." instead of a ":", the one could interpret the line meaning "the above paragraph mentions -fvia-C for completeness." But the ":" drives one to look at the next text and then not finding "-fvia-C" is confusing.