Language.Haskell.Liquid.Desugar.DsMonad

Documentation

type DsM = TcRnIf DsGblEnv DsLclEnv

mapM :: Traversable t => forall m a b. Monad m => (a -> m b) -> t a -> m (t b)

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see mapM_.

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

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

initDs :: HscEnv -> Module -> GlobalRdrEnv -> TypeEnv -> FamInstEnv -> DsM a -> IO (Messages, Maybe a)

initDsTc :: DsM a -> TcM a

initTcDsForSolver :: TcM a -> DsM (Messages, Maybe a)

fixDs :: (a -> DsM a) -> DsM a

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

Monadic version of foldl

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

Monadic version of foldr

whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()

unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a

class Functor f => Applicative f where

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

pure, (<*>)

Methods

pure :: a -> f a

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative []

Methods

pure :: a -> [a]

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

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

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

Applicative Maybe

Methods

pure :: a -> Maybe a

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

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

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

Applicative IO

Methods

pure :: a -> IO a

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

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

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

Applicative U1

Methods

pure :: a -> U1 a

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

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

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

Applicative Par1

Methods

pure :: a -> Par1 a

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

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

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

Applicative Q

Methods

pure :: a -> Q a

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

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

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

Applicative Last

Methods

pure :: a -> Last a

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

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

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

Applicative Get

Methods

pure :: a -> Get a

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

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

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

Applicative IResult

Methods

pure :: a -> IResult a

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

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

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

Applicative Result

Methods

pure :: a -> Result a

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

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

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

Applicative Parser

Methods

pure :: a -> Parser a

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

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

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

Applicative Id

Methods

pure :: a -> Id a

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

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

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

Applicative Identity

Methods

pure :: a -> Identity a

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

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

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

Applicative Min

Methods

pure :: a -> Min a

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

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

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

Applicative Max

Methods

pure :: a -> Max a

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

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

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

Applicative First

Methods

pure :: a -> First a

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

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

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

Applicative Option

Methods

pure :: a -> Option a

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

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

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

Applicative NonEmpty

Methods

pure :: a -> NonEmpty a

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

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

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

Applicative Complex

Methods

pure :: a -> Complex a

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

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

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

Applicative ZipList

Methods

pure :: a -> ZipList a

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

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

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

Applicative STM

Methods

pure :: a -> STM a

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

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

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

Applicative Dual

Methods

pure :: a -> Dual a

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

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

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

Applicative Sum

Methods

pure :: a -> Sum a

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

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

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

Applicative Product

Methods

pure :: a -> Product a

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

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

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

Applicative First

Methods

pure :: a -> First a

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

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

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

Applicative Last

Methods

pure :: a -> Last a

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

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

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

Applicative PutM

Methods

pure :: a -> PutM a

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

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

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

Applicative Put

Methods

pure :: a -> Put a

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

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

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

Applicative Get

Methods

pure :: a -> Get a

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

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

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

Applicative PutM

Methods

pure :: a -> PutM a

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

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

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

Applicative Tree

Methods

pure :: a -> Tree a

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

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

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

Applicative Seq

Methods

pure :: a -> Seq a

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

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

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

Applicative DList

Methods

pure :: a -> DList a

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

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

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

Applicative DFFV

Methods

pure :: a -> DFFV a

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

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

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

Applicative LintM

Methods

pure :: a -> LintM a

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

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

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

Applicative BcM

Methods

pure :: a -> BcM a

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

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

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

Applicative NormM

Methods

pure :: a -> NormM a

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

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

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

Applicative UM

Methods

pure :: a -> UM a

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

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

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

Applicative SimpleUniqueMonad

Methods

pure :: a -> SimpleUniqueMonad a

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

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

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

Applicative CoreM

Methods

pure :: a -> CoreM a

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

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

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

Applicative TcPluginM

Methods

pure :: a -> TcPluginM a

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

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

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

Applicative Ghc

Methods

pure :: a -> Ghc a

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

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

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

Applicative Hsc

Methods

pure :: a -> Hsc a

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

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

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

Applicative P

Methods

pure :: a -> P a

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

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

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

Applicative OccCheckResult

Methods

pure :: a -> OccCheckResult a

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

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

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

Applicative UnifyResultM

Methods

pure :: a -> UnifyResultM a

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

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

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

Applicative UniqSM

Methods

pure :: a -> UniqSM a

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

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

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

Applicative Pair

Methods

pure :: a -> Pair a

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

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

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

Applicative VM

Methods

pure :: a -> VM a

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

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

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

Applicative Array

Methods

pure :: a -> Array a

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

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

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

Applicative Vector

Methods

pure :: a -> Vector a

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

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

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

Applicative Id

Methods

pure :: a -> Id a

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

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

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

Applicative Box

