Add solutions to the typeclass chapter

Author: BoeingX

src/Typeclasses/ChapterExercises/DoesItTypecheck.md

@@ -0,0 +1,40 @@
+# Does it typecheck?
+
+1. The following code
+```haskell
+data Person = Person Bool
+
+printPerson :: Person -> IO ()
+printPerson person = putStrLn (show person)
+```
+does not typecheck because `Person` has no instance of `Show`.
+
+2. The following code
+```haskell
+data Mood = Blah
+          | Woot deriving Show
+
+settleDown x = if x == Woot
+                then Blah
+                else x
+```
+does not typecheck because `Mood` has no instance of `Eq`.
+
+3. Suppose that we were able to get `settleDown` to typecheck, then
+    a) it accepts `Blah` and `Woot` as input
+    b) `settleDown 9` gives an error saying *No instance for (Num Mood) arising from the literal '9'*.
+    c) `Blah > Woot` gives an error because `Mood` has no instance of `Ord`.
+
+4. The following code
+```haskell
+type Subject = String
+type Verb = String
+type Object = String
+
+data Sentence = Sentence Subject Verb Object
+    deriving (Eq, Show)
+
+s1 = Sentence "dogs" "drool"
+s2 = Sentence "Julie" "loves" "dogs"
+```
+does typecheck.

src/Typeclasses/ChapterExercises/GivenDatatypeDeclarationWhatCanWeDo.md

@@ -0,0 +1,26 @@
+# Given a datatype declaration, what can we do?
+
+Given the following datatype definitions:
+```haskell
+data Rocks = Rocks String deriving (Eq, Show)
+data Yeah = Yeah Bool deriving (Eq, Show)
+data Papu = Papu Rocks Yeah deriving (Eq, Show)
+```
+
+1. `phew = Papu "chases" True` does not typecheck because `"chases"` is not of type `Rocks` and `True` is not of type `Yeah`.
+
+2. `truth = Papu (Rocks "chomskydoz") (Yeah True)` typechecks.
+
+3. The following
+```haskell
+equalityForall :: Papu -> Papu -> Bool
+equalityForall p p' = p == p'
+```
+typechecks.
+
+4. The following
+```haskell
+comparePapus :: Papu -> Papu -> Bool
+comparePapus p p' = p > p'
+```
+does not typecheck because `Papu` has no instance of `Ord`.

src/Typeclasses/ChapterExercises/MatchTheTypes.md

@@ -0,0 +1,78 @@
+# Match the types
+
+1. For the following definition
+```haskell
+i :: Num a => a
+i = 1
+```
+we cannot replace the type signature with `i :: a`.
+Indeed, `i :: a` means that `i` could be resolved as **any** type,
+it is clearly impossible to resolve `1` as `String`.
+
+2. In
+```haskell
+f :: Float
+f = 1.0
+```
+we cannot replace the type signature by `f :: Num a => a`.
+Again, `f :: Num a => a` means `f` could be **any** type which
+has instance of `Num`.
+`1.0` clearly cannot be a `Integer`.
+Instead, `f :: (Fractional a) => a` **typechecks**
+(which answers the question 3).
+
+4. In
+```haskell
+f :: Float
+f = 1.0
+```
+we can replace the type signature by `f :: (RealFrac a) => a`.
+5. In 
+```haskell
+freud :: a -> a
+freud x = x
+```
+we can replace the type signature by `freud :: Ord a => a -> a`.
+
+6. In
+```haskell
+freud' :: a -> a
+freud' x = x
+```
+we can replace the type signature by `freud' :: Int -> Int`.
+
+7. In
+```haskell
+myX = 1 :: Int
+
+sigmund :: Int -> Int
+sigmund x = myX
+```
+we **cannot** write `sigmund :: a -> a` because `myX :: Int` could
+**not** be resolved as for example `String`.
+Similarly, `sigmund :: (Num a) => a -> a` does **not** typecheck
+(which answers the question 8).
+
+9. In
+```haskell
+jung :: Ord a => [a] -> a
+jung xs = head (sort xs)
+```
+we can write `jung :: [Int] -> Int`.
+
+10. In
+```haskell
+young :: [Char] -> Char
+young xs = head (sort xs)
+```
+we can write `young :: Ord a => [a] -> a`.
+
+11. In
+```haskell
+mySort :: [Char] -> [Char]
+mySort = sort
+
+signifier :: [Char] -> Char
+signifier xs = head (mySort xs)
+```
+we cannot write `signifier :: Ord a => [a] -> a` because `mySort` expects `[Char]` and returns `[Char]`.

