Supercompilation is a technique due to Turchin [1] which allows for the construction of program optimisers that are both simple and extremely powerful. Supercompilation is capable of achieving transformations such as deforestation [2], function specialisation and constructor specialisation [3]. Inspired by Mitchell’s promising results [4], we show how the call-by-need supercompilation algorithm can be recast to be based explicitly on an evaluator, and in the process extend it to deal with recursive let expressions.

The goal of my research is to allow programmers to write robust programs that can be compiled into efficient executables. This requires two things: i) tools that prevent common programming errors and aid the programmer in designing correct programs; and ii) a good optimizing compiler to turn the correct program into a correct and efficient executable. Solving these problems, and how difficult that is, greatly depends on the programming language in question. Statically typed functional programming languages such as F # and Haskell can through their type systems give compile time guarantees about the absence of certain errors in programs. By allowing programmers to write clear and concise programs they reduce the gap between the specification of the program and the program itself, leading to fewer mistakes in the translation. These languages also contain features specifically designed to help improve modular design of programs, something generally accepted as a key to successfully build large software systems. However, the clear and concise programs written in functional programming languages suffer from poor performance compared to their counterparts written in imperative languages such as Fortran or C. If we are prepared to sacrifice the clarity of the functional program it is often possible to achieve similar performance as Fortran or C, but this defeats much of our purpose to use a statically typed functional programming