John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Programming, pages 1--10, Pittsburgh, Pennsylvania, August 1982. ACM Press.  Home/Search   Document Not in Database   Summary   Related Articles   Check

....as depicted in figure 3.2. As the expression h 4 is hidden in the definition of the supercombinator M, h 4 will be evaluated each time M is applied i.e. twice. Again, one can do better: one can modify the lambda lifting algorithm so it abstracts away the maximal free expressions, as done in [Hug82] Then the resulting supercombinator program will be fully lazy in the sense that it has the same sharing properties as the original # expression when evaluated by a fully lazy implementation. Now E is translated into (as the maximal free expression h 4 is abstracted away from the definition of ....

John Hughes. Super combinators - a new implementation method for applicative languages. In ACM Symposium on Lisp and Functional Programming, Pittsburgh, pages 1--10, 1982.

....third problem are not solved its advantages in solving the fourth problem are such that it is still considered an attractive approach. In this section we will describe a compiler for lambda expressions to supercombinator code in terms of higher order attribute grammars. The algorithm is based on [Hughes 82] The basic idea of a super combinator is to define for each function which refers to global variables, an equivalent function to which the global variables are being passed explicitly. The resulting function is called a combinator, because it does not contain any free variables any more. At the ....

Hughes, R.J.M. Super-combinators: A New Implementation Method for Applicative Languages. In Proc. ACM Symp. on Lisp and Functional Progr., Pittsburgh, 1982.

....for future visits. Bindings computed by earlier visits are passed as an extra parameter to visit functions. The visit functions can be implemented in any imperative or functional language. Furthermore, visit functions have no free variables and can therefore be viewed as supercombinators [Hughes 82] Efficient caching is partly achieved by efficient equality testing between parameters of visit functions, which are trees, inherited attributes and bindings. Therefore, hash conslng for trees and bindings is used, so testing for equality between trees and between bindings is reduced to a fast ....

Hughes, R.J.M. Super-combinators: A New Implementation Method for Applicative Languages. In Proc. ACM Symp. on Lisp and Functional Progr., Pittsburgh, 1982. 14

....power induced by block structure and lexical scope. However block structure and lexical scope are not essential: in the mid 80 s, Hughes, Johnsson, and Peyton Jones showed how to lambda lift any block structured program into recursive equations, which can then be eciently compiled on the G machine [5, 6, 9]. Since then, lambda lifting has had its ups and downs: it is used for example in at least one compiler and two partial evaluators for the Scheme programming language [1, 2, 3] in an unpublished note, Down with Lambda Lifting [7] Meijer severely criticizes it; and it is no longer ....

....but scope insensitive, except for the names of the (ex )recursive equations, of course. We make it scope sensitive by preventing each function from passing variables whose end use is lexically visible. A simple example: Figure 1 displays the power function in ML. Many other examples exist [2, 4, 5, 6, 9, 10] but this one is simple and illustrative enough. One of its parameters is inert, i.e. it does not change through the recursive calls. The lambda lifted version carries the inert argument through each recursive call. The lambda dropped version does not, making it instead a free variable in the ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the

....have done here is to derive it using our rewriting account of partial evaluation. In particular, the resulting term need no post processing (such as erasing remaining annotations) Even systems with higher order types can be handled by first reducing the type order with supercombinator extraction [12], which one could call meta lifting since it is targeted at lifting out all higher order applications of . This is, in fact, what we did with the tree flattening Example 3.2.2, and what we use in the following general construction. Proof of Theorem 4.3.3. 14 Case ) Given the two level ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the

....lambda lifted or lambda dropped. For example, recursive equations can be eciently implemented on the Gmachine. This led Hughes, Johnsson, and Peyton Jones, in the mid 80 s, to devise lambda lifting as a meaning preserving transformation from blockstructured programs to recursive equations [21, 23, 34]. Recursive equations also o er a convenient format in Mix style partial evaluation [26] Indeed, modern partial evaluators such as Schism and Similix lambda lift source programs before specialization [9, 11] As a result, residual programs are also expressed as recursive equations. If ....

