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

Name for a new binder for the right-hand side of a case alternative. Includes the constructor matched by the alternative. For example, in:

x = case s of
  Idle -> ...
  _ -> ...

the right-hand sides are named c$x_case_Idle and c$x_case_default. Uses case_alt for literal patterns and constructors that are operators.

Name for a new binder for an argument of an application. Prefers names derived from what the argument is passed to:

• The record field name, for arguments of a data constructor, e.g. c$baudCount for n in Tx { txState = st, baudCount = n }
• The parameter name, for arguments of a global function, e.g. c$txStep_s for st in txStep st i, given txStep s input = ...

Falls back to mkDerivedName with suffix app_arg.

Make a new binder and variable reference for a term

Run a Core-type to HWType translation action against the session-wide translation cache (hwTypeCache).

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. This is a onLet handler: it receives the let-expression itself, its bindings, and its body.

Inline or lift the binders in a let-binding that have a certain property. This is a onLet handler: it receives the let-expression itself, its bindings, and its body.

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

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

Perform a transformation on a Term

The instrumentation core of apply (debug tracing, transformation counter, rewrite history, invariant checks) around an already-applied transformation action. Also returns whether the action signaled change.

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.

Strictly bump a counter in RewriteState, typically transformTriedCounters or transformAppliedCounters.

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

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.