Safe Haskell	None

Clean.Monad

Synopsis

Documentation

module Clean.Applicative

class Applicative m => Monad m whereSource

Methods

join :: m (m a) -> m aSource

(>>=) :: m a -> (a -> m b) -> m bSource

Instances

Monad []
Monad IO
Monad Tree
Monad Interleave
Monad Id
Monad ((->) a)
Monad (Either a)
Monoid w => Monad ((,) w)
Monad (Const a)
(Monad f, Contravariant f, Monad g) => Monad (Compose f g)
Monad m => Monad (ContT r m)
(Monoid w, Monad m) => Monad (WriterT w m)
Monad m => Monad (ReaderT r m)
Monad m => Monad (StateT s m)
Monad m => Monad (Kleisli m a)

class MonadFix m whereSource

Methods

mfix :: (a -> m a) -> m aSource

Instances

MonadFix Id
MonadFix ((->) b)

class MonadTrans t whereSource

Methods

lift :: Monad m => m a -> t m aSource

internal :: Monad m => (forall c. m (c, a) -> m (c, b)) -> t m a -> t m bSource

Instances

MonadTrans (ContT r)
Monoid w => MonadTrans (WriterT w)
MonadTrans (ReaderT r)
MonadTrans (StateT s)

class Monad m => MonadState s m whereSource

Methods

get :: m sSource

put :: s -> m ()Source

modify :: (s -> s) -> m ()Source

Instances

(Monoid w, MonadState r m) => MonadState r (WriterT w m)
MonadState s m => MonadState s (ReaderT r m)
Monad m => MonadState s (StateT s m)

class Monad m => MonadReader r m whereSource

Methods

ask :: m rSource

local :: (r -> r) -> m a -> m aSource

Instances

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Monad m => MonadReader r (ReaderT r m)
MonadReader r m => MonadReader r (StateT s m)

class (Monad m, Monoid w) => MonadWriter w m whereSource

Methods

tell :: w -> m ()Source

listen :: m a -> m (w, a)Source

censor :: m (a, w -> w) -> m aSource

Instances

(Monad m, Monoid w) => MonadWriter w (WriterT w m)
MonadWriter w m => MonadWriter w (ReaderT r m)
MonadWriter w m => MonadWriter w (StateT s m)

newtype StateT s m a Source

A simple State Monad

Constructors

StateT
Fields runStateT :: s -> m (s, a)

Instances

MonadWriter w m => MonadWriter w (StateT s m)
MonadReader r m => MonadReader r (StateT s m)
Monad m => MonadState s (StateT s m)
MonadTrans (StateT s)
Unit m => Unit (StateT s m)
Monad m => Monad (StateT s m)
Monad m => Applicative (StateT s m)
Monad m => Functor (StateT s m)

type State s a = StateT s Id aSource

newtype ReaderT r m a Source

A simple Reader monad

Constructors

ReaderT
Fields runReaderT :: r -> m a

Instances

MonadWriter w m => MonadWriter w (ReaderT r m)
Monad m => MonadReader r (ReaderT r m)
MonadState s m => MonadState s (ReaderT r m)
MonadTrans (ReaderT r)
Monad m => Unit (ReaderT r m)
Monad m => Monad (ReaderT r m)
Monad m => Applicative (ReaderT r m)
Monad m => Functor (ReaderT r m)

type Reader r a = ReaderT r Id aSource

newtype WriterT w m a Source

A simple Writer monad

Constructors

WriterT
Fields runWriterT :: m (w, a)

Instances

(Monad m, Monoid w) => MonadWriter w (WriterT w m)
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
(Monoid w, MonadState r m) => MonadState r (WriterT w m)
Monoid w => MonadTrans (WriterT w)
(Monoid w, Monad m) => Unit (WriterT w m)
(Monoid w, Monad m) => Monad (WriterT w m)
(Monoid w, Monad m) => Applicative (WriterT w m)
(Monoid w, Monad m) => Functor (WriterT w m)

type Writer w a = WriterT w Id aSource

newtype ContT r m a Source

A simple continuation monad implementation

Constructors

ContT
Fields runContT :: (a -> m r) -> m r

Instances

MonadTrans (ContT r)
Unit m => Unit (ContT r m)
Monad m => Monad (ContT r m)
Monad m => Applicative (ContT r m)
Monad m => Functor (ContT r m)

type Cont r a = ContT r Id aSource

(=<<) :: Monad m => (a -> m b) -> m a -> m bSource

(>>) :: Applicative f => f a1 -> f a -> f aSource

return :: Unit f => a -> f aSource