....uncurried and eager programs Johnsson concentrated on lambda lifting towards mutually recursive equations [23] but alternative approaches exist. The rst seems to be Hughes s supercombinator abstraction, where recursion is handled through self application and full laziness is a point of concern [21]. Peyton Jones provides a broad overview of fully lazy supercombinators [33, 34, 35] Essentially, instead of lifting only free variables, one lifts maximally free expressions. Fully lazy lambda dropping would amount to keeping maximally free expressions instead of identi ers in the initial calls ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, 54 Conference Record of the

....have a procedure with ten parameters, you probably missed some. Yet recursive equations can be efficiently implemented. This led Hughes, Johnsson, and Peyton Jones, in the mid 80 s, to devise a meaningpreserving transformation from block structured programs to recursive equations: lambda lifting [18, 19, 28]. We review lambda lifting in Section 2. Recursive equations also offer a convenient format in Mix style partial evaluation [22] Modern partial evaluators such as Schism and Similix lambda lift source programs before specialization [8, 10] lambda lifting As a result, residual programs ....

....and eager programs Johnsson concentrated on lambda lifting towards mutually recursive equations [19] but alternative approaches exist. The first one seems to be Hughes s supercombinator abstraction, where recursion is handled through self application and full laziness is a point of concern [18]. Peyton Jones provides a broad overview about fully lazy supercombinators [27, 28, 29] Essentially, instead of lifting only free variables, one lifts maximally free expressions. Fully lazy lambda dropping would amount to keep maximally free expressions instead of identifiers in the initial calls ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the

....lambda lifted or lambda dropped. For example, recursive equations can be e#ciently implemented on the Gmachine. This led Hughes, Johnsson, and Peyton Jones, in the mid 80 s, to devise lambda lifting as a meaning preserving transformation from blockstructured programs to recursive equations [21,23,34]. Recursive equations also o#er a convenient format in Mix style partial evaluation [26] Indeed, modern partial evaluators such as Schism and Similix lambda lift source programs before specialization [9,11] source block structured program lambda lifting ## source recursive equations ....

....uncurried and eager programs Johnsson concentrated on lambda lifting towards mutually recursive equations [23] but alternative approaches exist. The first seems to be Hughes s supercombinator abstraction, where recursion is handled through self application and full laziness is a point of concern [21]. Peyton Jones provides a broad overview of fully lazy supercombinators [33 35] Essentially, instead of lifting only free variables, one lifts maximally free expressions. Fully lazy lambdadropping would amount to keeping maximally free expressions instead of identifiers in the initial calls to ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the

.... the program to a fixed set of combinators (closed lambda terms all of whose abstractions are at the head) these may be thought of as graph rewriting rules [123] Later it was shown to be beneficial to let the program under consideration guide the choice of combinators (so called supercombinators) [62]. In his seminal paper [123] David Turner describes the SK machine to support the implementation of SASL. The compiler is based on the equivalence between combinatory logic [113] and the # calculus [40] It generates code for what is essentially a two 744 S. Diehl et al. Future Generation ....

R.J.M. Hughes, Super-combinators: A new implementation method for applicative languages, ACM Symposium on Lisp and Functional Programming, Pittsburgh, Pennsylvania, ACM, August 1982, pp. 1--10.

....proposed. The compiler can use either a fixed set of combinators or program derived combinators. As argued in [9] a fixed set of combinators provides the finest granularity of computation, while program derived combinators can provide a more appropriate level of granularity. Supercombinators [13] are program derived combinators designed for sequential evaluation. Hudak presents serial combinators as an alternative suitable for parallel evaluation. His main criterion for serial combinators are: 1. They have no subexpressions that can be executed in parallel; thus, no available parallelism ....

R.J.M. Hughes, "Super-combinators: A new implementation method for applicative languages, " in ACM Symp. on Lisp and Functional Prog., 1982, pp. 1-10.

