Safe Haskell	None
Language	Haskell2010

Algebra.Classes

Synopsis

Documentation

class Functor f where Source

Methods

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

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 Source

Minimal complete definition

Nothing

Methods

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

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 Source

Minimal complete definition

Nothing

Methods

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

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

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 Source

Methods

extract :: w a -> a Source

Instances

Counit (Cofree w)
Counit f => Counit (Free f)

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

Minimal complete definition

Nothing

Methods

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

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

Instances

Functor w => Comonad (Cofree w)
Comonad f => Comonad (Free f)

class Functor f => Foldable f where Source

Methods

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

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 Source

Methods

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

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 Source

The class of all monads that have a fixpoint

Methods

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

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 Source

Methods

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

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 Source

Methods

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

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 Source

Minimal complete definition

get

Methods

get :: m s Source

put :: s -> m () Source

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

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 Source

Methods

ask :: m r Source

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

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 Source

Methods

tell :: w -> m () Source

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

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

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 Source

Methods

getCounter :: m acc Source

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 Source

Methods

liftIO :: IO a -> m a Source

Instances

MonadIO IO
(MonadIO m, MonadTrans t, Monad (t m)) => MonadIO (t m)
MonadIO m => MonadIO (Free m)

class Monad m => MonadList m where Source

Methods

fork :: [a] -> m a Source

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 Source

Methods

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

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 Source

Methods

throw :: e -> m a Source

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

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 Source

Methods

future :: m a -> t a Source

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)