GHC.Utils.Monad

Utilities related to Monad and Applicative classes Mostly for backwards compatibility.

Documentation

class Functor f => Applicative (f :: Type -> Type) where

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = (id <$ u) <*> v

• u <* v = liftA2 const u v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

• pure = return

• m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

• (*>) = (>>)

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a

Lift a value.

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

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Example

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

(*>) :: f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

Examples

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative ZipList

f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Applicative Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

pure :: a -> Complex a

(<*>) :: Complex (a -> b) -> Complex a -> Complex b

liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

(*>) :: Complex a -> Complex b -> Complex b

(<*) :: Complex a -> Complex b -> Complex a

Applicative Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

Applicative First

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Applicative First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Max a

(<*>) :: Max (a -> b) -> Max a -> Max b

liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c

(*>) :: Max a -> Max b -> Max b

(<*) :: Max a -> Max b -> Max a

Applicative Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Min a

(<*>) :: Min (a -> b) -> Min a -> Min b

liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c

(*>) :: Min a -> Min b -> Min b

(<*) :: Min a -> Min b -> Min a

Applicative Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Dual a

(<*>) :: Dual (a -> b) -> Dual a -> Dual b

liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

(*>) :: Dual a -> Dual b -> Dual b

(<*) :: Dual a -> Dual b -> Dual a

Applicative Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Product a

(<*>) :: Product (a -> b) -> Product a -> Product b

liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c

(*>) :: Product a -> Product b -> Product b

(<*) :: Product a -> Product b -> Product a

Applicative Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Sum a

(<*>) :: Sum (a -> b) -> Sum a -> Sum b

liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

(*>) :: Sum a -> Sum b -> Sum b

(<*) :: Sum a -> Sum b -> Sum a

Applicative NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a

Applicative STM

Since: base-4.8.0.0

Defined in GHC.Conc.Sync

Methods

pure :: a -> STM a

(<*>) :: STM (a -> b) -> STM a -> STM b

liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c

(*>) :: STM a -> STM b -> STM b

(<*) :: STM a -> STM b -> STM a

Applicative Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Par1 a

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

(*>) :: Par1 a -> Par1 b -> Par1 b

(<*) :: Par1 a -> Par1 b -> Par1 a

Applicative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

Applicative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> ReadP a

