Safe Haskell | None |
---|
- class Functor f where
- map :: (a -> b) -> f a -> f b
- class (Unit f, Functor f) => Applicative f where
- (<*>) :: f (a -> b) -> f a -> f b
- class Applicative m => Monad m where
- class Functor f => Foldable f where
- class Functor t => Traversable t where
- sequence :: Applicative f => t (f a) -> f (t a)
- class Monad m => MonadFix m where
- mfix :: (a -> m a) -> m a
- class MonadTrans t where
- class MonadTrans t => ConcreteMonad t where
- generalize :: Monad m => t Id a -> t m a
- class Monad m => MonadState s m | m -> s where
- class Monad m => MonadReader r m | m -> r where
- class (Monad m, Monoid w) => MonadWriter w m | m -> w where
- class (SubSemi acc w, MonadWriter w m) => MonadWriterAcc w acc m where
- getAcc :: m acc
- class Monad m => MonadIO m where
- class Monad m => MonadList m where
- fork :: [a] -> m a
- class Monad m => MonadCont m where
- callCC :: ((a -> m b) -> m a) -> m a
- class Monad m => MonadError e m | m -> e where
- class MonadFuture m t | t -> m where
- future :: m a -> t a
Documentation
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 whereSource
Applicative [] | |
Applicative IO | |
Applicative Maybe | |
Applicative Tree | |
Applicative Interleave | |
Applicative Id | |
Applicative Strict | |
Applicative ((->) a) | |
Applicative (Either a) | |
Monoid w => Applicative ((,) w) | |
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 whereSource
Monad [] | |
Monad IO | |
Monad Maybe | |
Monad Tree | |
Monad Interleave | |
Monad Id | |
Monad Strict | |
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) | |
(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 whereSource
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 whereSource
sequence :: Applicative f => t (f a) -> f (t a)Source
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 whereSource
The class of all monads that have a fixpoint
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 whereSource
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
generalize :: Monad m => t Id a -> t m aSource
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
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
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
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
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 => MonadError e m | m -> e whereSource
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 whereSource
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) |