Algebra.Classes

Documentation

class Functor f where

Methods

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

Instances

Functor []

Functor IO

Functor Maybe

Functor Set

Functor Tree

Functor Interleave

Functor OrdList

Functor Id

Functor Strict

Functor ((->) a)

Functor (Either b)

Functor ((,) b)

Functor (Map k)

Functor (Const a)

Functor f => Functor (Backwards f)

Functor f => Functor (Zip f)

Functor m => Functor (MaybeT m)

Functor m => Functor (TreeT m)

Functor m => Functor (ListT m)

(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 f => Functor (Kleisli f a)

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 where

Methods

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

Instances

Applicative []

Applicative IO

Applicative Maybe

Applicative Tree

Applicative Interleave

Applicative Id

Applicative Strict

Applicative ((->) a)

Applicative (Either a)

Monoid w => Applicative ((,) w)

(Monoid k, Ord k) => Applicative (Map k)

Monoid a => Applicative (Const a)

Applicative f => Applicative (Backwards f)

Applicative (Zip [])

Applicative (Zip Tree)

Applicative m => Applicative (MaybeT m)

Applicative m => Applicative (TreeT m)

Applicative m => Applicative (ListT m)

(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 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 Strict

Monad ((->) a)

Monad (Either a)

Monoid w => Monad ((,) w)

(Monoid k, Ord k) => Monad (Map k)

MonadFix m => Monad (Backwards m)

Monad m => Monad (MaybeT m)

Monad m => Monad (TreeT m)

Monad m => Monad (ListT m)

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

(Traversable f, Monad f, Monad g) => 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 Functor f => Foldable f where

Methods

fold :: Monoid m => f m -> m

Instances

Foldable []

Foldable Maybe

Foldable Set

Foldable Tree

Foldable Interleave

Foldable OrdList

Foldable Id

Foldable (Either a)

Foldable ((,) a)

Foldable (Map k)

Foldable f => Foldable (Zip f)

Foldable m => Foldable (MaybeT m)

Foldable m => Foldable (TreeT m)

Foldable m => Foldable (ListT m)

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

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

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

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

Foldable m => Foldable (WriterT w m)

Foldable m => Foldable (EitherT e m)

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

class Functor t => Traversable t where

Methods

sequence :: Applicative f => t (f a) -> f (t a)

Instances

Traversable []

Traversable Maybe

Traversable Tree

Traversable Interleave

Traversable OrdList

Traversable (Either a)

Traversable ((,) c)

Eq k => Traversable (Map k)

Traversable f => Traversable (Zip f)

Traversable m => Traversable (MaybeT m)

Traversable m => Traversable (TreeT m)

Traversable m => Traversable (ListT m)

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

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

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

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

Traversable m => Traversable (WriterT w m)

Traversable m => Traversable (EitherT e m)

Traversable m => Traversable (RWST Void w Void 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, Traversable f, Monad 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 where

Methods

lift :: Monad m => m 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 (WriterAccT w acc)

Monoid w => MonadTrans (RWST r w s)

class MonadTrans t => ConcreteMonad t where

Methods

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

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

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

(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 where

Methods

getAcc :: m acc

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 => MonadIO m where

Methods

liftIO :: IO a -> m a

Instances

MonadIO IO

(MonadIO m, MonadTrans t, Monad (t m)) => MonadIO (t 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)

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

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

class MonadFuture m t | t -> m where

Methods

future :: m a -> t a

Instances

MonadFuture m (Backwards m)

(Monad m, MonadFuture n m) => MonadFuture n (StateT s m)

(Monad m, MonadFuture n m) => MonadFuture n (ReaderT r m)

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

(Monad m, Monoid w, MonadFuture n m) => MonadFuture n (WriterAccT w acc m)

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