haskell notes

Question 1

Functor laws

Answer 1

– preserve identity law
fmap id = id

– preserve function composition
fmap (g . h) = fmap g . fmap h

Question 2

Applicative laws

Answer 2

– preserves identity function
pure id ^*> x = x

– preserves function application
pure (g x) = pure g ^*> pure x

– order of evaluation does not matter
x ^> pure y = pure (\g -> g y) ^> x

– is associative
x ^> (y ^> z) = (pure (.) ^> x ^> y) ^*> z

Question 3

Monad laws

Answer 3

– bind returned value a function = apply function to value
return x&raquo_space;= f = f x

– bind return to a monadic value is the monadic value
mx&raquo_space;= return = mx

– binding is associative
(mx&raquo_space;= f)&raquo_space;= g = mx&raquo_space;= (\x -> (f x&raquo_space;= g))

Question 4

Functor Class definition

Answer 4

class Functor f where
    fmap::(a->b) -> f a -> f b

Question 5

list Functor instance

Answer 5

instance Functor [] where
– fmap :: (a -> b) -> [a] -> [b]
fmap = map

Question 6

Maybe Functor instance

Answer 6

instance Functor Maybe where
    -- fmap :: (a -> b) -> Maybe a -> Maybe b
    fmap _ Nothing = Nothing
    fmap g (Just x) = Just (g x)

Question 7

IO Functor instance

Answer 7

instance Functor IO where
– fmap :: (a -> b) -> IO a -> IO b
fmap g mx = do
x

Question 8

Applicative class definition

Answer 8

class Functor f => Applicative f where
pure::a -> f a
()::f (a -> b) -> f a -> f b

Question 9

Maybe Applicative instance

Answer 9

instance Applicative Maybe where
– pure:: a -> Maybe a
pure = Just

– ():: Maybe (a -> b) -> Maybe a -> Maybe b
Nothing _ = Nothing
(Just g) mx = fmap g mx

Question 10

list Applicative instance

Answer 10

instance Applicative [] where
– pure :: a -> [a]
pure a = [a]

-- ()::[a->b] -> [a] -> [b]
gs  xs = [g x | g

Question 11

IO Applicative instance

Answer 11

instance Applicative IO where
– pure:: a -> IO a
pure = return

-- () :: IO (a -> b) -> IO a -> IO b
mg  mx = do
        g

Question 12

Monad class definition

Answer 12

class Applicative m => Monad m where
    return :: a -> m a
    (>>=) :: m a -> (a -m b) -> m b

Question 13

Maybe Monad instance

Answer 13

instance Monad Maybe where
– (»=):: Maybe a -> (a -> Maybe b) -> Maybe b
Nothing&raquo_space;= _ = Nothing
(Just x)&raquo_space; f = f x

Question 14

list Monad instance

Answer 14

instance Monad [] where
– (»=) :: [a] -> (a -> [b]) -> [b]
xs&raquo_space;= f = [y | x

Question 15

Monoid class definition

Answer 15

class Monoid a where

mempty: :a
mappend: : a -> a-> a

mconcat:: [a] -> a
mconcat = foldr mappend mempty

Question 16

Monoid laws

Answer 16

– identity 1
mempty mappend x = x

– identity 2
x mappend mempty = x

–associativity
x mappend (y mappend z) = (x mappend y) `mappend z

Question 17

list Monoid instance

Answer 17

instance Monoid [a] where
– mempty :: [a]
mempty = []

-- mappend:: a -> a-> a
mappend = (++)

Question 18

Maybe Monoid instance

Answer 18

instance Monoid (Maybe a) where
–mempty :: Maybe a
Nothing

-- mappend :: a -> a -> a
Nothing `mappend` my = my
mx `mappend` Nothing = mx
Just x `mappend` Just y = Just (x `mappend` y)

Question 19

Foldable class definition

Answer 19

class Foldable t where
fold::Monoid a => t a -> a
foldMap:: Monoid b => (a -> b) -> t a -> t b
foldr:: (a -> b -> b) -> b -> t a -> b
foldl:: (a -> b -> a) -> a -> t b -> a

Question 20

list Foldable instance

Answer 20

instance Foldable [] where
– fold::Monoid a => t a -> a
fold [] = mempty
fold (x:xs) = x mappend fold xs

-- foldMap:: Monoid b => (a -> b)  -> t a -> t b
foldMap _ [] = mempty
foldMap f (x:xs) = f x `mappend` foldMap f xs

-- foldr:: (a -> b -> b) -> b -> t a -> b
foldr _ v [] = v
foldr f v (x:xs) = f x (foldr f v xs)

-- foldl:: (a -> b -> a) -> a -> t b -> a
foldl _ v [] = v
foldl f v (x:xs) = foldl f (f v x) xs

Question 21

other Foldable primitive functions

Answer 21

null            :: t a -> Bool
length       :: t a -> Int
elem         :: Eq a => a -> t a -> Bool
maximum :: Ord a => t a -> a
minimum  :: Ord a => t a -> a
sum          :: Num a => t a -> a
product    :: Num a => t a -> a

Question 22

class definition Traversable

Answer 22

class (Functor t, Foldable t) => Traversable t where

traverse:: Applicative f => (a -> f b) -> t a -> f (t b)