Merge branch 'master' of github.com:mukeshsoni/haskell-programming-book

Author: mukeshsoni

chapter16/FunctorLaws.hs

@@ -0,0 +1,22 @@
+import Test.QuickCheck
+import Test.QuickCheck.Function
+
+functorIdentity :: (Functor f, Eq (f a)) =>
+                        f a -> Bool
+functorIdentity f = fmap id f == f
+
+functorCompose :: (Functor f, Eq (f c)) =>
+                       (a -> b)
+                    -> (b -> c)
+                    -> f a
+                    -> Bool
+functorCompose f g x =
+    (fmap g (fmap f x)) == fmap (g . f) x
+
+functorCompose' :: (Eq (f c), Functor f) =>
+                       f a
+                    -> Fun a b
+                    -> Fun b c
+                    -> Bool
+functorCompose' x (Fun _ f) (Fun _ g) =
+    (fmap g (fmap f x)) == fmap (g . f) x

chapter16/Possibly.hs

@@ -0,0 +1,8 @@
+data Possibly a =
+      LolNope
+    | Yeppers a
+    deriving (Eq, Show)
+
+instance Functor Possibly where
+    fmap _ LolNope = LolNope
+    fmap f (Yeppers a) = Yeppers (f a)

chapter16/SumFunctor.hs

@@ -0,0 +1,8 @@
+data Sum a b =
+    First a
+  | Second b
+  deriving (Eq, Show)
+
+instance Functor (Sum a) where
+    fmap _ (First a) = First a
+    fmap f (Second b) = Second (f b)

chapter16/be_kind.md

@@ -0,0 +1,27 @@
+1. What is the kind of a?
+
+```
+a -> a
+```
+
+Ans -
+Kind of a is '\*'
+
+2. What are the kinds of b and T?
+
+```
+a -> b a -> T (b a)
+
+Ans -
+Kind of b is `* -> *`
+Kind of T is `* -> *`
+
+3. What is the kind of c?
+```
+
+c a b -> c b a
+
+```
+Ans -
+The kind of c is `* -> * -> *`
+```

chapter16/heavy_lifting.hs

@@ -0,0 +1,45 @@
+-- Instructions
+-- Add fmap, parentheses, and function composition to the expression
+-- as needed for the expression to typecheck and produce the 
+-- expected result.
+
+-- 1. a = (+1) $ read "[1]" :: [Int]
+a :: [Int]
+a = fmap (+1) $ (read "[1]" :: [Int])
+
+-- 2. b = (++ "lol") (Just ["Hi,", "Hello"])
+-- Expected value of b is Just ["Hi,lol", "Hellolol"]
+b :: Maybe [ String ]
+b = (fmap . fmap) (++ "lol") (Just ["Hi", "Hello"])
+
+-- 3. c = (*2) (\x -> x - 2)
+-- Preluce> c 1
+-- -2
+-- Solution Note - This one is tricky since the fmap is happening over the function functor (yes, no typo there)
+c :: Integer -> Integer
+c = fmap (*2) (\x -> x - 2)
+
+-- 4. d = ((return "1" ++) . show) (\x -> [x, 1..3]) 
+-- Prelude> d 0
+-- 1[0, 1, 2, 3]
+d :: Integer -> String
+d = fmap (("1" ++) . show) (\x -> [x, 1..3])
+
+-- 5. e :: IO Integer
+-- e = let ioi = readIO "1" :: IO Integer
+--         changed = read ("123" ++) show ioi
+--     in (*3) changed
+-- Prelude> e
+-- 3693
+e :: IO Integer
+e = let ioi = (readIO "1" :: IO Integer)
+        changed = fmap (read . ("123" ++) . show) ioi
+    in fmap (*3) changed
+
+main :: IO Integer
+main = do
+    print a
+    print b
+    print (c 1)
+    print (d 0)
+    e