When Will Deforestation Stop? A. B. Ferguson and Philip Wadler. Abstract

Transcription

1 When Will Deforestation Stop? A. B. Ferguson and Philip Wadler Abstract A compositional style of programming is often advocated by functional programmers. However, there is a certain eciency penalty involved in creating the requisite intermediate structures. Deforestation is a program transformation technique which removes such structures for some such programs. This paper is an investigation into the issues of termination of the transformation process. 1 Introduction Function composition is the basis of a style of programming practiced outside, as well as within the normal bounds of functional programming. The notion of constructing programs from a set of simple basic operations, and a collection of combining forms (sometimes richer than simple composition) is found in the imperative language APL [Ive62], is central to the strict applicative language FP [Bac77] and its successors, and is even present in the Unix shell P [Bou78], as well as in languages such as Miranda [Tur85]. n The familiar example i=1 i2 may be expressed as in APL, or similarly in Backus's FP as or (somewhat articially) as a Unix pipe: k +=(square( n (1))) (=+) ( square) (upto1 ) upto 1 n squares sum Indeed, even Prolog, a language whose syntax is at rst sight wholely uncompositional lends itself to this style: our example can be expressed sumnsquares (N ; S) :?upto (1; N ; L1); squarelist (L1 ; L2); sum (L2 ; S) Our concern is not with the presence or absence of composition operators per se, but with a programming style which treats a problem as a collection of essentially separable sub-problems to be combined to form a solution, rather than a monolithic entity whose various aspects are inextricably intertwined. Lazy functional programming may be seen as the epitome of this paradigm in many ways, and it is with this particular area that this paper will be concerned. The semantics 1

