Positive Supercompilation for a higher order call-by-value ... - CiteSeerX

Positive Supercompilation for a higher order call-by-value language Peter A. Jonsson and Johan Nordlander {pj,nordland}@csee.ltu.se Lule˚ a University of Technology

Abstract. Previous deforestation and supercompilation algorithms may introduce termination when applied to call-by-value programs. This hides looping bugs from the programmer, and changes the behaviour of a program depending on whether it is optimized or not. We present a supercompilation algorithm for a higher-order call-by-value language that preserves termination properties. This algorithm utilizes strictness information for deciding whether to substitute or not and compares favorably with previous call-by-name transformations.

1

Introduction

Intermediate lists in functional programs allow the programmer to write clear and concise programs, but carry a cost at run time since list cells need to be both allocated and garbage collected. Both deforestation [19] and supercompilation [14] are automatic program transformations that remove many of these intermediate structures. In a call-by-value context these transformations are unsound, and might hide looping bugs from the programmer. Consider the program (λx.y) ⊥. Applying Wadler’s deforestation algorithm [19] to the program will result in y, which is sound under call-by-name or call-by-need. The non-termination under call-by-value in the original program has been removed, and hence the meaning of the program has been altered by the transformation. Removal of intermediate structures in a strict language is still desirable though, perhaps even more than in a lazy language since the entire intermediate structure has to stay alive during the entire computation. We show how to construct a meaning-preserving supercompilation scheme for call-by-value languages. It might seem like such a result should be easily obtainable from a call-by-name algorithm by simply delaying beta-reduction until every function argument has been specialized to a value. However, it turns out that this strategy misses even simple opportunities to remove intermediate structures. The explanation is that eager specialization of function arguments risks destroying fold opportunities that might otherwise appear, something which may even prohibit complexity improvements to the resulting program.

The novelty of our supercompilation algorithm is that it concentrates all callby-value dependencies to a single rule that relies on the result from a separate strictness analysis for correct behavior. In effect, our algorithm delays transformation of function arguments past inlining, much like a call-by-name scheme does, although only as far as is legal with respect to call-by-value semantics. The result is an algorithm that is able to improve a wide range of illustrative examples like the existing algorithms do, but without the risk of introducing superficial termination. The specific contributions of our work are: – We provide an algorithm for positive supercompilation including folding, for a strict and pure higher-order functional language (Section 4). – Section 5 outlines extensions to improve transformational power. – We prove that a restricted version of our algorithm preserve call-by-value semantics (Section 6). We start out with some examples in Section 2 to give the reader an intuitive feel of how the algorithm behaves. Our language of study is defined in Section 3 right before the technical contributions are presented.

2

Examples

We call our transformation algorithm D and let DJeK denote the result of transforming an expression e. The transformation takes an expression and a set of global definitions as input, and returns a new expression together with a new set of global definitions. The inherent conflict between having call-by-value semantics and delaying evaluation of arguments as long as possible is the core of the problem we face when trying to construct an equally powerful call-by-value deforestation algorithm as the previous call-by-name ones. Consider a slightly contrived example, DJ skipFst ⊥ True K. Under call-by-name this evaluates to 1. However, this result is not possible to reach under call-by-value semantics, since there is obvious non-termination in the original code snippet. The call-by-value semantics force worse performance; the best transformation result that still preserves semantics is let x = ⊥ in 1. skipFst x cond = case cond of {True → 1; False → 2} append xs ys = case xs of {[] → ys; (x : xs) → x : append xs ys} Wadler [19] uses the example append (append xs ys) zs and shows that his deforestation algorithm transforms the program so that its complexity is reduced from 2|xs| + |ys| to |xs| + |ys|, thereby saving one traversal of the first list. If we na¨ıvely change Wadler’s algorithm to call-by-value semantics by eagerly attempting to transform arguments before attacking the body, we do not achieve this improvement in complexity. An example from a fictional driving algorithm that attacks arguments first is:

DJ append (append xs 0 ys 0 ) zs 0 K (Drive append xs 0 ys 0 in the context append [] zs 0 ) = DJ case xs 0 of [] → append ys 0 zs 0 (x : xs) → append (x : append xs ys 0 ) zs 0 K (Drive each branch, we focus on the (x:xs) case) = DJ append (x : append xs ys 0 ) zs 0 K (The expression has a previously seen expression embedded in it. x : append xs ys 0 is extracted for separate driving) = DJ x : append xs ys 0 K = DJ x : case xs of 0 [] → ys (x 0 : xs 0 ) → x 0 : append xs 0 ys 0 K (A renaming of a previous expression in the (x’:xs’) branch) The end result from this driving is: DJ append (append xs 0 ys 0 ) zs 0 K = case xs 0 of [] → h1 ys 0 zs 0 (x : xs) → h1 (h2 x xs ys 0 ) zs 0 h1 xs ys = case xs of {[] → ys; (x 0 : xs 0 ) → x 0 : h1 xs 0 ys} h2 x xs ys = x : case xs of {[] → ys; (x 0 : xs 0 ) → h2 x 0 xs 0 ys} The intermediate structure in the input is still there after the transformation, and the complexity remains at 2|xs| + |ys|! However, doing the exact opposite — that is, carefully delaying transformation of arguments to a function past inlining of its body — actually leads to the same result as Wadler obtains after transforming append (append xs ys) zs. Notice that the primitive operations ranged over by ⊕ in this language are supposed to be strict with regards to both arguments. This stands in contrast to ordinary functions, which can be inlined and partially evaluated for a couple of steps even if the arguments are unknown. Our algorithm leaves a primitive operation in place if any of its arguments fails to specialize to a primitive value. If we had a perfect strictness analysis and could decide whether an arbitrary expression will terminate or not, the only difference in results between our algorithm and a call-by-name counterpart would be for the non-terminating cases. In practice, we have to settle for an approximation, such as the simple analysis defined in Figure 3. One may speculate whether the transformations thus missed will have adverse effects on the usefulness of our algorithm in practice. We believe

we have seen clear indications that this is not the case, and that crucial factor instead is the ability to inline function bodies irrespective of whether arguments are values or not. We claim that our algorithm compares favorably with previous call-by-name transformations, and proceed with demonstrating the transformation of common examples. The results are equal to those of Wadler [19]. Our first example is transformation of sum (map square ys). The functions used in the examples are defined as: square x = x ∗ x map f xs = case xs of {[] → []; (x 0 : xs 0 ) → (f x 0 ) : (map f xs 0 ) } sum xs = case xs of {[] → 0; (x 0 : xs 0 ) → x 0 + sum xs 0 } We start our transformation by allocating a new fresh function name (h0 ) to this expression, inlining the body of sum and substituting map square ys into the body of sum: DJcase (map square ys) of {[] → 0; (x 0 : xs 0 ) → x 0 + sum xs 0 }K. After inlining map and substituting the arguments into the body the result becomes: DJ case (case ys of {[] → []; (x 0 : xs 0 ) → (square x 0 ) : (map square xs 0 )}) of [] → 0 (x 0 : xs 0 ) → x 0 + sum xs 0 K We duplicate the outer case in each of the inner case’s branches, using the expression in the branches as head of that case-statement. Continuing the transformation on each branch with ordinary reduction steps yields: case ys of {[] → 0; (x 0 : xs 0 ) → DJ square x 0 + sum (map square xs 0 ) K}) Now inline the body of the first square and observe that the second argument to (+) is similar to the expression we started with. A most specific generalization (msg) between the starting expression and the current expression is calculated, effectively splitting the expression in several parts. These expressions are transformed separately. We replace the second parameter to (+) with h0 xs 0 . The result of our transformation is h0 ys, with h0 defined as: h0 ys = case ys of [] → 0 (x 0 : xs 0 ) → x 0 ∗ x 0 + h0 xs 0 This new function only traverses its input once, and no intermediate structures are created. If the expression sum (map square xs) or a renaming thereof is detected elsewhere in the input, a call to h0 will be inserted there instead. The following examples are due to Ohori and Sasano [8]. We need the following new function definitions:

