In the functional programming literature, compiling is often expressed as a translation between source and target program calculi. In recent work, Sabry and Wadler proposed the notion of a reflection as a basis for relating the source and target calculi. A reflection elegantly describes the situation where there is a kernel of the source language that is isomorphic to the target language. However, we believe that the reflection criteria is so strong that it often excludes the usual situation in compiling where one is compiling from a higher-level to a lower-level language. We give a detailed analysis of several translations commonly used in compiling that fail to be reflections. We conclude that, in addition to the notion of reflection, there are several relations weaker a reflection that are useful for characterizing translations. We show that several familiar translations (that are not naturally reflections) form what we call a reduction correspondence. We introduce the more genera...

We formalize a partial evaluator for Eugenio Moggi's computational metalanguage. This formalization gives an evaluation-order independent view of binding-time analysis and program specialization, including a proper treatment of call unfolding, and enables us to express the essence of "control-based binding-time improvements" for let expressions. Specifically,

In this paper we present two type inference systems for detecting useless-code in higher-order typed functional programs. Type inference can be performed in an efficient and complete way, by reducing it to the solution of a system of constraints. We also give a useless-code elimination algorithm which is based on a combined use of these type inference systems. The main application of the technique is the optimization of programs extracted from proofs in logical frameworks, but it could be used as well in the elimination of useless-code determined by program transformations. Capsule Review Dead code is a subterm M of a term t = C[M] which does not matter to computation, that is, which may be replaced by any other term of the same type without altering the observational behaviour of the program: C[M] =obs C[N] for any N with the type of M. Dead-code may be replaced by dummy variable, or even completely removed, in order to optimize a program. The interest in dead-code by the authors started as a by-product of a proof system which generated programs meeting a specification out of proofs that the specification is satisfiable.

Abstract. We define a small functional calculus that expresses class-based object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to the one defined in [10], and show subject reduction and expansion, and argue that program analysis systems can be built on top of this system. Generalising the concept of approximant from the Lambda Calculus, we show that all expressions that we can assign a predicate to have an approximant that satisfies the same predicate. From this, a characterisation of (head-)normalisation follows. 1

ing with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works, requires prior specific permission and/or a fee. Permissions may be requested from Publications Dept, ACM Inc., 1515 Broadway, New York, NY 10036 USA, fax +1 (212) 869-0481, or permissions@acm.org. 2 \Delta J. Hatcliff e 2 Terms[ ml ] e ::= x j pnq j tick j x : e j @ e0 e1 j unit e j let x ( e1 in e2 2 Types[ ml ] ::= nat j 1 ! e 2 j e \Gamma 2 Assumptions[ ml ] \Gamma ::= \Delta j \Gamma; x : \Gamma ` ml x : \Gamma(x) \Gamma ` ml pnq : nat \Gamma ` ml tick : f nat \Gamma; x : 1 ` ml e : e 2 \Gamma ` ml x : e : 1 ! e 2 \Gamma ` ml e0 : 1 ! e 2 \Gamma ` ml e1 : 1 \Gamma ` ml @ e0 e1 : e 2 monadic constructs: \Gamma ` ml e : \Gamma ` ml unit e : e \Gamma ` ml e 1 : e 1 \Gamma; x : 1 ` ml e 2 : e 2 \Gamma ` ml let x ( e1 in e2 : e 2 Fig. 1. The computational meta-language ml input/output, and robust...

A system of annotated types is proposed as a means of describing and inferring static information, such as strictness and constancy, about functional programs. An abstract semantics is given in terms of projections. A close connection between annotated type assignment and projection analysis is demonstrated.

Research on partial evaluation has flourished in the context of pure functional languages, yet modern functional languages include many notions of computation that partial evaluation technology has only recently been able to handle. We summarize how using Moggi's computational metalanguage as intermediate language provides a foundation for this recent advance in technology. 1 Partial Evaluation of Programs with Computational Effects Partial evaluation is a highly useful program specialization technique that can be applied to programs from any language paradigm. Yet, it is in the paradigm of pure functional languages that partial evaluation technology grew to maturity. The simple semantics of pure functional programs (which do not include computational effects such as state modification, input/output, and first-class exceptions) makes it easier to perform the basic actions of partial evaluation such as static analysis, function unfolding (inlining), and symbolic execution. Clearly, t...

We formalize the notion of syntactic replacement restriction, which is useful for modeling reduction-based systems which compute with terms and impose restrictions on the possible computations (typically by means of strategies). We emphasize the syntactic flavour of our approach: the restrictions are associated to components of terms and (in principle) they do not depend on either a particular Term Rewriting System or a computational mechanism (like rewriting, narrowing, residuation, etc.). The replacement restrictions can be used to improve the computational behavior of the unrestricted mechanism. We give a general descriptive and algebraic framework to deal with replacement restrictions. For the descriptive part, we introduce and motivate properties which characterize classes of replacement restrictions. For the algebraic side, the set of replacement restrictions is presented as a complete Boolean algebra. The algebraic operations (and others which we also define) can be used to com...

We present an inference system for translating programs in a PCF-like source language into a variant of Moggi's computational lambda calculus. This translation combines a simple strictness analysis with its associated optimising transformations into a single system. The correctness of the translation is established using a logical relation between the denotational semantics of the source and target languages. 1 Introduction 1.1 Background Strictness analysis of lazy functional programs has been studied extensively during the the last 15 years or so, usually with the justification that the results of the analysis can be used in an optimising compiler [Myc81, BHA86, Ben92]. There has, however, been surprisingly little serious work on just how the results of strictness analysis can be used as the basis for optimising transformations. This is probably because it turns out to be rather more difficult to express and justify these optimisations than one might at first imagine. Roughly speak...

. A tension in language design has been between simple semantics