Safe Haskell	None

Algebra.Classes

Synopsis

Documentation

class Functor f whereSource

Methods

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

Instances

Functor []
Functor IO
Functor Maybe
Functor Set
Functor Tree
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 (ProbT t m)
Functor m => Functor (WriterAccT w acc m)
Functor f => Functor (RWST r w s f)

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

Methods

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

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)
(Ring t, Monad m) => Applicative (ProbT t m)
(Monoid w, Monad m) => Applicative (WriterAccT w acc m)
(Monoid w, Monad m) => Applicative (RWST r w s m)

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 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)
(Ring t, Monad m) => Monad (ProbT t m)
(Monoid w, Monad m) => Monad (WriterAccT w acc m)
(Monoid w, Monad m) => Monad (RWST r w s m)

class Monad m => MonadFix m whereSource

The class of all monads that have a fixpoint

Methods

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

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)
(Ring t, MonadFix m) => MonadFix (ProbT t m)
(Monoid w, MonadFix m) => MonadFix (WriterAccT w acc m)
(Monoid w, MonadFix m) => MonadFix (RWST r w s m)

class MonadTrans t whereSource

Methods

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

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 (WriterAccT w acc)
Monoid w => MonadTrans (RWST r w s)

class MonadTrans t => ConcreteMonad t whereSource

Methods

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

Instances

ConcreteMonad Backwards
Monad m => ConcreteMonad (:.: m)
Monad m => ConcreteMonad (Compose' m)
Monoid w => ConcreteMonad (RWST r w s)

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

Methods

get :: m sSource

put :: s -> m ()Source

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

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)
(MonadState s m, Monoid w, SubSemi acc w) => MonadState s (WriterAccT w acc m)
(Monad m, Monoid w) => MonadState s (RWST r w s m)
MonadState (IO ()) IO

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

Methods

ask :: m rSource

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

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 whereSource

Methods

tell :: w -> m ()Source

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

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

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)
(Monad m, SubSemi acc w, Monoid w) => MonadWriter w (WriterAccT w acc m)
(Monad m, Monoid w) => MonadWriter w (RWST r w s m)
(Ring t, Monad m) => MonadWriter (Product t) (ProbT t m)

class (SubSemi acc w, MonadWriter w m) => MonadWriterAcc w acc m whereSource

Methods

getAcc :: m accSource

Instances

MonadWriterAcc w acc m => MonadWriterAcc w acc (StateT s m)
MonadWriterAcc w acc m => MonadWriterAcc w acc (ReaderT r m)
(Monad m, Monoid w, SubSemi acc w) => MonadWriterAcc w acc (WriterAccT w acc m)

class Monad m => MonadList m whereSource

Methods

fork :: [a] -> m aSource

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)
(Monad m, Ring t, Fractional t) => MonadList (ProbT t m)
(Monoid w, MonadList m) => MonadList (RWST r w s m)

class Monad m => MonadCont m whereSource

Methods

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

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 whereSource

Methods

throw :: e -> m aSource

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

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)
(Monoid w, MonadError e m) => MonadError e (RWST r w s m)