NameSet

Names set type

type NameSet = UniqSet Name

Manipulating these sets

emptyNameSet :: NameSet

unitNameSet :: Name -> NameSet

mkNameSet :: [Name] -> NameSet

unionNameSet :: NameSet -> NameSet -> NameSet

unionNameSets :: [NameSet] -> NameSet

minusNameSet :: NameSet -> NameSet -> NameSet

elemNameSet :: Name -> NameSet -> Bool

extendNameSet :: NameSet -> Name -> NameSet

extendNameSetList :: NameSet -> [Name] -> NameSet

delFromNameSet :: NameSet -> Name -> NameSet

delListFromNameSet :: NameSet -> [Name] -> NameSet

isEmptyNameSet :: NameSet -> Bool

filterNameSet :: (Name -> Bool) -> NameSet -> NameSet

intersectsNameSet :: NameSet -> NameSet -> Bool

True if there is a non-empty intersection. s1 intersectsNameSet s2 doesn't compute s2 if s1 is empty

intersectNameSet :: NameSet -> NameSet -> NameSet

nameSetAny :: (Name -> Bool) -> NameSet -> Bool

nameSetAll :: (Name -> Bool) -> NameSet -> Bool

nameSetElemsStable :: NameSet -> [Name]

Get the elements of a NameSet with some stable ordering. This only works for Names that originate in the source code or have been tidied. See Note [Deterministic UniqFM] to learn about nondeterminism

Free variables

type FreeVars = NameSet

Manipulating sets of free variables

isEmptyFVs :: NameSet -> Bool

emptyFVs :: FreeVars

plusFVs :: [FreeVars] -> FreeVars

plusFV :: FreeVars -> FreeVars -> FreeVars

mkFVs :: [Name] -> FreeVars

addOneFV :: FreeVars -> Name -> FreeVars

unitFV :: Name -> FreeVars

delFV :: Name -> FreeVars -> FreeVars

delFVs :: [Name] -> FreeVars -> FreeVars

intersectFVs :: FreeVars -> FreeVars -> FreeVars

Defs and uses

type Defs = NameSet

A set of names that are defined somewhere

type Uses = NameSet

A set of names that are used somewhere

type DefUse = (Maybe Defs, Uses)

(Just ds, us) => The use of any member of the ds implies that all the us are used too. Also, us may mention ds.

Nothing => Nothing is defined in this group, but nevertheless all the uses are essential. Used for instance declarations, for example

type DefUses = [DefUse]

A number of DefUses in dependency order: earlier Defs scope over later Uses In a single (def, use) pair, the defs also scope over the uses

Manipulating defs and uses

emptyDUs :: DefUses

usesOnly :: Uses -> DefUses

mkDUs :: [(Defs, Uses)] -> DefUses

plusDU :: DefUses -> DefUses -> DefUses

findUses :: DefUses -> Uses -> Uses

Given some DefUses and some Uses, find all the uses, transitively. The result is a superset of the input Uses; and includes things defined in the input DefUses (but only if they are used)

duDefs :: DefUses -> Defs

duUses :: DefUses -> Uses

Collect all Uses, regardless of whether the group is itself used, but remove Defs on the way

allUses :: DefUses -> Uses

Just like duUses, but Defs are not eliminated from the Uses returned