ICFP '07 Post-Mortem: I

This is the first of a few posts outlining Creighton and myself's effort towards this years IFCP programming competition. We didn't get too far, but I've learned a lot (more) about Haskell along the way.

I plan on doing one post per module, and this first post defines the Maybe monad transformer, which isn't in GHC (yet?) but made our code look much neater.

• Part I
• Part II
• Part III
• Part IV

Check it out!

=======================
Maybe.lhs

> {-# OPTIONS -fallow-undecidable-instances -fglasgow-exts #-}

> module Maybe where

Almost all of this is taken from the Haskell Wiki

> import Control.Monad
> import Control.Monad.Trans
> import Control.Monad.State
 
> newtype MaybeT m a = MaybeT {runMaybeT :: m (Maybe a)}
 
> instance Functor m => Functor (MaybeT m) where
>   fmap f x = MaybeT $ fmap (fmap f) $ runMaybeT x
 
> instance Monad m => Monad (MaybeT m) where
>   return = MaybeT . return . return
>   x >>= f = MaybeT $ runMaybeT x >>= maybe (return Nothing) (runMaybeT . f)
>   fail _ = MaybeT $ return Nothing
 
> instance Monad m => MonadPlus (MaybeT m) where
>   mzero = MaybeT $ return mzero
>   mplus x y = MaybeT $ liftM2 mplus (runMaybeT x) (runMaybeT y)
 
> instance MonadTrans MaybeT where
>   lift = MaybeT . liftM return

Here are my contributions, which I shoudl proabbly give back to the wiki: the MonadIO instance and the MonadState instance. You'd think these would generalize to any instance of MonadTrans, seeing as I only use lift. I haven't tried it yet.

> instance MonadIO m => MonadIO (MaybeT m) where
>     liftIO = lift . liftIO

My Haskell-fu isn't good enough to make the instance of MonadState work without -fallow-undecidable-instances. If anyone knows why, let me know.

> instance (MonadState s m) => MonadState s (MaybeT m) where
>     get = lift get
>     put = lift . put