Results 1 
8 of
8
Tutorial Notes on Partial Evaluation
 Proceedings of the Twentieth Annual ACM Symposium on Principles of Programming Languages
, 1993
"... The last years have witnessed a flurry of new results in the area of partial evaluation. These tutorial notes survey the field and present a critical assessment of the state of the art. 1 Introduction Partial evaluation is a sourcetosource program transformation technique for specializing program ..."
Abstract

Cited by 237 (62 self)
 Add to MetaCart
The last years have witnessed a flurry of new results in the area of partial evaluation. These tutorial notes survey the field and present a critical assessment of the state of the art. 1 Introduction Partial evaluation is a sourcetosource program transformation technique for specializing programs with respect to parts of their input. In essence, partial evaluation removes layers of interpretation. In the most general sense, an interpreter can be defined as a program whose control flow is determined by its input data. As Abelson points out, [43, Foreword], even programs that are not themselves interpreters have important interpreterlike pieces. These pieces contain both compiletime and runtime constructs. Partial evaluation identifies and eliminates the compiletime constructs. 1.1 A complete example We consider a function producing formatted text. Such functions exist in most programming languages (e.g., format in Lisp and printf in C). Figure 1 displays a formatting functio...
Efficient Type Inference for HigherOrder BindingTime Analysis
 In Functional Programming and Computer Architecture
, 1991
"... Bindingtime analysis determines when variables and expressions in a program can be bound to their values, distinguishing between early (compiletime) and late (runtime) binding. Bindingtime information can be used by compilers to produce more efficient target programs by partially evaluating prog ..."
Abstract

Cited by 91 (4 self)
 Add to MetaCart
Bindingtime analysis determines when variables and expressions in a program can be bound to their values, distinguishing between early (compiletime) and late (runtime) binding. Bindingtime information can be used by compilers to produce more efficient target programs by partially evaluating programs at compiletime. Bindingtime analysis has been formulated in abstract interpretation contexts and more recently in a typetheoretic setting. In a typetheoretic setting bindingtime analysis is a type inference problem: the problem of inferring a completion of a λterm e with bindingtime annotations such that e satisfies the typing rules. Nielson and Nielson and Schmidt have shown that every simply typed λterm has a unique completion ê that minimizes late binding in TML, a monomorphic type system with explicit bindingtime annotations, and they present exponential time algorithms for computing such minimal completions. 1 Gomard proves the same results for a variant of his twolevel λcalculus without a socalled “lifting ” rule. He presents another algorithm for inferring completions in this somewhat restricted type system and states that it can be implemented in time O(n 3). He conjectures that the completions computed are minimal.
Simple closure analysis
, 1992
"... Closure analysis determines statically which function definitions reach which program points. This information is used for many different purposes; e.g., type inference for ..."
Abstract

Cited by 17 (1 self)
 Add to MetaCart
Closure analysis determines statically which function definitions reach which program points. This information is used for many different purposes; e.g., type inference for
Selfapplicable Partial Evaluation for Pure Lambda Calculus
 Yale University
, 1992
"... Partial evaluation of an applied lambda calculus was done some years ago in the lambdamix project. When moving to pure lambda calculus, some issues need to be considered, most importantly how we represent programs in pure lambda calculus. We start by presenting a compact representation schema for  ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
Partial evaluation of an applied lambda calculus was done some years ago in the lambdamix project. When moving to pure lambda calculus, some issues need to be considered, most importantly how we represent programs in pure lambda calculus. We start by presenting a compact representation schema for terms and show how this leads to an exceedingly small and elegant selfinterpreter. Partial evaluation is discussed, and it is shown that partial evaluation in the most general sense is uncomputable. There are several ways of restricting partial evaluation. We choose one of these, which requires explicit binding time information. Binding time annotations are discussed, and the representation schema is extended to include annotations. A partial evaluator is then constructed as an extension of the selfinterpreter, and selfapplication is performed to produce possibly the smallest nontrivial compiler generator in the literature. It is shown that binding time analysis can be done by modifying ...
A Typedirected, Online, Partial Evaluator for a Polymorphic Language
 In Proceedings of the Symposium on Partial Evaluation and SemanticsBased Program Manipulation
