monad.hs

module Monad where                                                                                                     
                                                                                                                       
import Prelude hiding (fmap, Functor, Monad)                                                                           
                                                                                                                       
class Functor f where                                                                                                  
                                                                                                                       
  fmap :: (a -> b) -> f a -> f b                                                                                       
                                                                                                                       
class Functor m => Applicative m where                                                                                 
                                                                                                                       
  pure :: a -> m a                                                                                                     
                                                                                                                       
  ap :: m (a -> b) -> m a -> m b                                                                                       
                                                                                                                       
class (Functor m, Applicative m) => Monad m where                                                                      
                                                                                                                       
  (<$>) :: (a -> b) -> m a -> m b                                                                                      
  f <$> a = bind (pure . f) a                                                                                          
                                                                                                                       
  (<*>) :: m (a -> b) -> m a -> m b                                                                                    
  f <*> a = bind (<$> a) f                                                                                       
                                                                                                                       
  join :: m (m a) -> m a                                                                                               
  join = bind id                                                                                                       
                                                                                                                       
  bind :: (a -> m b) -> m a -> m b                                                                                     
  bind f = join . fmap f