ghc-8.0.1: The GHC API

Safe HaskellSafe
LanguageHaskell2010

MonadUtils

Description

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

Synopsis

Documentation

class Functor f => Applicative f where Source #

A functor with application, providing operations to

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

A minimal complete definition must include implementations of these functions satisfying the following laws:

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:

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

If f is also a Monad, it should satisfy

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

Minimal complete definition

pure, (<*>)

Instances

Applicative [] 

Methods

pure :: a -> [a] Source #

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

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

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

Applicative Maybe 

Methods

pure :: a -> Maybe a Source #

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

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

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

Applicative IO 

Methods

pure :: a -> IO a Source #

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

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

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

Applicative U1 

Methods

pure :: a -> U1 a Source #

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

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

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

Applicative Par1 

Methods

pure :: a -> Par1 a Source #

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

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

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

Applicative Q 

Methods

pure :: a -> Q a Source #

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

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

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

Applicative Id 

Methods

pure :: a -> Id a Source #

(<*>) :: Id (a -> b) -> Id a -> Id b Source #

(*>) :: Id a -> Id b -> Id b Source #

(<*) :: Id a -> Id b -> Id a Source #

Applicative P 

Methods

pure :: a -> P a Source #

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

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

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

Applicative Identity 

Methods

pure :: a -> Identity a Source #

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

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

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

Applicative Min 

Methods

pure :: a -> Min a Source #

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

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

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

Applicative Max 

Methods

pure :: a -> Max a Source #

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

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

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

Applicative First 

Methods

pure :: a -> First a Source #

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

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

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

Applicative Last 

Methods

pure :: a -> Last a Source #

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

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

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

Applicative Option 

Methods

pure :: a -> Option a Source #

(<*>) :: Option (a -> b) -> Option a -> Option b Source #

(*>) :: Option a -> Option b -> Option b Source #

(<*) :: Option a -> Option b -> Option a Source #

Applicative NonEmpty 

Methods

pure :: a -> NonEmpty a Source #

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

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

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

Applicative Complex 

Methods

pure :: a -> Complex a Source #

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

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

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

Applicative ZipList 

Methods

pure :: a -> ZipList a Source #

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

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

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

Applicative STM 

Methods

pure :: a -> STM a Source #

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

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

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

Applicative Dual 

Methods

pure :: a -> Dual a Source #

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

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

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

Applicative Sum 

Methods

pure :: a -> Sum a Source #

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

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

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

Applicative Product 

Methods

pure :: a -> Product a Source #

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

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

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

Applicative First 

Methods

pure :: a -> First a Source #

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

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

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

Applicative Last 

Methods

pure :: a -> Last a Source #

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

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

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

Applicative ReadPrec 

Methods

pure :: a -> ReadPrec a Source #

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

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

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

Applicative ReadP 

Methods

pure :: a -> ReadP a Source #

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

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

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

Applicative PutM 

Methods

pure :: a -> PutM a Source #

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

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

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

Applicative Get 

Methods

pure :: a -> Get a Source #

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

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

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

Applicative Tree 

Methods

pure :: a -> Tree a Source #

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

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

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

Applicative Seq 

Methods

pure :: a -> Seq a Source #

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

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

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

Applicative VM 

Methods

pure :: a -> VM a Source #

(<*>) :: VM (a -> b) -> VM a -> VM b Source #

(*>) :: VM a -> VM b -> VM b Source #

(<*) :: VM a -> VM b -> VM a Source #

Applicative SimpleUniqueMonad 
Applicative PprM 

Methods

pure :: a -> PprM a Source #

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

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

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

Applicative Pair # 

Methods

pure :: a -> Pair a Source #

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

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

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

Applicative UniqSM # 

Methods

pure :: a -> UniqSM a Source #

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

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

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

Applicative P # 

Methods

pure :: a -> P a Source #

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

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

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

Applicative UnifyResultM # 
Applicative LlvmM # 

Methods

