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)

Ord t => Monad (Event t)

(Traversable g, Monad f, Monad g) => Monad (:.: 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)

(MonadFix f, Traversable g, Monad g) => MonadFix (:.: f g)

MonadFix 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 (EitherT e)

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) (c -> m' d) (Kleisli m a b) (Kleisli m' c d)

_Kleisli :: Iso (Kleisli m a b) (Kleisli m' c d) (a -> m b) (c -> m' d)

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

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

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

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

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

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

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

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

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

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

bind2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c

bind3 :: Monad m => (a -> b -> c -> m d) -> m a -> m b -> m c -> m d

(>>>=) :: Monad m => (m a, m b) -> (a -> b -> m c) -> m c

(>>>>=) :: Monad m => (m a, m b, m c) -> (a -> b -> c -> m d) -> m d

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)

MonadState (IO ()) IO

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

type IOLens a = Lens' (IO ()) (IO a)

_ioref :: IORef a -> IOLens a

_mvar :: MVar a -> IOLens a

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, Functor n) => Iso (StateT s m a) (StateT t n b) (s -> m (s, a)) (t -> n (t, b))

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

exec :: (Functor f, Functor f') => f (f' (a, b)) -> f (f' a)

_state :: Iso (State s a) (State t b) (s -> (s, a)) (t -> (t, b))

(=~) :: 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 => (a -> s -> (s, b)) -> t a -> s -> (s, t b)

mapAccum_ :: Traversable t => (a -> s -> (s, b)) -> t a -> s -> t b

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

mapAccumR_ :: Traversable t => (a -> s -> (s, b)) -> t a -> s -> t b

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

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

withPrev :: Traversable t => a -> t a -> t (a, a)

withNext :: Traversable t => t a -> a -> t (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, Functor m') => Iso (ReaderT r m a) (ReaderT r' m' b) (r -> m a) (r' -> m' b)

_reader :: Iso (Reader r a) (Reader r' b) (r -> a) (r' -> b)

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, Functor m') => Iso (WriterT w m a) (WriterT w' m' b) (m (w, a)) (m' (w', b))

_writer :: Iso (Writer w a) (Writer w' b) (w, a) (w', b)

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 :: Cont r r -> r

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 (ListT m a) (ListT m' a') (m [a]) (m' [a'])

The Error Monad

class Monad m => MonadError e m where

Methods

throw :: e -> m a

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

MonadTrans (EitherT e)

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)

MonadFix m => MonadFix (EitherT e m)

_eitherT :: Functor m => Iso (EitherT e m a) (EitherT f m b) (m (e :+: a)) (m (f :+: b))