(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

(*>) :: ReadP a -> ReadP b -> ReadP b

(<*) :: ReadP a -> ReadP b -> ReadP a

Applicative ReadPrec

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadPrec

Methods

pure :: a -> ReadPrec a

(<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b

liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c

(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b

(<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a

Applicative Get

Defined in Data.Binary.Get.Internal

Methods

pure :: a -> Get a

(<*>) :: Get (a -> b) -> Get a -> Get b

liftA2 :: (a -> b -> c) -> Get a -> Get b -> Get c

(*>) :: Get a -> Get b -> Get b

(<*) :: Get a -> Get b -> Get a

Applicative PutM

Defined in Data.Binary.Put

Methods

pure :: a -> PutM a

(<*>) :: PutM (a -> b) -> PutM a -> PutM b

liftA2 :: (a -> b -> c) -> PutM a -> PutM b -> PutM c

(*>) :: PutM a -> PutM b -> PutM b

(<*) :: PutM a -> PutM b -> PutM a

Applicative Put

Defined in Data.ByteString.Builder.Internal

Methods

pure :: a -> Put a

(<*>) :: Put (a -> b) -> Put a -> Put b

liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c

(*>) :: Put a -> Put b -> Put b

(<*) :: Put a -> Put b -> Put a

Applicative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

pure :: a -> Seq a

(<*>) :: Seq (a -> b) -> Seq a -> Seq b

liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

(*>) :: Seq a -> Seq b -> Seq b

(<*) :: Seq a -> Seq b -> Seq a

Applicative Tree

Defined in Data.Tree

Methods

pure :: a -> Tree a

(<*>) :: Tree (a -> b) -> Tree a -> Tree b

liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

(*>) :: Tree a -> Tree b -> Tree b

(<*) :: Tree a -> Tree b -> Tree a

Applicative CoreM

Defined in GHC.Core.Opt.Monad

Methods

pure :: a -> CoreM a

(<*>) :: CoreM (a -> b) -> CoreM a -> CoreM b

liftA2 :: (a -> b -> c) -> CoreM a -> CoreM b -> CoreM c

(*>) :: CoreM a -> CoreM b -> CoreM b

(<*) :: CoreM a -> CoreM b -> CoreM a

Applicative SimplM

Defined in GHC.Core.Opt.Simplify.Monad

Methods

pure :: a -> SimplM a

(<*>) :: SimplM (a -> b) -> SimplM a -> SimplM b

liftA2 :: (a -> b -> c) -> SimplM a -> SimplM b -> SimplM c

(*>) :: SimplM a -> SimplM b -> SimplM b

(<*) :: SimplM a -> SimplM b -> SimplM a

Applicative UnifyResultM

Defined in GHC.Core.Unify

Methods

pure :: a -> UnifyResultM a

(<*>) :: UnifyResultM (a -> b) -> UnifyResultM a -> UnifyResultM b

liftA2 :: (a -> b -> c) -> UnifyResultM a -> UnifyResultM b -> UnifyResultM c

(*>) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM b

(<*) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM a

Applicative Infinite

Defined in GHC.Data.List.Infinite

Methods

pure :: a -> Infinite a

(<*>) :: Infinite (a -> b) -> Infinite a -> Infinite b

liftA2 :: (a -> b -> c) -> Infinite a -> Infinite b -> Infinite c

(*>) :: Infinite a -> Infinite b -> Infinite b

(<*) :: Infinite a -> Infinite b -> Infinite a

Applicative Pair

Defined in GHC.Data.Pair

Methods

pure :: a -> Pair a

(<*>) :: Pair (a -> b) -> Pair a -> Pair b

liftA2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c

(*>) :: Pair a -> Pair b -> Pair b

(<*) :: Pair a -> Pair b -> Pair a

Applicative Maybe

Defined in GHC.Data.Strict

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative Hsc

Defined in GHC.Driver.Env.Types

Methods

pure :: a -> Hsc a

(<*>) :: Hsc (a -> b) -> Hsc a -> Hsc b

liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c

(*>) :: Hsc a -> Hsc b -> Hsc b

(<*) :: Hsc a -> Hsc b -> Hsc a

Applicative Ghc

Defined in GHC.Driver.Monad

Methods

pure :: a -> Ghc a

(<*>) :: Ghc (a -> b) -> Ghc a -> Ghc b

liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c

(*>) :: Ghc a -> Ghc b -> Ghc b

(<*) :: Ghc a -> Ghc b -> Ghc a

Applicative P

Defined in GHC.Parser.Lexer

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

Applicative PV

Defined in GHC.Parser.PostProcess

Methods

pure :: a -> PV a

(<*>) :: PV (a -> b) -> PV a -> PV b

liftA2 :: (a -> b -> c) -> PV a -> PV b -> PV c

(*>) :: PV a -> PV b -> PV b

(<*) :: PV a -> PV b -> PV a

Applicative TcPluginM

Defined in GHC.Tc.Types

Methods

pure :: a -> TcPluginM a

(<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b

liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c

(*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b

(<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a

Applicative ZonkM

Defined in GHC.Tc.Zonk.Monad

Methods

pure :: a -> ZonkM a

(<*>) :: ZonkM (a -> b) -> ZonkM a -> ZonkM b

liftA2 :: (a -> b -> c) -> ZonkM a -> ZonkM b -> ZonkM c

(*>) :: ZonkM a -> ZonkM b -> ZonkM b

(<*) :: ZonkM a -> ZonkM b -> ZonkM a

Applicative UniqSM

Defined in GHC.Types.Unique.Supply

Methods

pure :: a -> UniqSM a

(<*>) :: UniqSM (a -> b) -> UniqSM a -> UniqSM b

liftA2 :: (a -> b -> c) -> UniqSM a -> UniqSM b -> UniqSM c

(*>) :: UniqSM a -> UniqSM b -> UniqSM b

(<*) :: UniqSM a -> UniqSM b -> UniqSM a

Applicative PprM

Defined in Language.Haskell.TH.PprLib

Methods

pure :: a -> PprM a

(<*>) :: PprM (a -> b) -> PprM a -> PprM b

liftA2 :: (a -> b -> c) -> PprM a -> PprM b -> PprM c

(*>) :: PprM a -> PprM b -> PprM b

(<*) :: PprM a -> PprM b -> PprM a

Applicative Q

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Applicative Q

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative Solo

Since: base-4.15

Defined in GHC.Base

Methods

pure :: a -> Solo a

(<*>) :: Solo (a -> b) -> Solo a -> Solo b

liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c

(*>) :: Solo a -> Solo b -> Solo b

(<*) :: Solo a -> Solo b -> Solo a

Applicative List

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> [a]

(<*>) :: [a -> b] -> [a] -> [b]

liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c]

(*>) :: [a] -> [b] -> [b]

(<*) :: [a] -> [b] -> [a]

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> ArrowMonad a a0

(<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c

(*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b

(<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative (StateL s)

Since: base-4.0

Defined in Data.Functor.Utils

Methods

pure :: a -> StateL s a

(<*>) :: StateL s (a -> b) -> StateL s a -> StateL s b

liftA2 :: (a -> b -> c) -> StateL s a -> StateL s b -> StateL s c

(*>) :: StateL s a -> StateL s b -> StateL s b

(<*) :: StateL s a -> StateL s b -> StateL s a

Applicative (StateR s)

Since: base-4.0

Defined in Data.Functor.Utils

Methods

pure :: a -> StateR s a

(<*>) :: StateR s (a -> b) -> StateR s a -> StateR s b

liftA2 :: (a -> b -> c) -> StateR s a -> StateR s b -> StateR s c

(*>) :: StateR s a -> StateR s b -> StateR s b

(<*) :: StateR s a -> StateR s b -> StateR s a

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Applicative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> U1 a

(<*>) :: U1 (a -> b) -> U1 a -> U1 b

liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

(*>) :: U1 a -> U1 b -> U1 b

(<*) :: U1 a -> U1 b -> U1 a

Applicative (ST s)

Since: base-4.4.0.0

Defined in GHC.ST

Methods

pure :: a -> ST s a

(<*>) :: ST s (a -> b) -> ST s a -> ST s b

liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c

(*>) :: ST s a -> ST s b -> ST s b

(<*) :: ST s a -> ST s b -> ST s a

Applicative (SetM s)

Defined in Data.Graph

Methods

pure :: a -> SetM s a

(<*>) :: SetM s (a -> b) -> SetM s a -> SetM s b

liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c

(*>) :: SetM s a -> SetM s b -> SetM s b

(<*) :: SetM s a -> SetM s b -> SetM s a

Applicative (IOEnv m)

Defined in GHC.Data.IOEnv

Methods

pure :: a -> IOEnv m a

(<*>) :: IOEnv m (a -> b) -> IOEnv m a -> IOEnv m b

liftA2 :: (a -> b -> c) -> IOEnv m a -> IOEnv m b -> IOEnv m c

(*>) :: IOEnv m a -> IOEnv m b -> IOEnv m b

(<*) :: IOEnv m a -> IOEnv m b -> IOEnv m a

Applicative (MaybeErr err)

Defined in GHC.Data.Maybe

Methods

pure :: a -> MaybeErr err a

(<*>) :: MaybeErr err (a -> b) -> MaybeErr err a -> MaybeErr err b

liftA2 :: (a -> b -> c) -> MaybeErr err a -> MaybeErr err b -> MaybeErr err c

(*>) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err b

(<*) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err a

Monad m => Applicative (EwM m)

Defined in GHC.Driver.CmdLine

Methods

pure :: a -> EwM m a

(<*>) :: EwM m (a -> b) -> EwM m a -> EwM m b

liftA2 :: (a -> b -> c) -> EwM m a -> EwM m b -> EwM m c

(*>) :: EwM m a -> EwM m b -> EwM m b

(<*) :: EwM m a -> EwM m b -> EwM m a

Applicative m => Applicative (GhcT m)

Defined in GHC.Driver.Monad

Methods

pure :: a -> GhcT m a

(<*>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b

liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c

(*>) :: GhcT m a -> GhcT m b -> GhcT m b

(<*) :: GhcT m a -> GhcT m b -> GhcT m a

Applicative (CmdLineP s)

Defined in GHC.Driver.Session

Methods

pure :: a -> CmdLineP s a

(<*>) :: CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b

liftA2 :: (a -> b -> c) -> CmdLineP s a -> CmdLineP s b -> CmdLineP s c

(*>) :: CmdLineP s a -> CmdLineP s b -> CmdLineP s b

(<*) :: CmdLineP s a -> CmdLineP s b -> CmdLineP s a

Applicative (State s)

Defined in GHC.Utils.Monad.State.Strict

Methods

pure :: a -> State s a

(<*>) :: State s (a -> b) -> State s a -> State s b

liftA2 :: (a -> b -> c) -> State s a -> State s b -> State s c

(*>) :: State s a -> State s b -> State s b

(<*) :: State s a -> State s b -> State s a

(Functor m, Monad m) => Applicative (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

pure :: a -> MaybeT m a

(<*>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b

liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c

(*>) :: MaybeT m a -> MaybeT m b -> MaybeT m b

(<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> (a, a0)

(<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b)

liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c)

(*>) :: (a, a0) -> (a, b) -> (a, b)

(<*) :: (a, a0) -> (a, b) -> (a, a0)

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Applicative m => Applicative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0

Monoid m => Applicative (Const m :: Type -> Type)

Since: base-2.0.1

Defined in Data.Functor.Const

Methods

pure :: a -> Const m a

(<*>) :: Const m (a -> b) -> Const m a -> Const m b

liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

(*>) :: Const m a -> Const m b -> Const m b

(<*) :: Const m a -> Const m b -> Const m a

Monad m => Applicative (StateT s m)

Since: base-4.18.0.0

Defined in Data.Functor.Utils

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

Applicative f => Applicative (Ap f)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

pure :: a -> Ap f a

(<*>) :: Ap f (a -> b) -> Ap f a -> Ap f b

liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

(*>) :: Ap f a -> Ap f b -> Ap f b

(<*) :: Ap f a -> Ap f b -> Ap f a

Applicative f => Applicative (Alt f)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Alt f a

(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

(*>) :: Alt f a -> Alt f b -> Alt f b

(<*) :: Alt f a -> Alt f b -> Alt f a

(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

pure :: a -> Generically1 f a

(<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b

liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c

(*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b

(<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a

Applicative f => Applicative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Rec1 f a

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a

(Applicative f, Monad f) => Applicative (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMissing f x a

(<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b

liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c

(*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b

(<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a

Applicative (Stream m a)

Defined in GHC.Data.Stream

Methods

pure :: a0 -> Stream m a a0

(<*>) :: Stream m a (a0 -> b) -> Stream m a a0 -> Stream m a b

liftA2 :: (a0 -> b -> c) -> Stream m a a0 -> Stream m a b -> Stream m a c

(*>) :: Stream m a a0 -> Stream m a b -> Stream m a b

(<*) :: Stream m a a0 -> Stream m a b -> Stream m a a0

Monad m => Applicative (StreamS m a)

Defined in GHC.Data.Stream

Methods

pure :: a0 -> StreamS m a a0

(<*>) :: StreamS m a (a0 -> b) -> StreamS m a a0 -> StreamS m a b

liftA2 :: (a0 -> b -> c) -> StreamS m a a0 -> StreamS m a b -> StreamS m a c

(*>) :: StreamS m a a0 -> StreamS m a b -> StreamS m a b

(<*) :: StreamS m a a0 -> StreamS m a b -> StreamS m a a0

(Functor m, Monad m) => Applicative (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

pure :: a -> ExceptT e m a

(<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b

liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c

(*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b

(<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a

Applicative m => Applicative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

pure :: a -> IdentityT m a

(<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b

liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c

(*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

(<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a

Applicative m => Applicative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b

liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

(*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

(<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

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

Defined in Control.Monad.Trans.Writer.Lazy

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

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

Defined in Control.Monad.Trans.Writer.Strict

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

(Monoid a, Monoid b) => Applicative ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, a0)

(<*>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0)

liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c)

(*>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0)

(<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0)

(Applicative f, Applicative g) => Applicative (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

pure :: a -> Product f g a

(<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b

liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

(*>) :: Product f g a -> Product f g b -> Product f g b

(<*) :: Product f g a -> Product f g b -> Product f g a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

Monoid c => Applicative (K1 i c :: Type -> Type)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

pure :: a -> K1 i c a

(<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b

liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0

(*>) :: K1 i c a -> K1 i c b -> K1 i c b

(<*) :: K1 i c a -> K1 i c b -> K1 i c a

(Monad f, Applicative f) => Applicative (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMatched f x y a

(<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c

(*>) :: WhenMatched f x y 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 a

(Applicative f, Monad f) => Applicative (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMissing f k x a

(<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c

(*>) :: WhenMissing f k x 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 a

Applicative (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

pure :: a -> ContT r m a

(<*>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b

liftA2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c

(*>) :: ContT r m a -> ContT r m b -> ContT r m b

(<*) :: ContT r m a -> ContT r m b -> ContT r m a

(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, c, a0)

(<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0)

liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0)

(*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0)

(<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0)

Applicative ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> r -> a

(<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

(*>) :: (r -> a) -> (r -> b) -> r -> b

(<*) :: (r -> a) -> (r -> b) -> r -> a

(Applicative f, Applicative g) => Applicative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

pure :: a -> Compose f g a

(<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b

liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

(*>) :: Compose f g a -> Compose f g b -> Compose f g b

(<*) :: Compose f g a -> Compose f g b -> Compose f g a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :.: g) a

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

Applicative f => Applicative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> M1 i c f a

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b

liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0

(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a

(Monad f, Applicative f) => Applicative (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMatched f k x y a

(<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c

(*>) :: WhenMatched f k x y 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 a

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

Defined in Control.Monad.Trans.RWS.CPS

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Lazy

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Strict

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

class Monad m => MonadFix (m :: Type -> Type) where

Monads having fixed points with a 'knot-tying' semantics. Instances of MonadFix should satisfy the following laws:

Purity

mfix (return . h) = return (fix h)

Left shrinking (or Tightening)

mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y)

Sliding

mfix (liftM h . f) = liftM h (mfix (f . h)), for strict h.

Nesting

mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x)

This class is used in the translation of the recursive do notation supported by GHC and Hugs.

Methods

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

The fixed point of a monadic computation. mfix f executes the action f only once, with the eventual output fed back as the input. Hence f should not be strict, for then mfix f would diverge.

Instances

MonadFix Complex

Since: base-4.15.0.0

Defined in Data.Complex

Methods

mfix :: (a -> Complex a) -> Complex a

MonadFix Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

mfix :: (a -> Identity a) -> Identity a

MonadFix First

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> First a) -> First a

MonadFix Last

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Last a) -> Last a

MonadFix Down

Since: base-4.12.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Down a) -> Down a

MonadFix First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mfix :: (a -> First a) -> First a

MonadFix Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mfix :: (a -> Last a) -> Last a

MonadFix Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mfix :: (a -> Max a) -> Max a

MonadFix Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

mfix :: (a -> Min a) -> Min a

MonadFix Dual

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Dual a) -> Dual a

MonadFix Product

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Product a) -> Product a

MonadFix Sum

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Sum a) -> Sum a

MonadFix NonEmpty

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> NonEmpty a) -> NonEmpty a

MonadFix Par1

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Par1 a) -> Par1 a

MonadFix Seq

Since: containers-0.5.11

Defined in Data.Sequence.Internal

Methods

mfix :: (a -> Seq a) -> Seq a

MonadFix Tree

Since: containers-0.5.11

Defined in Data.Tree

Methods

mfix :: (a -> Tree a) -> Tree a

MonadFix Ghc

Defined in GHC.Driver.Monad

Methods

mfix :: (a -> Ghc a) -> Ghc a

MonadFix UniqSM

Defined in GHC.Types.Unique.Supply

Methods

mfix :: (a -> UniqSM a) -> UniqSM a

MonadFix Q

If the function passed to mfix inspects its argument, the resulting action will throw a FixIOException.

Since: 2.17.0.0

Defined in Language.Haskell.TH.Syntax

Methods

mfix :: (a -> Q a) -> Q a

MonadFix IO

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> IO a) -> IO a

MonadFix Q

If the function passed to mfix inspects its argument, the resulting action will throw a FixIOException.

Since: template-haskell-2.17.0.0

Defined in Language.Haskell.TH.Syntax

Methods

mfix :: (a -> Q a) -> Q a

MonadFix Maybe

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Maybe a) -> Maybe a

MonadFix Solo

Since: base-4.15

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Solo a) -> Solo a

MonadFix List

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> [a]) -> [a]

MonadFix (Either e)

Since: base-4.3.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Either e a) -> Either e a

MonadFix (ST s)

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> ST s a) -> ST s a

MonadFix (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

mfix :: (a -> IOEnv env a) -> IOEnv env a

MonadFix m => MonadFix (GhcT m)

Defined in GHC.Driver.Monad

Methods

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

MonadFix m => MonadFix (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

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

MonadFix f => MonadFix (Ap f)

Since: base-4.12.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Ap f a) -> Ap f a

MonadFix f => MonadFix (Alt f)

Since: base-4.8.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Alt f a) -> Alt f a

MonadFix f => MonadFix (Rec1 f)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> Rec1 f a) -> Rec1 f a

MonadFix m => MonadFix (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

mfix :: (a -> ExceptT e m a) -> ExceptT e m a

MonadFix m => MonadFix (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

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

MonadFix m => MonadFix (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

mfix :: (a -> ReaderT r m a) -> ReaderT r m a

MonadFix m => MonadFix (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

mfix :: (a -> StateT s m a) -> StateT s m a

MonadFix m => MonadFix (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mfix :: (a -> StateT s m a) -> StateT s m a

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

Defined in Control.Monad.Trans.Writer.Lazy

Methods

mfix :: (a -> WriterT w m a) -> WriterT w m a

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

Defined in Control.Monad.Trans.Writer.Strict

Methods

mfix :: (a -> WriterT w m a) -> WriterT w m a

(MonadFix f, MonadFix g) => MonadFix (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

mfix :: (a -> Product f g a) -> Product f g a

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

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> (f :*: g) a) -> (f :*: g) a

MonadFix ((->) r)

Since: base-2.1

Defined in Control.Monad.Fix

Methods

mfix :: (a -> r -> a) -> r -> a

MonadFix f => MonadFix (M1 i c f)

Since: base-4.9.0.0

Defined in Control.Monad.Fix

Methods

mfix :: (a -> M1 i c f a) -> M1 i c f a

MonadFix m => MonadFix (RWST r w s m)

Defined in Control.Monad.Trans.RWS.CPS

Methods

mfix :: (a -> RWST r w s m a) -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Lazy

Methods

mfix :: (a -> RWST r w s m a) -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Strict

Methods

mfix :: (a -> RWST r w s m a) -> RWST r w s m a

class Monad m => MonadIO (m :: Type -> Type) where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

MonadIO CoreM

Defined in GHC.Core.Opt.Monad

Methods

liftIO :: IO a -> CoreM a

MonadIO SimplM

Defined in GHC.Core.Opt.Simplify.Monad

Methods

liftIO :: IO a -> SimplM a

MonadIO Hsc

Defined in GHC.Driver.Env.Types

Methods

liftIO :: IO a -> Hsc a

MonadIO Ghc

Defined in GHC.Driver.Monad

Methods

liftIO :: IO a -> Ghc a

MonadIO ZonkM

Defined in GHC.Tc.Zonk.Monad

Methods

liftIO :: IO a -> ZonkM a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO (IOEnv env)

Defined in GHC.Data.IOEnv

Methods

liftIO :: IO a -> IOEnv env a

MonadIO m => MonadIO (EwM m)

Defined in GHC.Driver.CmdLine

Methods

liftIO :: IO a -> EwM m a

MonadIO m => MonadIO (GhcT m)

Defined in GHC.Driver.Monad

Methods

liftIO :: IO a -> GhcT m a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (Stream m b)

Defined in GHC.Data.Stream

Methods

liftIO :: IO a -> Stream m b a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

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

Defined in Control.Monad.Trans.Writer.Lazy

Methods

liftIO :: IO a -> WriterT w m a

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

Defined in Control.Monad.Trans.Writer.Strict

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

liftIO :: IO a -> ContT r m a

MonadIO m => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.CPS

Methods

liftIO :: IO a -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Lazy

Methods

liftIO :: IO a -> RWST r w s m a

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

Defined in Control.Monad.Trans.RWS.Strict

Methods

liftIO :: IO a -> RWST r w s m a

zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]

zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()

zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> [a] -> [b] -> [c] -> [d] -> m [e]

zipWithAndUnzipM :: Monad m => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])

zipWith3MNE :: Monad m => (a -> b -> c -> m d) -> NonEmpty a -> NonEmpty b -> NonEmpty c -> m (NonEmpty d)

zipWith3M for NonEmpty lists.

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])

The mapAndUnzipM function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state monad.

mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d])

mapAndUnzipM for triples

mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e])

mapAndUnzip5M :: Monad m => (a -> m (b, c, d, e, f)) -> [a] -> m ([b], [c], [d], [e], [f])

mapAccumLM

Arguments

:: (Monad m, Traversable t)

=> (acc -> x -> m (acc, y))

combining function

-> acc

initial state

-> t x

inputs

-> m (acc, t y)

final state, outputs

Monadic version of mapAccumL

mapSndM :: (Applicative m, Traversable f) => (b -> m c) -> f (a, b) -> m (f (a, c))

Monadic version of mapSnd

concatMapM :: (Monad m, Traversable f) => (a -> m [b]) -> f a -> m [b]

Monadic version of concatMap

mapMaybeM :: Applicative m => (a -> m (Maybe b)) -> [a] -> m [b]

Applicative version of mapMaybe

anyM :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m Bool

Monadic version of any, aborts the computation at the first True value

allM :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m Bool

Monad version of all, aborts the computation at the first False value

orM :: Monad m => m Bool -> m Bool -> m Bool

Monadic version of or

foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b

Left-to-right monadic fold over the elements of a structure.

Given a structure t with elements (a, b, ..., w, x, y), the result of a fold with an operator function f is equivalent to:

foldlM f z t = do
    aa <- f z a
    bb <- f aa b
    ...
    xx <- f ww x
    yy <- f xx y
    return yy -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldlM is that it amounts to an application to z of a Kleisli composition:

foldlM f z t =
    flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z

The monadic effects of foldlM are sequenced from left to right.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from an initial segment of the element sequence. If you want to evaluate the monadic effects in right-to-left order, or perhaps be able to short-circuit after processing a tail of the sequence of elements, you'll need to use foldrM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the rightmost element y, so that, ignoring effects, the result looks like a left fold:

((((z `f` a) `f` b) ... `f` w) `f` x) `f` y

Examples

Basic usage:

>>> let f a e = do { print e ; return $ e : a }
>>> foldlM f [] [0..3]
0
1
2
3
[3,2,1,0]

foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m ()

Monadic version of foldl that discards its result

foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b

Right-to-left monadic fold over the elements of a structure.

Given a structure t with elements (a, b, c, ..., x, y), the result of a fold with an operator function f is equivalent to:

foldrM f z t = do
    yy <- f y z
    xx <- f x yy
    ...
    bb <- f b cc
    aa <- f a bb
    return aa -- Just @return z@ when the structure is empty

For a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c, their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:

(f1 >=> f2) a = f1 a >>= f2

Another way of thinking about foldrM is that it amounts to an application to z of a Kleisli composition:

foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z

The monadic effects of foldrM are sequenced from right to left, and e.g. folds of infinite lists will diverge.

If at some step the bind operator (>>=) short-circuits (as with, e.g., mzero in a MonadPlus), the evaluated effects will be from a tail of the element sequence. If you want to evaluate the monadic effects in left-to-right order, or perhaps be able to short-circuit after an initial sequence of elements, you'll need to use foldlM instead.

If the monadic effects don't short-circuit, the outermost application of f is to the leftmost element a, so that, ignoring effects, the result looks like a right fold:

a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).

Examples

Basic usage:

>>> let f i acc = do { print i ; return $ i : acc }
>>> foldrM f [] [0..3]
3
2
1
0
[0,1,2,3]

whenM :: Monad m => m Bool -> m () -> m ()

Monadic version of when, taking the condition in the monad

unlessM :: Monad m => m Bool -> m () -> m ()

Monadic version of unless, taking the condition in the monad

filterOutM :: Applicative m => (a -> m Bool) -> [a] -> m [a]

Like filterM, only it reverses the sense of the test.

partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a])

Monadic version of partition