pure :: a -> LlvmM a Source #

(<*>) :: LlvmM (a -> b) -> LlvmM a -> LlvmM b Source #

(*>) :: LlvmM a -> LlvmM b -> LlvmM b Source #

(<*) :: LlvmM a -> LlvmM b -> LlvmM a Source #

Applicative NatM # 

Methods

pure :: a -> NatM a Source #

(<*>) :: NatM (a -> b) -> NatM a -> NatM b Source #

(*>) :: NatM a -> NatM b -> NatM b Source #

(<*) :: NatM a -> NatM b -> NatM a Source #

Applicative OccCheckResult # 
Applicative FCode # 

Methods

pure :: a -> FCode a Source #

(<*>) :: FCode (a -> b) -> FCode a -> FCode b Source #

(*>) :: FCode a -> FCode b -> FCode b Source #

(<*) :: FCode a -> FCode b -> FCode a Source #

Applicative CmmParse # 

Methods

pure :: a -> CmmParse a Source #

(<*>) :: CmmParse (a -> b) -> CmmParse a -> CmmParse b Source #

(*>) :: CmmParse a -> CmmParse b -> CmmParse b Source #

(<*) :: CmmParse a -> CmmParse b -> CmmParse a Source #

Applicative Hsc # 

Methods

pure :: a -> Hsc a Source #

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

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

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

Applicative Ghc # 

Methods

pure :: a -> Ghc a Source #

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

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

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

Applicative CompPipeline # 
Applicative TcPluginM # 
Applicative CpsRn # 

Methods

pure :: a -> CpsRn a Source #

(<*>) :: CpsRn (a -> b) -> CpsRn a -> CpsRn b Source #

(*>) :: CpsRn a -> CpsRn b -> CpsRn b Source #

(<*) :: CpsRn a -> CpsRn b -> CpsRn a Source #

Applicative TcS # 

Methods

pure :: a -> TcS a Source #

(<*>) :: TcS (a -> b) -> TcS a -> TcS b Source #

(*>) :: TcS a -> TcS b -> TcS b Source #

(<*) :: TcS a -> TcS b -> TcS a Source #

Applicative CoreM # 

Methods

pure :: a -> CoreM a Source #

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

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

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

Applicative VM # 

Methods

pure :: a -> VM a Source #

(<*>) :: VM (a -> b) -> VM a -> VM b Source #

(*>) :: VM a -> VM b -> VM b Source #

(<*) :: VM a -> VM b -> VM a Source #

Applicative SimplM # 

Methods

pure :: a -> SimplM a Source #

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

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

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

Applicative ((->) a) 

Methods

pure :: a -> a -> a Source #

(<*>) :: (a -> a -> b) -> (a -> a) -> a -> b Source #

(*>) :: (a -> a) -> (a -> b) -> a -> b Source #

(<*) :: (a -> a) -> (a -> b) -> a -> a Source #

Applicative (Either e) 

Methods

pure :: a -> Either e a Source #

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

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

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

Applicative f => Applicative (Rec1 f) 

Methods

pure :: a -> Rec1 f a Source #

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

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

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

Monoid a => Applicative ((,) a) 

Methods

pure :: a -> (a, a) Source #

(<*>) :: (a, a -> b) -> (a, a) -> (a, b) Source #

(*>) :: (a, a) -> (a, b) -> (a, b) Source #

(<*) :: (a, a) -> (a, b) -> (a, a) Source #

Applicative (ST s) 

Methods

pure :: a -> ST s a Source #

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

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

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

Applicative (StateL s) 

Methods

pure :: a -> StateL s a Source #

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

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

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

Applicative (StateR s) 

Methods

pure :: a -> StateR s a Source #

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

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

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

Applicative (ST s) 

Methods

pure :: a -> ST s a Source #

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

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

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

Monad m => Applicative (WrappedMonad m) 
Arrow a => Applicative (ArrowMonad a) 

Methods

