Demand

Documentation

data StrDmd

Vanilla strictness domain

Instances

Eq StrDmd

Defined in Demand

Methods

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

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

Show StrDmd

Defined in Demand

Methods

showsPrec :: Int -> StrDmd -> ShowS

show :: StrDmd -> String

showList :: [StrDmd] -> ShowS

Outputable StrDmd

Defined in Demand

Methods

ppr :: StrDmd -> SDoc

pprPrec :: Rational -> StrDmd -> SDoc

Binary StrDmd

Defined in Demand

Methods

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

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

get :: BinHandle -> IO StrDmd

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

Eq UseDmd

Defined in Demand

Methods

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

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

Show UseDmd

Defined in Demand

Methods

showsPrec :: Int -> UseDmd -> ShowS

show :: UseDmd -> String

showList :: [UseDmd] -> ShowS

Outputable UseDmd

Defined in Demand

Methods

ppr :: UseDmd -> SDoc

pprPrec :: Rational -> UseDmd -> SDoc

Binary UseDmd

Defined in Demand

Methods

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

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

get :: BinHandle -> IO UseDmd

data Count

Abstract counting of usages

Instances

Eq Count

Defined in Demand

Methods

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

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

Show Count

Defined in Demand

Methods

showsPrec :: Int -> Count -> ShowS

show :: Count -> String

showList :: [Count] -> ShowS

Outputable Count

Defined in Demand

Methods

ppr :: Count -> SDoc

pprPrec :: Rational -> Count -> SDoc

Binary Count

Defined in Demand

Methods

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

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

get :: BinHandle -> IO Count

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] DmdResult

Instances

Eq DmdType

Defined in Demand

Methods

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

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

Outputable DmdType

Defined in Demand

Methods

ppr :: DmdType -> SDoc

pprPrec :: Rational -> DmdType -> SDoc

Binary DmdType

Defined in Demand

Methods

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

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

get :: BinHandle -> IO DmdType

dmdTypeDepth :: DmdType -> Arity

lubDmdType :: DmdType -> DmdType -> DmdType

bothDmdType :: DmdType -> BothDmdArg -> DmdType

nopDmdType :: DmdType

botDmdType :: DmdType

mkDmdType :: DmdEnv -> [Demand] -> DmdResult -> DmdType

addDemand :: Demand -> DmdType -> DmdType

ensureArgs :: Arity -> DmdType -> DmdType

This makes sure we can use the demand type with n arguments. It extends the argument list with the correct resTypeArgDmd. It also adjusts the DmdResult: Divergence survives additional arguments, CPR information does not (and definite converge also would not).

type BothDmdArg = (DmdEnv, Termination ())

mkBothDmdArg :: DmdEnv -> BothDmdArg

toBothDmdArg :: DmdType -> BothDmdArg

type DmdEnv = VarEnv Demand

emptyDmdEnv :: VarEnv Demand

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

findIdDemand :: DmdType -> Var -> Demand

type DmdResult = Termination CPRResult

data CPRResult

Instances

Eq CPRResult

Defined in Demand

Methods

(==) :: CPRResult -> CPRResult -> Bool

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

Show CPRResult

Defined in Demand

Methods

showsPrec :: Int -> CPRResult -> ShowS

show :: CPRResult -> String

showList :: [CPRResult] -> ShowS

Outputable CPRResult

Defined in Demand

Methods

ppr :: CPRResult -> SDoc

pprPrec :: Rational -> CPRResult -> SDoc

Binary CPRResult

Defined in Demand

Methods

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

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

get :: BinHandle -> IO CPRResult

Binary DmdResult

Defined in Demand

Methods

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

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

get :: BinHandle -> IO DmdResult

isBotRes :: DmdResult -> Bool

True if the result diverges or throws an exception

isTopRes :: DmdResult -> Bool

topRes :: DmdResult

botRes :: DmdResult

cprProdRes :: [DmdType] -> DmdResult

vanillaCprProdRes :: Arity -> DmdResult

cprSumRes :: ConTag -> DmdResult

appIsBottom :: StrictSig -> Int -> Bool

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

isBottomingSig :: StrictSig -> Bool

True if the signature diverges or throws an exception

pprIfaceStrictSig :: StrictSig -> SDoc

trimCPRInfo :: Bool -> Bool -> DmdResult -> DmdResult

returnsCPR_maybe :: DmdResult -> Maybe ConTag

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

Eq StrictSig

Defined in Demand

Methods

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

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

Outputable StrictSig

Defined in Demand

Methods

ppr :: StrictSig -> SDoc

pprPrec :: Rational -> StrictSig -> SDoc

Binary StrictSig

Defined in Demand

Methods

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

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

get :: BinHandle -> IO StrictSig

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] -> DmdResult -> StrictSig

nopSig :: StrictSig

botSig :: StrictSig

cprProdSig :: Arity -> StrictSig

isTopSig :: StrictSig -> Bool

hasDemandEnvSig :: StrictSig -> Bool

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

strictSigDmdEnv :: StrictSig -> DmdEnv

increaseStrictSigArity :: Int -> StrictSig -> StrictSig

Add extra arguments to a strictness signature. In contrast to etaExpandStrictSig, this prepends additional argument demands and leaves CPR info intact.

etaExpandStrictSig :: Arity -> StrictSig -> StrictSig

We are expanding (x y. e) to (x y z. e z). In contrast to increaseStrictSigArity, this appends extra arg demands if necessary, potentially destroying the signature's CPR property.

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)

deferAfterIO :: DmdType -> DmdType

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 -> StrictSig -> 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 Demand

Methods

ppr :: TypeShape -> SDoc

pprPrec :: Rational -> TypeShape -> SDoc

peelTsFuns :: Arity -> TypeShape -> Maybe TypeShape

peelTsFuns n ts tries to peel off n TsFun constructors from ts and returns Just the wrapped TypeShape on success, and Nothing otherwise.

trimToType :: Demand -> TypeShape -> Demand

useCount :: Use u -> Count

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

reuseEnv :: DmdEnv -> DmdEnv

killUsageDemand :: DynFlags -> Demand -> Demand

killUsageSig :: DynFlags -> StrictSig -> StrictSig

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