Safe Haskell	None
Language	Haskell2010

MonadUtils

Description

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

Synopsis

class Functor f => Applicative (f :: * -> *) where
(<$>) :: Functor f => (a -> b) -> f a -> f b
class Monad m => MonadFix (m :: * -> *) where
class Monad m => MonadIO (m :: * -> *) where
liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b
liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c
liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d
liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e
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])
mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d])
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 :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])
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
allM :: Monad m => (a -> m Bool) -> [a] -> m Bool
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
maybeMapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)
whenM :: Monad m => m Bool -> m () -> m ()
unlessM :: Monad m => m Bool -> m () -> m ()

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 (<*> 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
```
```
(<*>) = ap
```
```
(*>) = (>>)
```

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

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a Source #

Lift a value.

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

Sequential application.

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

(*>) :: 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

Applicative []	Since: 2.1
Instance details Methods pure :: a -> [a] Source # (<>) :: [a -> b] -> [a] -> [b] Source # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] Source # (>) :: [a] -> [b] -> [b] Source # (<*) :: [a] -> [b] -> [a] Source #
Applicative Maybe	Since: 2.1
Instance details Methods pure :: a -> Maybe a Source # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source # (>) :: Maybe a -> Maybe b -> Maybe b Source # (<*) :: Maybe a -> Maybe b -> Maybe a Source #
Applicative IO	Since: 2.1
Instance details Methods pure :: a -> IO a Source # (<>) :: IO (a -> b) -> IO a -> IO b Source # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c Source # (>) :: IO a -> IO b -> IO b Source # (<*) :: IO a -> IO b -> IO a Source #
Applicative Par1	Since: 4.9.0.0
Instance details Methods pure :: a -> Par1 a Source # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source # (>) :: Par1 a -> Par1 b -> Par1 b Source # (<*) :: Par1 a -> Par1 b -> Par1 a Source #
Applicative Q
Instance details Methods pure :: a -> Q a Source # (<>) :: Q (a -> b) -> Q a -> Q b Source # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source # (>) :: Q a -> Q b -> Q b Source # (<*) :: Q a -> Q b -> Q a Source #
Applicative Complex	Since: 4.9.0.0
Instance details Methods pure :: a -> Complex a Source # (<>) :: Complex (a -> b) -> Complex a -> Complex b Source # liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c Source # (>) :: Complex a -> Complex b -> Complex b Source # (<*) :: Complex a -> Complex b -> Complex a Source #
Applicative Min	Since: 4.9.0.0
Instance details Methods pure :: a -> Min a Source # (<>) :: Min (a -> b) -> Min a -> Min b Source # liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c Source # (>) :: Min a -> Min b -> Min b Source # (<*) :: Min a -> Min b -> Min a Source #
Applicative Max	Since: 4.9.0.0
Instance details Methods pure :: a -> Max a Source # (<>) :: Max (a -> b) -> Max a -> Max b Source # liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c Source # (>) :: Max a -> Max b -> Max b Source # (<*) :: Max a -> Max b -> Max a Source #
Applicative First	Since: 4.9.0.0
Instance details Methods pure :: a -> First a Source # (<>) :: First (a -> b) -> First a -> First b Source # liftA2 :: (a -> b -> c) -> First a -> First b -> First c Source # (>) :: First a -> First b -> First b Source # (<*) :: First a -> First b -> First a Source #
Applicative Last	Since: 4.9.0.0
Instance details Methods pure :: a -> Last a Source # (<>) :: Last (a -> b) -> Last a -> Last b Source # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source # (>) :: Last a -> Last b -> Last b Source # (<*) :: Last a -> Last b -> Last a Source #
Applicative Option	Since: 4.9.0.0
Instance details Methods pure :: a -> Option a Source # (<>) :: Option (a -> b) -> Option a -> Option b Source # liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c Source # (>) :: Option a -> Option b -> Option b Source # (<*) :: Option a -> Option b -> Option a Source #
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: 2.1
Instance details Methods pure :: a -> ZipList a Source # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c Source # (>) :: ZipList a -> ZipList b -> ZipList b Source # (<*) :: ZipList a -> ZipList b -> ZipList a Source #
Applicative Identity	Since: 4.8.0.0
Instance details Methods pure :: a -> Identity a Source # (<>) :: Identity (a -> b) -> Identity a -> Identity b Source # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source # (>) :: Identity a -> Identity b -> Identity b Source # (<*) :: Identity a -> Identity b -> Identity a Source #
Applicative STM	Since: 4.8.0.0
Instance details Methods pure :: a -> STM a Source # (<>) :: STM (a -> b) -> STM a -> STM b Source # liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c Source # (>) :: STM a -> STM b -> STM b Source # (<*) :: STM a -> STM b -> STM a Source #
Applicative First
Instance details Methods pure :: a -> First a Source # (<>) :: First (a -> b) -> First a -> First b Source # liftA2 :: (a -> b -> c) -> First a -> First b -> First c Source # (>) :: First a -> First b -> First b Source # (<*) :: First a -> First b -> First a Source #
Applicative Last
Instance details Methods pure :: a -> Last a Source # (<>) :: Last (a -> b) -> Last a -> Last b Source # liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source # (>) :: Last a -> Last b -> Last b Source # (<*) :: Last a -> Last b -> Last a Source #
Applicative Dual	Since: 4.8.0.0
Instance details Methods pure :: a -> Dual a Source # (<>) :: Dual (a -> b) -> Dual a -> Dual b Source # liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source # (>) :: Dual a -> Dual b -> Dual b Source # (<*) :: Dual a -> Dual b -> Dual a Source #
Applicative Sum	Since: 4.8.0.0
Instance details Methods pure :: a -> Sum a Source # (<>) :: Sum (a -> b) -> Sum a -> Sum b Source # liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source # (>) :: Sum a -> Sum b -> Sum b Source # (<*) :: Sum a -> Sum b -> Sum a Source #
Applicative Product	Since: 4.8.0.0
Instance details Methods pure :: a -> Product a Source # (<>) :: Product (a -> b) -> Product a -> Product b Source # liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c Source # (>) :: Product a -> Product b -> Product b Source # (<*) :: Product a -> Product b -> Product a Source #
Applicative Down	Since: 4.11.0.0
Instance details Methods pure :: a -> Down a Source # (<>) :: Down (a -> b) -> Down a -> Down b Source # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c Source # (>) :: Down a -> Down b -> Down b Source # (<*) :: Down a -> Down b -> Down a Source #
Applicative ReadPrec	Since: 4.6.0.0
Instance details Methods pure :: a -> ReadPrec a Source # (<>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b Source # liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c Source # (>) :: ReadPrec a -> ReadPrec b -> ReadPrec b Source # (<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a Source #
Applicative ReadP	Since: 4.6.0.0
Instance details Methods pure :: a -> ReadP a Source # (<>) :: ReadP (a -> b) -> ReadP a -> ReadP b Source # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c Source # (>) :: ReadP a -> ReadP b -> ReadP b Source # (<*) :: ReadP a -> ReadP b -> ReadP a Source #
Applicative NonEmpty	Since: 4.9.0.0
Instance details Methods pure :: a -> NonEmpty a Source # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source #
Applicative Put
Instance details Methods pure :: a -> Put a Source # (<>) :: Put (a -> b) -> Put a -> Put b Source # liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c Source # (>) :: Put a -> Put b -> Put b Source # (<*) :: Put a -> Put b -> Put a Source #
Applicative PutM
Instance details Methods pure :: a -> PutM a Source # (<>) :: PutM (a -> b) -> PutM a -> PutM b Source # liftA2 :: (a -> b -> c) -> PutM a -> PutM b -> PutM c Source # (>) :: PutM a -> PutM b -> PutM b Source # (<*) :: PutM a -> PutM b -> PutM a Source #
Applicative Get
Instance details Methods pure :: a -> Get a Source # (<>) :: Get (a -> b) -> Get a -> Get b Source # liftA2 :: (a -> b -> c) -> Get a -> Get b -> Get c Source # (>) :: Get a -> Get b -> Get b Source # (<*) :: Get a -> Get b -> Get a Source #
Applicative Tree
Instance details Methods pure :: a -> Tree a Source # (<>) :: Tree (a -> b) -> Tree a -> Tree b Source # liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c Source # (>) :: Tree a -> Tree b -> Tree b Source # (<*) :: Tree a -> Tree b -> Tree a Source #
Applicative Seq	Since: 0.5.4
Instance details Methods pure :: a -> Seq a Source # (<>) :: Seq (a -> b) -> Seq a -> Seq b Source # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source # (>) :: Seq a -> Seq b -> Seq b Source # (<*) :: Seq a -> Seq b -> Seq a Source #
Applicative Capability
Instance details Methods pure :: a -> Capability a Source # (<>) :: Capability (a -> b) -> Capability a -> Capability b Source # liftA2 :: (a -> b -> c) -> Capability a -> Capability b -> Capability c Source # (>) :: Capability a -> Capability b -> Capability b Source # (<*) :: Capability a -> Capability b -> Capability a Source #
Applicative P	Since: 4.5.0.0
Instance details Methods pure :: a -> P a Source # (<>) :: P (a -> b) -> P a -> P b Source # liftA2 :: (a -> b -> c) -> P a -> P b -> P c Source # (>) :: P a -> P b -> P b Source # (<*) :: P a -> P b -> P a Source #
Applicative Pair #
Instance details Methods pure :: a -> Pair a Source # (<>) :: Pair (a -> b) -> Pair a -> Pair b Source # liftA2 :: (a -> b -> c) -> Pair a -> Pair b -> Pair c Source # (>) :: Pair a -> Pair b -> Pair b Source # (<*) :: Pair a -> Pair b -> Pair a Source #
Applicative UniqSM #
Instance details Methods pure :: a -> UniqSM a Source # (<>) :: UniqSM (a -> b) -> UniqSM a -> UniqSM b Source # liftA2 :: (a -> b -> c) -> UniqSM a -> UniqSM b -> UniqSM c Source # (>) :: UniqSM a -> UniqSM b -> UniqSM b Source # (<*) :: UniqSM a -> UniqSM b -> UniqSM a Source #
Applicative P #
Instance details Methods pure :: a -> P a Source # (<>) :: P (a -> b) -> P a -> P b Source # liftA2 :: (a -> b -> c) -> P a -> P b -> P c Source # (>) :: P a -> P b -> P b Source # (<*) :: P a -> P b -> P a Source #
Applicative PD #
Instance details Methods pure :: a -> PD a Source # (<>) :: PD (a -> b) -> PD a -> PD b Source # liftA2 :: (a -> b -> c) -> PD a -> PD b -> PD c Source # (>) :: PD a -> PD b -> PD b Source # (<*) :: PD a -> PD b -> PD a Source #
Applicative UnifyResultM #
Instance details Methods pure :: a -> UnifyResultM a Source # (<>) :: UnifyResultM (a -> b) -> UnifyResultM a -> UnifyResultM b Source # liftA2 :: (a -> b -> c) -> UnifyResultM a -> UnifyResultM b -> UnifyResultM c Source # (>) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM b Source # (<*) :: UnifyResultM a -> UnifyResultM b -> UnifyResultM a Source #
Applicative LlvmM #
Instance details Methods pure :: a -> LlvmM a Source # (<>) :: LlvmM (a -> b) -> LlvmM a -> LlvmM b Source # liftA2 :: (a -> b -> c) -> LlvmM a -> LlvmM b -> LlvmM c Source # (>) :: LlvmM a -> LlvmM b -> LlvmM b Source # (<*) :: LlvmM a -> LlvmM b -> LlvmM a Source #
Applicative FCode #
Instance details Methods pure :: a -> FCode a Source # (<>) :: FCode (a -> b) -> FCode a -> FCode b Source # liftA2 :: (a -> b -> c) -> FCode a -> FCode b -> FCode c Source # (>) :: FCode a -> FCode b -> FCode b Source # (<*) :: FCode a -> FCode b -> FCode a Source #
Applicative CmmParse #
Instance details Methods pure :: a -> CmmParse a Source # (<>) :: CmmParse (a -> b) -> CmmParse a -> CmmParse b Source # liftA2 :: (a -> b -> c) -> CmmParse a -> CmmParse b -> CmmParse c Source # (>) :: CmmParse a -> CmmParse b -> CmmParse b Source # (<*) :: CmmParse a -> CmmParse b -> CmmParse a Source #
Applicative Hsc #
Instance details Methods pure :: a -> Hsc a Source # (<>) :: Hsc (a -> b) -> Hsc a -> Hsc b Source # liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c Source # (>) :: Hsc a -> Hsc b -> Hsc b Source # (<*) :: Hsc a -> Hsc b -> Hsc a Source #
Applicative TcPluginM #
Instance details Methods pure :: a -> TcPluginM a Source # (<>) :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b Source # liftA2 :: (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c Source # (>) :: TcPluginM a -> TcPluginM b -> TcPluginM b Source # (<*) :: TcPluginM a -> TcPluginM b -> TcPluginM a Source #
Applicative CompPipeline #
Instance details Methods pure :: a -> CompPipeline a Source # (<>) :: CompPipeline (a -> b) -> CompPipeline a -> CompPipeline b Source # liftA2 :: (a -> b -> c) -> CompPipeline a -> CompPipeline b -> CompPipeline c Source # (>) :: CompPipeline a -> CompPipeline b -> CompPipeline b Source # (<*) :: CompPipeline a -> CompPipeline b -> CompPipeline a Source #
Applicative Ghc #
Instance details Methods pure :: a -> Ghc a Source # (<>) :: Ghc (a -> b) -> Ghc a -> Ghc b Source # liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c Source # (>) :: Ghc a -> Ghc b -> Ghc b Source # (<*) :: Ghc a -> Ghc b -> Ghc a Source #
Applicative CoreM #
Instance details Methods pure :: a -> CoreM a Source # (<>) :: CoreM (a -> b) -> CoreM a -> CoreM b Source # liftA2 :: (a -> b -> c) -> CoreM a -> CoreM b -> CoreM c Source # (>) :: CoreM a -> CoreM b -> CoreM b Source # (<*) :: CoreM a -> CoreM b -> CoreM a Source #
Applicative SimplM #
Instance details Methods pure :: a -> SimplM a Source # (<>) :: SimplM (a -> b) -> SimplM a -> SimplM b Source # liftA2 :: (a -> b -> c) -> SimplM a -> SimplM b -> SimplM c Source # (>) :: SimplM a -> SimplM b -> SimplM b Source # (<*) :: SimplM a -> SimplM b -> SimplM a Source #
Applicative CpsRn #
Instance details Methods pure :: a -> CpsRn a Source # (<>) :: CpsRn (a -> b) -> CpsRn a -> CpsRn b Source # liftA2 :: (a -> b -> c) -> CpsRn a -> CpsRn b -> CpsRn c Source # (>) :: CpsRn a -> CpsRn b -> CpsRn b Source # (<*) :: CpsRn a -> CpsRn b -> CpsRn a Source #
Applicative OccCheckResult #
Instance details Methods pure :: a -> OccCheckResult a Source # (<>) :: OccCheckResult (a -> b) -> OccCheckResult a -> OccCheckResult b Source # liftA2 :: (a -> b -> c) -> OccCheckResult a -> OccCheckResult b -> OccCheckResult c Source # (>) :: OccCheckResult a -> OccCheckResult b -> OccCheckResult b Source # (<*) :: OccCheckResult a -> OccCheckResult b -> OccCheckResult a Source #
Applicative TcS #
Instance details Methods pure :: a -> TcS a Source # (<>) :: TcS (a -> b) -> TcS a -> TcS b Source # liftA2 :: (a -> b -> c) -> TcS a -> TcS b -> TcS c Source # (>) :: TcS a -> TcS b -> TcS b Source # (<*) :: TcS a -> TcS b -> TcS a Source #
Applicative VM #
Instance details Methods pure :: a -> VM a Source # (<>) :: VM (a -> b) -> VM a -> VM b Source # liftA2 :: (a -> b -> c) -> VM a -> VM b -> VM c Source # (>) :: VM a -> VM b -> VM b Source # (<*) :: VM a -> VM b -> VM a Source #
Applicative NatM #
Instance details Methods pure :: a -> NatM a Source # (<>) :: NatM (a -> b) -> NatM a -> NatM b Source # liftA2 :: (a -> b -> c) -> NatM a -> NatM b -> NatM c Source # (>) :: NatM a -> NatM b -> NatM b Source # (<*) :: NatM a -> NatM b -> NatM a Source #
Applicative (Either e)	Since: 3.0
Instance details Methods pure :: a -> Either e a Source # (<>) :: Either e (a -> b) -> Either e a -> Either e b Source # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c Source # (>) :: Either e a -> Either e b -> Either e b Source # (<*) :: Either e a -> Either e b -> Either e a Source #
Applicative (U1 :: * -> *)	Since: 4.9.0.0
Instance details Methods pure :: a -> U1 a Source # (<>) :: U1 (a -> b) -> U1 a -> U1 b Source # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source # (>) :: U1 a -> U1 b -> U1 b Source # (<*) :: U1 a -> U1 b -> U1 a Source #
Monoid a => Applicative ((,) a)	For tuples, the `Monoid` constraint on `a` determines how the first values merge. For example, `String`s concatenate: ("hello ", (+15)) <> ("world!", 2002) ("hello world!",2017) Since: 2.1*
Instance details Methods pure :: a0 -> (a, a0) Source # (<>) :: (a, a0 -> b) -> (a, a0) -> (a, b) Source # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) Source # (>) :: (a, a0) -> (a, b) -> (a, b) Source # (<*) :: (a, a0) -> (a, b) -> (a, a0) Source #
Monad m => Applicative (WrappedMonad m)	Since: 2.1
Instance details Methods pure :: a -> WrappedMonad m a Source # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c 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)	Since: 4.6.0.0
Instance details Methods pure :: a0 -> ArrowMonad a a0 Source # (<>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b Source # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c Source # (>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b Source # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 Source #
Applicative (Proxy :: * -> *)	Since: 4.7.0.0
Instance details Methods pure :: a -> Proxy a Source # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b Source # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source # (>) :: Proxy a -> Proxy b -> Proxy b Source # (<*) :: Proxy a -> Proxy b -> Proxy a Source #
Applicative (ST s)	Since: 4.4.0.0
Instance details Methods pure :: a -> ST s a Source # (<>) :: ST s (a -> b) -> ST s a -> ST s b Source # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c Source # (>) :: ST s a -> ST s b -> ST s b Source # (<*) :: ST s a -> ST s b -> ST s a Source #
(Functor m, Monad m) => Applicative (MaybeT m)
Instance details Methods pure :: a -> MaybeT m a Source # (<>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b Source # liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c Source # (>) :: MaybeT m a -> MaybeT m b -> MaybeT m b Source # (<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a Source #
Applicative (ListT f) #
Instance details Methods pure :: a -> ListT f a Source # (<>) :: ListT f (a -> b) -> ListT f a -> ListT f b Source # liftA2 :: (a -> b -> c) -> ListT f a -> ListT f b -> ListT f c Source # (>) :: ListT f a -> ListT f b -> ListT f b Source # (<*) :: ListT f a -> ListT f b -> ListT f a Source #
Applicative (State s) #
Instance details Methods pure :: a -> State s a Source # (<>) :: State s (a -> b) -> State s a -> State s b Source # liftA2 :: (a -> b -> c) -> State s a -> State s b -> State s c Source # (>) :: State s a -> State s b -> State s b Source # (<*) :: State s a -> State s b -> State s a Source #
Applicative (MaybeErr err) #
Instance details Methods pure :: a -> MaybeErr err a Source # (<>) :: MaybeErr err (a -> b) -> MaybeErr err a -> MaybeErr err b Source # liftA2 :: (a -> b -> c) -> MaybeErr err a -> MaybeErr err b -> MaybeErr err c Source # (>) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err b Source # (<*) :: MaybeErr err a -> MaybeErr err b -> MaybeErr err a Source #
Applicative (SetM s)
Instance details Methods pure :: a -> SetM s a Source # (<>) :: SetM s (a -> b) -> SetM s a -> SetM s b Source # liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c Source # (>) :: SetM s a -> SetM s b -> SetM s b Source # (<*) :: SetM s a -> SetM s b -> SetM s a Source #
Applicative (CmdLineP s) #
Instance details Methods pure :: a -> CmdLineP s a Source # (<>) :: CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b Source # liftA2 :: (a -> b -> c) -> CmdLineP s a -> CmdLineP s b -> CmdLineP s c 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) #
Instance details Methods pure :: a -> EwM m a Source # (<>) :: EwM m (a -> b) -> EwM m a -> EwM m b Source # liftA2 :: (a -> b -> c) -> EwM m a -> EwM m b -> EwM m c Source # (>) :: EwM m a -> EwM m b -> EwM m b Source # (<*) :: EwM m a -> EwM m b -> EwM m a Source #
Applicative (IOEnv m) #
Instance details Methods pure :: a -> IOEnv m a Source # (<>) :: IOEnv m (a -> b) -> IOEnv m a -> IOEnv m b Source # liftA2 :: (a -> b -> c) -> IOEnv m a -> IOEnv m b -> IOEnv m c Source # (>) :: IOEnv m a -> IOEnv m b -> IOEnv m b Source # (<*) :: IOEnv m a -> IOEnv m b -> IOEnv m a Source #
Applicative (RegM freeRegs) #
Instance details Methods pure :: a -> RegM freeRegs a Source # (<>) :: RegM freeRegs (a -> b) -> RegM freeRegs a -> RegM freeRegs b Source # liftA2 :: (a -> b -> c) -> RegM freeRegs a -> RegM freeRegs b -> RegM freeRegs c 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) #
Instance details Methods pure :: a -> GhcT m a Source # (<>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b Source # liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c Source # (>) :: GhcT m a -> GhcT m b -> GhcT m b Source # (<*) :: GhcT m a -> GhcT m b -> GhcT m a Source #
Applicative f => Applicative (Rec1 f)	Since: 4.9.0.0
Instance details Methods pure :: a -> Rec1 f a Source # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source #
Arrow a => Applicative (WrappedArrow a b)	Since: 2.1
Instance details Methods pure :: a0 -> WrappedArrow a b a0 Source # (<>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source # (>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #
Monoid m => Applicative (Const m :: * -> *)	Since: 2.0.1
Instance details Methods pure :: a -> Const m a Source # (<>) :: Const m (a -> b) -> Const m a -> Const m b Source # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c 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)
Instance details Methods pure :: a -> Alt f a Source # (<>) :: Alt f (a -> b) -> Alt f a -> Alt f b Source # liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c Source # (>) :: Alt f a -> Alt f b -> Alt f b Source # (<*) :: Alt f a -> Alt f b -> Alt f a Source #
(Applicative f, Monad f) => Applicative (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: 0.5.9
Instance details Methods pure :: a -> WhenMissing f x a Source # (<>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c Source # (>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b Source # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a Source #
(Monoid w, Applicative m) => Applicative (WriterT w m)
Instance details Methods pure :: a -> WriterT w m a Source # (<>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c 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)
Instance details Methods pure :: a -> StateT s m a Source # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c 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)
Instance details Methods pure :: a -> StateT s m a Source # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c 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)
Instance details Methods pure :: a -> ExceptT e m a Source # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b Source # liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c 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) #
Instance details Methods pure :: a0 -> Stream m a a0 Source # (<>) :: Stream m a (a0 -> b) -> Stream m a a0 -> Stream m a b Source # liftA2 :: (a0 -> b -> c) -> Stream m a a0 -> Stream m a b -> Stream m a c Source # (>) :: Stream m a a0 -> Stream m a b -> Stream m a b Source # (<*) :: Stream m a a0 -> Stream m a b -> Stream m a a0 Source #
Applicative ((->) a :: * -> *)	Since: 2.1
Instance details Methods pure :: a0 -> a -> a0 Source # (<>) :: (a -> a0 -> b) -> (a -> a0) -> a -> b Source # liftA2 :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c Source # (>) :: (a -> a0) -> (a -> b) -> a -> b Source # (<*) :: (a -> a0) -> (a -> b) -> a -> a0 Source #
(Applicative f, Applicative g) => Applicative (f :*: g)	Since: 4.9.0.0
Instance details Methods pure :: a -> (f :: g) a Source # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b Source # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c 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 (Product f g)	Since: 4.9.0.0
Instance details Methods pure :: a -> Product f g a Source # (<>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source # liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source # (>) :: Product f g a -> Product f g b -> Product f g b Source # (<*) :: Product f g a -> Product f g b -> Product f g a Source #
(Monad f, Applicative f) => Applicative (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: 0.5.9
Instance details Methods pure :: a -> WhenMatched f x y a Source # (<>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c Source # (>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b Source # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a Source #
(Applicative f, Monad f) => Applicative (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: 0.5.9
Instance details Methods pure :: a -> WhenMissing f k x a Source # (<>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b Source # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c Source # (>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b Source # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a Source #
Applicative m => Applicative (ReaderT r m)
Instance details Methods pure :: a -> ReaderT r m a Source # (<>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b Source # liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c 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 #
Applicative f => Applicative (M1 i c f)	Since: 4.9.0.0
Instance details 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 # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 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 f, Applicative g) => Applicative (f :.: g)	Since: 4.9.0.0
Instance details Methods pure :: a -> (f :.: g) a Source # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c 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 (Compose f g)	Since: 4.9.0.0
Instance details Methods pure :: a -> Compose f g a Source # (<>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source # (>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<*) :: Compose f g a -> Compose f g b -> Compose f g a Source #
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: 0.5.9
Instance details Methods pure :: a -> WhenMatched f k x y a Source # (<>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b Source # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c Source # (>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b Source # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y 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

Expand

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.

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

MonadFix []	Since: 2.1
Instance details Methods mfix :: (a -> [a]) -> [a] Source #
MonadFix Maybe	Since: 2.1
Instance details Methods mfix :: (a -> Maybe a) -> Maybe a Source #
MonadFix IO	Since: 2.1
Instance details Methods mfix :: (a -> IO a) -> IO a Source #
MonadFix Par1	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Par1 a) -> Par1 a Source #
MonadFix Min	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Min a) -> Min a Source #
MonadFix Max	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Max a) -> Max a Source #
MonadFix First	Since: 4.9.0.0
Instance details Methods mfix :: (a -> First a) -> First a Source #
MonadFix Last	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Last a) -> Last a Source #
MonadFix Option	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Option a) -> Option a Source #
MonadFix Identity	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Identity a) -> Identity a Source #
MonadFix First	Since: 4.8.0.0
Instance details Methods mfix :: (a -> First a) -> First a Source #
MonadFix Last	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Last a) -> Last a Source #
MonadFix Dual	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Dual a) -> Dual a Source #
MonadFix Sum	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Sum a) -> Sum a Source #
MonadFix Product	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Product a) -> Product a Source #
MonadFix NonEmpty	Since: 4.9.0.0
Instance details Methods mfix :: (a -> NonEmpty a) -> NonEmpty a Source #
MonadFix Tree	Since: 0.5.11
Instance details Methods mfix :: (a -> Tree a) -> Tree a Source #
MonadFix Seq	Since: 0.5.11
Instance details Methods mfix :: (a -> Seq a) -> Seq a Source #
MonadFix UniqSM #
Instance details Methods mfix :: (a -> UniqSM a) -> UniqSM a Source #
MonadFix Ghc #
Instance details Methods mfix :: (a -> Ghc a) -> Ghc a Source #
MonadFix (Either e)	Since: 4.3.0.0
Instance details Methods mfix :: (a -> Either e a) -> Either e a Source #
MonadFix (ST s)	Since: 2.1
Instance details Methods mfix :: (a -> ST s a) -> ST s a Source #
MonadFix m => MonadFix (MaybeT m)
Instance details Methods mfix :: (a -> MaybeT m a) -> MaybeT m a Source #
MonadFix f => MonadFix (Rec1 f)	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Rec1 f a) -> Rec1 f a Source #
MonadFix f => MonadFix (Alt f)	Since: 4.8.0.0
Instance details Methods mfix :: (a -> Alt f a) -> Alt f a Source #
(Monoid w, MonadFix m) => MonadFix (WriterT w m)
Instance details Methods mfix :: (a -> WriterT w m a) -> WriterT w m a Source #
MonadFix m => MonadFix (StateT s m)
Instance details Methods mfix :: (a -> StateT s m a) -> StateT s m a Source #
MonadFix m => MonadFix (StateT s m)
Instance details Methods mfix :: (a -> StateT s m a) -> StateT s m a Source #
MonadFix m => MonadFix (ExceptT e m)
Instance details Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a Source #
MonadFix ((->) r :: * -> *)	Since: 2.1
Instance details Methods mfix :: (a -> r -> a) -> r -> a Source #
(MonadFix f, MonadFix g) => MonadFix (f :*: g)	Since: 4.9.0.0
Instance details Methods mfix :: (a -> (f :: g) a) -> (f :: g) a Source #
(MonadFix f, MonadFix g) => MonadFix (Product f g)	Since: 4.9.0.0
Instance details Methods mfix :: (a -> Product f g a) -> Product f g a Source #
MonadFix m => MonadFix (ReaderT r m)
Instance details Methods mfix :: (a -> ReaderT r m a) -> ReaderT r m a Source #
MonadFix f => MonadFix (M1 i c f)	Since: 4.9.0.0
Instance details Methods mfix :: (a -> M1 i c f a) -> M1 i c f 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:

```
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

MonadIO IO	Since: 4.9.0.0
Instance details Methods liftIO :: IO a -> IO a Source #
MonadIO Q
Instance details Methods liftIO :: IO a -> Q a Source #
MonadIO Hsc #
Instance details Methods liftIO :: IO a -> Hsc a Source #
MonadIO CompPipeline #
Instance details Methods liftIO :: IO a -> CompPipeline a Source #
MonadIO Ghc #
Instance details Methods liftIO :: IO a -> Ghc a Source #
MonadIO CoreM #
Instance details Methods liftIO :: IO a -> CoreM a Source #
MonadIO SimplM #
Instance details Methods liftIO :: IO a -> SimplM a Source #
MonadIO VM #
Instance details Methods liftIO :: IO a -> VM a Source #
MonadIO m => MonadIO (MaybeT m)
Instance details Methods liftIO :: IO a -> MaybeT m a Source #
MonadIO (IOEnv env) #
Instance details Methods liftIO :: IO a -> IOEnv env a Source #
MonadIO m => MonadIO (GhcT m) #
Instance details Methods liftIO :: IO a -> GhcT m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Methods liftIO :: IO a -> WriterT w m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO (ExceptT e m)
Instance details Methods liftIO :: IO a -> ExceptT e m a Source #
MonadIO m => MonadIO (ReaderT r m)
Instance details 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 function
-> 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