Algebra.Monad

Documentation

class Functor f where

Methods

map :: (a -> b) -> f a -> f b

Instances

Functor []

Functor IO

Functor Maybe

Functor Tree

Functor Set

Functor Interleave

Functor OrdList

Functor Id

Functor ZipTree

Functor ZipList

Functor TimeVal

Functor ((->) a)

Functor (Either b)

Functor ((,) b)

Functor (Map k)

Functor (Const a)

Functor f => Functor (Backwards f)

Functor m => Functor (MaybeT m)

Functor m => Functor (TreeT m)

Functor m => Functor (ListT m)

Functor (Future t)

Functor (Reactive t)

Functor (Event t)

(Functor f, Functor g) => Functor (:++: f g)

(Functor f, Functor g) => Functor (:**: f g)

(Functor f, Functor g) => Functor (:.: f g)

(Functor f, Functor g) => Functor (Compose' f g)

Functor m => Functor (StateT s m)

Functor m => Functor (ReaderT r m)

Functor m => Functor (WriterT w m)

Functor f => Functor (ContT r f)

Functor m => Functor (EitherT e m)

Functor m => Functor (ParserT w s m)

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

class (Unit f, Functor f) => Applicative f where

Methods

(<*>) :: f (a -> b) -> f a -> f b

Instances

Applicative []

Applicative IO

Applicative Maybe

Applicative Tree

Applicative Interleave

Applicative Id

Applicative ZipTree

Applicative ZipList

Applicative TimeVal

Applicative ((->) a)

Applicative (Either a)

Monoid w => Applicative ((,) w)

Monoid a => Applicative (Const a)

Applicative f => Applicative (Backwards f)

Applicative m => Applicative (MaybeT m)

Applicative m => Applicative (TreeT m)

Applicative m => Applicative (ListT m)

Ord t => Applicative (Future t)

Ord t => Applicative (Reactive t)

Ord t => Applicative (Event t)

(Applicative f, Applicative g) => Applicative (:**: f g)

(Applicative f, Applicative g) => Applicative (:.: f g)

(Applicative f, Applicative g) => Applicative (Compose' f g)

Monad m => Applicative (StateT s m)

Monad m => Applicative (ReaderT r m)

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

Applicative m => Applicative (ContT r m)

Applicative m => Applicative (EitherT e m)

(Monoid w, Monad m) => Applicative (ParserT w s m)

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

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 (MaybeT m)

Monad m => Monad (TreeT 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 f, Monad g, Traversable f) => Monad (Compose' f g)

Monad m => Monad (StateT s m)

Monad m => Monad (ReaderT r m)

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

Monad m => Monad (ContT r m)

Monad m => Monad (EitherT e m)

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

MonadFix m => MonadFix (MaybeT m)

MonadFix m => MonadFix (TreeT m)

MonadFix m => MonadFix (ListT m)

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

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

MonadFix m => MonadFix (StateT s m)

MonadFix m => MonadFix (ReaderT r m)

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

MonadFix m => MonadFix (EitherT e m)

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

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

class MonadTrans t where

Methods

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

generalize :: Monad m => t Id a -> t m a

Instances

MonadTrans Backwards

MonadTrans MaybeT

MonadTrans TreeT

MonadTrans ListT

Monad m => MonadTrans (:.: m)

Monad m => MonadTrans (Compose' m)

MonadTrans (StateT s)

MonadTrans (ReaderT r)

Monoid w => MonadTrans (WriterT w)

MonadTrans (ContT r)

MonadTrans (EitherT e)

Monoid w => MonadTrans (ParserT w s)

Monoid w => MonadTrans (RWST r w s)

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

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)

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

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

(Monoid w, Monad m) => MonadState s (ParserT w s m)

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

MonadState (IO ()) IO

class Monad m => MonadReader r m | m -> r where

Methods

ask :: m r

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

Instances

MonadReader r ((->) r)

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

Monad m => MonadReader r (ReaderT r m)

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

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

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

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

MonadWriter w m => MonadWriter w (ListT m)

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

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

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

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

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

class Monad m => MonadList m where

Methods

fork :: [a] -> m a

Instances

MonadList []

Monad m => MonadList (ListT m)

MonadList m => MonadList (StateT s m)

MonadList m => MonadList (ReaderT r m)

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

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

class Monad m => MonadCont m where

Methods

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

Instances

MonadCont m => MonadCont (StateT s m)

MonadCont m => MonadCont (ReaderT r m)

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

Monad m => MonadCont (ContT r m)

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

class Monad m => MonadError e m | m -> e where

Methods

throw :: e -> m a

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

Instances

MonadError SomeException 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)

module Algebra.Applicative

module Algebra.Core

module Algebra.Traversable

module Control.Lens

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

joinMap :: 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

only :: (Monoid (m ()), Monad m) => (a -> Bool) -> m a -> 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

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

while :: Monad m => m Bool -> 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

Instance utilities

newtype Compose' f g a

Constructors

Compose' ((g :.: f) a)

Instances

Monad m => MonadTrans (Compose' m)

(Unit f, Unit g) => Unit (Compose' f g)

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

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

(Applicative f, Applicative g) => Applicative (Compose' f g)

(Functor f, Functor g) => Functor (Compose' f g)

(Foldable f, Foldable g) => Foldable (Compose' f g)

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

(Monoid (f a), Applicative g) => Monoid (Compose' f g a)

(Semigroup (f a), Applicative g) => Semigroup (Compose' f g a)

_Compose' :: Iso (Compose' f g a) (Compose' h i b) (g (f a)) (i (h b))

Common monads

module Algebra.Monad.RWS

module Algebra.Monad.State

module Algebra.Monad.Reader

module Algebra.Monad.Writer

module Algebra.Monad.Cont

module Algebra.Monad.Foldable

module Algebra.Monad.Error