ghc-8.0.2: The GHC API

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: • u *> v = pure (const id) <*> u <*> v • u <* v = pure const <*> u <*> v As a consequence of these laws, the Functor instance for f will satisfy • fmap f x = pure f <*> x If f is also a Monad, it should satisfy • pure = return • (<*>) = ap (which implies that pure and <*> satisfy the applicative functor laws). Minimal complete definition Methods pure :: a -> f a Source # Lift a value. (<*>) :: f (a -> b) -> f a -> f b infixl 4 Source # Sequential application. (*>) :: f a -> f b -> f b infixl 4 Source # Sequence actions, discarding the value of the first argument. (<*) :: f a -> f b -> f a infixl 4 Source # Sequence actions, discarding the value of the second argument. Instances  Methodspure :: a -> [a] Source #(<*>) :: [a -> b] -> [a] -> [b] Source #(*>) :: [a] -> [b] -> [b] Source #(<*) :: [a] -> [b] -> [a] Source # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: 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 # Methodspure :: a -> SimpleUniqueMonad a Source #(<*>) :: SimpleUniqueMonad (a -> b) -> SimpleUniqueMonad a -> SimpleUniqueMonad b Source # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: a -> UnifyResultM a Source #(<*>) :: UnifyResultM (a -> b) -> UnifyResultM a -> UnifyResultM b Source # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: a -> OccCheckResult a Source #(<*>) :: OccCheckResult (a -> b) -> OccCheckResult a -> OccCheckResult b Source # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: a -> CompPipeline a Source #(<*>) :: CompPipeline (a -> b) -> CompPipeline a -> CompPipeline b Source # # Methodspure :: a -> TcPluginM a Source #(<*>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b Source #(*>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source #(<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a Source # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 # # Methodspure :: 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 ((->) a) Methodspure :: 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 # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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 # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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 # Monad m => Applicative (WrappedMonad m) Methodspure :: a -> WrappedMonad m a Source #(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source #(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source #(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # Arrow a => Applicative (ArrowMonad a) Methodspure :: 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 # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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 # Methodspure :: a -> CheckingFuelMonad m a Source #(<*>) :: CheckingFuelMonad m (a -> b) -> CheckingFuelMonad m a -> CheckingFuelMonad m b Source #(*>) :: CheckingFuelMonad m a -> CheckingFuelMonad m b -> CheckingFuelMonad m b Source #(<*) :: CheckingFuelMonad m a -> CheckingFuelMonad m b -> CheckingFuelMonad m a Source # Methodspure :: a -> InfiniteFuelMonad m a Source #(<*>) :: InfiniteFuelMonad m (a -> b) -> InfiniteFuelMonad m a -> InfiniteFuelMonad m b Source #(*>) :: InfiniteFuelMonad m a -> InfiniteFuelMonad m b -> InfiniteFuelMonad m b Source #(<*) :: InfiniteFuelMonad m a -> InfiniteFuelMonad m b -> InfiniteFuelMonad m a Source # Monad m => Applicative (UniqueMonadT m) Methodspure :: a -> UniqueMonadT m a Source #(<*>) :: UniqueMonadT m (a -> b) -> UniqueMonadT m a -> UniqueMonadT m b Source #(*>) :: UniqueMonadT m a -> UniqueMonadT m b -> UniqueMonadT m b Source #(<*) :: UniqueMonadT m a -> UniqueMonadT m b -> UniqueMonadT m a Source # (Functor m, Monad m) => Applicative (MaybeT m) Methodspure :: 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 # # Methodspure :: 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) # Methodspure :: 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 # # Methodspure :: 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) # Methodspure :: 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 # # Methodspure :: 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) # Methodspure :: 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) # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) Methodspure :: 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) # Methodspure :: 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) Methodspure :: 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) Methodspure :: 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)


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.

Minimal complete definition

mfix

Methods

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

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

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)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad.

Instances

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

Lift an IO operation with 1 argument into another monad

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

Lift an IO operation with 2 arguments into another monad

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

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 #

Lift an IO operation with 4 arguments into another monad

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]) #

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]) #

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]) #

Arguments

 :: Monad m => (acc -> x -> m (acc, y)) combining funcction -> acc initial state -> [x] inputs -> m (acc, [y]) final state, outputs

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

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

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

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

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

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

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

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

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

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

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

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

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

Monadic version of when, taking the condition in the monad
Monadic version of unless, taking the condition in the monad