Safe Haskell  None 

Language  Haskell2010 
Synopsis
 type DsM = TcRnIf DsGblEnv DsLclEnv
 mapM :: (Traversable t, Monad m) => (a > m b) > t a > m (t b)
 mapAndUnzipM :: Applicative m => (a > m (b, c)) > [a] > m ([b], [c])
 initDs :: HscEnv > TcGblEnv > DsM a > IO (Messages DsMessage, Maybe a)
 initDsTc :: DsM a > TcM (Messages DsMessage, Maybe a)
 initTcDsForSolver :: TcM a > DsM a
 initDsWithModGuts :: HscEnv > ModGuts > DsM a > IO (Messages DsMessage, Maybe a)
 fixDs :: (a > DsM a) > DsM a
 foldlM :: (Foldable t, Monad m) => (b > a > m b) > b > t a > m b
 foldrM :: (Foldable t, Monad m) => (a > b > m b) > b > t a > m b
 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
 xoptM :: Extension > TcRnIf gbl lcl Bool
 class Functor f => Applicative (f :: Type > Type) where
 (<$>) :: Functor f => (a > b) > f a > f b
 duplicateLocalDs :: Id > DsM Id
 newSysLocalDs :: Mult > Type > DsM Id
 newSysLocalsDs :: [Scaled Type] > DsM [Id]
 newUniqueId :: Id > Mult > Type > DsM Id
 newFailLocalDs :: Mult > Type > DsM Id
 newPredVarDs :: PredType > DsM Var
 getSrcSpanDs :: DsM SrcSpan
 putSrcSpanDs :: SrcSpan > DsM a > DsM a
 putSrcSpanDsA :: SrcSpanAnn' ann > DsM a > DsM a
 mkNamePprCtxDs :: DsM NamePprCtx
 newUnique :: TcRnIf gbl lcl Unique
 data UniqSupply
 newUniqueSupply :: TcRnIf gbl lcl UniqSupply
 getGhcModeDs :: DsM GhcMode
 dsGetFamInstEnvs :: DsM FamInstEnvs
 dsLookupGlobal :: Name > DsM TyThing
 dsLookupGlobalId :: Name > DsM Id
 dsLookupTyCon :: Name > DsM TyCon
 dsLookupDataCon :: Name > DsM DataCon
 dsLookupConLike :: Name > DsM ConLike
 getCCIndexDsM :: FastString > DsM CostCentreIndex
 type DsMetaEnv = NameEnv DsMetaVal
 data DsMetaVal
 dsGetMetaEnv :: DsM (NameEnv DsMetaVal)
 dsLookupMetaEnv :: Name > DsM (Maybe DsMetaVal)
 dsExtendMetaEnv :: DsMetaEnv > DsM a > DsM a
 getPmNablas :: DsM Nablas
 updPmNablas :: Nablas > DsM a > DsM a
 addUnspecables :: Set EvId > DsM a > DsM a
 getUnspecables :: DsM (Set EvId)
 dsGetCompleteMatches :: DsM CompleteMatches
 type DsWarning = (SrcSpan, SDoc)
 diagnosticDs :: DsMessage > DsM ()
 errDsCoreExpr :: DsMessage > DsM CoreExpr
 failWithDs :: DsMessage > DsM a
 failDs :: DsM a
 discardWarningsDs :: DsM a > DsM a
 data DsMatchContext = DsMatchContext (HsMatchContext GhcTc) SrcSpan
 data EquationInfo = EqnInfo {}
 data MatchResult a
 = MR_Infallible (DsM a)
  MR_Fallible (CoreExpr > DsM a)
 runMatchResult :: CoreExpr > MatchResult a > DsM a
 type DsWrapper = CoreExpr > CoreExpr
 idDsWrapper :: DsWrapper
 pprRuntimeTrace :: String > SDoc > CoreExpr > DsM CoreExpr
Documentation
mapM :: (Traversable t, Monad m) => (a > m b) > t a > m (t b) Source #
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_
.
Examples
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 monad.
initTcDsForSolver :: TcM a > DsM a Source #
foldlM :: (Foldable t, Monad m) => (b > a > m b) > b > t a > m b Source #
Lefttoright monadic fold over the elements of a structure.
Given a structure t
with elements (a, b, ..., w, x, y)
, the result of
a fold with an operator function f
is equivalent to:
foldlM f z t = do aa < f z a bb < f aa b ... xx < f ww x yy < f xx y return yy  Just @return z@ when the structure is empty
For a Monad m
, given two functions f1 :: a > m b
and f2 :: b > m c
,
their Kleisli composition (f1 >=> f2) :: a > m c
is defined by:
(f1 >=> f2) a = f1 a >>= f2
Another way of thinking about foldlM
is that it amounts to an application
to z
of a Kleisli composition:
foldlM f z t = flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ z
The monadic effects of foldlM
are sequenced from left to right.
If at some step the bind operator (
shortcircuits (as with, e.g.,
>>=
)mzero
in a MonadPlus
), the evaluated effects will be from an initial
segment of the element sequence. If you want to evaluate the monadic
effects in righttoleft order, or perhaps be able to shortcircuit after
processing a tail of the sequence of elements, you'll need to use foldrM
instead.
If the monadic effects don't shortcircuit, the outermost application of
f
is to the rightmost element y
, so that, ignoring effects, the result
looks like a left fold:
((((z `f` a) `f` b) ... `f` w) `f` x) `f` y
Examples
Basic usage:
>>>
let f a e = do { print e ; return $ e : a }
>>>
foldlM f [] [0..3]
0 1 2 3 [3,2,1,0]
foldrM :: (Foldable t, Monad m) => (a > b > m b) > b > t a > m b Source #
Righttoleft monadic fold over the elements of a structure.
Given a structure t
with elements (a, b, c, ..., x, y)
, the result of
a fold with an operator function f
is equivalent to:
foldrM f z t = do yy < f y z xx < f x yy ... bb < f b cc aa < f a bb return aa  Just @return z@ when the structure is empty
For a Monad m
, given two functions f1 :: a > m b
and f2 :: b > m c
,
their Kleisli composition (f1 >=> f2) :: a > m c
is defined by:
(f1 >=> f2) a = f1 a >>= f2
Another way of thinking about foldrM
is that it amounts to an application
to z
of a Kleisli composition:
foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z
The monadic effects of foldrM
are sequenced from right to left, and e.g.
folds of infinite lists will diverge.
If at some step the bind operator (
shortcircuits (as with, e.g.,
>>=
)mzero
in a MonadPlus
), the evaluated effects will be from a tail of the
element sequence. If you want to evaluate the monadic effects in
lefttoright order, or perhaps be able to shortcircuit after an initial
sequence of elements, you'll need to use foldlM
instead.
If the monadic effects don't shortcircuit, the outermost application of
f
is to the leftmost element a
, so that, ignoring effects, the result
looks like a right fold:
a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).
Examples
Basic usage:
>>>
let f i acc = do { print i ; return $ i : acc }
>>>
foldrM f [] [0..3]
3 2 1 0 [0,1,2,3]
unsetGOptM :: GeneralFlag > TcRnIf gbl lcl a > TcRnIf gbl lcl a Source #
unsetWOptM :: WarningFlag > TcRnIf gbl lcl a > TcRnIf gbl lcl a Source #
class Functor f => Applicative (f :: Type > Type) where Source #
A functor with application, providing operations to
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:
As a consequence of these laws, the Functor
instance for f
will satisfy
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
(which implies that pure
and <*>
satisfy the applicative functor laws).
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.
Example
Used in combination with (
, <$>
)(
can be used to build a record.<*>
)
>>>
data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
>>>
produceFoo :: Applicative f => f Foo
>>>
produceBar :: Applicative f => f Bar
>>>
produceBaz :: Applicative f => f Baz
>>>
mkState :: Applicative f => f MyState
>>>
mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
liftA2 :: (a > b > c) > f a > f b > f c Source #
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more
efficient than the default one. In particular, if fmap
is an
expensive operation, it is likely better to use liftA2
than to
fmap
over the structure and then use <*>
.
This became a typeclass method in 4.10.0.0. Prior to that, it was
a function defined in terms of <*>
and fmap
.
Example
>>>
liftA2 (,) (Just 3) (Just 5)
Just (3,5)
(*>) :: f a > f b > f b infixl 4 Source #
Sequence actions, discarding the value of the first argument.
Examples
If used in conjunction with the Applicative instance for Maybe
,
you can chain Maybe computations, with a possible "early return"
in case of Nothing
.
>>>
Just 2 *> Just 3
Just 3
>>>
Nothing *> Just 3
Nothing
Of course a more interesting use case would be to have effectful computations instead of just returning pure values.
>>>
import Data.Char
>>>
import Text.ParserCombinators.ReadP
>>>
let p = string "my name is " *> munch1 isAlpha <* eof
>>>
readP_to_S p "my name is Simon"
[("Simon","")]
(<*) :: f a > f b > f a infixl 4 Source #
Sequence actions, discarding the value of the second argument.
Instances
Applicative ZipList  f <$> ZipList xs1 <*> ... <*> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where (\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: base2.1 
Applicative Complex  Since: base4.9.0.0 
Applicative Identity  Since: base4.8.0.0 
Defined in Data.Functor.Identity  
Applicative First  Since: base4.8.0.0 
Applicative Last  Since: base4.8.0.0 
Applicative Down  Since: base4.11.0.0 
Applicative First  Since: base4.9.0.0 
Applicative Last  Since: base4.9.0.0 
Applicative Max  Since: base4.9.0.0 
Applicative Min  Since: base4.9.0.0 
Applicative Dual  Since: base4.8.0.0 
Applicative Product  Since: base4.8.0.0 
Defined in Data.Semigroup.Internal  
Applicative Sum  Since: base4.8.0.0 
Applicative NonEmpty  Since: base4.9.0.0 
Applicative STM  Since: base4.8.0.0 
Applicative NoIO  Since: base4.8.0.0 
Applicative Par1  Since: base4.9.0.0 
Applicative P  Since: base4.5.0.0 
Applicative ReadP  Since: base4.6.0.0 
Applicative ReadPrec  Since: base4.6.0.0 
Defined in Text.ParserCombinators.ReadPrec  
Applicative Get  
Applicative PutM  
Applicative Put  
Applicative Seq  Since: containers0.5.4 
Applicative Tree  
Applicative PD Source #  
Applicative NatM Source #  
Applicative LlvmM Source #  
Applicative CoreM Source #  
Applicative SimplM Source #  
Applicative UnifyResultM Source #  
Defined in GHC.Core.Unify 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 NullCollapseViz Source #  
Defined in GHC.Data.Graph.Collapse pure :: a > NullCollapseViz a Source # (<*>) :: NullCollapseViz (a > b) > NullCollapseViz a > NullCollapseViz b Source # liftA2 :: (a > b > c) > NullCollapseViz a > NullCollapseViz b > NullCollapseViz c Source # (*>) :: NullCollapseViz a > NullCollapseViz b > NullCollapseViz b Source # (<*) :: NullCollapseViz a > NullCollapseViz b > NullCollapseViz a Source #  
Applicative Infinite Source #  
Defined in GHC.Data.List.Infinite  
Applicative Pair Source #  
Applicative Maybe Source #  
Applicative Hsc Source #  
Applicative Ghc Source #  
Applicative HookedUse Source #  
Defined in GHC.Driver.Pipeline.Execute  
Applicative MatchResult Source #  Product is an "or" on fallibilitythe combined match result is infallible only if the left and right argument match results both were. This is useful for combining a bunch of alternatives together and then
getting the overall fallibility of the entire group. See 
Defined in GHC.HsToCore.Monad pure :: a > MatchResult a Source # (<*>) :: MatchResult (a > b) > MatchResult a > MatchResult b Source # liftA2 :: (a > b > c) > MatchResult a > MatchResult b > MatchResult c Source # (*>) :: MatchResult a > MatchResult b > MatchResult b Source # (<*) :: MatchResult a > MatchResult b > MatchResult a Source #  
Applicative P Source #  
Applicative PV Source #  
Applicative CpsRn Source #  
Applicative LiftM Source #  
Applicative CmmParse Source #  
Defined in GHC.StgToCmm.ExtCode  
Applicative FCode Source #  
Applicative SolverStage Source #  
Defined in GHC.Tc.Solver.Monad pure :: a > SolverStage a Source # (<*>) :: SolverStage (a > b) > SolverStage a > SolverStage b Source # liftA2 :: (a > b > c) > SolverStage a > SolverStage b > SolverStage c Source # (*>) :: SolverStage a > SolverStage b > SolverStage b Source # (<*) :: SolverStage a > SolverStage b > SolverStage a Source #  
Applicative TcS Source #  
Applicative TcPluginM Source #  
Defined in GHC.Tc.Types  
Applicative ZonkM Source #  
Applicative UniqSM Source #  
Applicative IO  Since: base2.1 
Applicative GHCiQ  
Applicative PprM  
Applicative Q  
Applicative Maybe  Since: base2.1 
Applicative Solo  Since: base4.15 
Applicative []  Since: base2.1 
Monad m => Applicative (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative 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: base4.6.0.0 
Defined in Control.Arrow 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 (Either e)  Since: base3.0 
Defined in Data.Either  
Applicative (Proxy :: Type > Type)  Since: base4.7.0.0 
Applicative (U1 :: Type > Type)  Since: base4.9.0.0 
Applicative (ST s)  Since: base4.4.0.0 
Applicative (SetM s)  
Monad m => Applicative (CatchT m)  
Defined in Control.Monad.Catch.Pure  
Applicative (RegM freeRegs) Source #  
Defined in GHC.CmmToAsm.Reg.Linear.State 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 (WasmCodeGenM w) Source #  
Defined in GHC.CmmToAsm.Wasm.Types pure :: a > WasmCodeGenM w a Source # (<*>) :: WasmCodeGenM w (a > b) > WasmCodeGenM w a > WasmCodeGenM w b Source # liftA2 :: (a > b > c) > WasmCodeGenM w a > WasmCodeGenM w b > WasmCodeGenM w c Source # (*>) :: WasmCodeGenM w a > WasmCodeGenM w b > WasmCodeGenM w b Source # (<*) :: WasmCodeGenM w a > WasmCodeGenM w b > WasmCodeGenM w a Source #  
Applicative (IOEnv m) Source #  
Applicative (MaybeErr err) Source #  
Defined in GHC.Data.Maybe 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 #  
Monad m => Applicative (EwM m) Source #  
Applicative m => Applicative (GhcT m) Source #  
Applicative (CmdLineP s) Source #  
Defined in GHC.Driver.Session 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 #  
Applicative (PuResult a) Source #  
Defined in GHC.Tc.Utils.Unify pure :: a0 > PuResult a a0 Source # (<*>) :: PuResult a (a0 > b) > PuResult a a0 > PuResult a b Source # liftA2 :: (a0 > b > c) > PuResult a a0 > PuResult a b > PuResult a c Source # (*>) :: PuResult a a0 > PuResult a b > PuResult a b Source # (<*) :: PuResult a a0 > PuResult a b > PuResult a a0 Source #  
Applicative (ZonkBndrT m) Source #  
Defined in GHC.Tc.Zonk.Env pure :: a > ZonkBndrT m a Source # (<*>) :: ZonkBndrT m (a > b) > ZonkBndrT m a > ZonkBndrT m b Source # liftA2 :: (a > b > c) > ZonkBndrT m a > ZonkBndrT m b > ZonkBndrT m c Source # (*>) :: ZonkBndrT m a > ZonkBndrT m b > ZonkBndrT m b Source # (<*) :: ZonkBndrT m a > ZonkBndrT m b > ZonkBndrT m a Source #  
Applicative m => Applicative (ZonkT m) Source #  
Applicative (Codensity f) Source #  
Defined in GHC.Utils.Monad.Codensity pure :: a > Codensity f a Source # (<*>) :: Codensity f (a > b) > Codensity f a > Codensity f b Source # liftA2 :: (a > b > c) > Codensity f a > Codensity f b > Codensity f c Source # (*>) :: Codensity f a > Codensity f b > Codensity f b Source # (<*) :: Codensity f a > Codensity f b > Codensity f a Source #  
Applicative (State s) Source #  
Defined in GHC.Utils.Monad.State.Strict  
Applicative f => Applicative (Lift f)  A combination is 
(Functor m, Monad m) => Applicative (MaybeT m)  
Defined in Control.Monad.Trans.Maybe  
Monoid a => Applicative ((,) a)  For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: base2.1 
Arrow a => Applicative (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative 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 #  
Applicative m => Applicative (Kleisli m a)  Since: base4.14.0.0 
Defined in Control.Arrow pure :: a0 > Kleisli m a a0 Source # (<*>) :: Kleisli m a (a0 > b) > Kleisli m a a0 > Kleisli m a b Source # liftA2 :: (a0 > b > c) > Kleisli m a a0 > Kleisli m a b > Kleisli m a c Source # (*>) :: Kleisli m a a0 > Kleisli m a b > Kleisli m a b Source # (<*) :: Kleisli m a a0 > Kleisli m a b > Kleisli m a a0 Source #  
Monoid m => Applicative (Const m :: Type > Type)  Since: base2.0.1 
Applicative f => Applicative (Ap f)  Since: base4.12.0.0 
Applicative f => Applicative (Alt f)  Since: base4.8.0.0 
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f)  Since: base4.17.0.0 
Defined in GHC.Generics pure :: a > Generically1 f a Source # (<*>) :: Generically1 f (a > b) > Generically1 f a > Generically1 f b Source # liftA2 :: (a > b > c) > Generically1 f a > Generically1 f b > Generically1 f c Source # (*>) :: Generically1 f a > Generically1 f b > Generically1 f b Source # (<*) :: Generically1 f a > Generically1 f b > Generically1 f a Source #  
Applicative f => Applicative (Rec1 f)  Since: base4.9.0.0 
(Applicative f, Monad f) => Applicative (WhenMissing f x)  Equivalent to Since: containers0.5.9 
Defined in Data.IntMap.Internal 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 #  
Applicative (Stream m a) Source #  
Defined in GHC.Data.Stream 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 #  
Monad m => Applicative (StreamS m a) Source #  
Defined in GHC.Data.Stream pure :: a0 > StreamS m a a0 Source # (<*>) :: StreamS m a (a0 > b) > StreamS m a a0 > StreamS m a b Source # liftA2 :: (a0 > b > c) > StreamS m a a0 > StreamS m a b > StreamS m a c Source # (*>) :: StreamS m a a0 > StreamS m a b > StreamS m a b Source # (<*) :: StreamS m a a0 > StreamS m a b > StreamS m a a0 Source #  
Applicative f => Applicative (Backwards f)  Apply 
Defined in Control.Applicative.Backwards pure :: a > Backwards f a Source # (<*>) :: Backwards f (a > b) > Backwards f a > Backwards f b Source # liftA2 :: (a > b > c) > Backwards f a > Backwards f b > Backwards f c Source # (*>) :: Backwards f a > Backwards f b > Backwards f b Source # (<*) :: Backwards f a > Backwards f b > Backwards f a Source #  
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m)  
Defined in Control.Monad.Trans.Accum pure :: a > AccumT w m a Source # (<*>) :: AccumT w m (a > b) > AccumT w m a > AccumT w m b Source # liftA2 :: (a > b > c) > AccumT w m a > AccumT w m b > AccumT w m c Source # (*>) :: AccumT w m a > AccumT w m b > AccumT w m b Source # (<*) :: AccumT w m a > AccumT w m b > AccumT w m a Source #  
(Functor m, Monad m) => Applicative (ExceptT e m)  
Defined in Control.Monad.Trans.Except 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 #  
Applicative m => Applicative (IdentityT m)  
Defined in Control.Monad.Trans.Identity pure :: a > IdentityT m a Source # (<*>) :: IdentityT m (a > b) > IdentityT m a > IdentityT m b Source # liftA2 :: (a > b > c) > IdentityT m a > IdentityT m b > IdentityT m c Source # (*>) :: IdentityT m a > IdentityT m b > IdentityT m b Source # (<*) :: IdentityT m a > IdentityT m b > IdentityT m a Source #  
Applicative m => Applicative (ReaderT r m)  
Defined in Control.Monad.Trans.Reader 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 #  
(Functor m, Monad m) => Applicative (SelectT r m)  
Defined in Control.Monad.Trans.Select pure :: a > SelectT r m a Source # (<*>) :: SelectT r m (a > b) > SelectT r m a > SelectT r m b Source # liftA2 :: (a > b > c) > SelectT r m a > SelectT r m b > SelectT r m c Source # (*>) :: SelectT r m a > SelectT r m b > SelectT r m b Source # (<*) :: SelectT r m a > SelectT r m b > SelectT r m a Source #  
(Functor m, Monad m) => Applicative (StateT s m)  
Defined in Control.Monad.Trans.State.Lazy 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)  
Defined in Control.Monad.Trans.State.Strict 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 (WriterT w m)  
Defined in Control.Monad.Trans.Writer.CPS 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 #  
(Monoid w, Applicative m) => Applicative (WriterT w m)  
Defined in Control.Monad.Trans.Writer.Lazy 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 #  
(Monoid w, Applicative m) => Applicative (WriterT w m)  
Defined in Control.Monad.Trans.Writer.Strict 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 #  
Monoid a => Applicative (Constant a :: Type > Type)  
Defined in Data.Functor.Constant pure :: a0 > Constant a a0 Source # (<*>) :: Constant a (a0 > b) > Constant a a0 > Constant a b Source # liftA2 :: (a0 > b > c) > Constant a a0 > Constant a b > Constant a c Source # (*>) :: Constant a a0 > Constant a b > Constant a b Source # (<*) :: Constant a a0 > Constant a b > Constant a a0 Source #  
Applicative f => Applicative (Reverse f)  Derived instance. 
Defined in Data.Functor.Reverse  
(Monoid a, Monoid b) => Applicative ((,,) a b)  Since: base4.14.0.0 
Defined in GHC.Base  
(Applicative f, Applicative g) => Applicative (Product f g)  Since: base4.9.0.0 
Defined in Data.Functor.Product 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 #  
(Applicative f, Applicative g) => Applicative (f :*: g)  Since: base4.9.0.0 
Defined in GHC.Generics  
Monoid c => Applicative (K1 i c :: Type > Type)  Since: base4.12.0.0 
(Monad f, Applicative f) => Applicative (WhenMatched f x y)  Equivalent to Since: containers0.5.9 
Defined in Data.IntMap.Internal 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 Since: containers0.5.9 
Defined in Data.Map.Internal 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 (ContT r m)  
Defined in Control.Monad.Trans.Cont  
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)  Since: base4.14.0.0 
Defined in GHC.Base pure :: a0 > (a, b, c, a0) Source # (<*>) :: (a, b, c, a0 > b0) > (a, b, c, a0) > (a, b, c, b0) Source # liftA2 :: (a0 > b0 > c0) > (a, b, c, a0) > (a, b, c, b0) > (a, b, c, c0) Source # (*>) :: (a, b, c, a0) > (a, b, c, b0) > (a, b, c, b0) Source # (<*) :: (a, b, c, a0) > (a, b, c, b0) > (a, b, c, a0) Source #  
Applicative ((>) r)  Since: base2.1 
(Applicative f, Applicative g) => Applicative (Compose f g)  Since: base4.9.0.0 
Defined in Data.Functor.Compose 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 #  
(Applicative f, Applicative g) => Applicative (f :.: g)  Since: base4.9.0.0 
Defined in GHC.Generics  
Applicative f => Applicative (M1 i c f)  Since: base4.9.0.0 
Defined in GHC.Generics  
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)  Equivalent to Since: containers0.5.9 
Defined in Data.Map.Internal 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 m, Monad m) => Applicative (RWST r w s m)  
Defined in Control.Monad.Trans.RWS.CPS pure :: a > RWST r w s m a Source # (<*>) :: RWST r w s m (a > b) > RWST r w s m a > RWST r w s m b Source # liftA2 :: (a > b > c) > RWST r w s m a > RWST r w s m b > RWST r w s m c Source # (*>) :: RWST r w s m a > RWST r w s m b > RWST r w s m b Source # (<*) :: RWST r w s m a > RWST r w s m b > RWST r w s m a Source #  
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)  
Defined in Control.Monad.Trans.RWS.Lazy pure :: a > RWST r w s m a Source # (<*>) :: RWST r w s m (a > b) > RWST r w s m a > RWST r w s m b Source # liftA2 :: (a > b > c) > RWST r w s m a > RWST r w s m b > RWST r w s m c Source # (*>) :: RWST r w s m a > RWST r w s m b > RWST r w s m b Source # (<*) :: RWST r w s m a > RWST r w s m b > RWST r w s m a Source #  
(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)  
Defined in Control.Monad.Trans.RWS.Strict pure :: a > RWST r w s m a Source # (<*>) :: RWST r w s m (a > b) > RWST r w s m a > RWST r w s m b Source # liftA2 :: (a > b > c) > RWST r w s m a > RWST r w s m b > RWST r w s m c Source # (*>) :: RWST r w s m a > RWST r w s m b > RWST r w s m b Source # (<*) :: RWST r w s m a > RWST r w s m b > RWST r w s 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
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an
Either
Int
Int
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)
putSrcSpanDsA :: SrcSpanAnn' ann > DsM a > DsM a Source #
data UniqSupply Source #
Unique Supply
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 Source #
getCCIndexDsM :: FastString > DsM CostCentreIndex Source #
See getCCIndexM
.
getPmNablas :: DsM Nablas Source #
Get the current pattern match oracle state. See dsl_nablas
.
updPmNablas :: Nablas > DsM a > DsM a Source #
Set the pattern match oracle state within the scope of the given action.
See dsl_nablas
.
dsGetCompleteMatches :: DsM CompleteMatches Source #
The COMPLETE
pragmas that are in scope.
diagnosticDs :: DsMessage > DsM () Source #
Emit a diagnostic for the current source location. In case the diagnostic is a warning,
the latter will be ignored and discarded if the relevant WarningFlag
is not set in the DynFlags.
See Note [Discarding Messages] in Error
.
errDsCoreExpr :: DsMessage > DsM CoreExpr Source #
Issue an error, but return the expression for (), so that we can continue reporting errors.
failWithDs :: DsMessage > DsM a Source #
discardWarningsDs :: DsM a > DsM a Source #
data DsMatchContext Source #
Instances
Outputable DsMatchContext Source #  
Defined in GHC.HsToCore.Monad ppr :: DsMatchContext > SDoc Source # 
data EquationInfo Source #
EqnInfo  

