| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Monad
Synopsis
- class Applicative m => Monad (m :: * -> *) where
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- join :: Monad m => m (m a) -> m a
- loopM :: Monad m => (a -> m (Either a b)) -> a -> m b
- unlessM :: Monad m => m Bool -> m () -> m ()
- whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- whenM :: Monad m => m Bool -> m () -> m ()
- whileM :: Monad m => m Bool -> m ()
- newtype Kleisli (m :: * -> *) a b = Kleisli {
- runKleisli :: a -> m b
- class (MFunctor t, MonadTrans t) => MMonad (t :: (* -> *) -> * -> *) where
- squash :: (Monad m, MMonad t) => t (t m) a -> t m a
- (>|>) :: (Monad m3, MMonad t) => (forall a. m1 a -> t m2 a) -> (forall b. m2 b -> t m3 b) -> m1 c -> t m3 c
- (<|<) :: (Monad m3, MMonad t) => (forall b. m2 b -> t m3 b) -> (forall a. m1 a -> t m2 a) -> m1 c -> t m3 c
- (=<|) :: (Monad n, MMonad t) => (forall a. m a -> t n a) -> t m b -> t n b
- (|>=) :: (Monad n, MMonad t) => t m b -> (forall a. m a -> t n a) -> t n b
Monad
class Applicative m => Monad (m :: * -> *) where #
The Monad class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do expressions provide a convenient syntax for writing
monadic expressions.
Instances of Monad should satisfy the following laws:
Furthermore, the Monad and Applicative operations should relate as follows:
The above laws imply:
and that pure and (<*>) satisfy the applicative functor laws.
The instances of Monad for lists, Maybe and IO
defined in the Prelude satisfy these laws.
Minimal complete definition
Methods
(>>=) :: m a -> (a -> m b) -> m b infixl 1 #
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
Inject a value into the monadic type.
Instances
| Monad [] | Since: base-2.1 |
| Monad Maybe | Since: base-2.1 |
| Monad IO | Since: base-2.1 |
| Monad Par1 | Since: base-4.9.0.0 |
| Monad Q | |
| Monad IResult | |
| Monad Result | |
| Monad Parser | |
| Monad Complex | Since: base-4.9.0.0 |
| Monad Min | Since: base-4.9.0.0 |
| Monad Max | Since: base-4.9.0.0 |
| Monad First | Since: base-4.9.0.0 |
| Monad Last | Since: base-4.9.0.0 |
| Monad Option | Since: base-4.9.0.0 |
| Monad Identity | Since: base-4.8.0.0 |
| Monad STM | Since: base-4.3.0.0 |
| Monad First | |
| Monad Last | |
| Monad Dual | Since: base-4.8.0.0 |
| Monad Sum | Since: base-4.8.0.0 |
| Monad Product | Since: base-4.8.0.0 |
| Monad Down | Since: base-4.11.0.0 |
| Monad ReadPrec | Since: base-2.1 |
| Monad ReadP | Since: base-2.1 |
| Monad NonEmpty | Since: base-4.9.0.0 |
| Monad Put | |
| Monad Tree | |
| Monad Seq | |
| Monad DList | |
| Monad Eval | |
| Monad Vector | |
| Monad Log | |
| Monad Managed | |
| Monad ReadM | |
| Monad ParserM | |
| Monad ParserResult | |
Defined in Options.Applicative.Types Methods (>>=) :: ParserResult a -> (a -> ParserResult b) -> ParserResult b # (>>) :: ParserResult a -> ParserResult b -> ParserResult b # return :: a -> ParserResult a # fail :: String -> ParserResult a # | |
| Monad SmallArray | |
Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a # fail :: String -> SmallArray a # | |
| Monad Array | |
| Monad Future | |
| Monad Moment | |
| Monad MomentIO | |
| Monad Element | |
| Monad Memoized | |
| Monad P | Since: base-2.1 |
| () :=> (Monad ((->) a :: * -> *)) | |
Defined in Data.Constraint | |
| () :=> (Monad []) | |
Defined in Data.Constraint | |
| () :=> (Monad IO) | |
| () :=> (Monad (Either a)) | |
| () :=> (Monad Identity) | |
| Monad (Either e) | Since: base-4.4.0.0 |
| Monad (U1 :: * -> *) | Since: base-4.9.0.0 |
| Monoid a => Monad ((,) a) | Since: base-4.9.0.0 |
| Monad (ST s) | Since: base-2.1 |
| Monad (Results s) | |
| Monad (Grammar r) | |
| Representable f => Monad (Co f) | |
| Monad m => Monad (WrappedMonad m) | |
Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # fail :: String -> WrappedMonad m a # | |
| ArrowApply a => Monad (ArrowMonad a) | Since: base-2.1 |
Defined in Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # return :: a0 -> ArrowMonad a a0 # fail :: String -> ArrowMonad a a0 # | |
| Monad (Proxy :: * -> *) | Since: base-4.7.0.0 |
| Monad m => Monad (MaybeT m) | |
| Alternative f => Monad (Cofree f) | |
| Functor f => Monad (Free f) | |
| Monad m => Monad (Yoneda m) | |
| Monad (ReifiedGetter s) | |
Defined in Control.Lens.Reified Methods (>>=) :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b # (>>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b # return :: a -> ReifiedGetter s a # fail :: String -> ReifiedGetter s a # | |
| Monad (ReifiedFold s) | |
Defined in Control.Lens.Reified Methods (>>=) :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b # (>>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b # return :: a -> ReifiedFold s a # fail :: String -> ReifiedFold s a # | |
| Monad m => Monad (ListT m) | |
| Monad (LogicT m) | |
| (Monad (Rep p), Representable p) => Monad (Prep p) | |
| Monad (IParser t) | |
| Monad (SetM s) | |
| Monad (IncrementalDecoder s) | |
| Class (Applicative f) (Monad f) | |
Defined in Data.Constraint Methods cls :: Monad f :- Applicative f # | |
| (Monad m) :=> (Functor (WrappedMonad m)) | |
Defined in Data.Constraint | |
| (Monad m) :=> (Applicative (WrappedMonad m)) | |
Defined in Data.Constraint Methods ins :: Monad m :- Applicative (WrappedMonad m) # | |
| Monad f => Monad (Rec1 f) | Since: base-4.9.0.0 |
| Monad (Results t s) | |
| Monad f => Monad (Alt f) | |
| Monad m => Monad (IdentityT m) | |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a # fail :: String -> WhenMissing f x a # | |
| Monad m => Monad (ExceptT e m) | |
| Monad m => Monad (GT m g) | |
| (Functor f, Monad m) => Monad (FreeT f m) | |
| (Alternative f, Monad w) => Monad (CofreeT f w) | |
| (Monad m, Error e) => Monad (ErrorT e m) | |
| Monad (Indexed i a) | |
| Monad m => Monad (StateT s m) | |
| Monad (STE e s) | |
| Monad m => Monad (StateT s m) | |
| Monad f => Monad (Star f a) | |
| Monad (Costar f a) | |
| Monad (Tagged s) | |
| Monad m => Monad (WriterT w m) | |
| Class (Monad f, Alternative f) (MonadPlus f) | |
Defined in Data.Constraint | |
| Monad ((->) r :: * -> *) | Since: base-2.1 |
| (Monad f, Monad g) => Monad (f :*: g) | Since: base-4.9.0.0 |
| (Monad f, Monad g) => Monad (Product f g) | Since: base-4.9.0.0 |
| Monad (Cokleisli w a) | |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a # fail :: String -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a # fail :: String -> WhenMissing f k x a # | |
| Monad m => Monad (ReaderT r m) | |
| Stream s => Monad (ParsecT e s m) |
|
| Monad (ContT r m) | |
| Monad f => Monad (M1 i c f) | Since: base-4.9.0.0 |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | Equivalent to Since: containers-0.5.9 |
Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a # fail :: String -> WhenMatched f k x y a # | |
(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #
Same as >>=, but with the arguments interchanged.
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #
Left-to-right Kleisli composition of monads.
join :: Monad m => m (m a) -> m a #
The join function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () #
Like whenJust, but where the test can be monadic.
Newtypes
newtype Kleisli (m :: * -> *) a b #
Kleisli arrows of a monad.
Constructors
| Kleisli | |
Fields
| |
Instances
| Monad m => Arrow (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
| MonadPlus m => ArrowZero (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
| MonadPlus m => ArrowPlus (Kleisli m) | Since: base-2.1 |
| Monad m => ArrowChoice (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
| Monad m => ArrowApply (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
| MonadFix m => ArrowLoop (Kleisli m) | Beware that for many monads (those for which the Since: base-2.1 |
Defined in Control.Arrow | |
| Monad m => Profunctor (Kleisli m) | |
Defined in Data.Profunctor.Unsafe Methods dimap :: (a -> b) -> (c -> d) -> Kleisli m b c -> Kleisli m a d # lmap :: (a -> b) -> Kleisli m b c -> Kleisli m a c # rmap :: (b -> c) -> Kleisli m a b -> Kleisli m a c # (#.) :: Coercible c b => (b -> c) -> Kleisli m a b -> Kleisli m a c # (.#) :: Coercible b a => Kleisli m b c -> (a -> b) -> Kleisli m a c # | |
| (Monad m, Functor m) => Representable (Kleisli m) | |
| Monad m => Choice (Kleisli m) | |
| (Monad m, Distributive m) => Mapping (Kleisli m) | |
| (Distributive f, Monad f) => Closed (Kleisli f) | |
Defined in Data.Profunctor.Closed | |
| Monad m => Strong (Kleisli m) | |
| MonadFix m => Costrong (Kleisli m) | |
| Monad m => Category (Kleisli m :: * -> * -> *) | Since: base-3.0 |
| Bind m => Semigroupoid (Kleisli m :: * -> * -> *) | |
| Wrapped (Kleisli m a b) | |
| t ~ Kleisli m' a' b' => Rewrapped (Kleisli m a b) t | |
Defined in Control.Lens.Wrapped | |
| type Rep (Kleisli m) | |
Defined in Data.Profunctor.Rep | |
| type Unwrapped (Kleisli m a b) | |
Defined in Control.Lens.Wrapped | |
MMonad
class (MFunctor t, MonadTrans t) => MMonad (t :: (* -> *) -> * -> *) where #
A monad in the category of monads, using lift from MonadTrans as the
analog of return and embed as the analog of (=<<):
embed lift = id embed f (lift m) = f m embed g (embed f t) = embed (\m -> embed g (f m)) t
Minimal complete definition
(>|>) :: (Monad m3, MMonad t) => (forall a. m1 a -> t m2 a) -> (forall b. m2 b -> t m3 b) -> m1 c -> t m3 c infixr 2 #
(<|<) :: (Monad m3, MMonad t) => (forall b. m2 b -> t m3 b) -> (forall a. m1 a -> t m2 a) -> m1 c -> t m3 c infixl 2 #