SimpleH.Monad

Documentation

module SimpleH.Applicative

The basic Monad interface

class Applicative m => Monad m where

Methods

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

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

Instances

Monad []

Monad IO

Monad Maybe

Monad Tree

Monad Interleave

Monad Id

Monad TimeVal

Monad ((->) a)

Monad (Either a)

Monoid w => Monad ((,) w)

MonadFix m => Monad (Backwards m)

Monad m => Monad (ListT m)

Ord t => Monad (Future t)

(Bounded t, Ord t) => Monad (Event t)

(Traversable g, Monad f, Monad g) => Monad (Compose f g)

Monad m => Monad (EitherT e m)

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)

(Monoid w, Monad m) => Monad (ParserT w c m)

(Monoid w, Monad m) => Monad (RWST r w s m)

class Monad m => MonadFix m where

The class of all monads that have a fixpoint

Methods

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

Instances

MonadFix []

MonadFix IO

MonadFix Id

MonadFix ((->) b)

MonadFix (Either e)

MonadFix m => MonadFix (ListT m)

(Contravariant f, Monad f, Traversable g, MonadFix g) => MonadFix (Compose f g)

(Monad m, Contravariant m) => MonadFix (EitherT e m)

(Monoid w, MonadFix m) => MonadFix (WriterT w m)

MonadFix m => MonadFix (ReaderT r m)

MonadFix m => MonadFix (StateT s m)

(Monoid w, MonadFix m) => MonadFix (ParserT w c m)

(Monoid w, MonadFix m) => MonadFix (RWST r w s m)

class MonadTrans t where

Methods

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

Instances

MonadTrans Backwards

MonadTrans ListT

MonadTrans (ContT r)

Monoid w => MonadTrans (WriterT w)

MonadTrans (ReaderT r)

MonadTrans (StateT s)

Monoid w => MonadTrans (RWST r w s)

Monad utilities

newtype Kleisli m a b

Constructors

Kleisli

Fields

runKleisli :: a -> m b

Instances

Monad m => Split (Kleisli m)

Monad m => Choice (Kleisli m)

Monad m => Category (Kleisli m)

Monad m => Apply (Kleisli m)

Monad m => Arrow (Kleisli m)

Isomorphic (a -> m b) (a -> m c) (Kleisli m a b) (Kleisli m a c)

_Kleisli :: (Functor f, Bifunctor p) => p (Kleisli m a b) (f (Kleisli m a b)) -> p (a -> m b) (f (a -> m b))

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

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

(>=>) :: Monad m => (t -> m a) -> (a -> m b) -> t -> m b

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

(<*=) :: Monad m => m b -> (b -> m a1) -> m b

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

foldlM :: (Monad m, Foldable t) => (b -> a -> m a) -> a -> t b -> m a

foldrM :: (Monad m, Foldable t) => (b -> a -> m a) -> a -> t b -> m a

while :: Monad m => m (Maybe a) -> m ()

until :: Monad m => m (Maybe b) -> m b

Common monads

The RWS Monad

newtype RWST r w s m a

Constructors

RWST

Fields

runRWST :: (r, s) -> m (a, s, w)

Instances

(Monoid w, MonadError e m) => MonadError e (RWST r w s m)

(Monad m, Monoid w) => MonadWriter w (RWST r w s m)

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

(Monad m, Monoid w) => MonadState s (RWST r w s m)

Monoid w => MonadTrans (RWST r w s)

(Unit f, Monoid w) => Unit (RWST r w s f)

(Monoid w, Monad m) => Monad (RWST r w s m)

(Monoid w, Monad m) => Applicative (RWST r w s m)

Functor f => Functor (RWST r w s f)

Foldable m => Foldable (RWST Void w Void m)

Traversable m => Traversable (RWST Void w Void m)

(Monoid w, MonadCont m) => MonadCont (RWST r w s m)

(Monoid w, MonadFix m) => MonadFix (RWST r w s m)

Ring (m (a, s, w)) => Ring (RWST r w s m a)

Monoid (m (a, s, w)) => Monoid (RWST r w s m a)

Semigroup (m (a, s, w)) => Semigroup (RWST r w s m a)