2 of a lazy language allow compositional programs to include non-terminating components, and still terminate themselves. For example, we may obtain a list of the rst n primes from one function to compute all the primes, and another to select the desired elements. Operationally, the desired piecewise generation of the linking structures is maintained by the lazy evaluation strategy (which is important due to considerations of space eciency). Our example may be written in this style as (sum map square upto 1) n in which each of the key steps (generate the rst n integers, square each, sum the result) is captured as a function, and composition is used to `glue' them together as required. Although this solution is satisfactory in terms of being correct, operationally reasonable, and clearly expressed, it has one disadvantage over a non-compositional solution: it is less ecient, due to the necessity of having to build, and immediately destroy, two intermediate lists ([1; 2; : : : ; n] and [1; 4; : : : ; n 2 ]). A program which recties this fault is: sumnsquares 0 1 n where sumnsquares a m n = if m > n then a else sumnsquares (a + square m) (m + 1) n This has the same semantics and operational behaviour, but is more ecient. Our modied solution performs exactly the same numerical computations, but eliminates all the list operations present in the original. However, it has the disadvantage of being considerably less clear. The ideal solution would be to allow the programmer to write the former version, but have an automated assistant produce the latter. If a suitably simple characterisation of a set of sucient preconditions can be arrived at, the details of the transformation can be hidden entirely inside a compiler, with the programmer able to reason about the eciency of the resulting code independently if this becomes necessary. This is what was done in this paper's immediate ancestor [Wad87b]; here we will present a reformulation of some of the same material, which will facilitate our main result, concerning termination of the transformation. We shall present the following: Section 2.1 { The language used Section 2.2 { Treeless Form : a description of a form of program which is free from intermediate structures Section 2.3 { Restricted Treeless Form : a subset of the above Section 2.4 { The Deforestation Theorem : a condition sucient to guarantee the desired behaviour of the algorithm Section 2.5 { The Deforestation Algorithm : an algorithm to produce a treeless program from treeless components 2

3 Section 2.6 { Termination : a proof Section 3 { Related Work Section 4 { Conclusion 2 An Alternative View of the Deforestation Algorithm 2.1 Language Consider a language with terms t ::= v (variable) j c t1 : : : t n (constructor) j f t1 : : : t n (function application) j g t0 : : : t n (function with pattern match) and function denitions or f v1 : : : v n = t g p1 v1 : : : v n =. t1 g p m v1 : : : v n = t m where p ::= c v1 : : : v k This describes a rst order language, with functions possibly involving the matching of a single simple pattern (i.e. only one constructor deep). Compilation to such a form requires only well known techniques, being essentially equivalent to compiling to simple case expressions [Aug85, Wad87a]. (The key step is replacing a pattern match several constructors deep with a corresponding number of simple pattern matches, introducing appropriate new functions.) The intended semantics is the usual normal order reduction of the lambda calculus. Pattern matching, however, is strict: when a pattern matching function is applied, the rst argument is evaluated to head normal form before the body is entered. Figure 1 shows some sample denitions. 2.2 Treeless Form A term is treeless if it is linear (no variable may appear more than once) and conforms to the following grammar: tt ::= v j c tt1 : : : tt n (constructors applied to anything treeless) j f v1 : : : v n (only variables occur as arguments) j g v0 : : : v n (pattern match only on a variable) 3

4 ip (Leaf n) = Leaf n ip (Branch t1 t2) = Branch (ip t2 ) (ip t1 ) seconds Nil = Nil seconds (Cons x xs) = Cons x (seconds 0 xs) seconds 0 Nil = Nil seconds 0 (Cons x xs) = seconds xs thirds Nil = Nil thirds (Cons x xs) = Cons x (thirds 0 xs) thirds 0 Nil = Nil thirds 0 (Cons x xs) = thirds 00 xs thirds 00 Nil = Nil thirds 00 (Cons x xs) = thirds xs Figure 1: Sample denitions where each f or g is a treeless function denition: that is, the rhs of the denition of an f, and each rhs of the denition of a g, is a restricted treeless term. The linearity restriction is required so as to ensure that functions may be unfolded without risk of duplicating work. The grammar requires that terms be at most a single function deep, and constrains functions (and hence case analyses) to variables only. This prevents a previously computed value being passed to a function, and so there is no possibility of the function examining such a value, thus having the eect of disallowing intermediate structures. Note that treelessness is an intensional, not an extensional, property of a function: for any given treeless function denition, a non-treeless version may be contrived which is equivalent in all respects save eciency; unfortunately the converse is not true. For example, atten 1 and atten 2 (gure 2) are respectively non-treeless and treeless denitions of the same function. (Note, however that there is little dierence in terms of actual eciency; the apparent intermediate structure in the rst is never actually examined, but instead is incorporated directly into the result.) Functions for which no treeless denitions exist include reverse, because of the need for a structure to accumulate the segment of the list reversed so far, but not available for output; and attening a tree into a list of its nodes, this being due to the particular nature of the treeless form we require, which means that although the denition tatten (Leaf n) l = Cons n l tatten (Branch t1 t2 ) l = tatten t1 (tatten t2 l) involves no data structure operations other than those for input and output, it is not considered treeless. 4

5 atten 1 Nil = Nil atten 1 (Cons xs xss) = append xs (atten 1 xss) atten 2 Nil = Nil atten 2 (Cons xs xss) = atten 0 2 xs xss atten 0 2 Nil xss = atten 2 xss atten 0 2 (Cons x xs) xss = Cons x (atten 0 2 xs xss) Figure 2: Alternative denitions of atten This is similarly true for the linearity requirement: for example the term x + x is non-treeless, and x 2 a treeless equivalent. Clearly terms such as copy x = Pair x x have no linear equivalents. 2.3 Restricted Treeless Form In order to present our main result, we will make a number of further restrictions on the terms we will consider as terms suitable for deforestation. These seem somewhat arbitrary at rst, and are indeed motivated by technical considerations pertaining to the proof, but fortunately none involve any actual loss of power. We are at present unsure as to whether any of the restrictions are important in practice; some may be necessary preconditions for termination of our transformation, or it may transpire that they are purely artifacts of the formalism we have chosen. Firstly, we introduce the notion of a restricted treeless term: rtt ::= rtt 0 j rtt 0 ::= v j j c rtt 0 1 : : : rtt 0 n f v1 : : : v n g v0 : : : v n where right hand sides of the denition of each f or g are restricted treeless terms. This denes the subset of treeless terms containing only a single constructor (with that being outermost, as already required). In a sense, this is a symmetrical restriction to the requirement present in the original grammar that patterns be only one constructor deep, in the respect that when a function (pattern-matching or otherwise) is nested inside a pattern-matching function, constructors are `consumed' no more slowly than they are `produced'. It is easy to see that this restriction involves no loss of generality, as any term may be made to conform to it by introducing a new function denition for each sub-term starting with a constructor which appears where one is disallowed (that is, in t 0 terms of the grammar). Also, rather than attempting to treat general terms we shall consider only function terms (that is, those with no constructors) as being suitable input for our deforester, as 5

