You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
40 lines
2.5 KiB
40 lines
2.5 KiB
# Exercises: Understanding folds |
|
## Exercise 1 |
|
This will evaluate to: `(1*(2*(3*(4*(5*1))))`, so |
|
1. Is not correct as the types are incorrect. |
|
2. Will return the same result. |
|
3. Will also return the same result. |
|
The latter two are the same because multiplication is commutative. |
|
|
|
## Exercise 2 |
|
``` |
|
fMul = flip (*) |
|
| ------- accumulator -------| |
|
foldl fMul 1 [1,2,3] |
|
= foldl fMUl (fMul 1 1) [2,3] |
|
= foldl fMul (fMul (fMul 1 1) 2) [3] |
|
= foldl fMul (fMul (fMul (fMul 1 1) 2) 3) [] |
|
= fMul (fMul (fMul 1 1) 2) 3 |
|
= 3*(2*(1*1)) |
|
= 6 |
|
``` |
|
|
|
## Exercise 3 |
|
1. They both traverse the spine from right to left. This evident by the `(x:xs)` pattern matching in both functions' definition. |
|
2. They both force the rest of the fold as they are both recursive functions. |
|
3. **True, `foldr` associates from the right and `foldl` assocatiates from the left.** |
|
4. They are both recursive |
|
|
|
## Exercise 4 |
|
(a) Catamorphism means to shape downwards and thus reduce structure. This is evident in the application of the folds which can reduce lists to a single value. |
|
|
|
## Exercise 5 |
|
1. The zero value is missing: `foldr (++) "" ["woot", "WOOT", "woot"]` |
|
2. The wrong zero value is used, a `Char` is expected: `foldr max 'a' "fear is the litle death"` |
|
3. `and :: [a] -> Bool` is a function which takes an array and returns `True` if all values are `True`. This is not the same type as expected: `(a -> b -> b)`. **Should be: `foldr (&&) True [False, True]`** |
|
4. The wrong zero value is used as this will always return `True`. Such is the nature of the `(||)`operator. Should be: `foldr (||) False [False, True]` |
|
5. `foldl` expects a `b -> a -> b` function. `((++) . show) :: Show a => a -> [Char] -> [Char]`. If we use this function this means that, because the accumalator starting values `""` is of type `[Char]`, our fold function is: `[Char] -> [Char] -> [Char]` which does not fit, because this would mean our elements of the array should be of type `[Char]`. **It should be: `foldr (flip $ ((++) . show) "" [1..5]`** |
|
6. The result of the `const` application should be the same type as the zero value (`Char`), but `const` returns the type of the second argument, in this case `Num a => a`. **It should be: `foldr (flip const) 'a' [1..5]`** |
|
7. Same as (6). It should be: `foldr (flip const) 0 "tacos"` |
|
8. This is similar to the previous questions. The `flip` is not needed here for the same reasons it is needed in (6) and (7). It should be: `foldl const 0 "burritos"` |
|
9. Same as (8). It should be `foldl const 'z' [1..5]` |