4-Applicative-3-Instances

1. Implement an instance of Applicative for Maybe.

instance Applicative Maybe where
  pure g = Just g
  (<*>) (Just g) = fmap g
  (<*>) Nothing  = \_ -> Nothing

Identity law:

pure id <*> v = (Just id) <*> v = fmap id v
fmap id Nothing = Nothing
fmap id (Just x) = Just (id x) = Just x

Homomorphism:

pure g <*> pure x = (Just g) <*> (Just x)
  = fmap g (Just x) = Just (g x) = pure (g x)

Interchange:

-- show:
u <*> pure y = pure ($ y) <*> u
-- u = Nothing
Nothing <*> pure y = Nothing = fmap ($ y) Nothing
  = pure ($ y) <*> Nothing
-- u = Just g
Just g <*> pure y = Just (g y) = Just (($ y) g)
  = fmap ($ y) (Just g) = pure ($ y) <*> Just g

Composition:

u <*> (v <*> w) = pure (.) <*> u <*> v <*> w
-- TODO

2. Determine the correct definition of pure for the ZipList instance of Applicative—there is only one implementation that satisfies the law relating pure and (<*>).

newtype ZipList a = ZipList { getZipList :: [a] }
 
instance Applicative ZipList where
  pure :: a -> ZipList a
  pure = ZipList . repeat
 
  (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b
  (ZipList gs) <*> (ZipList xs) = ZipList (zipWith ($) gs xs)