Documentation

Record if a transformation is successfully applied

Determine if a type cannot be represented in hardware

Evaluate a RewriteSession to its inner monad.

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

Determine if a term cannot be represented in hardware

Make a new binder and variable reference for a term

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

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.

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

Lift an action working in the _extra state to the RewriteMonad

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

Notify that a transformation has changed the expression

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

Make a global function for a name-term tuple

Perform a transformation on a Term

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.

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

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

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.

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.

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

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

Add a function to the set of global binders

Binds variables on the PureHeap over the result of the rewrite

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