6 follows: ft ::= v j f ft 1 : : : ft n j g ft 0 : : : ft n This restriction clearly also involves no loss of generality: any term admitted by the more general schema can be converted to such a form by replacing each constructor with a suitably dened function. 2.4 The Deforestation Theorem Theorem: A linear term comprised of functions with treeless denitions may be eectively transformed to an equivalent term, in treeless form, which will be no less ecient. We shall not prove our claim about eciency, but instead appeal to the informal argument that we will produce a program no more folded than the original, and that the linearity condition ensures that where we unfold, we do not worsen eciency. Treelessness is seen rather easily by inspection of our transformation rules. We shall present a proof about the size of terms encountered by the transformer, and then argue that this is sucient to ensure termination. In fact, the transformed term will be strictly more ecient, provided the original required an intermediate structure. This is in the sense of a `real' intermediate structure, one which is built and then destroyed internally, as opposed to one which is constructed, and then passed to a function which does not re-examine it. For example, atten 1 has already been cited as a non-treeless function denition which is no less ecient than its treeless equivalent. Our theorem requires that all the constituent functions already have treeless denitions: this precludes the deforestation of recursive or mutually recursive function denitions. Note that if we remove the restriction on linearity, a weaker property still holds: terms may still be eectively transformed, but the resulting terms may be less ecient, and may of course themselves be non-linear. Examples: ip (ip t) and seconds (thirds l) are suitable candidates for transformation, according to the preconditions of the theorem; their deforested equivalents are shown in gure 3. The second example illustrates one questionable feature of deforestation: the resulting program can be substantially larger than the original. Here the treeless program is proportional in size to the product of the sizes of the original functions (including the auxiliary functions for each). If we were to transform a similar program consisting of n nested applications of the function selecting every m th element of a list (a program of size proportional to n + m), the resultant program would be of size proportional to m n. This exponential growth seems to suggest that programs might become unacceptably large after being deforested: we consider this to be unlikely in practise, and expect only modest growth in program size, which would not constitute any particular drawback. (This aspect of deforestation bears a passing resemblance to ML typechecking, which can be shown to be of PSPACE-complete time complexity, but which is not in practice found to 6

7 ip (ip t) transforms to: seconds (thirds l) transforms to: g t where g (Leaf n) = Leaf n g (Branch t1 t2 ) = Branch (g t1) (g t2 ) g1 l where g1 Nil = Nil g1 (Cons x xs) = Cons x (g2 xs) g2 Nil = Nil g2 (Cons x xs) = g3 xs g3 Nil = Nil g3 (Cons x xs) = g4 xs g4 Nil = Nil g4 (Cons x xs) = g5 xs g5 Nil = Nil g5 (Cons x xs) = g6 xs g6 Nil = Nil g6 (Cons x xs) = g1 xs Figure 3: Results of transforming two terms be at all inecient. Our problem is of course worse: the time complexity of deforestation is explicitly exponential!) It is an open question as to how often we may expect to nd terms suitable for transformation; it is certainly the case that most programs of signicant size will have at least portions which are non-linear, or where a recursive function is dened by a compositional term, preventing us from synthesising treeless denitions for such components. It is hoped that linear, non-recursive sub-terms will prove to be suciently common to allow the transformation of a signicant proportion of the terms present in a program. 2.5 The Deforestation Algorithm We will now give a set of transformation rules which will convert a term into a treeless equivalent. We shall assume that the term satises the preconditions of the deforestation theorem; that is, it consists of a linear composition of treeless functions. This requires of a practical transformer that treeless denitions be produced for all a term's components beforehand, and of course if the term is recursive, it will not be possible to do so. 7

8 T [[v]] = v (1) T [[c t1 : : : t n ]] = c (T [[t1]]) : : :(T [[t n ]]) (2) T [[ f t1 : : : t n ]] = T [[ t[t1=v1; : : : ; t n =v n ] ]] where f is dened by (3) f v1 : : : v n = t T [[ g (c t 0 1 : : : t 0 m) t1 : : : t n ]] = T [[ t[t1=v1; : : : ; t n =v n ; t 0 1=u1; : : : t 0 m=u m ] ]] (4) where g has a dening equation g (c u1 : : : u m ) v1 : : : v n = t T [[ g v0t1 : : : t n ]] = let g 0 p1v 0 1 : : : v 0 m = T [[ g p1t1 : : : t n ]]. g 0 p m v 0 1 : : : v 0 m = T [[ g p m t1 : : : t n ]] in g 0 v0v 0 1 : : : v 0 m where g is dened by g p1v1 : : : v n = t 0 1. g p m v1 : : : v n = t 0 m and v 0 1 : : : v 0 m = vars ( g v0t1 : : : t n )? v0 (5) For correctness, we must have that Figure 4: Transformation Rules T [[t]] = t 0 ) E[[t]] = E[[t 0 ]] where E[[t]] denotes the semantic function on terms, and T [[t]] denotes the transformation: that is, transformed term and original must compute the same value. Use t to denote a context of nested pattern matching functions, as follows: t ::= t j g ( t ) t1 : : : t n where g is some pattern matching function. For example, the expression ip (ip t) is such a context for the term t (for the given denition of ip), as is t itself. The rules for the transformation are shown in gure 4. The transformation rules essentially use case analysis on the leftmost syntactic construct which is not a pattern-matching function: there are two cases for a leftmost variable, depending on whether it occurs at the outermost level or not, and likewise for constructors; only a single case for a non pattern-matching function is required when that occurs 8

9 leftmost. An innite chain of pattern matches is not possible, the input terms being nite, so a construct other than a pattern-matching function must occur somewhere. Observe rst of all that the cases given are exhaustive, since an outermost variable or constructor is covered by the rst two rules; a variable or constructor nested inside any number of pattern matching functions is covered by the last two; and a non-pattern matching function, nested or otherwise, is covered by rule (3). Secondly we note that the transformation preserves equivalence: the rst two rules do not alter the basic form of the expression; the third and fourth are simply unfold steps; and the last performs instantiation of a pattern match, by transforming the expression with each of the possible patterns in turn, and generating a new function to perform case analysis on the instantiated variable. This last possibility is valid due to the strictness of the pattern matching, which ensures that a chain of pattern matches will necessarily require matching against the innermost pattern. Also, everything produced by this transformation will be in treeless form, since each rule rhs is treeless under the assumption that the recursive calls result in treeless terms: in rule (1) the result is a variable; in rule (2) a constructor is applied to the results of further transformation, and so will be treeless provided the transformed components are; the unfold steps give terms to be further transformed en masse; the fth rule results in a function call with all-variable arguments, with rhs's being the results of further transformation. Note that although the inputs are in restricted treeless form, the output is not: it is a general treeless term. This is because our rule for dealing with constructors may well emit several consecutively; we could alter the rules to prevent this, but this seems unnecessary (and possibly undesirable, since this would result in a more folded, and hence less ecient term). However this does mean that when we are recursively transforming a term, by rst deforesting its components, we must convert our result to the restricted form, as described above. The result of this transformation, is however not necessarily nite. For example, consider the transformation of the term ip (ip t), shown in gure 5. The transformation rules are applied until we obtain two sub-problems which are renamings of the original. What we should do now is fold, replacing each instance of the terms to be transformed with a call to the function already introduced. In general, however, it is necessary to introduce new functions, as the recurring term may not coincide with a pattern-matching function already introduced, so our policy will be to introduce new function denitions for terms which appear more than once, and use these to fold the potentially innite term. Clearly it is not possible to do this with the transformation rules as they stand, as a function to fold the recurring terms as they are output would not be computable, requiring as it would equality over innite and non-total objects. The problem is that in unfolding we have thrown away the information we require to eectively compare terms. We can however retain this information by labelling each unfold with the corresponding function call, as shown in gure 6. We now introduce the function shown in gure 7. (Note that the construct e as p is used to refer to an argument both as a meta-variable, and by pattern-matching.) The function F folds the potentially innite term output by the labelled transformation rules to a nite version by noting the terms already encountered by the transformer, in 9

10 T [[ip (ip t)]] = g t where g (Leaf n) = T [[ip (ip (Leaf n))]] g (Branch t1 t2) = T [[ip (ip (Branch t1 t2))]] (By 5) T [[ip (ip (Leaf n))]] = T [[ip (Leaf n)]] (By 4) = T [[Leaf n]] (By 4) = Leaf n (By 2, 1) T [[ip (ip (Branch t1 t2 ))]] = T [[ip (Branch (ip t2 ) (ip t1 ))]] (By 4) = T [[Branch (ip (ip t1 )) (ip (ip t2 ))]] (By 4) = Branch (T [[ip (ip t1 )]]) (T [[ip (ip t2 )]]) (By 2) T [[ip (ip t)]] = g t where g (Leaf n) = Leaf n g (Branch t1 t2 ) = Branch (g t1 ) (g t2 ) Figure 5: Steps in the transformation of ip (ip t) the form of a set of function denitions. When re-encountering (a renaming of) such a term, we fold this subsequent occurrence with the appropriate denition. To see that this function preserves treelessness, note that each of the equation rhs's is a (general) treeless term under the assumption that each recursive call yields a treeless result. While this corresponds reasonably closely to the basic notion of folding outlined initially, note that this function is based on weak intensional equality over terms, rather than strong extensional equality. That is, we identify terms when they are syntactically equivalent, rather than attempting to see if they compute the same result. Whenever our original term satises the preconditions of the Deforestation Theorem, we will be able to produce a term folded to be nite, and the folding process may terminate even if this is not the case. For instance, the function atten 1 is not a simple composition of treeless terms, but here the Deforestation Algorithm does terminate; when this occurs for linear programs, the result will still be treeless, by the above argument. Termination will not occur in general: certainly for any linear program with no treeless equivalent, our transformation will be non-terminating. If a program is non-linear, but conforms to our grammar for transformable terms, the transformation will terminate, but the output may not be treeless, as well as possibly less ecient. The test for inclusion in the set of denitions, d 2 R ds, uses the normal rules for set membership, but based on equality up to renaming of bound variables. x 2 R fg ^= False (f v1 : : : v n = t) 2 R ff 0 v 0 1 : : : v 0 m = t 0 g ^= False; if f 6= f 0 (f v1 : : : v n = t) 2 R ff v 0 1 : : : v 0 n = t 0 g ^= t = [v1=v 0 1; : : : ; v n =v 0 n]t 0 x 2 R a [ b ^= (x 2 R a) _ (x 2 R b) 10

11 T [[v]] = v (1) T [[c t1 : : : t n ]] = c (T [[t1]]) : : :(T [[t n ]]) (2) T [[e as f t1 : : : t n ]] = Label e T [[ t[t1=v1; : : : ; t n =v n ] ]] where f is dened by (3) f v1 : : : v n = t T [[e as g (c t 0 1 : : : t 0 m) t1 : : : t n ]] = Label e T [[ t[t1=v1; : : : ; t n =v n ; t 0 1=u1; : : : t 0 m=u m ] ]] (4) where g has a dening equation g (c u1 : : : u m ) v1 : : : v n = t T [[ g v0t1 : : : t n ]] = let g 0 p1v 0 1 : : : v 0 m = T [[ g p1t1 : : : t n ]]. g 0 p m v 0 1 : : : v 0 m = T [[ g p m t1 : : : t n ]] in g 0 v0v 0 1 : : : v 0 m where g is dened by g p1v1 : : : v n = t 0 1. g p m v1 : : : v n = t 0 m and v 0 1 : : : v 0 m = vars ( g v0t1 : : : t n )? v0 (5) Figure 6: Labelled Transformation Rules 11

12 F [[v]] ds = v F [[c t1 : : : t n ]] ds = c (F [[t1]] ds) : : : (F [[t n ]] ds) F let g p1u1 : : : u n = t1 in g p m u1 : : : u n = t m g u0u1 : : : u n = let g p1u1 : : : u n = F [[t1]] ds in ds. g p m u1 : : : u n = F [[t m ]] ds g u0u1 : : : u n F [[Label l t]] ds = f v1 : : : v k ; if (f v1 : : : v k = t) 2 R ds = let f 0 v1 : : : v k = F [[t]] (ff 0 v1 : : : v k = tg [ ds) in f 0 v1 : : : v k where f 0 is a new function name v1 : : : v k = vars t Figure 7: Function for folding labelled terms 12

13 2.6 Proof of Termination We can observe from gure 5 that in the course of the transformation the number of functions remains the same, while at most one constructor is present at any stage; in fact this is also true of our other example, seconds (thirds l) (although we have not shown the steps), which is interesting in view of the exponential growth of the resulting program. This gives us some notion as to how to proceed with the proof. We shall show that there exists a bound on the size of the terms produced by recursive calls to the transformer relative to that of the original term. Any measure will suce, so long as it itself bounds the size of terms in some way. Thus, since a nite alphabet of symbols is used, terms will eventually re-occur, and will be folded to produce a nite result. As a rst step, we observe that for any composition of treeless functions, the transformation steps do not increase the depth in functions (the nesting). This is intuitively clear from the observation that unfolded function bodies are themselves only a single function deep. Dene nesting as follows: N [[v]] = 0 N [[c t1 : : : t n ]] = max f(n [[t1]]) : : : (N [[t n ]])g N [[f t1 : : : t n ]] = 1 + max f(n [[t1]]) : : :(N [[t n ]])g N [[g t1 : : : t n ]] = 1 + max f(n [[t0]]) : : :(N [[t n ]])g A comment of the strategy employed here: nesting is not, of itself, a measure which bounds the size of terms, as our measure ignores constructors and counts only nonconstructor functions, although a measure which counted both clearly would. We choose the former as it would not be straightforward to show a bound on such a measure directly, as the relationship between the numbers of constructors and the numbers of other functions is not as clear as the bound we may obtain of the quantities considered separately. Thus we postpone our treatment of constructors until our second lemma. Lemma 1: After a given number of transformation steps, the remaining terms to be transformed will have a nesting at most that of the original term. Proof: Assume Lemma holds for some n 0 steps. We require to prove that a further step will not increase nesting, showing Lemma holds for n + 1 steps, sucient for result for any number of steps. Prove: for each transformation step T [[t]] = : : : T [[t i ]] : : :, Case (1) v : nothing to prove 8i N [[t i ]] N [[t]] Case (2) c t1 : : : t n : From the denition, N [[c t1 : : : t n ]] = max fn [[t1]] : : : N [[t n ]]g therefore N [[t i ]] N [[c t1 : : : t n ]] 13

14 Case (3) (f t1 : : : t n ) ; where f v1 : : : v n = t : From the denition : N [[f t1 : : : t n ]] = 1 + max fn [[t1]] : : : N [[t n ]]g Since f is treeless, N [[t]] 1 N [[t]] + max fn [[t1]] : : : N [[t n ]]g N [[t[t1=v1; : : : ; t n =v n ]]] Therefore, adding the context to each side: N [[ t[t1=v1; : : : ; t n v n ] ]] N [[ (f t1 : : : t n ) ]] Case (4) (g (c t 0 1 : : : t 0 m) t1 : : : t n ) : where t = g (c v 0 1 : : : v 0 m) v1 : : : v n From the denition, N [[g (c t 0 1 : : : t 0 m) t1 : : : t n ]] = 1 + max fn [[t1]] : : :N [[t n ]]; N [[t 0 1]] : : : N [[t 0 m]]g g is treeless, so N [[t]] 1, N [[t]] + max fn [[t1]] : : : N [[t n ]]; N [[t 0 1]] : : : N [[t 0 m]]g N [[t[t1=v1; : : : ; t n =v n ; t 0 1=v 0 1; : : : t 0 m=v 0 m]]] (by an obvious property of substitution) Adding the context: N [[ t[t1=v1; : : : ; t n =v n ; t 0 1=v 0 1; : : : t 0 m=v 0 m] ]] N [[ (g (c t 0 1 : : : t 0 m) t1 : : : t n ) ]] Case (5) (g v t1 : : : t n ) : From the denition: N [[g v t1 : : : t n ]] = 1 + max fn [[t1]] : : : N [[t n ]]g Using the denition again, = N [[g (c v 0 1 : : : v 0 m) t1 : : : t n ]] for all patterns c v 0 1 : : : v 0 m Adding the context: N [[ (g (c v 0 1 : : : v 0 m) t1 : : : t n ) ]] N [[ g v t1 : : : t n ]] Thus we have proved that the nesting of terms to be transformed is never increasing, and is therefore bounded. Further, the number of constructors in the terms encountered to be recursively transformed is at most one. To see this informally, observe that the original term t has none, as it is simply a composition of (non-constructor) functions, and that none of the rules increase number of constructors apart from (3) and (5). However, these rules will only be applied when there are no constructors in the expression, since in each case the subexpressions of the redex contain no constructors. This is trivially true for (3) { no subexpressions { and can be seen to be true for rule (5) as well since constructors are always on the outside of an unfolded term, and cannot be contained within a redex. 14

15 Dene: ct ::= (c ft 1 : : : ft n ) fct ::= ft j ct where t is a context of pattern-matching functions, as before, but with the occurrences of general terms replaced by function terms: i.e. t ::= t j g ( t ) ft 1 : : : ft n Note that although this assumption would seem to limit the applicability of our rules, the next lemma, together with our restriction to input terms which conform to the grammar ft, indicates that they remain exhaustive. The grammar fct denes terms having at most one constructor, and if one is present, occurring nested within only pattern-matching functions; thus any constructor in the term lies at the position of the `redex'. Lemma 2: After a given number of transformation steps, the terms remaining to be transformed will conform to the grammar fct. Proof: Again, assume Lemma holds for some n 0 steps, and prove that a further step will not falsify the desired property, showing Lemma holds for n + 1 steps, sucient for result for any number of steps. Prove: for each transformation step T [[t]] = : : : T [[t i ]] : : :, Case (1) v : nothing to prove 8i t 2 fct ) t i 2 fct Case (2) c t1 : : : t n : c t1 : : : t n 2 fct ) c t1 : : : t n 2 c ft 1 : : : ft n (matches ct case, with null context) ) t i 2 ft i ) t i 2 fct Case (3) (f t1 : : : t n ) ; where f v1 : : : v n = t : (f t1 : : : t n ) 2 fct ) (f t1 : : : t n ) 2 ft (f inside context matches ft) ) t i 2 ft Since f is treeless, t 2 tt ) t 2 fct ) t[t1=v1; : : : ; t n =v n ] 2 fct (since an ft is allowed anywhere a v is) 15

