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 TimeVal

Functor DeQue

Functor ((->) a)

Functor (Either b)

Functor ((,) b)

Functor (Map k)

Functor (Assoc k)

Functor (Increasing k)

Functor (Const a)

Functor f => Functor (Backwards f)

Functor f => Functor (Zip f)

Functor (ContT f)

Functor m => Functor (StrictT m)

Functor m => Functor (MaybeT m)

Functor m => Functor (TreeT m)

Functor m => Functor (ListT m)

Functor w => Functor (Cofree w)

Functor f => Functor (Free f)

Functor (LogicT 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 m => Functor (EitherT e m)

Functor (Queue push pop)

Functor m => Functor (ProbT t m)

Functor m => Functor (CounterT w acc m)

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

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

Minimal complete definition

Nothing

Methods

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

Instances

Applicative []

Applicative IO

Applicative Maybe

Applicative Tree

Applicative Interleave

Applicative Id

Applicative Strict

Applicative TimeVal

Applicative ((->) a)

Applicative (Either a)

Monoid w => Applicative ((,) w)

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

Monoid a => Applicative (Const a)

Applicative f => Applicative (Backwards f)

Applicative (Zip [])

Ord k => Applicative (Zip (Map k))

Applicative (Zip Tree)

Applicative (ContT m)

Applicative m => Applicative (StrictT m)

Applicative m => Applicative (MaybeT m)

Applicative m => Applicative (TreeT m)

Applicative m => Applicative (ListT m)

Applicative m => Applicative (Cofree m)

Functor f => Applicative (Free f)

Applicative (LogicT 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 (EitherT e m)

(Ring t, Monad m) => Applicative (ProbT t m)

(Monoid w, Monad m) => Applicative (CounterT w acc m)

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

class Applicative m => Monad m where

Minimal complete definition

Nothing

Methods

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

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

Instances

Monad []

Monad IO

Monad Maybe

Monad Tree

Monad Interleave

Monad Id

Monad Strict

Monad TimeVal

Monad ((->) a)

Monad (Either a)

Monoid w => Monad ((,) w)

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

MonadFix m => Monad (Backwards m)

Monad (ContT m)

Monad m => Monad (StrictT m)

Monad m => Monad (MaybeT m)

Monad m => Monad (TreeT m)

Monad m => Monad (ListT m)

Applicative m => Monad (Cofree m)

Functor f => Monad (Free f)

Monad (LogicT m)

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

(Ring t, Monad m) => Monad (ProbT t m)

(Monoid w, SubSemi a w, Monad m) => Monad (CounterT w a m)

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

class Counit w where

Methods

extract :: w a -> a

Instances

Counit (Cofree w)

Counit f => Counit (Free f)

class (Functor w, Counit w) => Comonad w where

Minimal complete definition

Nothing

Methods

duplicate :: w a -> w (w a)

(=>>) :: w a -> (w a -> b) -> w b infixl 1

Instances

Functor w => Comonad (Cofree w)

Comonad f => Comonad (Free f)

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 Strict

Foldable TimeVal

Foldable DeQue

Foldable (Either a)

Foldable ((,) a)

Foldable (Map k)

Foldable (Assoc k)

Foldable (Increasing k)

Foldable f => Foldable (Zip f)

Foldable m => Foldable (StrictT m)

Foldable m => Foldable (MaybeT m)

Foldable m => Foldable (TreeT m)

Foldable m => Foldable (ListT m)

Foldable w => Foldable (Cofree w)

Foldable f => Foldable (Free f)

(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 (Queue push pop)

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 Strict

Traversable TimeVal

Traversable DeQue

Traversable (Either a)

Traversable ((,) c)

Eq k => Traversable (Map k)

Traversable (Assoc k)

Traversable (Increasing k)

Traversable f => Traversable (Zip f)

Traversable m => Traversable (StrictT m)

Traversable m => Traversable (MaybeT m)

Traversable m => Traversable (TreeT m)

Traversable m => Traversable (ListT m)

Traversable w => Traversable (Cofree w)

Traversable f => Traversable (Free f)

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

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

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

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

Traversable m => Traversable (WriterT e m)

Traversable m => Traversable (EitherT e m)

Traversable (Queue push pop)

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 Strict

MonadFix ((->) b)

MonadFix (Either e)

MonadFix m => MonadFix (Backwards m)

MonadFix m => MonadFix (ContT m)

MonadFix m => MonadFix (StrictT m)

MonadFix m => MonadFix (MaybeT m)

MonadFix m => MonadFix (TreeT m)

MonadFix m => MonadFix (ListT m)

MonadFix f => MonadFix (Free f)

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

(SubSemi acc w, Monoid w, MonadFix m) => MonadFix (CounterT 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 ContT

MonadTrans StrictT

MonadTrans MaybeT

MonadTrans TreeT

MonadTrans ListT

MonadTrans Free

MonadTrans LogicT

Monad m => MonadTrans ((:.:) m)

Monad m => MonadTrans (Compose' m)

MonadTrans (StateT s)

MonadTrans (ReaderT r)

Monoid w => MonadTrans (WriterT w)

MonadTrans (EitherT e)

Monoid w => MonadTrans (CounterT 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

ConcreteMonad Free

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

Minimal complete definition

get

Methods

get :: m s

put :: s -> m ()

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

Instances

MonadState s m => MonadState s (ListT m)

MonadState s m => MonadState s (Free m)

MonadState s m => MonadState s (LogicT m)

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

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

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 (CounterT 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 (Free m)

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

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

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

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

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

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 (CounterT 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) => MonadCounter w acc m | m -> acc where

Methods

getCounter :: m acc

Instances

MonadCounter w a m => MonadCounter w a (Free m)

MonadCounter w acc m => MonadCounter w acc (StateT s m)

MonadCounter w acc m => MonadCounter w acc (ReaderT r m)

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

MonadIO m => MonadIO (Free m)

class Monad m => MonadList m where

Methods

fork :: [a] -> m a

Instances

MonadList []

Monad m => MonadList (ListT m)

MonadList m => MonadList (Free m)

MonadList m => MonadList (StateT s m)

MonadList m => MonadList (ReaderT r m)

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

(Monad m, Invertible t) => MonadList (ProbT t m)

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

class Monad m => MonadCont m where

Methods

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

Instances

MonadCont (ContT m)

MonadCont m => MonadCont (StateT s m)

MonadCont m => MonadCont (ReaderT r m)

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

MonadError e m => MonadError e (Free m)

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 MonadFix t => MonadFuture m t | t -> m where

Methods

future :: m a -> t a

Instances

MonadFix m => MonadFuture m (Backwards m)

MonadFuture m t => MonadFuture m (Free t)

(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, SubSemi acc w, MonadFuture n m) => MonadFuture n (CounterT w acc m)

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