module Control.Monad where




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

class (Control.Applicative.Alternative m, Monad m) => MonadPlus m where
  -- mzero :: m a -- this is a critical case: too generic, yet we might need it
                  -- at times
  -- more specific than (<|>)
  -- mplus :: m a -> m a -> m a

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
join :: Monad m => m (m a) -> m a
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
mfilter :: MonadPlus m => (a -> Data.Bool.Bool) -> m a -> m a 
zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c] 
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b 
forever :: Monad m => m () -> m Void
(>>) :: Monad m => m () -> m b -> m b

instance Monad []
instance Monad IO
instance Monad Data.Maybe.Maybe
instance Monad ReadP
instance Monad ReadPrec
instance Monad STM
-- instance Monad ((->) r)
instance Monad (Data.Either.Either e)
instance Monad (ST s)
-- instance Monad (Proxy *)
instance ArrowApply a => Monad (ArrowMonad a)
instance Monad (ST s)
instance Monad m => Monad (WrappedMonad m)