....delayed as long as possible by representing subterms of common origin by identical subgraphs. This way all duplicates profit from any reductions happening to that particular subterm (or graph, as it were) This technique was combined with combinator reduction by Turner (1979) and generalized by Hughes (1982) into supercombinator graph reduction which is the computational model underlying most implementations of functional languages today. The second issue, evaluation sequence, was addressed partly by Plotkin (1975) who identified the difference between the evaluation sequence or reduction strategy ....

Hughes, J. M. (1982), Super-combinators: A new implementation method for applicative languages, in `1982 ACM Symposium on LISP and Functional Programming', Pittsburgh, Pensylvania, pp. 1--10.

....of functional programming languages. Its task is to close local function definitions by parameterizing them over their free variables. Once all functions have been closed in this way (turned into combinators) they are moved to the top level where the compiler generates efficient code for them [9]. Lambda lifting is also a key transformation in program specializers, because it increases code sharing of specialized functions [4] The intention is that the specializer runs at most once for every pair of source function and specializationtime arguments. A log keeps track of the started ....

....but is not directly applicable to strict languages. The main difference between the two algorithm lies in the order in which they apply the elementary transformations and which restrictions they impose. The basic idea of Peyton Jones s algorithm is close enough to the remaining algorithms [9, 19, 20] that we do not have to consider them separately. In the following sections, we formalize the elementary transformation steps of lambda lifting, we examine their typing properties in an ML style type system, and we outline a refined lambda lifter that overcomes the typing problems. Our algorithm ....

R. J. M. Hughes. Super-combinators: A new implementation method for applicative languages. In ACM Symposium on LISP and Functional Programming, Pittsburgh, Pennsylvania, 1982. ACM Press.

....Evaluation (or Mixed Computation) technique [Ershov 82, Jones et al. 93] and 3. the Finite Differencing technique [Paige Koenig 82] and compare them with the strategies we have considered above. For other methods, such as: i) combinatory techniques [Turner 79] ii) supercombinator methods [Hughes 82] iii) local recursions [Bird 84a] iv) promotion strategies [Bird 84b] v) lambda liftings [Johnsson 85] and vi) lambda hoistings [Takeichi 87] we suggest to look at the original papers. There are some other techniques which have been proposed in the literature for transforming functional and ....

Hughes, R. J. M.: Super-combinators a New Implementation Method for Applicative Languages. Proc. 1982 ACM Symposium on Lisp and Functional Programming, Pittsburgh, PA, USA (1982) 1--10

....have done here is to derive it using our rewriting account of partial evaluation. In particular, the resulting term need no post processing (such as erasing remaining annotations) Even systems with higher order types can be handled by first reducing the type order with supercombinator extraction [10], which one could call meta lifting since it is targeted at lifting out all higher order applications of . This is, in fact, what we did with the tree flattening Example 3.2.2, and what we use in the following general construction. Proof of Theorem 4.3.3. Case ) Given the two level derivor, ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, Pennsylvania, August 1982.

....map is used to square each of these numbers, and the function fold is used to add these together. Programs in the language consist of an expression to evaluate and a set of function definitions. It is assumed that the compiler for the language implements the full laziness technique described in [ 5 ] . Nested function definitions are not allowed in the language. Programs involving nested definitions can be transformed into this restricted form of program using a technique called lambda lifting [ 7 ] For the purposes of this paper, constants (e.g. numbers) and basic functions ( Gamma, ....

....as Psi is the only blazing annotation which is used. 3 This is the occurrence of a variable as the bound variable in a lambda abstraction, or within the pattern of a case expression. 4 This relies upon the fact that the language is implemented using the full laziness technique described in [ 5 ] , since it is possible to duplicate references to a partially applied function which contains expressions that will be re evaluated when it is fully applied. fold ( 0 (map square (until ( n) repeat ( 1) 1) where fold = f Psi :a:xs:case xs of N il : a Cons x xs : fold f (f a x) ....

R.J.M. Hughes. Supercombinators: A new implementation method for applicative languages. In Proceedings of the ACM Conference on LISP and Functional Programming, pages 1--10, 1982.

.... is used in conjunction with the tupling strategy [Pet84] Apart from accumulation, lambda abstraction can also be used to derive programs with continuations, e.g. for deriving complicated programs for traversing datastructures in one pass as in [Bir84b] Related techniques are described in [Hug82, Joh85, Tak87] 12 Hughes novel implementation of lists In [Hug86] the idea is presented that a list x could be represented by rep(x) y:x k y; with corresponding abstraction function abs(x) x[ It is shown how this allows a straightforward derivation of the fast reverse (cf. ....

John Hughes. Super-combinators: A new implementation method for applicative languages. In Conference Record of the 1982 ACM Symposium on LISP and Functional Programming, pages 1--10, Pittsburgh, August 1982.

....C Figure 1.1: Structure of the Naira compiler The pattern matching compiler takes the AST input, compiles the syntactic sugar inside patterns and produces an AST closer to the underlying computation model. The lambda lifter then inputs the resulting AST and turns functions into supercombinators [Hugh82, John87, PeLe91] Lambda lifting is particularly beneficial in a parallel implementation since supercombinator invocations can be distributed across the processors of the parallel machine without worrying about access to free variables. The AST is then type checked and further simplified to ....

RJM Hughes, Supercombinators - A New Implementation Method for Applicative Languages. In Proc. of the 1982 ACM Symposium of Lisp and Functional Programming, pp. 1-10, Pittsburgh, 1982.

....performance of the remaining programs is unchanged. An observation about supercombinators, however, tells us that this interpretive overhead can be reduced without a separate stack for markers. 7 Supercombinators The TIM assumes that all programs have been converted either into supercombinators [5] or lambda lifted combinators [6] Let us assume conversion to supercombinators as described in [5] Starting with the leftmost, innermost lambda abstraction of the program, every lambda abstraction v.E is converted into an application of a new supercombinator C to the maximal free expressions e 1 ....

....tells us that this interpretive overhead can be reduced without a separate stack for markers. 7 Supercombinators The TIM assumes that all programs have been converted either into supercombinators [5] or lambda lifted combinators [6] Let us assume conversion to supercombinators as described in [5]. Starting with the leftmost, innermost lambda abstraction of the program, every lambda abstraction v.E is converted into an application of a new supercombinator C to the maximal free expressions e 1 : e n of E. The new supercombinator C itself is then defined as C i 1 : i n v = E[ i 1 e ....

R. J. M. Hughes. Super-combinators: A New Implementation Method for Applicative Languages. In 1982 ACM Symposium on LISP and Functional Programming, pages 1--10, August 1982.

....MMH96] whereas closure conversion attempts to optimize the representation of closures, lambda lifting attempts change the closure allocation behavior of a program or even to remove the need for some closures entirely. Incremental lambda lifting is also distinct from the super combinators of [Hug82] in that procedures are not necessarily lifted to the top level. The process of incremental lambda lifting can be performed repeatedly in order to bring a deeply nested procedure to the top level, as would be done with traditional lambda lifting. However, being able to lift only one level at a ....

R. J. M. Hughes. Super-combinators: A new implementation method for applicative languages. In Proc. 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, 1982.

....with local definitions. The traditional way of dealing with local nonrecursive and recursive definitions (let and letrec) both in defining their meaning and in implementations, is to treat them as syntactic sugaring for lambda expressions and the fix point combinator Y [Lan66] Tur79] [Hug82]. The following two transformation rules are then used. let x = e 1 in e 2 ) x:e 2 )e 1 letrec x = e 1 in e 2 ) let x = Y (x:e 1 ) in e 2 The resulting expression contains lambda expressions in place of the lets and letrecs, and can then be treated as described before. The following example ....

R. J. M. Hughes. Super Combinators---A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982.

....rule i 0 . The logic CL q is useful for creating implementations of by value languages. Burge [2] rediscovered combinators for computer science. Turner [14] popularized and improved the translation using a larger set of combinators so that the resulting CL programs were shorter. Then Hughes [8] developed supercombinators that made the translation linear in terms of size. Hudak and Goldberg [7] created serial combinators that are used to execute CL programs on multiprocessors without shared memory. Finally, Kennaway and Sleep [9] developed director strings that allow even more efficient ....

R. Hughes. Super-combinators: A new implementation method for applicative languages. In Sym. on Lisp and Functional Prog., pages 1--10. ACM, Aug 1982.

.... types, both user defined and predefined ones (e.g. integers and lists) After parsing and type checking the compiler transforms pattern matching into simple case expressions; see [Aug85] The program is then transformed into a set of global recursive functions, reminiscent of super combinators [Hug82] This transformation is called lambda lifting and is described in [Joh85] Then each of the global functions are compiled into G machine code. The G machine is the abstract machine that embodies our paradigm for compiled graph reduction; it is described in [Joh84] Finally, the G machine code ....

R. J. M. Hughes. Super Combinators---A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982.

....in terms of the conjunction operator, and thus, we do not need separate strategies for composition and tupling. The goal generalization strategy presented in this paper is also related to techniques for higher order generalization in functional programming, such as the supercombinators technique [6], lambda lifting [7] lambda hoisting [17] and the lambda abstraction strategy [14] because the introduction of goal variables is analogous to the introduction of a higher order object. However, we insist on the fact that programs of our transformation language which allows for the use of goal ....

R. J. M. Hughes. Super-combinators: a new implementation method for applicative languages. In Proc. ACM Symposium on Lisp and Functional Programming, Pittsburgh, PA, USA, pages 1--10. ACM Press, 1982.

....; will evaluate the redex II twice. This is what happens also in the interpreter of Henderson and Morris (1976) and in the G machine (Peyton Jones Salkild, 1989) However, the redex II will be evaluated only once following the combinator machine of Turner (1979) supercombinator approach of Hughes (1982) and Wadsworth s interpreter (1971) We refer to these implementations as fully lazy. Wadsworth (1971) was the first one to provide a fully lazy interpreter. He observed that the redex II should not be copied, since no occurrence of the bound variable w occurs in II. This can be captured by ....

....for programs that do not contain mfe s. Moreover, the corollary suggests that we could lift all the mfe s of a program at compile time and then use our call by need interpreter. The lifting of mfe s at compile time is the essence of the sophisticated lambda lifting algorithms pioneered by John Hughes (1982). Since we cannot predict at compile time whether or not a lambda abstraction will be shared, we have to resort to the mfe axiom. It is strongly normalizing, which implies that we can mfe normalize the program before evaluating. However, as described earlier, it is non confluent. To encompass this ....

Hughes, R. J. M. (1982). Super-combinators: a new implementation method for applicative languages. Pages 1--10 of: Proc. ACM Symposium on Lisp and Functional Programming.

....if (ternary if then else) Note that there is no lambda expression in the syntax of expressions, functions are defined only globally. Functional programs with local function definitions and lambda expressions with free variables can be transformed into the form above, using super combinators [Hug82]; an algorithm to the same effect is used in our compiler implementation, however, the program resulting from our transformation does not exhibit full laziness , as is the main issue in Hughes work. C 5.2 Compilation rules The abstract compiler given in table 3 is subdivided into 4 ....

....compiler [HK84] resembles our work in many respects. He uses the standard combinators as a convenient intermediate language for performing program transformations and optimisations. The program is the converted into one containing macro combinators, which is similar to Hughes super combinators [Hug82] and our global function definitions. Each macro combinator is then translated into code for a conventional machine. Dick Kieburtz et. al at Oregon Graduate Center is currently in the process of designing and implementing a VLSI chip for the G machine. 9 Acknowledgements This work was supported ....

J. Hughes. Super combinators - a new implementation method for applicative languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982.

....programming style that is not possible with recursive equations. Yet recursive equations can be efficiently implemented. This led Hughes, Johnsson, and Peyton Jones, in the mid 80 s, to devise a meaning preserving transformation from block structured programs to recursive equations: lambdalifting [18, 19, 28]. We review lambda lifting in Section 2. Recursive equations also offer a convenient format in Mix style partial evaluation [22] Modern partial evaluators such as Schism and Similix lambda lift source programs before specialization [8, 10] source block structured program lambda lifting F NaN F ....

....and eager programs Johnsson concentrated on lambda lifting towards mutually recursive equations [19] but alternative approaches exist. The first one seems to be Hughes s supercombinator abstraction, where recursion is handled through self application and full laziness is a point of concern [18]. Peyton Jones provides a broad overview about fully lazy supercombinators [27, 28, 29] Essentially, instead of lifting only free variables, one lifts maximally free expressions. Fully lazy lambdadropping would amount to keep maximally free expressions instead of identifiers in the initial calls ....

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, Pennsylvania, August 1982.

.... way These kinds of questions were asked in a provocative paper by Frandsen and Sturtivant [FS91] who proposed various implementation independent cost models for the calculus, and showed that several well known implementation techniques (Turner combinators [Tur79] Hughes supercombinators [Hug82]) are too inefficient to satisfy these cost models. They leave as an open question whether their cost models, while conscientiously justified, are indeed attainable. This paper continues their work by analyzing optimal evaluators in the same vein. We discover that optimal reduction fails to be ....

....define a more parsimonious cost model, Frandsen and Sturtivant [FS91] proposed the following: the cost of a reduction to normal form is the length of the the initial and final term, plus the number of parallel fi steps. They point out that several standard combinatorbased implementations (e.g. [Tur79, Hug82]) require time exponential in the cost model. We observe that optimal reduction strategies, even without counting bookkeeping, fail to run polynomially in the Frandsen Sturtivant cost metric. 5.1 Optimal evaluators fail the Frandsen Sturtivant test Our evidence against the Frandsen Sturtivant ....

John Hughes. Supercombinators: a new implementation method for applicative languages. 1982 ACM Symposium on Lisp and Functional Programming, pp. 1--10.

....: f m 1 1 x11 1 1 1 x1m 1 = e1 . f mn n xn1 1 1 1 x1mn = en e : x e1 1 1 1 em (m 0) j f k i e1 1 1 1 em (m 0) j ck e1 1 1 1 em (m 0) j case e in ck 1 v1 1 1 1 vm : e1k 1 1 1 end That is, a program is a set of functions assumed to be the result of super combinator abstraction [Hug82] or lambdalifting [Joh85] We also assume that the value of the program is the value of an application of one of those functions, main say, to some argument to the program (we ignore the further details of program startup) Expressions consists of parameters x i possibly applied to some ....

R. J. M. Hughes. Super Combinators---A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982.

....10 programs, with a maximum of 11 . 7.2 Lambda lifting Lambda lifting is a transformation that eliminates free variables from function definitions by passing them as arguments. After this is done, as the functions do not have free variables anymore, they can be lifted to the top level [Joh85, Hug82] Therefore after lambda lifting all the function definitions are in the top level, in the form of supercombinators [Hug82] This is an essential transformation for some implementations of functional languages in which all function definitions have to be in the top level, like the G machine ....

....from function definitions by passing them as arguments. After this is done, as the functions do not have free variables anymore, they can be lifted to the top level [Joh85, Hug82] Therefore after lambda lifting all the function definitions are in the top level, in the form of supercombinators [Hug82] This is an essential transformation for some implementations of functional languages in which all function definitions have to be in the top level, like the G machine [Joh83] In the STG machine lambda lifting is not needed, but is there any advantage in performing lambda lifting in the context ....

[Article contains additional citation context not shown here]

John M. Hughes. Super combinators: A new implementation method for applicative languages. In ACM Conference on Lisp and Functional Programming, pages 1--10, Pittsburg, 1982.

....means that the target language instructions are easily implementable by translation to single instructions or short sequences of instructions on conventional machines. For the compilers we have considered, requiring the meaning of each target machine instruction to be a tail form supercombinator [6, 10] turns out to be a reasonable choice. By examining this reduction behavior, we can obtain an operational semantics for the target language. The soundness of this operational semantics must then be proved. For example, the operational semantics of the addition instruction might be given by h(add ....

R. J. M. Hughes. Super Combinators: A New Implementation Method for Applicative Languages. In Proc. 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, 1982.

....can be summarised very briefly as follows. Our approach stems from Turner s S, K, I standard combinator reduction approach [Tur79] But instead of using a standard, fixed set of combinators, the compiler tranforms the program into a new set of specialised combinators, or super combinators [Hug82]. This transformation process is called lambda lifting [Joh85] Each of these super combinators are then compiled into machine code for the machine at hand, this code implements the graph rewrite rule that the combinator implies. Put another way, the compiler constructs a specialised, ....

R. J. M. Hughes. Super Combinators---A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982.

....However, the interest in specialpurpose reduction machines waned, and researchers focused their attention on efficient implementation techniques for stock hardware. Hughes paved the way for a third generation of functional language implementations with a system based on supercombinator reduction [Hughes 82] Supercombinators are combinators that are drawn from the source program rather than from an a priori fixed set of basic combinators. Because supercombinators are specifically tuned for each source program, an implementation based on supercombinators is usually more efficient than an ....

....qualify as supercombinators. However, there is a subjective component of the supercombinator definition as well. Hughes originally coined the term supercombinator to refer to combinators that were extracted from the source program according to a specific transformation algorithm presented in [Hughes 82] Since then, the term has been used to refer to any combinators that are naturally drawn from the functions that appear in the source program, and there are now several different algorithms for performing the derivation. The principal technique common to all supercombinator derivations is known ....

R.J.M. Hughes. Super-combinators: A new implementation method for applicative languages. In [ACM 82], pages 1--10.

....is then converted back to a expression, which is compiled into conventional machine code using an closure based technique. Several projects aimed at constructing efficient hardware for SKI combinator reduction have been, and are being pursued [CGMN80, Sto85] Sch86] SOH85] The work by Hughes [Hug82] is based on the observation that while the self optimizing properties of combinator reduction a la Turner are desirable, the reduction process itself can be very inefficient. Each combinator reduction step constitutes a very small step in the overall reduction of the program (propagating a ....

....into code for a stack A machine for graph reduction, called the G machine; and finally part D deals with target code generation from G machine code. The work on program transformation into global recursive functions, called lambdalifting) which is described in paper B, differs from Hughes work [Hug82] in the following respects. Firstly, we are not concerned with the full laziness property, which is his main point of interest. Secondly, we want to cater for the particular idiosyncrasies of the Gmachine, and obtain a form which can be compiled into as efficient G machine code as possible. Using ....

[Article contains additional citation context not shown here]

J. Hughes. Super combinators - a new implementation method for applicative languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pages 1--10, Pittsburgh, 1982. A

No context found.

John Hughes. Super combinators: A new implementation method for applicative languages. In Daniel P. Friedman and David S. Wise, editors, Programming, pages 1--10, Pittsburgh, Pennsylvania, August 1982. ACM Press.

No context found.

Hughes, R. J. M., Super Combinators: A New Implementation Method for Applicative Languages. In Proceedings of the 1982 ACM Symposium on Lisp and Functional Programming, pp.1-10.

Online articles have much greater impact   More about CiteSeer.IST   Add search form to your site   Submit documents   Feedback  

CiteSeer.IST - Copyright Penn State and NEC