| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Control.Monad.Compat
Documentation
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
| Functor ZipList | |
Defined in Control.Applicative | |
| Functor Handler | |
| Functor Complex | |
| Functor Identity | |
| Functor First | |
| Functor Last | |
| Functor Down | |
| Functor First | |
| Functor Last | |
| Functor Max | |
| Functor Min | |
| Functor Dual | |
| Functor Product | |
| Functor Sum | |
| Functor NonEmpty | |
| Functor STM | |
Defined in GHC.Conc.Sync | |
| Functor NoIO | |
| Functor Par1 | |
Defined in GHC.Generics | |
| Functor ArgDescr | |
Defined in System.Console.GetOpt | |
| Functor ArgOrder | |
Defined in System.Console.GetOpt | |
| Functor OptDescr | |
Defined in System.Console.GetOpt | |
| Functor P | |
Defined in Text.ParserCombinators.ReadP | |
| Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
| Functor ReadPrec | |
| Functor IO | |
| Functor Maybe | |
| Functor Solo | |
| Functor [] | |
| Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
| Arrow a => Functor (ArrowMonad a) | |
Defined in Control.Arrow | |
| Functor (ST s) | |
Defined in Control.Monad.ST.Lazy.Imp | |
| Functor (Either a) | |
| Functor (Proxy :: Type -> Type) | |
| Functor (Arg a) | |
| Functor (Array i) | |
| Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
| Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
| Functor (ST s) | |
| Functor ((,) a) | |
| Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
| Functor m => Functor (Kleisli m a) | |
Defined in Control.Arrow | |
| Functor (Const m :: Type -> Type) | |
| Functor f => Functor (Ap f) | |
| Functor f => Functor (Alt f) | |
| (Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Generics | |
| Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
| Functor (URec (Ptr ()) :: Type -> Type) | |
| Functor (URec Char :: Type -> Type) | |
| Functor (URec Double :: Type -> Type) | |
| Functor (URec Float :: Type -> Type) | |
| Functor (URec Int :: Type -> Type) | |
| Functor (URec Word :: Type -> Type) | |
| Functor ((,,) a b) | |
| (Functor f, Functor g) => Functor (Product f g) | |
| (Functor f, Functor g) => Functor (Sum f g) | |
| (Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
| (Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
| Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
| Functor ((,,,) a b c) | |
| Functor ((->) r) | |
| (Functor f, Functor g) => Functor (Compose f g) | |
| (Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
| Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
| Functor ((,,,,) a b c d) | |
| Functor ((,,,,,) a b c d e) | |
| Functor ((,,,,,,) a b c d e f) | |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
| Monad Complex | |
| Monad Identity | |
| Monad First | |
| Monad Last | |
| Monad Down | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad Dual | |
| Monad Product | |
| Monad Sum | |
| Monad NonEmpty | |
| Monad STM | |
| Monad NoIO | |
| Monad Par1 | |
| Monad P | |
| Monad ReadP | |
| Monad ReadPrec | |
| Monad IO | |
| Monad Maybe | |
| Monad Solo | |
| Monad [] | |
| Monad m => Monad (WrappedMonad m) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (ST s) | |
| Monad (Either e) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (U1 :: Type -> Type) | |
| Monad (ST s) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (Kleisli m a) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Alt f) | |
| Monad f => Monad (Rec1 f) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad ((->) r) | |
| Monad f => Monad (M1 i c f) | |
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #
Minimal complete definition
Nothing
Instances
| MonadPlus STM | |
Defined in GHC.Conc.Sync | |
| MonadPlus P | |
Defined in Text.ParserCombinators.ReadP | |
| MonadPlus ReadP | |
Defined in Text.ParserCombinators.ReadP | |
| MonadPlus ReadPrec | |
| MonadPlus IO | |
| MonadPlus Maybe | |
| MonadPlus [] | |
| (ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) | |
Defined in Control.Arrow | |
| MonadPlus (Proxy :: Type -> Type) | |
| MonadPlus (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
| MonadPlus m => MonadPlus (Kleisli m a) | |
Defined in Control.Arrow | |
| MonadPlus f => MonadPlus (Ap f) | |
| MonadPlus f => MonadPlus (Alt f) | |
| MonadPlus f => MonadPlus (Rec1 f) | |
Defined in GHC.Generics | |
| (MonadPlus f, MonadPlus g) => MonadPlus (Product f g) | |
| (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) | |
Defined in GHC.Generics | |
| MonadPlus f => MonadPlus (M1 i c f) | |
Defined in GHC.Generics | |
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #
when :: Applicative f => Bool -> f () -> f () #
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) #
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) #
class Monad m => MonadFail (m :: Type -> Type) #
Minimal complete definition
Instances
| MonadFail P | |
Defined in Text.ParserCombinators.ReadP | |
| MonadFail ReadP | |
Defined in Text.ParserCombinators.ReadP | |
| MonadFail ReadPrec | |
Defined in Text.ParserCombinators.ReadPrec | |
| MonadFail IO | |
Defined in Control.Monad.Fail | |
| MonadFail Maybe | |
Defined in Control.Monad.Fail | |
| MonadFail [] | |
Defined in Control.Monad.Fail | |
| MonadFail f => MonadFail (Ap f) | |
Defined in Data.Monoid | |
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
forever :: Applicative f => f a -> f b #
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
replicateM :: Applicative m => Int -> m a -> m [a] #
replicateM_ :: Applicative m => Int -> m a -> m () #
unless :: Applicative f => Bool -> f () -> f () #
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #