GHC.Types.Demand

Documentation

data StrDmd

Vanilla strictness domain

Instances

Show StrDmd

Defined in GHC.Types.Demand

Methods

showsPrec :: Int -> StrDmd -> ShowS

show :: StrDmd -> String

showList :: [StrDmd] -> ShowS

Binary StrDmd

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> StrDmd -> IO ()

put :: BinHandle -> StrDmd -> IO (Bin StrDmd)

get :: BinHandle -> IO StrDmd

Outputable StrDmd

Defined in GHC.Types.Demand

Methods

ppr :: StrDmd -> SDoc

pprPrec :: Rational -> StrDmd -> SDoc

Eq StrDmd

Defined in GHC.Types.Demand

Methods

(==) :: StrDmd -> StrDmd -> Bool

(/=) :: StrDmd -> StrDmd -> Bool

data UseDmd

Domain for genuine usage

Constructors

UCall Count UseDmd

Call demand for absence. Used only for values of function type

UProd [ArgUse]

Product. Used only for values of product type See Note [Don't optimise UProd(Used) to Used]

Invariant: Not all components are Abs (in that case, use UHead)

UHead

May be used but its sub-components are definitely *not* used. For product types, UHead is equivalent to U(AAA); see mkUProd.

UHead is needed only to express the demand of seq and 'case' which are polymorphic; i.e. the scrutinised value is of type a rather than a product type. That's why we can't use UProd [A,A,A]

Since (UCall _ Abs) is ill-typed, UHead doesn't make sense for lambdas

Used

May be used and its sub-components may be used. (top of the lattice)

Instances

Show UseDmd

Defined in GHC.Types.Demand

Methods

showsPrec :: Int -> UseDmd -> ShowS

show :: UseDmd -> String

showList :: [UseDmd] -> ShowS

Binary UseDmd

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> UseDmd -> IO ()

put :: BinHandle -> UseDmd -> IO (Bin UseDmd)

get :: BinHandle -> IO UseDmd

Outputable UseDmd

Defined in GHC.Types.Demand

Methods

ppr :: UseDmd -> SDoc

pprPrec :: Rational -> UseDmd -> SDoc

Eq UseDmd

Defined in GHC.Types.Demand

Methods

(==) :: UseDmd -> UseDmd -> Bool

(/=) :: UseDmd -> UseDmd -> Bool

data Count

Abstract counting of usages

Instances

Show Count

Defined in GHC.Types.Demand

Methods

showsPrec :: Int -> Count -> ShowS

show :: Count -> String

showList :: [Count] -> ShowS

Binary Count

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> Count -> IO ()

put :: BinHandle -> Count -> IO (Bin Count)

get :: BinHandle -> IO Count

Outputable Count

Defined in GHC.Types.Demand

Methods

ppr :: Count -> SDoc

pprPrec :: Rational -> Count -> SDoc

Eq Count

Defined in GHC.Types.Demand

Methods

(==) :: Count -> Count -> Bool

(/=) :: Count -> Count -> Bool

type Demand = JointDmd ArgStr ArgUse

type DmdShell = JointDmd (Str ()) (Use ())

type CleanDemand = JointDmd StrDmd UseDmd

getStrDmd :: JointDmd s u -> s

getUseDmd :: JointDmd s u -> u

mkProdDmd :: [Demand] -> CleanDemand

mkOnceUsedDmd :: CleanDemand -> Demand

mkManyUsedDmd :: CleanDemand -> Demand

mkHeadStrict :: CleanDemand -> CleanDemand

oneifyDmd :: JointDmd s (Use u) -> JointDmd s (Use u)

toCleanDmd :: Demand -> (DmdShell, CleanDemand)

absDmd :: Demand

topDmd :: Demand

botDmd :: Demand

seqDmd :: Demand

lubDmd :: Demand -> Demand -> Demand

bothDmd :: Demand -> Demand -> Demand

lazyApply1Dmd :: Demand

lazyApply2Dmd :: Demand

strictApply1Dmd :: Demand

isTopDmd :: Demand -> Bool

isAbsDmd :: JointDmd (Str s) (Use u) -> Bool

isSeqDmd :: Demand -> Bool

peelUseCall :: UseDmd -> Maybe (Count, UseDmd)

cleanUseDmd_maybe :: Demand -> Maybe UseDmd

strictenDmd :: Demand -> Demand

bothCleanDmd :: CleanDemand -> CleanDemand -> CleanDemand

addCaseBndrDmd :: Demand -> [Demand] -> [Demand]

data DmdType

Constructors

DmdType DmdEnv [Demand] Divergence

Instances

Binary DmdType

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> DmdType -> IO ()

put :: BinHandle -> DmdType -> IO (Bin DmdType)

get :: BinHandle -> IO DmdType

Outputable DmdType

Defined in GHC.Types.Demand

Methods

ppr :: DmdType -> SDoc

pprPrec :: Rational -> DmdType -> SDoc

Eq DmdType

Defined in GHC.Types.Demand

Methods

(==) :: DmdType -> DmdType -> Bool

(/=) :: DmdType -> DmdType -> Bool

dmdTypeDepth :: DmdType -> Arity

lubDmdType :: DmdType -> DmdType -> DmdType

Compute the least upper bound of two DmdTypes elicited /by the same incoming demand/!

bothDmdType :: DmdType -> BothDmdArg -> DmdType

type BothDmdArg = (DmdEnv, Divergence)

mkBothDmdArg :: DmdEnv -> BothDmdArg

toBothDmdArg :: DmdType -> BothDmdArg

nopDmdType :: DmdType

The demand type of doing nothing (lazy, absent, no Divergence information). Note that it is 'not' the top of the lattice (which would be "may use everything"), so it is (no longer) called topDmdType. (SG: I agree, but why is it still topDmd then?)

botDmdType :: DmdType

addDemand :: Demand -> DmdType -> DmdType

type DmdEnv = VarEnv Demand

emptyDmdEnv :: VarEnv Demand

keepAliveDmdEnv :: DmdEnv -> IdSet -> DmdEnv

peelFV :: DmdType -> Var -> (DmdType, Demand)

findIdDemand :: DmdType -> Var -> Demand

data Divergence

Divergence lattice. Models a subset lattice of the following exhaustive set of divergence results:

n

nontermination (e.g. loops)

i

throws imprecise exception

p

throws precise exception

c

converges (reduces to WHNF)

The different lattice elements correspond to different subsets, indicated by juxtaposition of indicators (e.g. nc definitely doesn't throw an exception, and may or may not reduce to WHNF).

            Dunno (nipc)
                 |
           ExnOrDiv (nip)
                 |
           Diverges (ni)

As you can see, we don't distinguish n and i. See Note [Precise exceptions and strictness analysis] for why p is so special compared to i.

Constructors

Diverges

Definitely throws an imprecise exception or diverges.

ExnOrDiv

Definitely throws a *precise* exception, an imprecise exception or diverges. Never converges, hence isDeadEndDiv! See scenario 1 in Note [Precise exceptions and strictness analysis].

Dunno

Might diverge, throw any kind of exception or converge.

Instances

Show Divergence

Defined in GHC.Types.Demand

Methods

showsPrec :: Int -> Divergence -> ShowS

show :: Divergence -> String

showList :: [Divergence] -> ShowS

Binary Divergence

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> Divergence -> IO ()

put :: BinHandle -> Divergence -> IO (Bin Divergence)

get :: BinHandle -> IO Divergence

Outputable Divergence

Defined in GHC.Types.Demand

Methods

ppr :: Divergence -> SDoc

pprPrec :: Rational -> Divergence -> SDoc

Eq Divergence

Defined in GHC.Types.Demand

Methods

(==) :: Divergence -> Divergence -> Bool

(/=) :: Divergence -> Divergence -> Bool

lubDivergence :: Divergence -> Divergence -> Divergence

isDeadEndDiv :: Divergence -> Bool

True if the result indicates that evaluation will not return. See Note [Dead ends].

topDiv :: Divergence

botDiv :: Divergence

exnDiv :: Divergence

appIsDeadEnd :: StrictSig -> Int -> Bool

Returns true if an application to n args would diverge or throw an exception. See Note [Unsaturated applications] and Note [Dead ends].

isDeadEndSig :: StrictSig -> Bool

True if the signature diverges or throws an exception in a saturated call. See Note [Dead ends].

pprIfaceStrictSig :: StrictSig -> SDoc

newtype StrictSig

The depth of the wrapped DmdType encodes the arity at which it is safe to unleash. Better construct this through mkStrictSigForArity. See Note [Understanding DmdType and StrictSig]

Constructors

StrictSig DmdType

Instances

Binary StrictSig

Defined in GHC.Types.Demand

Methods

put_ :: BinHandle -> StrictSig -> IO ()

put :: BinHandle -> StrictSig -> IO (Bin StrictSig)

get :: BinHandle -> IO StrictSig

Outputable StrictSig

Defined in GHC.Types.Demand

Methods

ppr :: StrictSig -> SDoc

pprPrec :: Rational -> StrictSig -> SDoc

Eq StrictSig

Defined in GHC.Types.Demand

Methods

(==) :: StrictSig -> StrictSig -> Bool

(/=) :: StrictSig -> StrictSig -> Bool

mkStrictSigForArity :: Arity -> DmdType -> StrictSig

Turns a DmdType computed for the particular Arity into a StrictSig unleashable at that arity. See Note [Understanding DmdType and StrictSig]

mkClosedStrictSig :: [Demand] -> Divergence -> StrictSig

nopSig :: StrictSig

botSig :: StrictSig

isTopSig :: StrictSig -> Bool

hasDemandEnvSig :: StrictSig -> Bool

splitStrictSig :: StrictSig -> ([Demand], Divergence)

strictSigDmdEnv :: StrictSig -> DmdEnv

prependArgsStrictSig :: Int -> StrictSig -> StrictSig

Add extra (topDmd) arguments to a strictness signature. In contrast to etaConvertStrictSig, this prepends additional argument demands. This is used by FloatOut.

etaConvertStrictSig :: Arity -> StrictSig -> StrictSig

We are expanding (x y. e) to (x y z. e z) or reducing from the latter to the former (when the Simplifier identifies a new join points, for example). In contrast to prependArgsStrictSig, this appends extra arg demands if necessary. This works by looking at the DmdType (which was produced under a call demand for the old arity) and trying to transfer as many facts as we can to the call demand of new arity. An arity increase (resulting in a stronger incoming demand) can retain much of the info, while an arity decrease (a weakening of the incoming demand) must fall back to a conservative default.

seqDemand :: Demand -> ()

seqDemandList :: [Demand] -> ()

seqDmdType :: DmdType -> ()

seqStrictSig :: StrictSig -> ()

evalDmd :: Demand

cleanEvalDmd :: CleanDemand

cleanEvalProdDmd :: Arity -> CleanDemand

isStrictDmd :: JointDmd (Str s) (Use u) -> Bool

splitDmdTy :: DmdType -> (Demand, DmdType)

splitFVs :: Bool -> DmdEnv -> (DmdEnv, DmdEnv)

deferAfterPreciseException :: DmdType -> DmdType

When e is evaluated after executing an IO action that may throw a precise exception, we act as if there is an additional control flow path that is taken if e throws a precise exception. The demand type of this control flow path * is lazy and absent (topDmd) in all free variables and arguments * has exnDiv Divergence result So we can simply take a variant of nopDmdType, exnDmdType. Why not nopDmdType? Because then the result of e can never be exnDiv! That means failure to drop dead-ends, see #18086. See Note [Precise exceptions and strictness analysis]

postProcessUnsat :: DmdShell -> DmdType -> DmdType

postProcessDmdType :: DmdShell -> DmdType -> BothDmdArg

splitProdDmd_maybe :: Demand -> Maybe [Demand]

peelCallDmd :: CleanDemand -> (CleanDemand, DmdShell)

peelManyCalls :: Int -> CleanDemand -> DmdShell

mkCallDmd :: CleanDemand -> CleanDemand

Wraps the CleanDemand with a one-shot call demand: d -> C1(d).

mkCallDmds :: Arity -> CleanDemand -> CleanDemand

mkCallDmds n d returns C1(C1...(C1 d)) where there are n C1's.

mkWorkerDemand :: Int -> Demand

dmdTransformSig :: StrictSig -> CleanDemand -> DmdType

dmdTransformDataConSig :: Arity -> CleanDemand -> DmdType

dmdTransformDictSelSig :: StrictSig -> CleanDemand -> DmdType

argOneShots :: Demand -> [OneShotInfo]

argsOneShots :: StrictSig -> Arity -> [[OneShotInfo]]

saturatedByOneShots :: Int -> Demand -> Bool

data TypeShape

Constructors

TsFun TypeShape

TsProd [TypeShape]

TsUnk

Instances

Outputable TypeShape

Defined in GHC.Types.Demand

Methods

ppr :: TypeShape -> SDoc

pprPrec :: Rational -> TypeShape -> SDoc

trimToType :: Demand -> TypeShape -> Demand

useCount :: Use u -> Count

isUsedOnce :: JointDmd (Str s) (Use u) -> Bool

reuseEnv :: DmdEnv -> DmdEnv

zapUsageDemand :: Demand -> Demand

zapUsageEnvSig :: StrictSig -> StrictSig

zapUsedOnceDemand :: Demand -> Demand

Remove all 1* information (but not C1 information) from the demand

zapUsedOnceSig :: StrictSig -> StrictSig

Remove all 1* information (but not C1 information) from the strictness signature

strictifyDictDmd :: Type -> Demand -> Demand

strictifyDmd :: Demand -> Demand