pure :: a -> ArrowMonad a a Source #

(<*>) :: ArrowMonad a (a -> b) -> ArrowMonad a a -> ArrowMonad a b Source #

(*>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b Source #

(<*) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a a Source #

Applicative (Proxy *) 

Methods

pure :: a -> Proxy * a Source #

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

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

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

Applicative (SetM s) 

Methods

pure :: a -> SetM s a Source #

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

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

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

Applicative (State s) 

Methods

pure :: a -> State s a Source #

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

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

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

Monad m => Applicative (CheckingFuelMonad m) 
Monad m => Applicative (InfiniteFuelMonad m) 
Monad m => Applicative (UniqueMonadT m) 
(Functor m, Monad m) => Applicative (MaybeT m) 

Methods

pure :: a -> MaybeT m a Source #

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

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

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

Applicative (State s) # 

Methods

pure :: a -> State s a Source #

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

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

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

Applicative (MaybeErr err) # 

Methods

pure :: a -> MaybeErr err a Source #

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

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

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

Applicative (CmdLineP s) # 

Methods

pure :: a -> CmdLineP s a Source #

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

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

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

Monad m => Applicative (EwM m) # 

Methods

pure :: a -> EwM m a Source #

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

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

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

Applicative (IOEnv m) # 

Methods

pure :: a -> IOEnv m a Source #

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

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

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

Applicative (RegM freeRegs) # 

Methods

pure :: a -> RegM freeRegs a Source #

(<*>) :: RegM freeRegs (a -> b) -> RegM freeRegs a -> RegM freeRegs b Source #

(*>) :: RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs b Source #

(<*) :: RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs a Source #

Applicative m => Applicative (GhcT m) # 

Methods

pure :: a -> GhcT m a Source #

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

Arrow a => Applicative (WrappedArrow a b) 

Methods

pure :: a -> WrappedArrow a b a Source #

(<*>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b Source #

(*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b Source #

(<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a Source #

Monoid m => Applicative (Const * m) 

Methods

pure :: a -> Const * m a Source #

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

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

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

Applicative f => Applicative (Alt * f) 

Methods

pure :: a -> Alt * f a Source #

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

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

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

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

Methods

pure :: a -> WriterT w m a Source #

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

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

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

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

Methods

pure :: a -> StateT s m a Source #

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

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

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

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

Methods

pure :: a -> StateT s m a Source #

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

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

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

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

Methods

pure :: a -> ExceptT e m a Source #

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

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

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

Monad m => Applicative (Stream m a) # 

Methods

pure :: a -> Stream m a a Source #

(<*>) :: Stream m a (a -> b) -> Stream m a a -> Stream m a b Source #

(*>) :: Stream m a a -> Stream m a b -> Stream m a b Source #

(<*) :: Stream m a a -> Stream m a b -> Stream m a a Source #

Applicative f => Applicative (M1 i c f) 

Methods

pure :: a -> M1 i c f a Source #

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

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

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

Applicative m => Applicative (ReaderT * r m) 

Methods

pure :: a -> ReaderT * r m a Source #

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

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

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

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

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 where Source #

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.

Instances

MonadFix [] 

Methods

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

MonadFix Maybe 

Methods

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

MonadFix IO 

Methods

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

MonadFix Par1 

Methods

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

MonadFix Identity 

Methods

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

MonadFix Min 

Methods

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

MonadFix Max 

Methods

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

MonadFix First 

Methods

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

MonadFix Last 

Methods

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

MonadFix Option 

Methods

mfix :: (a -> Option a) -> Option a Source #

MonadFix NonEmpty 

Methods

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

MonadFix Dual 

Methods

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

MonadFix Sum 

Methods

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

MonadFix Product 

Methods

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

MonadFix First 

Methods

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

MonadFix Last 

Methods

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

MonadFix UniqSM # 

Methods

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

MonadFix Ghc # 

Methods

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

MonadFix ((->) r) 

Methods

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

MonadFix (Either e) 

Methods

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

MonadFix f => MonadFix (Rec1 f) 

Methods

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

MonadFix (ST s) 

Methods

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

MonadFix (ST s) 

Methods

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

MonadFix m => MonadFix (MaybeT m) 

Methods

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

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

Methods

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

MonadFix f => MonadFix (Alt * f) 

Methods

mfix :: (a -> Alt * f a) -> Alt * f a Source #

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

Methods

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

MonadFix m => MonadFix (StateT s m) 

Methods

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

MonadFix m => MonadFix (StateT s m) 

Methods

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

MonadFix m => MonadFix (ExceptT e m) 

Methods

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

MonadFix f => MonadFix (M1 i c f) 

Methods

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

MonadFix m => MonadFix (ReaderT * r m) 

Methods

mfix :: (a -> ReaderT * r m a) -> ReaderT * r m a Source #

class Monad m => MonadIO m where Source #

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:

Instances

MonadIO IO 

Methods

liftIO :: IO a -> IO a Source #

MonadIO Hsc # 

Methods

liftIO :: IO a -> Hsc a Source #

MonadIO Ghc # 

Methods

liftIO :: IO a -> Ghc a Source #

MonadIO CompPipeline # 

Methods

liftIO :: IO a -> CompPipeline a Source #

MonadIO CoreM # 

Methods

liftIO :: IO a -> CoreM a Source #

MonadIO VM # 

Methods

liftIO :: IO a -> VM a Source #

MonadIO SimplM # 

Methods

liftIO :: IO a -> SimplM a Source #

MonadIO m => MonadIO (MaybeT m) 

Methods

liftIO :: IO a -> MaybeT m a Source #

MonadIO (IOEnv env) # 

Methods

liftIO :: IO a -> IOEnv env a Source #

(Applicative m, MonadIO m) => MonadIO (GhcT m) # 

Methods

liftIO :: IO a -> GhcT m a Source #

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

Methods

liftIO :: IO a -> WriterT w m a Source #

MonadIO m => MonadIO (StateT s m) 

Methods

liftIO :: IO a -> StateT s m a Source #

MonadIO m => MonadIO (StateT s m) 

Methods

liftIO :: IO a -> StateT s m a Source #

MonadIO m => MonadIO (ExceptT e m) 

Methods

liftIO :: IO a -> ExceptT e m a Source #

MonadIO m => MonadIO (ReaderT * r m) 

Methods

liftIO :: IO a -> ReaderT * r m a Source #

liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b Source #

Lift an IO operation with 1 argument into another monad

liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c Source #

Lift an IO operation with 2 arguments into another monad

liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d Source #

Lift an IO operation with 3 arguments into another monad

liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e Source #

Lift an IO operation with 4 arguments into another monad

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

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

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

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

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

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-transforming monad.

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

mapAndUnzipM for triples

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

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

mapAccumLM Source #

Arguments

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

combining funcction

-> acc

initial state

-> [x]

inputs

-> m (acc, [y])

final state, outputs

Monadic version of mapAccumL

mapSndM :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)] Source #

Monadic version of mapSnd

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b] Source #

Monadic version of concatMap

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] Source #

Monadic version of mapMaybe

fmapMaybeM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source #

Monadic version of fmap

fmapEitherM :: Monad m => (a -> m b) -> (c -> m d) -> Either a c -> m (Either b d) Source #

Monadic version of fmap

anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool Source #

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

allM :: Monad m => (a -> m Bool) -> [a] -> m Bool Source #

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

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

Monadic version of or

foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a Source #

Monadic version of foldl

foldlM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m () Source #

Monadic version of foldl that discards its result

foldrM :: Monad m => (b -> a -> m a) -> a -> [b] -> m a Source #

Monadic version of foldr

maybeMapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source #

Monadic version of fmap specialised for Maybe

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

Monadic version of when, taking the condition in the monad

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

Monadic version of unless, taking the condition in the monad