16 Case (4) (g (c t 0 1 : : : t 0 m) t1 : : : t n ) ; where g (c v 0 1 : : : v 0 m) v1 : : : v n ) = t : (g (c t 0 1 : : : t 0 m) t1 : : : t n ) 2 fct ) t i 2 ft; t 0 i 2 ft Since g is treeless, t 2 tt ) t 2 fct ) t[t1=v1; : : : ; t n =v n ; t 0 1=v 0 1; : : : ; t 0 m=v 0 m] 2 fct (similar to above) Case (5) (g v t1 : : : t n ) : (g v t1 : : : t n ) 2 fct ) (g v t1 : : : t n ) 2 ft ) (g (c v 0 1 : : : v 0 m) t1 : : : t n ) 2 ct ) (g (c v 0 1 : : : v 0 m) t1 : : : t n ) 2 fct So having initial term t 2 fct means that for all terms t 0 to be transformed subsequently, t 0 2 fct and thus each has at most one constructor. The bound on nesting, together with the the above result about constructors, means that terms are bounded in size, and for a nite alphabet of symbols, there are only nitely many such terms. To see that we do indeed have only nitely many symbols, notice that our equality test identies all variables, and although we do make up new function names, these are never incorporated into the terms we recursively transform, and only appear directly in the output. Thus, in eect, our set of symbols is simply the function names in the original program, which is clearly bounded. This further guarantees that when we attempt to collapse the generated term, only nitely many sub-terms will be encountered before all remaining ones are renamings of some of their forerunners, and so will be all folded to appropriately introduced denitions. 3 Related Work As already noted, this paper is the successor to the initial work on deforestation [Wad87b]. Another relative of this paper is the work on listlessness [Wad84, Wad85], which is concerned specically with the elimination of intermediate lists, and is not a source-to-source transformation, but gives a non-functional result. Listlessness does allow non-linear functions (that is, a list may be traversed more than once, e.g. the mean calculation sum l =length l), and is higher-order, unlike the present transformation (although extensions are envisaged). Torben Mogensen suggests an interesting variant on deforestation: removing intermediate structures from Prolog programs. If we restrict our attention to a subset of the language excluding meta-logical constructs, then in principle fold-unfold transformations are valid. 16

