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
7 years ago
|
# 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]`
|