Clash.Core.VarEnv

Environment with variables as keys

type VarEnv a = UniqMap a

Map indexed by variables

Accessors

Size information

nullVarEnv :: VarEnv a -> Bool

Is the environment empty

Indexing

lookupVarEnv :: Var b -> VarEnv a -> Maybe a

Look up a value based on the variable

lookupVarEnv' :: HasCallStack => VarEnv a -> Var b -> a

Lookup a value based on the variable

Errors out when the variable is not present

lookupVarEnvDirectly :: Unique -> VarEnv a -> Maybe a

Lookup a value based on the unique of a variable

Construction

emptyVarEnv :: VarEnv a

Empty map

unitVarEnv :: Var b -> a -> VarEnv a

Environment containing a single variable-value pair

mkVarEnv :: [(Var a, b)] -> VarEnv b

Create an environment given a list of var-value pairs

Modification

extendVarEnv :: Var b -> a -> VarEnv a -> VarEnv a

Add a variable-value pair to the environment; overwrites the value if the variable already exists

extendVarEnvList :: VarEnv a -> [(Var b, a)] -> VarEnv a

Add a list of variable-value pairs; the values of existing keys will be overwritten

extendVarEnvWith :: Var b -> a -> (a -> a -> a) -> VarEnv a -> VarEnv a

Add a variable-value pair to the environment; if the variable already exists, the two values are merged with the given function

delVarEnv :: VarEnv a -> Var b -> VarEnv a

Remove a variable-value pair from the environment

delVarEnvList :: VarEnv a -> [Var b] -> VarEnv a

Remove a list of variable-value pairs from the environment

unionVarEnv :: VarEnv a -> VarEnv a -> VarEnv a

Get the (left-biased) union of two environments

unionVarEnvWith :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a

Get the union of two environments, mapped values existing in both environments will be merged with the given function.

Element-wise operations

Mapping

mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b

Apply a function to every element in the environment

mapMaybeVarEnv :: (a -> Maybe b) -> VarEnv a -> VarEnv b

Apply a function to every element in the environment; values for which the function returns Nothing are removed from the environment

Folding

foldlWithUniqueVarEnv' :: (a -> Unique -> b -> a) -> a -> VarEnv b -> a

Strict left-fold over an environment using both the unique of the the variable and the value

Working with predicates

Searching

elemVarEnv :: Var a -> VarEnv b -> Bool

Does the variable exist in the environment

notElemVarEnv :: Var a -> VarEnv b -> Bool

Does the variable not exist in the environment

Conversions

Lists

eltsVarEnv :: VarEnv a -> [a]

Extract the elements

Sets of variables

type VarSet = UniqSet (Var Any)

Set of variables

Construction

emptyVarSet :: VarSet

The empty set

unitVarSet :: Var a -> VarSet

The set of a single variable

Modification

delVarSetByKey :: Unique -> VarSet -> VarSet

Remove a variable from the set based on its Unique

unionVarSet :: VarSet -> VarSet -> VarSet

Union two sets

differenceVarSet :: VarSet -> VarSet -> VarSet

Take the difference of two sets

Working with predicates

nullVarSet :: VarSet -> Bool

Check whether a varset is empty

Searching

elemVarSet :: Var a -> VarSet -> Bool

Is the variable an element in the set

notElemVarSet :: Var a -> VarSet -> Bool

Is the variable not an element in the set

subsetVarSet

Arguments

:: VarSet

Set of variables A

-> VarSet

Set of variables B

-> Bool

Is the set of variables A a subset of the variables B

disjointVarSet :: VarSet -> VarSet -> Bool

Are the sets of variables disjoint

Conversions

Lists

mkVarSet :: [Var a] -> VarSet

Create a set from a list of variables

eltsVarSet :: VarSet -> [Var Any]

In-scope sets

data InScopeSet

Set of variables that is in scope at some point

The Int is a kind of hash-value used to generate new uniques. It should never be zero

See "Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 for the motivation

Instances

Generic InScopeSet

Defined in Clash.Core.VarEnv

Associated Types

type Rep InScopeSet :: Type -> Type

