Clean.Monad

Contents

• The basic Monad interface
• Common monads
  • The State Monad
  • The Reader monad
  • The Writer monad
  • The Continuation monad

Synopsis

• module Clean.Applicative
• class Applicative m => Monad m where
  • join :: m (m a) -> m a
  • (>>=) :: m a -> (a -> m b) -> m b
• class Monad m => MonadFix m where
  • mfix :: (a -> m a) -> m a
• class MonadTrans t where
  • lift :: Monad m => m a -> t m a
  • internal :: Monad m => (forall c. m (c, a) -> m (c, b)) -> t m a -> t m b
• (=<<) :: Monad m => (a -> m b) -> m a -> m b
• (>>) :: Applicative f => f a1 -> f a -> f a
• return :: Unit f => a -> f a
• class Monad m => MonadState s m where
  • get :: m s
  • put :: s -> m ()
  • modify :: (s -> s) -> m ()
• newtype StateT s m a = StateT {
  • runStateT :: s -> m (s, a)
  }
• type State s a = StateT s Id a
• evalStateT :: Functor f => StateT a f b -> a -> f b
• execStateT :: Functor f => StateT b f b1 -> b -> f b
• runState :: State s a -> s -> (s, a)
• execState :: State s a -> s -> s
• evalState :: State s a -> s -> a
• class Monad m => MonadReader r m where
  • ask :: m r
  • local :: (r -> r) -> m a -> m a
• newtype ReaderT r m a = ReaderT {
  • runReaderT :: r -> m a
  }
• type Reader r a = ReaderT r Id a
• class (Monad m, Monoid w) => MonadWriter w m where
  • tell :: w -> m ()
  • listen :: m a -> m (w, a)
  • censor :: m (a, w -> w) -> m a
• newtype WriterT w m a = WriterT {
  • runWriterT :: m (w, a)
  }
• type Writer w a = WriterT w Id a
• runWriter :: WriterT w Id a -> (w, a)
• class Monad m => MonadCont m where
  • callCC :: ((a -> m b) -> m a) -> m a
• newtype ContT r m a = ContT {
  • runContT :: (a -> m r) -> m r
  }
• type Cont r a = ContT r Id a
• evalContT :: Unit m => ContT r m r -> m r
• evalCont :: ContT a Id a -> a

Documentation

The basic Monad interface

Common monads

The State Monad

The Reader monad

The Writer monad

The Continuation monad