Errata

Our first clause stipulates that if we hit the end of our
glob pattern (by which time we'll be looking at the empty
string), we return $, the regular expression symbol for
"match end-of-line."

Not true. The "first clause" returns the empty string, not "$". That maybe the way it was originally but refactored the "$" into the PARENT or CALLING function (the non-prime globToRegex).

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.

Definition of struct vector is missing in C code.

Should add:

struct vector {
double a;
double b;
}

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

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.

On Windows PCs the following differences were noted:
[note: $./Interact should be InteractWith - this was noted in a separate errata - this occurs in two places].
1. ./Interact should simply be
Interact [or more correctly InteractWith]
2. ./Interact hello-in.txt hello-out.txt should simply be
Interact hello-in.txt hello-out.txt
3. cat hello-in.txt should be type hello-in.txt
4. cat hello-out.txt should be type hello-out.txt
[note: cat is not a valid PC DOS command].

On Windows PCs the following differences were noted:
[note: $./Interact should be InteractWith - this was noted in a separate errata - this occurs in two places].
1. ./Interact should simply be
Interact [or more correctly InteractWith]
2. ./Interact hello-in.txt hello-out.txt should simply be
Interact hello-in.txt hello-out.txt
3. cat hello-in.txt should be type hello-in.txt
4. cat hello-out.txt should be type hello-out.txt
[note: cat is not a valid PC DOS command].

"square on the remainder of the empty list." should be "square on the remainder of the nonempty list."

"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.

module Main () where

should be

module Main (main) where

or at least

module Main where

The values of width and col are 0 and 2, respectively ->

The values of width and col are 2 and 0, respectively

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.

The 3rd line should be removed because compile error doesn't occur.

This code also needs FlexibleInstances language extension.

? file: ch06/Overlap.hs
class Borked a where
bork :: a -> String

should be

? file: ch06/Overlap.hs
{}
class Borked a where
bork :: a -> String

? file: ch06/JSONClassExport.hs

should be&#65306;
? file: ch06/JSONClass.hs

? file: ch06/JSONClassExport.hs

should be

? file: ch06/JSONClass.hs

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)

)

checkDigit ds = 10 - (sum products `mod` 10)
should be
checkDigit ds = (10 - sum products `mod` 10) `mod` 10

Original checkDigit function cause Exception(Error in array index).

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.

where (left, right) = splitAt 5 rest
should be
where (left, right) = splitAt 6 rest

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.

buildMap = M.mapKeys (10 -)
should be
buildMap = M.mapKeys (\c -> (10 - c) `mod` 10)

Original buildMap function build map that has key 10, not key 0.

-> (s -> (b, s)) -- (makeStep result) newState
should be
-> (s -> (b, s)) -- makeStep result

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.

Code example doesn't run ... error output printed in book but text implies that there was no problem.

In the exercises at the top of page 436 it should be StateT instead of WriterT

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.