Introduction The commonly accepted basis for functional programming is the -calculus; and it is folklore that the -calculus is the prototypical functional language in puri ed form. But what is the -calculus? The syntax is simple and classical; variables, abstraction and application in the pure calculus, with applied calculi obtained by adding constants. The further elaboration of the theory, covering conversion, reduction, theories and models, is laid out in Barendregt's already classical treatise [Bar84]. It is instructive to recall the following crux, which occurs rather early in that work (p. 39): Meaning of -terms: rst attempt The meaning of a -term is its normal form (if it exists). All terms without normal forms are identi ed. This proposal incorporates such a simple and natural interpretation of the -calculus as

The foundations of functional programming languages are examined from both historical and technical perspectives. Their evolution is traced through several critical periods: early work on lambda calculus and combinatory calculus, Lisp, Iswim, FP, ML, and modern functional languages such as Miranda ’ and Haskell. The fundamental premises on which

Compiler generation is often emphasized as being the most important application of partial evaluation. But most of the larger practical applications have, to the best of our knowledge, been outside this field. Especially, no one has generated compilers for languages other that small languages. This paper describes a large application of partial evaluation where a realistic compiler was generated for a strongly typed lazy functional language. The language, that was called BAWL, was modeled after the language in Bird and Wadler [BW88] and is a combinator language with pattern matching, guarded alternatives, local definitions and list comprehensions. The paper describes the most important techniques used, especially the binding time improvements needed in order to get small and efficient target programs. Finally, the performance of the compiler is compared with two compilers for similar languages: Miranda and LML. Keywords Compiler generation, partial evaluation, binding time improvemen...

Syntax Q = fT N jEg E = E EjE Ej:EjT 2 RjA!Aj9T : R:Ej8T : R:E A = N jBjT [N ] op =! j ? j j j 6= j = 5.3 Semantic Domains T uple = List V al V al = Num+Bool + Unb Unb = T ide X Num Dbase = RIde ! Set T uple Env = T Ide ! T uple 5.4 Semantic Functions 5.4.1 j : Nmls ! V al Not specified 5.4.2 fi : Bools ! V al Not specified 5.4.3 Q : Query ! Dbase ! SetT uple Q[jfT N jEgj] ffi = fae[jT j]j ae 2 E[jEj] ffi fT ! unbtuplegg where unbtuple = null [jT j] j[jN j] 5.4.4 E : Exp ! Dbase ! Env ! Set Env E[jE 0 E 1 j] ffi ae = fae 1 jae 0 2 (E[jE 0 j]ffiae) ae 1 2 (E[jE 1 j]ffiae 0 )g E[jE 0 E 1 j] ffi ae = fae 0 jae 0 2 (E[jE 0 j]ffiae) ae 0 2 (E[jE 1 j]ffiae)g E[j:Ej] ffi ae = f ilter (E[jEj]ffiae) = OE ae E[jT 2 Rj] ffi ae = (unbtuple? ae[jT j] !fae \Phi fT 7! vgj v 2 ffi[jRj]g; f ilter (ae[jT j] 2 ffi[jRj]) ae) E[jA 0 ! A 1 j] ffi ae = \Theta [j!j] (A[jA 0 j]ae) (A[jA 1 j]ae) ae E[j9T : R:Ej] ffi ae = fae 1 jv 2 ffi[jRj] ae 1 2 (E[jEj] ffi ae \Phi fT 7! vg)g E[j8T : R:E...

In this report describes techniques required to generate efficient compilers for realistic languages by partial evaluation and to what extent these techniques can be automated. It also describes a large application where a realistic compiler was generated for a strongly typed lazy functional language. Compiler generation is often emphasized as being the most important application of partial evaluation, but most of the larger practical applications have been outside this field. Especially, no one has generated compilers for languages other than small example languages. It is well known how compilers can be generated from interpreters by partial evaluation. So we show how to obtain interpreters (in strict functional languages) from formal language descriptions. One way is to specialize a meta-interpreter with respect to language definitions to generate interpreters. This meta-interpreter approach has the advantage that one may define new and better definition languages without having to write new partial evaluators. We have studied what kind of binding time improvements of interpreters are needed to obtain compilers which are both efficient and generate good target code.

Recursive functions are representable as lambda terms, and de nability in the calculus may be regarded as a de nition of computability. This forms part of the standard foundations of computer science. Lambda calculus is the commonly accepted basis of functional programming languages � and it is folklore that the calculus is the prototypical functional language in puri ed form. The course investigates the syntax and semantics of lambda calculus both as a theory of functions from a foundational point of view, and as a minimal programming language. Synopsis Formal theory, xed point theorems, combinatory logic: combinatory completeness, translations between lambda calculus and combinatory logic � reduction: Church-Rosser theorem � Bohm's theorem and applications � basic recursion theory � lambda calculi considered as programming languages � simple type theory and pcf: correspondence between operational and denotational semantics � current developments. Relationship with other courses Basic knowledge of logic and computability in paper B1 is assumed.