17 4 Conclusion The claim has been made that Deforestation would be a suitable candidate for inclusion in an advanced compiler for a functional language, after the fashion of the many program transformations employed in the LML compiler ([Aug87, Joh87]). In order for this to be convincing, we must be assured of termination; that is what, by means of a reformulation, we have established here. Our reformulation may have other benets: anyone who has tried to transform terms by hand using the old formulation using case-expressions will realise that for some programs the size of sub-terms to be transformed becomes rather large; this is because that version of the transformation operates on terms which are, in a sense, maximally unfolded, meaning that functions with cases are unfolded before anything protable may be done with them. By not unfolding these until it becomes appropriate, the version presented here keeps the term size as small as possible. Not only does this make hand transformations less painful, but much more signicantly for our purposes, it is likely to be somewhat less wasteful of space when automated. References [Aug85] L. Augustsson, Compiling pattern matching. In Proceedings of the Conference on Functional Programming Languages and Computer Architecture, Nancy, France, September LNCS 201, Springer-Verlag, [Aug87] L. Augustsson, Compiling lazy functional languages, Part II. Ph.D. dissertation, Department of Computer Science, Chalmers Tekniska Hogskola, Goteborg, Sweden, [Bac77] J. Backus, Can Programming Be liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs Turing Award Lecture, Communications of the ACM, Volume 21, Number 8. [Bou78] S. R. Bourne, \UNIX Time-Sharing System: The Unix Shell". In Bell Sys. Tech. J. 57(6) [Ive62] K. Iverson, A programming Language, Wiley, New York, [Joh87] T. Johnsson, Compiling lazy functional languages. Ph.D. dissertation, Department of Computer Science, Chalmers Tekniska Hogskola, Goteborg, Sweden, [Tur85] D. A. Turner, Miranda: A non-strict functional language with polymorphic types. In Proceedings of the Conference on Functional Programming Languages and Computer Architecture, Nancy, France, September LNCS 201, Springer-Verlag, [Wad84] P. L. Wadler, Listlessness is better than laziness: Lazy evaluation and garbage collection at compile-time. In Proceedings of the ACM Symposium on Lisp and Functional Programming, Austin, Texas, August

18 [Wad85] P. L. Wadler, Listlessness is better than laziness II: Composing listless functions. In Proceedings of the Workshop on Programs as Data Objects, Copenhagen, October LNCS 217, Springer-Verlag, [Wad87a] P. L. Wadler, Ecient compilation of pattern-matching. In The Implementation of Functional Programming Languages, Prentice Hall, 1987, S. L. Peyton Jones. [Wad87b] P. L. Wadler, Deforestation: Transforming programs to eliminate trees. European Symposium On Programming (ESOP), Nancy, France, March