mapsq xs = case xs of { [] → []; (x 0 : xs 0 ) → (x 0 ∗ x 0 ) : (mapsq xs 0 ) } f xs = case xs of { [] → []; (x 0 : xs 0 ) → (2 ∗ x 0 ) : (g xs 0 ) g xs = case xs of { [] → []; (x 0 : xs 0 ) → (3 ∗ x 0 ) : (f xs 0 ) Evaluating DJ mapsq (mapsq xs)K will inline the outer mapsq, substitute the argument in the function body and inline the inner call to mapsq: DJ case (case xs of {[] → []; (x 0 : xs 0 ) → (x 0 ∗ x 0 ) : (mapsq xs 0 )}) of [] → [] (x 0 : xs 0 ) → (x 0 ∗ x 0 ) : (mapsq xs 0 ) K As previously, we duplicate the outer case in each of the inner case’s branches, using the expression in the branches as head of that case-statement. Continuing the transformation on each branch by ordinary reduction steps yields: case xs of {[] → [];(x 0 : xs 0 ) → DJ (x 0 ∗ x 0 ∗ x 0 ∗ x 0 ) : (mapsq (mapsq xs 0 )) K } This will fold in a few steps, and the final result of our transformation is h1 xs, with the new residual function h1 that only traverses its input once: h1 xs = case xs of {[] → []; (x 0 : xs 0 ) → ((x 0 ∗ x 0 ) ∗ (x 0 ∗ x 0 )) : (h1 xs 0 )) K } For an example of transforming mutually recursive functions, consider the transformation DJ sum (f xs)K . Inlining the body of sum, substituting its arguments in the function body and inlining the body of f yields: DJ case (case xs of {[] → []; (x 0 : xs 0 ) → (2 ∗ x 0 ) : (g xs 0 )}) of [] → 0 (x 0 : xs 0 ) → x 0 + sum xs 0 K Moving down the outer case into each branch, performing reductions to end up with: case xs of {[] → 0; (x 0 : xs 0 ) → DJ (2 ∗ x 0 ) + sum (g xs 0 ) K }

We notice that unlike in previous examples, sum (g xs 0 ) is not similar to what we started transforming. For space reasons, we focus on the transformation of the expression in the last branch, DJ(2 ∗ x 0 ) + sum (g xs 0 ) K, while keeping the functions already seen in mind. We inline the body of sum, perform the substitution of its arguments and inline the body of g: DJ (2 ∗ x 0 ) + case (case xs 0 of {[] → []; (x 00 : xs 00 ) → (3 ∗ x 00 ) : (f xs 00 )}) of [] → 0 (x 0 : xs 0 ) → x 0 + sum xs 0 K

We now move down both (2 ∗ x 0 ) and the outer case into each branch, and perform reductions: case xs 0 of [] → (2 ∗ x 0 ) + 0 (x 00 : xs 00 ) → DJ (2 ∗ x 0 ) + (3 ∗ x 00 ) + sum (f xs 00 ) K

We notice a familiar expression in sum (f xs 00 ), and fold when reaching it. Adding it all together gives a new function h2 : h2 xs = case xs of [] → 0 (x 0 : xs 0 ) → case xs 0 of [] → (2 ∗ x 0 ) + 0 (x 00 : xs 00 ) → (2 ∗ x 0 ) + (3 ∗ x 00 ) + h2 xs 00 Kort [4] studied a ray-tracer written in Haskell, and identified a critical function in the innermost loop of a matrix multiplication, called vecDot: vecDot xs ys = sum (zipWith (∗) xs ys) This is simplified by our positive supercompiler to: vecDot xs ys = h1 xs ys h1 xs ys = case xs of (x 0 : xs 0 ) → case ys of (y 0 : ys 0 ) → x 0 ∗ y 0 + h1 xs 0 ys 0 → 0 → 0 The intermediate list between sum and zipWith is transformed away, and the complexity is reduced from 2|xs| + |ys| to |xs| + |ys| (since this is matrix multiplication |xs| = |ys|).

3

Language

Our language of study is a strict, higher-order, functional language with letbindings and case-expressions. Its syntax for expressions, values and patterns is: e, f ::= n | x | g | f e | λx.e | k e | e1 ⊕ e2 | let x = f in e | case e of {pi → ei } p ::= n | k x v ::= n | λx.e | k v We let constructor symbols be denoted by k. Let g range over a set G of global definitions whose right-hand sides are all values. Recursion is only allowed at the top level but this restriction is not particularly burdensome – if a local function needs to be recursive, it can always be lambda-lifted [3] to the top level. The language contains integer values n and arithmetic operations ⊕, although these meta-variables can preferably be understood as ranging over primitive values in general and arbitrary operations on these. We let + denote the semantic meaning of ⊕. All functions have a specific arity and all applications must be saturated; hence λx .map (+1) x is legal whereas map (+1) is not. We abbreviate a list of expressions e1 . . . en as e, and a list of variables x1 . . . xn as x.

Reduction contexts E ::= [ ] | E e | (λx.e) E | k E | E ⊕ e | n ⊕ E | let x = E in e | case E of {pi → ei } Evaluation relation Ehgi Eh(λx.e) vi Ehlet x = v in ei Ehcase k v of {ki xi → ei }i Ehcase n of {ni → ei }i Ehn1 ⊕ n2 i

7→ 7→ 7 → 7→ 7→ 7→

Ehvi, Eh[v/x]ei Eh[v/x]ei Eh[v/xj ]ej i, Ehej i, Ehni,

if (g = v) ∈ G

if k = kj if n = nj if n = n1 + n2

(Global) (App) (Let) (KCase) (NCase) (Arith)

Fig. 1. Reduction semantics

A program is an expression with no free variables except those defined in G. The intended operational semantics is given in Figure 1, where [e/x]e0 is the capture-free substitution of expressions e for variables x in e0 . A reduction context E is a term containing a single hole [ ], which indicates the next expression to be reduced. The expression Ehei is the term obtained by replacing the hole in E with e. E denotes a list of terms with just a single hole, evaluated from left to right. We use ≡ to denote equality up to renaming of variables. If a variable appears no more than once in a term, that term is said to be linear with respect to that variable. Like Wadler [19], we extend the definition slightly for linear case terms: no variable may appear in both the selector and a branch, although a variable may appear in more than one branch. The definition of append is linear, although ys appears in both branches.

4

Higher Order Positive Supercompilation

Our supercompiler is defined as a set of rewrite rules that pattern-match on expressions. This algorithm is called the driving algorithm, and is defined in Figure 2. Two additional parameters appear as subscripts to the rewrite rules: a memoization list ρ and a driving context R. The memoization list holds information about expressions already traversed and is explained more in detail in Section 4.1. The driving context R is smaller than E, and is defined as follows: R ::= [ ] | R e | case R of {pi → ei } | R ⊕ e | e ⊕ R Interestingly this definition coincides with the evaluation contexts for a call-byname language. The reason our algorithm still preserves a call-by-value semantics is that beta-reduction (rule R8) results in a let-binding, whose further specialization in rule R11 depends on whether the body expression f is strict in the bound variable x or not. In principle, an expression e is strict with regards to a variable x if it eventually evaluates x; in other words, if e 7→ . . . 7→ Ehxi. Such information is in

DJnKR,ρ DJk eK[],ρ DJx eKR,ρ DJλx.eK[],ρ DJn1 ⊕ n2 KR,ρ DJe1 ⊕ e2 KR,ρ

= = = = = =

DJg eKR,ρ DJ(λx.f ) eKR,ρ DJe eKR,ρ DJlet x = v in f KR,ρ DJlet x = e in f KR,ρ

= = = = =

DJcase x of {pi → ei }KR,ρ DJcase kj e of {ki xi → ei }KR,ρ DJcase nj of {ni → ei }KR,ρ DJcase a of {pi → ei }KR,ρ DJcase e of {pi → ei }KR,ρ DJeK[],ρ

= = = = = =

Rhni k DJeK[],ρ Rhx DJeK[],ρ i (λx.DJeK[],ρ ) DJRhniK[],ρ , where n = n1 + n2 DJe1 K[],ρ ⊕ DJe2 K[],ρ , if e1 ⊕ e2 = a DJe2 KRhe1 ⊕[]i,ρ , if e1 = n or e1 = a DJe1 KRh[]⊕e2 i,ρ , otherwise Dapp Jg eKR,ρ DJlet x = e in f KR,ρ DJeKRh[] ei,ρ DJRh[v/x]f iK[],ρ DJRh[e/x]f iK[],ρ , if e = g|x or x ∈ strict(f ) let x = DJeK[],ρ in DJRhf iK[],ρ , otherwise case x of {pi → DJRh[pi /x]ei iK[],ρ } DJlet xj = e in ej KR,ρ DJRhej iK[],ρ case DJaK[],ρ of {pi → DJRhei iK[],ρ }, DJeKRhcase [] of {pi →ei }i,ρ DJe1 K[],ρ , . . . , DJen K[],ρ

(R1) (R2) (R3) (R4) (R5) (R6)

(R7) (R8) (R9) (R10) (R11) (R12) (R13) (R14) (R15) (R16) (R17)

Fig. 2. Driving algorithm

general not computable, although call-by-value semantics allows for reasonably tight approximations. One such approximation is given in Figure 3, where the strict variables of an expression e are defined as all free variables of e except those that only appear under a lambda or not inside all branches of a case.

strict(x) strict(n) strict(g) strict(k e) strict(λx.e) strict(f e) strict(let x = e in f ) strict(case e of {pi → ei }) strict(e1 ⊕ e2 )

= = = = = = = = =

{x} ∅ ∅ strict(e) ∅ strict(f ) ∪ strict(e) strict(e) ∪ (strict(f )\{x}) T strict(e) ∪ ( (strict(ei )\f v(pi )) strict(e1 ) ∪ strict(e2 )

Fig. 3. The strict variables of an expression

There is an ordering between rules; i.e., all rules must be tried in the order they appear. Rules R9 and R16 are the default fallback cases which extend the given driving context R and zoom in on the next expression to be driven. Metavariable a in rules R6 and R15 stands for an “annoying” expression; i.e., an expression that would be further reducible were it not for a free variable getting

in the way. The grammar for annoying expressions is as follows: a ::= x | n ⊕ a | a ⊕ n | a ⊕ a | a e It is important to note that we allow empty argument vectors for all rules. Further, we assume that rule R7 matches the largest possible redex. The first alternative for rule R6 will only be selected if R is the empty context since rule R15 catches any ⊕s that are in the head of a case statement. Some expressions should be handled differently depending on context. If a constructor application appears in an empty context, there is not much we can do but to drive the argument expressions (rule R2). On the other hand - if the application occurs at the head of a case expression, we may choose a branch on basis of the constructor and leave the arguments unevaluated in the hope of finding fold opportunities further down the syntax tree (rule R13). The argumentation is analogous for lambda abstractions: if there is a surrounding context we perform a beta reduction, otherwise we drive its body. The algorithm only performs substitutions of expressions in one rule (R11), hence there is only one possible source of code duplication. Duplicating code forces evaluation of the same expression multiple times, in addition to the increase in code size. If duplication must be avoided, restrict substitution in R11 to the cases where the body of f is linear with respect to the bound variable x. However, this issue is a bit more complicated, as it might sometimes be beneficial to duplicate code that enables further transformations. The current algorithm has no means of finding a suitable trade-off, so it ignores the problem and always performs substitution when strictness so allows. Obtaining a more refined behavior in this respect is left for future work. 4.1

Application Rule

In the driving algorithm rule R7 refers to Dapp J K, defined in Figure 4. This algorithm destructively updates a set defs with new function definitions as a side-effect. The input definitions are also accessed as the implicit parameter G. Dapp J K can be inlined in the definition of the driving algorithm, it is merely given a separate name for improved clarity of the presentation. Dapp Jg eKR,ρ = h0 x, if ∃(t, h0 ) ∈ ρ . t ≡ Rhg ei θ20 DJtg K[],ρ , if ∃(t, h0 ) ∈ ρ . t E Rhg ei and tg6= x θ3 DJRhyiK[],ρ , if ∃(t, h0 ) ∈ ρ . t E Rhg ei and tg= x 0 h x, defs := defs ∪ (h, λx.e ), if h ∈ f v(e0 ) e0 , otherwise where (g = v) ∈ G, e0 = DJRhv eiK[],ρ0 , (tg , θ1 , θ2 ) = msg(t, Rhg ei) x = fv(Rhg ei), ρ0 = ρ ∪ (Rhg ei, h), h, y and x0 fresh, θ20 = DJθ2 K[],ρ , θ3 = [DJg x0 K[],ρ /y, DJeK[],ρ /x0 ] Fig. 4. Driving applications

Care needs to be taken to ensure that recursive functions are not inlined forever. The driving algorithm keeps a record of previously seen applications in the memoization list ρ; whenever it detects an expression that is equivalent (up to alpha conversion) to a previous expression, the algorithm creates a new recursive function hn for some n. Whenever such an expression is encountered again, a call to hn is inserted. This is not sufficient to guarantee termination of the algorithm, but the mechanism is crucial for the complexity improvements mentioned in Section 2. To ensure termination, we use the homeomorphic embedding relation E to define a predicate called “the whistle”. The intuition is that when e E f , f contains all subterms of e, possibly embedded in other terms. For any infinite sequence e0 , e1 , . . . there exists i and j such that i < j and ei E ej . This condition is sufficient to ensure termination. We need a definition of uniform terms analogous to the work by Sørensen and Gl¨ uck [13], with some small adjustments specific to our language. Definition 1 (Uniform terms). Let s range over a the set G ∪ X ∪ K ∪ {caseof , letin}, and let caseof (e) (letin(e)) denote a case (let) expression containing subexpressions e. The set of small terms T is the smallest set of arity respecting symbol applications s(e). Definition 2 (Homeomorphic embedding). Define E as the smallest relation on T satisfying: x E y, n1 E n2 ,

e E fi for some i e1 E f1 , . . . , en E fn , e E s(f1 , . . . , fn ) s(e1 , . . . , en ) E s(f1 , . . . , fn )

Whenever the whistle blows, our algorithm splits the current input expression into strictly smaller terms that are driven separately in the empty context. We split the expression by calculating the most specific generalization of the input and the embedded expression. The most specific generalization entails the smallest possible loss of knowledge, and is defined as: Definition 3 (Most specific generalization). – An instance of a term e is a term of the form θe for some substitution θ. – A generalization of two terms e and f is a triple (tg , θ1 , θ2 ), where θ1 , θ2 are substitutions such that θ1 tg ≡ e and θ2 tg ≡ f . – A most specific generalization (msg) of two terms e and f is a generalization (tg , θ1 , θ2 ) such that for every other generalization (t0g , θ10 , θ20 ) of e and f it holds that tg is an instance of t0g . We refer to tg as the ground term. For background infromation and an algorithm to compute most specific generalizations, see Lassez et. al [5]. An example of the homeomorphic embedding and the msg is: e e Right e fac y

E E E

f Just e Right (e, e 0 ) fac (y − 1)

tg x Right x fac x

θ1 [e/x] [e/x] [y/x]

θ2 [Just e/x] [(e, e0 )/x] [(y − 1)/x]

4.2

Positive Supercompilation versus Deforestation

The additional strength in positive supercompilation comes from propagating information about the pattern of each branch in a case statement (rule R12 in our definition). It is not hard to craft a program by hand that benefits from this extra information propagation. It turns out that this information is useful for real programs as well. An example collected from Conway’s Life in the nofib benchmark suite [9] is the expression concat (map star xs) with star defined as: star n = case n of {0 →

00 00

;1 →

00 00

o }

Evaluating DJ concat (map star xs)K results in the function h10 xs: h10 (x : xs) = case x of 0 → case xs of [] → [0 0 ] (x 0 : xs 0 ) → let h2 = h10 xs in [0 0 , h2 ] 1 → case xs of [] → [0 0 ,0 o 0 ]) (x 0 : xs 0 ) → let h3 = h10 xs in [0 0 , 0 o 0 , h3 ] h1 (x : xs) = case x of 0 → case xs of [] → case x of { 0 → [0 0 ]; 1 → [0 0 , 0 o 0 ] } (x 0 : xs 0 ) → let h2 = h1 xs in case x of 0 → [0 0 , 1 → [0 0 , 1 → case xs of [] → case x of { 0 → [0 0 ]; 1 → [0 0 , 0 o 0 ] } (x 0 : xs 0 ) → let h3 = h1 xs in case x of 0 → [0 0 , 1 → [0 0 ,

h2 ] 0 0 o , h2 ]

h3 ] 0 0 o , h3 ]

In comparison, the function h1 is the output from our algorithm if we remove the extra information propagation from rule R12. There are two case-statements in this function that pattern matches on x. The second one is not necessary, since the value of x must be either 0 or 1 depending on which branch it has previously taken.

5

Extended Let-rule

The driving algorithm can be extended in various ways that will make it more powerful. We show that with an extended Let-rule in combination with a disabled whistle for closed expressions we can evaluate arbitrary closed expressions. If the let-expression contains no free variables we could drive either the right hand side or the body and see what the result is. We could augment rule R11

with a second and third alternative: DJlet x = e in f KR,ρ = DJRh[e/x]f iK[],ρ , if e = g, e = x or x ∈ strict(f ) DJRh[v/x]f iK[],ρ , if DJeK[],ρ = v DJRh[e/x]f 0 iK[],ρ , if DJf K[],ρ = f 0 , and x ∈ strict(f 0 ) let x = DJeK[],ρ in DJRhf iK[],ρ , otherwise The reasoning behind this is that a closed expression contains all information that is needed to evaluate it, thus a fold should be unnecessary. If the expression diverges, then so does the final program. The immediate question following from the above is whether this is beneficial for expressions that are not closed, a question we have no definite answer to. An example of the benefit of driving the body is bodyEx as shown below. bodyEx = let x = e in case [] {[] → x ; (x : xs) → y} DJ bodyEx K = DJ let x = e in case [] of { [] → x ; (x : xs) → yK } = DJ e K

(R7) (R11)

We can see how the body becomes strict after driving it, which opens up for further transformations. Disabling the whistle for closed expressions in combination with the let rule above yields 6 from DJ fac 3 K. This works for arbitrary closed expressions that are in the language, so, for example DJ sum [1..3] K = 6.

6

Total Correctness

The problem with previous deforestation and supercompilation algorithms in a call-by-value context is that they might change termination properties of programs. In this section, we prove that a slightly restricted version of our supercompiler does not alter whether a program terminates or not. We define the standard notions of operational approximation and equivalence. A general context C which has zero or more holes in the place of some subexpressions is introduced. Definition 4 (Operational approximation, Operational Equivalence). – e operationally approximates e’, e@e0 , if for all contexts C such that C[e], e terminates then so does evaluation of C[e’] are closed, if evaluation of C[e] C[e’]. – e is operationally equivalent to e’, e ∼ = e0 , if e@e0 and e0 @e e e The correctness of deforestation in a call-by-name setting has previously been shown by Sands [10] using his improvement theory. Notice that improvement D below is not the same as the homeomorphic embedding E defined previuosly. We use Sands’s definitions for improvement and strong improvement:

Definition 5 (Strong Improvement, Cost equivalent). – e is improved by e’, e D e0 , if for all contexts C such that C[e], C[e’] are closed, if computation of C[e] terminates using n function calls, then computation of C[e’] also terminates, and uses no more than n function calls. – e is strongly improved by e’, e Ds e0 , iff e D e0 and e ∼ = e0 . 0 0 0 – e and e’ are cost equivalent, e ED e iff e D e and e D e Cost equivalence implies strong improvement. With these definitions in place, total correctness for a transformation can be stated: Theorem 1 (Sands). If e Ds e0 , a transformation that replaces e by e’ is totally correct. Improvement theory in a call-by-value setting requires Sands’s operational metatheory for functional languages [11], where the improvement theory is a simple corollary of improvement induction over the well fonded resource structure hN, 0, +, ≥i. Our set G corresponds to Sands’s global recursive constants. We therefore label evaluation in one step using the Global-rule with the resource 1. We use e 7→k v to denote that e will evaluate to v using the Global rule k times, and any other rule as many times as it needs. The expression let x = e in (x , x ) is not improved by (e, e), so we restrict rule R11 to only allow substitution if the body is both strict and linear with respect to the variable bound. We let v R† v 0 for some relation R mean that v = (λx.e), v 0 = (λx.e0 ) and e R e0 or v = v 0 . Proposition 1 (Total Correctness). For all well-formed and well-typed expressions e, e Ds DJeK[],ρ . Proof (Proof sketch for D of R11). Let R be the relation containing ≡, together with all pairs of closed expressions where f is linear and strict with respect to x on the form (Rhlet x = e in f i, Rh[e/x]f i). Assume f 7→l Ehxi, e 7→k v, and notice that Rhlet x = [] in f i is a reduction context. Evaluation yields Rhlet x = e in f i 7→k Rhlet x = v in f i which will evaluate to Rh[v/x]f i, and proceed Rh[v/x]f i 7→l Ehvi. There are matching evaluation steps (in different order) in Rh[e/x]f i: Rh[e/x]f i 7→l Ehei 7→k Ehvi. From this we conclude that Rhlet x = e in f i 7→n v, for some n ≥ k + l. The remaining conditions for improvement simulation are satisfied since v ≡† v, which implies v R† v as required. The proof for rule R7 is similar in structure to the proof by Sands [10, p. 24], and all other rules are cost equivalences, which implies strong improvement. The structure of the proofs for cost equivalence closely resembles the example by Sands [10, p. 14].

7

Termination

The homeomorphic embedding is a sufficient condition for ensuring termination. When the whistle blows, we split our expression into several strictly smaller expressions that are driven in the empty context. Termination can be proved using the framework by Sørensen [16]. Our proof is similar in structure to Sørensen’s termination proof for supercompilation [16]. It is however simpler since we avoid partitioning nodes into trivial and non-trivial nodes and use a single predicate (the homeomorphic embedding) to control inlining.

8

Related work

There exists much literature concerning algorithms that remove intermediate structures in functional programs. Most of it is however in a call-by-name or call-by-need context which makes it a different, yet difficult, problem.

8.1

Transformations for Strict Languages

The seminal work by Turchin on Supercompilation [17] is closely related to our work. The supercompiler was originally intended for the strict functional language Refal [18]. The supercompiler could therefore introduce termination in Refal programs, the problem we set out to solve with our work. More recently Ohori and Sasano presented a lightweight fusion algorihtm [8], which they applied to variant of Standard ML. They limit their algorithm to inlining each function at most once, thereby avoiding termination problems. This gives the unfortunate side effect that it does not handle two successive applications of the same function, nor mutually recursive functions as our examples in Section 2.

8.2

Transformations for Lazy Languages

Focusing on the closest relatives to our algorithm will bring out Wadler’s deforestation algorithm [19] for a first order language as the start for deforestation research. This was later extended to a higher-order language by Marlow and Wadler [6]. Refinements to this was made by Marlow [7] and Hamilton [1, 2]. Work by Sørensen et. al. on the positive supercompiler [14] deserves a special mention. Their work clearly explains the difference between deforestation and supercompilation, giving lots of illustrative examples. While the context is a lazy language, many of their insights apply to our work as well. Secher and Sørensen later refined this work to propagate both negative and positive information in the perfect supercompiler [12].

9

Conclusion

We have presented a positive supercompiler for a higher-order call-by-value language. It is proven correct for all input. The adjustment to the algorithm for preserving call-by-value semantics is new and works surprisingly well for many examples that were intended to show the usefulness of call-by-name transformations. 9.1

Future work

We believe that the restriction of rule R11 in the proof of correctness is not necessary for the soundness of our algorithm, but have not found a way to prove it yet. We will investigate how the concept of an inline budget may be used to obtain good balance between code size and inlining benefits. The current termination strategy could be improved with respect to the transformation result, the current definition inlines a little too much. The algorithm should start over and calculate a msg at the expression t when the whistle blows, just like Supercompilation [15] does. More work could be done on strictness analysis component of our supercompiler. We do not intend to focus on that subject, though; instead we hope that the modular dependency on strictness analysis will allow our supercompiler to readily take advantage of general improvements in the area. Acknowledgements The authors would like to thank Simon Marlow, Duncan Coutts and Neil Mitchell for valuable discussions. We would also like to thank Viktor Leijon for reading earlier drafts of this paper and providing useful comments for improvements.

References 1. G. W. Hamilton. Higher order deforestation. In PLILP ’96: Proceedings of the 8th International Symposium on Programming Languages: Implementations, Logics, and Programs, pages 213–227, London, UK, 1996. Springer-Verlag. ISBN 3-540-61756-6. 2. G. W. Hamilton. Higher order deforestation. Fundam. Informaticae, 69(1-2):39–61, 2006. 3. T. Johnsson. Lambda lifting: Transforming programs to recursive equations. In FPCA, pages 190–203, 1985. 4. J. Kort. Deforestation of a raytracer. Master’s thesis, University of Amsterdam, 1996. 5. J-L. Lassez, M. Maher, and K. Marriott. Unification revisited. In Jack Minker, editor, Foundations of Deductive Databases and Logic Programming, pages 587–625. Morgan Kaufmann, 1988. 6. S. Marlow and P. Wadler. Deforestation for higher-order functions. In John Launchbury and Patrick M. Sansom, editors, Functional Programming, Workshops in Computing, pages 154–165. Springer, 1992. ISBN 3-540-19820-2.

7. S. D. Marlow. Deforestation for Higher-Order Functional Programs. PhD thesis, Univ. of Glasgow, 27 April 1995. 8. A. Ohori and I. Sasano. Lightweight fusion by fixed point promotion. In M. Hofmann and M. Felleisen, editors, Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007, pages 143–154. ACM, 2007. ISBN 1-59593-575-4. 9. W. Partain. The nofib benchmark suite of haskell programs. In John Launchbury and Patrick M. Sansom, editors, Functional Programming, Workshops in Computing, pages 195–202. Springer, 1992. ISBN 3-540-19820-2. 10. D. Sands. Proving the correctness of recursion-based automatic program transformations. Theoretical Computer Science, 167(1–2):193–233, 30 October 1996. 11. D. Sands. From SOS rules to proof principles: An operational metatheory for functional languages. In Proceedings of the 24th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL). ACM Press, January 1997. 12. J. P. Secher and M. H. Sørensen. On perfect supercompilation. In D. Bjørner, M. Broy, and A. Zamulin, editors, Proceedings of Perspectives of System Informatics, volume 1755 of Lecture Notes in Computer Science, pages 113–127. Springer-Verlag, 2000. 13. M. H. Sørensen and R. Gl¨ uck. An algorithm of generalization in positive supercompilation. In J.W. Lloyd, editor, International Logic Programming Symposium, pages 465–479. Cambridge, MA: MIT Press, 1995. 14. M. H. Sørensen, R. Gl¨ uck, and N. D. Jones. A positive supercompiler. Journal of Functional Programming, 6(6):811–838, 1996. 15. M.H. Sørensen and R. Gl¨ uck. Introduction to supercompilation. In Partial Evaluation - Practice and Theory, DIKU 1998 International Summer School, pages 246– 270, London, UK, 1999. Springer-Verlag. 16. M.H. Sørensen. Convergence of program transformers in the metric space of trees. Sci. Comput. Program, 37(1-3):163–205, 2000. 17. V. F. Turchin. The concept of a supercompiler. ACM Transactions on Programming Languages and Systems, 8(3):292–325, July 1986. 18. V. F. Turchin. Refal-5, Programming Guide & Reference Manual. Holyoke, MA: New England Publishing Co., 1989. 19. P. Wadler. Deforestation: transforming programs to eliminate trees. Theoretical Computer Science, 73(2):231–248, June 1990. ISSN 0304-3975.