Methods

from :: InScopeSet -> Rep InScopeSet x

to :: Rep InScopeSet x -> InScopeSet

Binary InScopeSet

Defined in Clash.Core.VarEnv

Methods

put :: InScopeSet -> Put

get :: Get InScopeSet

putList :: [InScopeSet] -> Put

NFData InScopeSet

Defined in Clash.Core.VarEnv

Methods

rnf :: InScopeSet -> ()

ClashPretty InScopeSet

Defined in Clash.Core.VarEnv

Methods

clashPretty :: InScopeSet -> Doc ()

type Rep InScopeSet

Defined in Clash.Core.VarEnv

type Rep InScopeSet = D1 ('MetaData "InScopeSet" "Clash.Core.VarEnv" "clash-lib-1.6.6-inplace" 'False) (C1 ('MetaCons "InScopeSet" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 VarSet) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Int)))

Accessors

Size information

emptyInScopeSet :: InScopeSet

The empty set

Indexing

lookupInScope :: InScopeSet -> Var a -> Maybe (Var Any)

Look up a variable in the InScopeSet. This gives you the canonical version of the variable

Construction

mkInScopeSet :: VarSet -> InScopeSet

Create a set of variables in scope

Modification

extendInScopeSet :: InScopeSet -> Var a -> InScopeSet

The empty set

extendInScopeSetList :: InScopeSet -> [Var a] -> InScopeSet

Add a list of variables in scope

unionInScope :: InScopeSet -> InScopeSet -> InScopeSet

Union two sets of in scope variables

Working with predicates

Searching

elemInScopeSet :: Var a -> InScopeSet -> Bool

Is the variable in scope

elemUniqInScopeSet :: Unique -> InScopeSet -> Bool

Check whether an element exists in the set based on the Unique contained in that element

notElemInScopeSet :: Var a -> InScopeSet -> Bool

Is the variable not in scope

varSetInScope :: VarSet -> InScopeSet -> Bool

Is the set of variables in scope

Unique generation

uniqAway :: (Uniquable a, ClashPretty a) => InScopeSet -> a -> a

Ensure that the Unique of a variable does not occur in the InScopeSet

uniqAway'

Arguments

:: (Uniquable a, ClashPretty a)

=> (Unique -> Bool)

Unique in scope test

-> Int

Seed

-> a

-> a

Dual renaming

data RnEnv

Rename environment for e.g. alpha equivalence

When going under binders for e.g.

x -> e1  aeq y -> e2

We want to rename [x -> y] or [y -> x], but we have to pick a binder that is neither free in e1 nor e2 or we risk accidental capture.

So we must maintain:

1. A renaming for the left term
2. A renaming for the right term
3. A set of in scope variables

Construction

mkRnEnv :: InScopeSet -> RnEnv

Create an empty renaming environment

Renaming

rnTmBndr :: RnEnv -> Id -> Id -> RnEnv

Simultaneously go under the binder bL and binder bR, finds a new binder newTvB, and return an environment mapping [bL -> newB] and [bR -> newB]

rnTyBndr :: RnEnv -> TyVar -> TyVar -> RnEnv

Simultaneously go under the type-variable binder bTvL and type-variable binder bTvR, finds a new binder newTvB, and return an environment mapping [bTvL -> newB] and [bTvR -> newB]

rnTmBndrs :: RnEnv -> [Id] -> [Id] -> RnEnv

Applies rnTmBndr to several variables: the two variable lists must be of equal length.

rnTyBndrs :: RnEnv -> [TyVar] -> [TyVar] -> RnEnv

Applies rnTyBndr to several variables: the two variable lists must be of equal length.

rnOccLId :: RnEnv -> Id -> Id

Look up the renaming of an occurrence in the left term

rnOccRId :: RnEnv -> Id -> Id

Look up the renaming of an occurrence in the left term

rnOccLTy :: RnEnv -> TyVar -> TyVar

Look up the renaming of an type-variable occurrence in the left term

rnOccRTy :: RnEnv -> TyVar -> TyVar

Look up the renaming of an type-variable occurrence in the right term