Add solutions to the More functional patterns chapter

Author: BoeingX

src/MoreFunctionalPatterns/AnonymousFunctions/IntermissionExercises.md

@@ -0,0 +1,18 @@
+# Intermission: Exercises
+
+1. All expressions are equivalent.
+
+2. The type of `mTh 3` is `Num a => a -> a -> a`.
+
+3. We have
+
+```haskell
+addOneIfOdd n = case odd n of
+    True -> f n
+    False -> n
+    where f = \n -> n + 1
+
+addFive x y = \x y -> (if x > y then y else x) + 5
+
+mflip f x y = f y x
+```

src/MoreFunctionalPatterns/CaseExpressions/IntermissionExercises.hs

@@ -0,0 +1,14 @@
+module MoreFunctionalPatterns.CaseExpressions.IntermissionExercises where
+
+functionC x y = case compare x y of
+                    GT -> x
+                    _ -> y
+
+ifEvenAdd2 n = case even n of 
+                    True -> n+2
+                    _ -> n
+
+nums x = case compare x 0 of
+           LT -> -1
+           EQ -> 0
+           GT -> 1

src/MoreFunctionalPatterns/ChapterExercises/LetUsWriteCode.hs

@@ -0,0 +1,36 @@
+module MoreFunctionalPatterns.ChapterExercises.LetUsWriteCode where
+
+-- Question 1
+tensDigit :: Integral a => a -> a
+tensDigit x = d
+    where (xLast, _) = x `divMod` 10
+          (_, d)     = xLast `divMod` 10
+
+
+hunsDigit :: Integral a => a -> a
+hunsDigit x = d
+    where xLast = x `div` 100
+          d     = xLast `mod` 10
+
+-- Question 2
+foldBool :: a -> a -> Bool -> a
+foldBool x y z = case z of
+                   True -> x
+                   _    -> y
+
+foldBool' :: a -> a -> Bool -> a
+foldBool' x y z
+  | z = x
+  | otherwise = y
+
+-- Question 3
+g :: (a -> b) -> (a, c) -> (b, c)
+g f (a, c) = (f a, c)
+
+-- Question 5
+roundTrip :: (Show a, Read a) => a -> a
+roundTrip = read . show
+
+-- Question 6
+roundTrip' :: (Show a, Read b) => a -> b
+roundTrip' = read . show

src/MoreFunctionalPatterns/ChapterExercises/MultipleChoice.md

@@ -0,0 +1,21 @@
+# Multiple Choice
+
+1. A polymorphic function d) may resolve to values of different types, depending on inputs.
+
+2. Two functions named `f` and `g` have types `Char -> String` and
+`String -> [String]` respectively.
+The composed function `g . f` has the type
+b) `Char -> [String]`.
+
+3. A function `f` has the type `Ord a => a -> a -> Bool`
+and we apply it to one numeric value,
+its type is now d) `(Num a, Ord a) => a -> Bool`.
+
+4. A function with type `(a -> b) -> c` b) is a higher-order function
+
+5. Given the following definition of `f`
+```haskell
+f :: a -> a
+f x = x
+```
+the type of `f True` is a) `f True :: Bool`.

src/MoreFunctionalPatterns/Guards/IntermissionExercises.md

@@ -0,0 +1,22 @@
+# Intermission: Exercises
+
+3. The following function
+```haskell
+pal xs
+    | xs == reverse xs = True
+    | otherwise = False
+```
+b) returns `True` when `xs` is a palindrome.
+
+5. `pal :: [a] -> Bool` (or `pal :: (Foldable t) => t a -> Bool`).
+
+6. The following function
+```haskell
+numbers x
+    | x < 0 = -1
+    | x == 0 = 0
+    | x > 0 = 1
+```
+c) returns an indication of whether its argument is a positive or negative number or zero
+
+8. `numbers :: (Num a, Ord a) => a -> a`

src/MoreFunctionalPatterns/HigherOrderFunctions/IntermissionExercises.hs

@@ -0,0 +1,10 @@
+module MoreFunctionalPatterns.HigherOrderFunctions.IntermissionExercises where
+
+dodgy :: (Num a) => a -> a -> a
+dodgy x y = x + y * 10
+
+oneIsOne :: (Num a) => a -> a
+oneIsOne = dodgy 1
+
+oneIsTwo :: (Num a) => a -> a
+oneIsTwo = (flip dodgy) 2

src/MoreFunctionalPatterns/PatternMatching/IntermissionExercises.md

@@ -0,0 +1,18 @@
+# Intermission: Exercises
+
+1. Given the following declarations
+```haskell
+k (x, y) = x
+k1 = k ((4-1), 10)
+k2 = k ("three", (1 + 2))
+k3 = k (3, True)
+```
+    a) `k :: (a, b) -> a`.
+    b) `k2 :: String`, which is different from `k1 :: Num a => a` and `k3 :: Num a => a`.
+    c) `k1` and `k3` returns `3` as result.
+
+2. We have
+```haskell
+f :: (a, b, c) -> (d, e, f) -> ((a, d), (c, f))
+f (a, b, c) (d, e, f) = ((a, d), (c, f))
+```

test/MoreFunctionalPatterns/ChapterExercises/LetUsWriteCodeSpec.hs

@@ -0,0 +1,10 @@
+module MoreFunctionalPatterns.ChapterExercises.LetUsWriteCodeSpec where
+
+import Test.Hspec
+import MoreFunctionalPatterns.ChapterExercises.LetUsWriteCode
+
+spec :: Spec
+spec = do
+    describe "Test roundTrip'" $ do
+        it "roundTrip' 4" $ do
+            roundTrip' 4 `shouldBe` 4