Documentation

Lift an action working in the _extra state to the RewriteMonad

Some transformations might erroneously introduce shadowing. For example, a transformation might result in:

let a = ... b = ... a = ...

where the last a, shadows the first, while Clash assumes that this can't happen. This function finds those constructs and a list of found duplicates.

Record if a transformation is successfully applied

Perform a transformation on a Term

Evaluate a RewriteSession to its inner monad.

Notify that a transformation has changed the expression

Identity function that additionally notifies that a transformation has changed the expression

Make a new binder and variable reference for a term

Make a new binder and variable reference for either a term or a type

Make a new, unique, identifier

Inline the binders in a let-binding that have a certain property

Determine whether a binder is a join-point created for a complex case expression.

A join-point is when a local function only occurs in tail-call positions, and when it does, more than once.

Count the number of (only) tail calls of a function in an expression. Nothing indicates that the function was used in a non-tail call position.

Determines whether a function has the following shape:

\(w :: Void) -> f a b c

i.e. is a wrapper around a (partially) applied function f, where the introduced argument w is not used by f

Inline the first set of binder into the second set of binders and into the body of the original let expression.

Lift the first set of binders to the level of global bindings, and substitute these lifted bindings into the second set of binders and the body of the original let expression.

Determines whether a global binder is work free. Errors if binder does not exist.

Determine whether a term does any work, i.e. adds to the size of the circuit

Determine if a term represents a constant

A conservative version of isWorkFree. Is used to determine in bindConstantVar to determine whether an expression can be "bound" (locally inlined). While binding workfree expressions won't result in extra work for the circuit, it might very well cause extra work for Clash. In fact, using isWorkFree in bindConstantVar makes Clash two orders of magnitude slower for some of our test cases.

In effect, this function is a version of isConstant that also considers references to clocks and resets constant. This allows us to bind HiddenClock(ResetEnable) constructs, allowing Clash to constant spec subconstants - most notably KnownDomain. Doing that enables Clash to eliminate any case-constructs on it.

Create a global function for a Let-binding and return a Let-binding where the RHS is a reference to the new global function applied to the free variables of the original RHS

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

Make a global function for a name-term tuple

Add a function to the set of global binders

Create a new name out of the given name, but with another unique. Resulting unique is guaranteed to not be in the given InScopeSet.

Create a new name out of the given name, but with another unique. Resulting unique is guaranteed to not be in the given BindingMap.

Determine if a term cannot be represented in hardware

Determine if a type cannot be represented in hardware

Make a binder that should not be referenced

Make a case-decomposition that extracts a field out of a (Sum-of-)Product type

Specialise an application on its argument

Specialise an application on its argument

Create binders and variable references for free variables in specArg

Evaluate an expression to weak-head normal form (WHNF), and apply a transformation on the expression in WHNF.

Binds variables on the PureHeap over the result of the rewrite

To prevent unnecessary rewrites only do this when rewrite changed something.

Remove unused binders in given let-binding. Returns Nothing if no unused binders were found.