Instances
Outputable EquationInfo Source #  
Defined in GHC.HsToCore.Monad ppr :: EquationInfo > SDoc Source # 
data MatchResult a Source #
This is a value of type a with potentially a CoreExprshaped hole in it. This is used to deal with cases where we are potentially handling pattern match failure, and want to later specify how failure is handled.
MR_Infallible (DsM a)  We represent the case where there is no hole without a function from

MR_Fallible (CoreExpr > DsM a) 
Instances
Applicative MatchResult Source #  Product is an "or" on fallibilitythe combined match result is infallible only if the left and right argument match results both were. This is useful for combining a bunch of alternatives together and then
getting the overall fallibility of the entire group. See 
Defined in GHC.HsToCore.Monad pure :: a > MatchResult a Source # (<*>) :: MatchResult (a > b) > MatchResult a > MatchResult b Source # liftA2 :: (a > b > c) > MatchResult a > MatchResult b > MatchResult c Source # (*>) :: MatchResult a > MatchResult b > MatchResult b Source # (<*) :: MatchResult a > MatchResult b > MatchResult a Source #  
Functor MatchResult Source #  
Defined in GHC.HsToCore.Monad fmap :: (a > b) > MatchResult a > MatchResult b Source # (<$) :: a > MatchResult b > MatchResult a Source # 
runMatchResult :: CoreExpr > MatchResult a > DsM a Source #
Inject a trace message into the compiled program. Whereas pprTrace prints out information *while compiling*, pprRuntimeTrace captures that information and causes it to be printed *at runtime* using Debug.Trace.trace.
pprRuntimeTrace hdr doc expr
will produce an expression that looks like
trace (hdr + doc) expr
When using this to debug a module that Debug.Trace depends on, it is necessary to import {# SOURCE #} Debug.Trace () in that module. We could avoid this inconvenience by wiring in Debug.Trace.trace, but that doesn't seem worth the effort and maintenance cost.