Methods

pure :: a -> Box a

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

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

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

Applicative Target

Methods

pure :: a -> Target a

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

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

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

Applicative ((->) a)

Methods

pure :: a -> a -> a

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

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

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

Applicative (Either e)

Methods

pure :: a -> Either e a

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

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

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

Applicative f => Applicative (Rec1 f)

Methods

pure :: a -> Rec1 f a

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

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

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

Monoid a => Applicative ((,) a)

Methods

pure :: a -> (a, a)

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

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

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

Applicative (ST s)

Methods

pure :: a -> ST s a

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

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

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

Applicative (Parser i)

Methods

pure :: a -> Parser i a

(<*>) :: Parser i (a -> b) -> Parser i a -> Parser i b

(*>) :: Parser i a -> Parser i b -> Parser i b

(<*) :: Parser i a -> Parser i b -> Parser i a

Applicative (StateL s)

Methods

pure :: a -> StateL s a

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

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

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

Applicative (StateR s)

Methods

pure :: a -> StateR s a

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

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

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

Monad m => Applicative (WrappedMonad m)

Methods

pure :: a -> WrappedMonad m a

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

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

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

Arrow a => Applicative (ArrowMonad a)

Methods

pure :: a -> ArrowMonad a a

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

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

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

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

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

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

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

Applicative (SetM s)

Methods

pure :: a -> SetM s a

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

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

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

Applicative (State s)

Methods

pure :: a -> State s a

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

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

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

Monad m => Applicative (UniqueMonadT m)

Methods

pure :: a -> UniqueMonadT m a

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

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

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

Monad m => Applicative (InfiniteFuelMonad m)

Methods

pure :: a -> InfiniteFuelMonad m a

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

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

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

Monad m => Applicative (CheckingFuelMonad m)

Methods

pure :: a -> CheckingFuelMonad m a

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

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

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

Applicative m => Applicative (GhcT m)

Methods

pure :: a -> GhcT m a

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

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

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

Applicative (IOEnv m)

Methods

pure :: a -> IOEnv m a

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

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

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

Applicative (MaybeErr err)

Methods

pure :: a -> MaybeErr err a

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

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

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

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

Methods

pure :: a -> MaybeT m a

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

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

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

Applicative m => Applicative (ListT m)

Methods

pure :: a -> ListT m a

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

Arrow a => Applicative (WrappedArrow a b)

Methods

pure :: a -> WrappedArrow a b a

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

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

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

Monoid m => Applicative (Const * m)

Methods

pure :: a -> Const * m a

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

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

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

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

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

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

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

Applicative m => Applicative (IdentityT * m)

Methods

pure :: a -> IdentityT * m a

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

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

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

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

Methods

pure :: a -> ErrorT e m a

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

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

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

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

Methods

pure :: a -> ExceptT e m a

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

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

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

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

Methods

pure :: a -> StateT s m a

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

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

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

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

Methods

pure :: a -> StateT s m a

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

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

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

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

Methods

pure :: a -> WriterT w m a

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

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

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

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

Methods

pure :: a -> WriterT w m a

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

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

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

Applicative (Tagged k s)

Methods

pure :: a -> Tagged k s a

(<*>) :: Tagged k s (a -> b) -> Tagged k s a -> Tagged k s b

(*>) :: Tagged k s a -> Tagged k s b -> Tagged k s b

(<*) :: Tagged k s a -> Tagged k s b -> Tagged k s a

Applicative f => Applicative (M1 i c f)

Methods

pure :: a -> M1 i c f a

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

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

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

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

Methods

pure :: a -> Product * f g a

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

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

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

Applicative (ContT k r m)

Methods

pure :: a -> ContT k r m a

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

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

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

Applicative m => Applicative (ReaderT * r m)

Methods

pure :: a -> ReaderT * r m a

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

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

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

Applicative (ParsecT s u m)

Methods

pure :: a -> ParsecT s u m a

(<*>) :: ParsecT s u m (a -> b) -> ParsecT s u m a -> ParsecT s u m b

(*>) :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m b

(<*) :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m a

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

Methods

pure :: a -> Compose * * f g a

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

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

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

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

Methods

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

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

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

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

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

Methods

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

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

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

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

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

An infix synonym for fmap.

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

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

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

Examples

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

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

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

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

Double each element of a list:

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

Apply even to the second element of a pair:

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

newLocalName :: Name -> TcM Name

duplicateLocalDs :: Id -> DsM Id

newSysLocalDs :: Type -> DsM Id

newSysLocalsDs :: [Type] -> DsM [Id]

newUniqueId :: Id -> Type -> DsM Id

newFailLocalDs :: Type -> DsM Id

newPredVarDs :: PredType -> DsM Var

getSrcSpanDs :: DsM SrcSpan