, 1997
"... Recently, Olivier Danvy introduced a new, simple method for implementing powerful partial evaluators, namely typedirected partial evaluation[9]. He introduced a partial evaluator for the simplytyped lambda calculus (x2). This paper explores the possibility of using the same techniques over a lambda ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
Recently, Olivier Danvy introduced a new, simple method for implementing powerful partial evaluators, namely typedirected partial evaluation[9]. He introduced a partial evaluator for the simplytyped lambda calculus (x2). This paper explores the possibility of using the same techniques over a lambda calculus with a richer type system. We generalize and extend Danvy's work in four ways: 1. Our system handles a much richer language than that presented by Danvy, including all of the features functional programmers have come to expect, such as polymorphism (x5), inductive datatypes (x10), and recursion (x9). 2. Our system includes a new systematic treatment of primitive operators (x7) and the propagation of residualized code (x7.1). This question has either been ignored or treated in an adhoc manner in previous work. 3. Our system handles nonclosed terms (x6). This makes typedirected partial evaluation much more practically useful, and can easily be extended to work in languages wit...
Exact Flow Analysis
 In Proceedings of SAS’97, International Static Analysis Symposium
, 1997
"... We present a typebased ow analysis for simply typed lambda calculus with booleans, datastructures and recursion. The analysis is exact in the following sense: if the analysis predicts a redex, then there exists a reduction sequence (using standard reduction plus context propagation rules) such tha ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
We present a typebased ow analysis for simply typed lambda calculus with booleans, datastructures and recursion. The analysis is exact in the following sense: if the analysis predicts a redex, then there exists a reduction sequence (using standard reduction plus context propagation rules) such that this redex will be reduced. The precision is accomplished using intersection typing. It follows that the analysis is nonelementary recursive  more surprisingly, the analysis is decidable. We argue that the specication of such an analysis provides a good starting point for developing new ow analyses and an important benchmark against which other ow analyses can be compared. Furthermore, we believe that the techniques employed for stating and proving exactness are of independent interest: they provide methods for reasoning about the precision of program analyses. 1
Bindingtime Analysis: Abstract Interpretation versus Type Inference
 IN PROC. ICCL'94, FIFTH IEEE INTERNATIONAL CONFERENCE ON COMPUTER LANGUAGES
, 1994
"... Bindingtime analysis is important in partial evaluators. Its task is to determine which parts of a program can be evaluated if some of the expected input is known. Two approaches to do this are abstract interpretation and type inference. We compare two specific such analyses to see which one deter ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
Bindingtime analysis is important in partial evaluators. Its task is to determine which parts of a program can be evaluated if some of the expected input is known. Two approaches to do this are abstract interpretation and type inference. We compare two specific such analyses to see which one determines most program parts to be eliminable. The first is a an abstract interpretation approach based on closure analysis and the second is the type inference approach of Gomard and Jones. Both apply to the pure calculus. We prove that the abstract interpretation approach is more powerful than that of Gomard and Jones: the former determines the same and possibly more program parts to be eliminable as the latter.
PARA11ETER SPLITTING IN A HIGHER ORDER FUNCTIONAL PROGRA1111ING LANGUAGE
, 1990
"... This project is a part of a larger one consisting of constructing a Miranda to 'C' compiler. This compiler is to be constructed by first implementing a Mirandainterpreter in Scheme, then using a partial evaluator to generate a Miranda to Scheme compiler written in Scheme, and finally generating 'C' ..."
Abstract
 Add to MetaCart
This project is a part of a larger one consisting of constructing a Miranda to 'C' compiler. This compiler is to be constructed by first implementing a Mirandainterpreter in Scheme, then using a partial evaluator to generate a Miranda to Scheme compiler written in Scheme, and finally generating 'C'code from the Schemecode. Vve will develop a theory for doing parameter splitting in a higher order functional programming language based on a theory for doing parameter splitting in a first order functional programming language [Romanenko 90]. A reason for doing parameter splitting in connection with program specialization IS given the abstract of [Romanenko 90]. It states: Experiments on generating compilers by specializing specializers with respect to interpreters have shown that the compilers thus obtained have a natural structure only if the specializer does vm·iable splitting. Variable splitting can result in a residual program using several variables to represent the values of a single variable of the original program. In the case of functional programming, variable splitting is done be raising the a.rities of functions.