type RWS r w s a = RWST r w s Id a

The State Monad

class Monad m => MonadState s m | m -> s where

A simple State Monad

Methods

get :: m s

put :: s -> m ()

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

Instances

MonadState s m => MonadState s (ListT m)

Monad m => MonadState s (StateT s m)

(Monoid w, MonadState r m) => MonadState r (WriterT w m)

MonadState s m => MonadState s (ReaderT r m)

(Monad m, Monoid w) => MonadState s (RWST r w s m)

(Monoid w, Monad m) => MonadState [c] (ParserT w c m)

data StateT s m a

Instances

MonadError e m => MonadError e (StateT s m)

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)

Functor m => Functor (StateT s m)

MonadCont m => MonadCont (StateT s m)

MonadFix m => MonadFix (StateT s m)

Ring (m (a, s, Void)) => Ring (StateT s m a)

Monoid (m (a, s, Void)) => Monoid (StateT s m a)

Semigroup (m (a, s, Void)) => Semigroup (StateT s m a)

type State s a = StateT s Id a

_stateT :: Functor m => Iso' (s -> m (s, a)) (StateT s m a)

eval :: (Functor f, Functor f1) => f (f1 (a, b)) -> f (f1 b)

exec :: (Functor f, Functor f1) => f (f1 (b, b1)) -> f (f1 b)

_state :: Iso' (s -> (s, a)) (State s a)

(=~) :: MonadState s m => Lens' s s' -> (s' -> s') -> m ()

(=-) :: MonadState s m => Lens' s s' -> s' -> m ()

gets :: MonadState s m => Lens' s s' -> m s'

saving :: MonadState s m => Lens' s s' -> m a -> m a

mapAccum :: Traversable t => (a1 -> s -> (s, a)) -> t a1 -> s -> (s, t a)

mapAccum_ :: Traversable t => (a2 -> a -> (a, a1)) -> t a2 -> a -> t a1

mapAccumR :: Traversable t => (a1 -> s -> (s, a)) -> t a1 -> s -> (s, t a)

mapAccumR_ :: Traversable t => (a1 -> a -> (a, a2)) -> t a1 -> a -> t a2

push :: Traversable t => t a -> a -> t a

pop :: Traversable t => t a -> a -> t a

withPrev :: (Applicative f, Traversable f) => a -> f a -> f (a, a)

withNext :: (Applicative f, Traversable f) => f a -> a -> f (a, a)

The Reader monad

class Monad m => MonadReader r m where

Methods

ask :: m r

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

Instances

MonadReader r ((->) r)

Monad m => MonadReader r (ReaderT r m)

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

MonadReader r m => MonadReader r (StateT s m)

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

data ReaderT r m a

A simple Reader monad

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)

Unit m => Unit (ReaderT r m)

Monad m => Monad (ReaderT r m)

Monad m => Applicative (ReaderT r m)

Functor m => Functor (ReaderT r m)

MonadCont m => MonadCont (ReaderT r m)

MonadFix m => MonadFix (ReaderT r m)

Ring (m (a, Void, Void)) => Ring (ReaderT r m a)

Monoid (m (a, Void, Void)) => Monoid (ReaderT r m a)

Semigroup (m (a, Void, Void)) => Semigroup (ReaderT r m a)

type Reader r a = ReaderT r Id a

_readerT :: Functor m => Iso' (r -> m a) (ReaderT r m a)

_reader :: (Functor f, Bifunctor p) => p (ReaderT r Id a) (f (ReaderT r Id a)) -> p (r -> a) (f (r -> a))

The Writer monad

class (Monad m, Monoid w) => MonadWriter w m | m -> w where

Methods

tell :: w -> m ()

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

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

Instances

MonadWriter w m => MonadWriter w (ListT m)

Monoid w => MonadWriter w ((,) w)

(Monoid w, Monad m) => MonadWriter w (WriterT w m)

MonadWriter w m => MonadWriter w (ReaderT r m)

MonadWriter w m => MonadWriter w (StateT s m)

(Monoid w, Monad m) => MonadWriter w (ParserT w c m)