putSrcSpanDs :: SrcSpan -> DsM a -> DsM a

mkPrintUnqualifiedDs :: DsM PrintUnqualified

newUnique :: TcRnIf gbl lcl Unique

data UniqSupply :: *

A value of type UniqSupply is unique, and it can supply one distinct Unique. Also, from the supply, one can also manufacture an arbitrary number of further UniqueSupply values, which will be distinct from the first and from all others.

newUniqueSupply :: TcRnIf gbl lcl UniqSupply

getGhcModeDs :: DsM GhcMode

dsGetFamInstEnvs :: DsM FamInstEnvs

dsGetStaticBindsVar :: DsM (IORef [(Fingerprint, (Id, CoreExpr))])

Gets a reference to the SPT entries created so far.

dsLookupGlobal :: Name -> DsM TyThing

dsLookupGlobalId :: Name -> DsM Id

dsDPHBuiltin :: (PArrBuiltin -> a) -> DsM a

Get a name from Data.Array.Parallel for the desugarer, from the ds_parr_bi component of the global desugerar environment.

dsLookupTyCon :: Name -> DsM TyCon

dsLookupDataCon :: Name -> DsM DataCon

data PArrBuiltin :: *

Constructors

PArrBuiltin

Fields

• lengthPVar :: Var

  lengthP

• replicatePVar :: Var

  replicateP

• singletonPVar :: Var

  singletonP

• mapPVar :: Var

  mapP

• filterPVar :: Var

  filterP

• zipPVar :: Var

  zipP

• crossMapPVar :: Var

  crossMapP

• indexPVar :: Var

  (!:)

• emptyPVar :: Var

  emptyP

• appPVar :: Var

  (+:+)

• enumFromToPVar :: Var

  enumFromToP

• enumFromThenToPVar :: Var

  enumFromThenToP

dsLookupDPHRdrEnv :: OccName -> DsM Name

Lookup a name exported by Prim or Prim. Panic if there isn't one, or if it is defined multiple times.

dsLookupDPHRdrEnv_maybe :: OccName -> DsM (Maybe Name)

Lookup a name exported by Prim or Prim, returning Nothing if it's not defined. Panic if it's defined multiple times.

dsInitPArrBuiltin :: DsM a -> DsM a

type DsMetaEnv = NameEnv DsMetaVal

data DsMetaVal :: *

Constructors

DsBound Id

DsSplice (HsExpr Id)

dsGetMetaEnv :: DsM (NameEnv DsMetaVal)

dsLookupMetaEnv :: Name -> DsM (Maybe DsMetaVal)

dsExtendMetaEnv :: DsMetaEnv -> DsM a -> DsM a

getDictsDs :: DsM (Bag EvVar)

Get in-scope type constraints (pm check)

addDictsDs :: Bag EvVar -> DsM a -> DsM a

Add in-scope type constraints (pm check)

getTmCsDs :: DsM (Bag SimpleEq)

Get in-scope term constraints (pm check)

addTmCsDs :: Bag SimpleEq -> DsM a -> DsM a

Add in-scope term constraints (pm check)

incrCheckPmIterDs :: DsM ()

Increase the counter for elapsed pattern match check iterations. If the current counter is already over the limit, fail

resetPmIterDs :: DsM ()

Reset the counter for pattern match check iterations to zero

type DsWarning = (SrcSpan, SDoc)

warnDs :: WarnReason -> SDoc -> DsM ()

Emit a warning for the current source location

failWithDs :: SDoc -> DsM a

discardWarningsDs :: DsM a -> DsM a

data DsMatchContext

Constructors

DsMatchContext (HsMatchContext Name) SrcSpan

data EquationInfo

Constructors

EqnInfo

Fields

• eqn_pats :: [Pat Id]
• eqn_rhs :: MatchResult

Instances

Outputable EquationInfo

Methods

ppr :: EquationInfo -> SDoc

pprPrec :: Rational -> EquationInfo -> SDoc

data MatchResult

Constructors

MatchResult CanItFail (CoreExpr -> DsM CoreExpr)

type DsWrapper = CoreExpr -> CoreExpr

idDsWrapper :: DsWrapper

data CanItFail

Constructors

CanFail

CantFail

orFail :: CanItFail -> CanItFail -> CanItFail

Orphan instances

MonadThings (IOEnv (Env DsGblEnv DsLclEnv))

Methods

lookupThing :: Name -> IOEnv (Env DsGblEnv DsLclEnv) TyThing

lookupId :: Name -> IOEnv (Env DsGblEnv DsLclEnv) Id

lookupDataCon :: Name -> IOEnv (Env DsGblEnv DsLclEnv) DataCon

lookupTyCon :: Name -> IOEnv (Env DsGblEnv DsLclEnv) TyCon