Instances in the Monad class

Monads we have encountered before

instance Monad IO     -- predefined
instance Monad Gen    -- from QuickCheck
instance Monad Parser -- from the Parsing module

The Maybe type is a monad

• instance Monad Maybe where
    return x = Just x
    
    Just x  >>= f  = f x
    Nothing >>= _  = Nothing

• In this instance:

• return :: a -> Maybe a
  (>>=)  :: Maybe a -> (a->Maybe b) -> Maybe b

The list type is a monad

• instance Monad [] where
    return x = [x]
    xs >>= f = [y | x<-xs, y<-f x]
  

• In this instance:

• return :: a -> [a]
  (>>=)  :: [a] -> (a->[b]) -> [b]
  

List comprehensions vs do blocks

• The similarity is not a coincidence

  • [y | x<-xs, y<-f x]

    ⟺

    do   x<-xs; y<-f x; return y

• The list monad is the same as list comprehensions

Instances in the Functor class

• instance Functor IO
  instance Functor Gen  -- from QuickCheck
  instance Functor Parser

• So we have

• fmap :: (a->b) -> IO a -> IO b
  fmap :: (a->b) -> Gen a -> Gen b
  fmap :: (a->b) -> Parser a -> Parser b

The Maybe type is a Functor

• instance Functor Maybe where
    fmap f Nothing = Nothing
    fmap f (Just x) = Just (f x)
  

• In this instance

• fmap :: (a->b) -> Maybe a -> Maybe b

The list type is a Functor

• instance Functor [] where
    fmap = map

• In this instance

• fmap :: (a->b) -> [a] -> [b]
  

Instances in the Applicative class

• instance Applicative IO
  instance Applicative Gen  -- from QuickCheck
  instance Applicative Parser

• So we have

• (<*>) :: IO     (a->b) -> IO a     -> IO b
  (<*>) :: Gen    (a->b) -> Gen a    -> Gen b
  (<*>) :: Parser (a->b) -> Parser a -> Parser b

The list type is in Applicative

• instance Applicative [] where
    pure x = [x]
    fs <*> xs = [f x | f<-fs, x<-xs]
  

• In this instance

• pure  :: a -> [a]
  (<*>) :: [a->b] -> [a] -> [b]
  

The Maybe type is in Applicative

• instance Applicative Maybe where
    pure x = Just x
    Just f <*> Just x = Just (f x)
    _      <*> _      = Nothing

• In this instance

• pure  :: a -> Maybe a
  (<*>) :: Maybe (a->b) -> Maybe a -> Maybe b

A note about changes in GHC 7.10

• Starting with GHC 7.10,

  Applicative

    is a superclass of

  Monad

  ,

  • class Applicative m => Monad m where -- ...
    

• so to make a

  Monad

    instance you also have to make an

  Applicative

  instance and a

  Functor

  instance.
• This is easy using standard library functions:

  • fmap

    =

    liftM

  • pure

    =

    return

  • (<*>)

    =

    ap