(Monad m, Monoid w) => MonadWriter w (RWST r w s m)

data WriterT w m a

A simple Writer monad

Instances

(Monoid w, Monad m) => 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)

(Unit m, Monoid w) => Unit (WriterT w m)

(Monoid w, Monad m) => Monad (WriterT w m)

(Monoid w, Monad m) => Applicative (WriterT w m)

Functor m => Functor (WriterT w m)

Foldable m => Foldable (WriterT w m)

Traversable m => Traversable (WriterT w m)

(Monoid w, MonadCont m) => MonadCont (WriterT w m)

(Monoid w, MonadFix m) => MonadFix (WriterT w m)

Ring (m (a, Void, w)) => Ring (WriterT w m a)

Monoid (m (a, Void, w)) => Monoid (WriterT w m a)

Semigroup (m (a, Void, w)) => Semigroup (WriterT w m a)

type Writer w a = WriterT w Id a

_writerT :: Functor m => Iso' (m (w, a)) (WriterT w m a)

_writer :: (Functor f, Bifunctor p) => p (WriterT w Id a) (f (WriterT w Id a)) -> p (w, a) (f (w, a))

mute :: (MonadWriter w m, Monoid w) => m a -> m a

intercept :: (MonadWriter w m, Monoid w) => m a -> m (w, a)

The Continuation monad

class Monad m => MonadCont m where

A simple continuation monad implementation

Methods

callCC :: ((a -> m b) -> m a) -> m a

Instances

Monad m => MonadCont (ContT r m)

(Monoid w, MonadCont m) => MonadCont (WriterT w m)

MonadCont m => MonadCont (ReaderT r m)

MonadCont m => MonadCont (StateT s m)

(Monoid w, MonadCont m) => MonadCont (RWST r w s m)

newtype ContT r m a

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)

Applicative m => Applicative (ContT r m)

Functor f => Functor (ContT r f)

Monad m => MonadCont (ContT r m)

Ring (m r) => Ring (ContT r m a)

Monoid (m r) => Monoid (ContT r m a)

Semigroup (m r) => Semigroup (ContT r m a)

type Cont r a = ContT r Id a

evalContT :: Unit m => ContT r m r -> m r

evalCont :: ContT a Id a -> a

The List monad

class Monad m => MonadList m where

Methods

fork :: [a] -> m a

Instances

MonadList []

Monad m => MonadList (ListT m)

data ListT m a

Instances

MonadTrans ListT

Monad m => MonadError Void (ListT m)

MonadWriter w m => MonadWriter w (ListT m)

MonadState s m => MonadState s (ListT m)

Unit m => Unit (ListT m)

Monad m => Monad (ListT m)

Applicative m => Applicative (ListT m)

Functor m => Functor (ListT m)

Foldable m => Foldable (ListT m)

Traversable m => Traversable (ListT m)

Monad m => MonadList (ListT m)

MonadFix m => MonadFix (ListT m)

Applicative m => Monoid (ListT m a)

Applicative m => Semigroup (ListT m a)

_listT :: Iso' (m [a]) (ListT m a)

The Error Monad

class Monad m => MonadError e m where

Methods

throw :: e -> m Void

catch :: (e -> m a) -> m a -> m a

Instances

Exception e => MonadError e IO

MonadError Void []

MonadError Void Maybe

MonadError e (Either e)

Monad m => MonadError Void (ListT m)

MonadError e m => MonadError e (StateT s m)

(Monad m, Monoid w) => MonadError Void (ParserT w c m)

(Monoid w, MonadError e m) => MonadError e (RWST r w s m)

try :: MonadError Void m => m a -> m a -> m a

data EitherT e m a

Instances

Unit m => Unit (EitherT e m)

Monad m => Monad (EitherT e m)

Applicative m => Applicative (EitherT e m)

Functor m => Functor (EitherT e m)

Foldable m => Foldable (EitherT e m)

Traversable m => Traversable (EitherT e m)

(Monad m, Contravariant m) => MonadFix (EitherT e m)

eitherT :: m (Either e a) -> EitherT e m a

runEitherT :: EitherT t f a -> f (Either t a)