Yet Another Haskell Tutorial/Errata< Yet Another Haskell Tutorial(Redirected from Haskell/YAHT/Errata)
- Exercise 3.1: "We’ve seen that multiplication binds more tightly than division." - as far as I'm concerned, multiplication and division have the same priority, so they bind equally tightly. Maybe you meant addition vs multiplication or multiplication vs exponentiation? I see it has been fixed in the online version already.
- There is a bug in the solution to Exercise 7.1 on page 79, under "7.3 Partial Application" (see Advanced Language: Partial Application for the corresponding HTML version (which has already been corrected)), for which the exercise is stated as follows:
Convert the following functions into point-free style, if possible.
[...] func5 f l = foldr (\x y -> f (y,x)) 0 l
- On page 81, text states
"we create a value, call it x, which has value Red. We then apply this to colorToRGB. We check to see if we can “match” x against Red. This match fails because according to the definition of Eq Color, Red is not equal to Yellow."
Clearly, the premise is wrong, the initial value x should be 'Yellow' in order for the rest of the paragraph to make sense.
- According to the page 172 of the PDF file, the solution is stated as follows:
[...] func5 = foldr (uncurry $ flip f) 0
However, as pointed out by Michael Mossey on the Haskell-Beginners mailing list, that solution is actually incorrect.
Here is the correct solution:
[...] func5 = flip foldr 0 . flip . curry
As a sidenote, Daniel Fischer has provided a succinct way of verifying correctness of the solutions, using types, as follows:
A simple way to check for sanity of the results is:
Prelude> :t flip foldr 0 . flip. curry flip foldr 0 . flip. curry :: (Num c) => ((c, b) -> c) -> [b] -> c Prelude> :t \f list -> foldr (\x y -> f (y,x)) 0 list \f list -> foldr (\x y -> f (y,x)) 0 list :: (Num b) => ((b, a) -> b) -> [a] -> b Prelude> :t \f -> foldr (uncurry $ flip f) 0 \f -> foldr (uncurry $ flip f) 0 :: (Num b1) => (b -> a -> b1 -> b1) -> [(a, b)] -> b1
So you see that your result has the correct type, while Hal's hasn't.
In the above-mentioned description, the first pair of two lines show that the type of
flip foldr 0 . flip. curry
(i.e., the solution to verify) is
(Num c) => ((c, b) -> c) -> [b] -> c
The second pair of two lines show that the type of
\f list -> foldr (\x y -> f (y,x)) 0 list
(i.e., essentially the expression given in the exercise, which was
f l = foldr (\x y -> f (y,x)) 0 l) is also
(Num b) => ((b, a) -> b) -> [a] -> b
(Note that this is the same type as above, only written with renamed variables.)
The third pair of two lines show that the type of
\f -> foldr (uncurry $ flip f) 0
(i.e., the solution given by Hal in the PDF version of the tutorial) is
(Num b1) => (b -> a -> b1 -> b1) -> [(a, b)] -> b1
which is a different type. Hence, the solution given by Hal is incorrect.
2. Exercise 4.11:
|4.11. Test whether the CPS-style fold mimicks either of foldr and foldl. If not, where is the difference?|
It does not specify the "CPS-style fold" function, so the reader should assume that the exercise is about the previously defined cfold:
cfold’ f z  = z cfold’ f z (x:xs) = f x z (\y -> cfold’ f y xs) cfold f z l = cfold’ (\x t g -> f x (g t)) z l
But the solution given in YAHT is actually not about about this function. In fact, this function behaves exactly as foldr. The solution is about very similar function: the only difference is in the order of arguments for the second case of cfold', namely
cfold' f z (x:xs) = f z x (\y -> cfold' f y xs)
||YAHT has never been comprehensively proofread, so this is only a partial list.|
||This is still a work in progress. Feel free to add to it as needed!|