src/Typeclasses/ChapterExercises/MultipleChoice.md

@@ -0,0 +1,12 @@
+# Multiple Choice
+
+1. The `Eq` class c) makes equality tests possible.
+
+2. The typeclass `Ord` b) is a subclass of `Eq`.
+
+3. Suppose the typeclass `Ord` has an operator `>`. Then the type of
+`>` is a) `Ord a => a -> a -> Bool`.
+
+4. In `x = divMod 16 12`,  c) the type of `x` is a tuple.
+
+5. The typeclass `Integral` includes a) `Int` and `Integer` numbers.

src/Typeclasses/ChapterExercises/TypeKwonDo.hs

@@ -0,0 +1,9 @@
+module Typeclasses.ChapterExercises.TypeKwonDo where
+
+-- Question 1
+chk :: Eq b => (a -> b) -> a -> b -> Bool
+chk f a = (==) (f a)
+
+-- Question 2
+arith :: Num b => (a -> b) -> Integer -> a -> b
+arith f _ = f

src/Typeclasses/Ord/IntermissionExercises.md

@@ -0,0 +1,9 @@
+# Intermission: Exercises
+
+1. `max (length [1, 2, 3]) (length [8, 9, 10, 11, 12]) = 5`
+
+2. `compare (3 * 4) (3 * 5) = LT`
+
+3. `compare "Julie" True` gives an error because `"Julie" :: String` and `True :: Bool`
+
+4. `(5 + 3) > (3 + 6) = False`

src/Typeclasses/WritingTypeclassInstances/IntermissionExercises.hs

@@ -0,0 +1,49 @@
+module Typeclasses.WritingTypeclassInstances.IntermissionExercises where
+
+-- Question 1
+data TisAnInteger = TisAn Integer
+
+instance Eq TisAnInteger where
+    TisAn x == TisAn y = x == y
+
+-- Question 2
+data TwoIntegers = Two Integer Integer
+
+instance Eq TwoIntegers where
+    Two x y == Two x' y' = x == x' && y == y'
+
+-- Question 3
+data StringOrInt = TisAnInt Int | TisAString String
+
+instance Eq StringOrInt where
+    TisAnInt x      == TisAnInt y       = x == y
+    TisAString x    == TisAString y     = x == y
+    _               == _                = False
+
+-- Question 4
+data Pair a = Pair a a
+
+instance (Eq a) => Eq (Pair a) where
+    Pair a a' == Pair b b' = a == b && a' == b'
+
+-- Question 5
+data Tuple a b = Tuple a b
+
+instance (Eq a, Eq b) => Eq (Tuple a b) where
+    Tuple a b == Tuple a' b' = a == a' && b == b'
+
+-- Question 6
+data Which a = ThisOne a | ThatOne a
+
+instance (Eq a) => Eq (Which a) where
+    ThisOne a   == ThisOne a'   = a == a'
+    ThatOne a   == ThatOne a'   = a == a'
+    _           == _            = False
+
+-- Question 7
+data EitherOr a b = Hello a | Goodbye b
+
+instance (Eq a, Eq b) => Eq (EitherOr a b) where
+    Hello a     == Hello a'     = a == a'
+    Goodbye b   == Goodbye b'   = b == b'
+    _           == _            = False