This module contains a compiler pass that transforms all expressions from function declarations into a flat form. An expression is "flat" if all function and constructors are only applied to variables.

Examples

Example 1

The following function does contain functions, which are applied on other function calls.

dot :: (b -> c) -> (a -> b) -> a -> c
dot (f :: b -> c) (g :: a -> b) (x :: a) = f (g x)

The pass transforms the example the following way.

dot :: (b -> c) -> (a -> b) -> a -> c
dot (f :: b -> c) (g :: a -> b) (x :: a) = let {y = g x} in f y

where y is a fresh variable.

Example 2

dollar :: (a -> b) -> a -> b
dollar (f :: a -> b) (x :: a) = f x

Should not be changed by the transformation.

Specification

Preconditions

There are no special requirements.

Translation

For every function or constructor applications f e₁ … eₙ where e₁, …, eₙ are arbitrary expressions the transformation generates the following expression

let {x₁ = e₁ ; … ; xₙ = eₙ} in f x₁ … xₙ

where x₁, …, xₙ are fresh variables. The let-bindings are only introduced if the corresponding expression is not a variable. The translation is applied to the expressions e₁, …, eₙ recursively.

Postconditions

All applications of functions and constructors have the form f x₁ … xₙ where f is a function or constructor and x₁, …, xₙ are variables.