Documentation

Lift an action working in the _extra state to the RewriteMonad

Record if a transformation is succesfully 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

Create a type and kind context out of a transformation context

Create a complete type and kind context out of the global binders and the transformation context

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 and corresponding variable reference

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

Substitute the RHS of the first set of Let-binders for references to the first set of Let-binders in: the second set of Let-binders and the additional term

Calculate the local free variable of an expression: the free variables that are not bound in the global environment.

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

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

Test whether a term is a variable reference to a local binder

Determine if a term cannot be represented in hardware

Determine if a type cannot be represented in hardware

Is the Context a Lambda/Term-abstraction context?

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