Results 1 
9 of
9
LambdaDropping: Transforming Recursive Equations into Programs with Block Structure
, 2001
"... Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack ..."
Abstract

Cited by 42 (11 self)
 Add to MetaCart
(Show Context)
Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack
A Theory of Stack Allocation in Polymorphically Typed Languages
, 1993
"... We present a stackallocation scheme for the callbyvalue lambda calculus typed according to Milner's polymorphic type discipline. All the values a program produces, including function closures, are put into regions at runtime. Regions are allocated and deallocated in a stacklike manner. Regi ..."
Abstract

Cited by 29 (5 self)
 Add to MetaCart
We present a stackallocation scheme for the callbyvalue lambda calculus typed according to Milner's polymorphic type discipline. All the values a program produces, including function closures, are put into regions at runtime. Regions are allocated and deallocated in a stacklike manner. Region inference and effect inference is used to infer where regions can be allocated and deallocated. By allowing a limited form of polymorphic recursion in region types, the region inference is able to distinguish between the lifetimes of different invocations of a function, even when the function is recursive. The region analysis is eager in its attempt to reclaim memory as quickly as possible. The main result of this report is that region inference is safe, a result which entails that regions really can be deallocated, when region inference says they can. We give detailed proofs of this claim, which (in various forms) has been advanced several times in the literature. An algorithm for implementi...
Orderofevaluation Analysis for Destructive Updates in Strict Functional Languages with Flat Aggregates
 In Conference on Functional Programming Languages and Computer Architecture
, 1993
"... The aggregate update problem in functional languages is concerned with detecting cases where a functional array update operation can be implemented destructively in constant time. Previous work on this problem has assumed a fixed order of evaluation of expressions. In this paper, we devise a simple ..."
Abstract

Cited by 19 (1 self)
 Add to MetaCart
(Show Context)
The aggregate update problem in functional languages is concerned with detecting cases where a functional array update operation can be implemented destructively in constant time. Previous work on this problem has assumed a fixed order of evaluation of expressions. In this paper, we devise a simple analysis, for strict functional languages with flat aggregates, that derives a good order of evaluation for making the updates destructive. Our work improves Hudak's work [14] on abstract reference counting, which assumes fixed order of evaluation and uses the domain of sticky reference counts. Our abstract reference counting uses a 2point domain. We show that for programs with no aliasing, our analysis is provably more precise than Hudak's approach (even if the fixed order of evaluation chosen by Hudak happens to be the right order). We also show that our analysis algorithm runs in polynomial time. To the best of our knowledge, no previous work shows polynomial time complexity. We suggest ...
Derivation of Static Analysers of Functional Programs From Path Properties of a Natural Semantics
, 1995
"... We advocate the use of operational semantics as a basis for specifying program analyses for functional languages. We put forward a methodology for defining a static analysis by successive refinements of the natural semantics of the language. We use paths as the abstract representation of proof tree ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
We advocate the use of operational semantics as a basis for specifying program analyses for functional languages. We put forward a methodology for defining a static analysis by successive refinements of the natural semantics of the language. We use paths as the abstract representation of proof trees and we provide a language for defining properties in terms of recurrence equations on paths. We show the specification of several standard properties on paths (neededness, absence, uniqueness, . . .) and the mechanical derivation of the corresponding analyses.
Calculi for Functional Programming Languages with Assignment
, 1996
"... Calculi for Functional Programming Languages with Assignment Daniel Eli Rabin 1996 Pure functional programming and imperative programming appear to be contradictory approaches to the design of programming languages. Pure functional programming insists that variables have unchanging bindings and tha ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Calculi for Functional Programming Languages with Assignment Daniel Eli Rabin 1996 Pure functional programming and imperative programming appear to be contradictory approaches to the design of programming languages. Pure functional programming insists that variables have unchanging bindings and that these bindings may be substituted freely for occurrences of the variables. Imperative programming, however, relies for its computational power on the alteration of variable bindings by the action of the program. One particular approach to merging the two design principles into the same programming language introduces a notion of assignable variable distinct from that of functionally bound variable. In this approach, functional programming languages are extended with new syntactic constructs denoting sequences of actions, including assignment to and reading from assignable variables. Swarup, Reddy and Ireland have proposed a typed lambdacalculus in this style as a foundation for programmin...
Lambdadropping: transforming recursive equations
"... into programs with block structure ..."
(Show Context)
Une Analyse De Globalisation De Programmes Fonctionnels Basée Sur Une Sémantique Naturelle
"... Introduction Nous d'ecrivons d'abord la motivation g'en'erale de ce travail puis nous pr'esentons la d'emarche suivie dans le corps de l'article. 1.1 Motivation Les travaux sur l'analyse statique de programmes ont 'et'e nombreuses durant ces derni` ..."
Abstract
 Add to MetaCart
Introduction Nous d'ecrivons d'abord la motivation g'en'erale de ce travail puis nous pr'esentons la d'emarche suivie dans le corps de l'article. 1.1 Motivation Les travaux sur l'analyse statique de programmes ont 'et'e nombreuses durant ces derni`eres ann'ees parce que l'optimisation des compilateurs est cruciale pour l'impl'ementation des langages fonctionnels. En particulier un certain nombre de cadres et d'algorithmes sophistiqu'es ont 'et'e propos'es pour l'analyse de strictness [4, 12], de chemin [3, 2, 15] et de globalisation [8, 14, 16]. La correction et la pr'ecision des analyses ont 'et'e beaucoup 'etudi'ees et plusieurs techniques ont 'et'e r'ecemment propos'ees pour am'eliorer l'efficacit'e des analyseurs [11, 13]. En d'epit du fait que l'interpr'etation abstraite a 'et'e `a l'origine d'efinie dans un cadre op'erationnel [6], la plupart des analyseurs pour les langages fonctionnels sont bas'es sur des interpr'etations abstraites de
c○2000 Elsevier Publishing, published in TCS Volume 248/12 Abstract LambdaDropping: Transforming Recursive Equations into Programs with Block Structure
"... Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack of block structure and lexical scope, recursive equati ..."
Abstract
 Add to MetaCart
(Show Context)
Lambdalifting a blockstructured program transforms it into a set of recursive equations. We present the symmetric transformation: lambdadropping. Lambdadropping a set of recursive equations restores block structure and lexical scope. For lack of block structure and lexical scope, recursive equations must carry around all the parameters that any of their callees might possibly need. Both lambdalifting and lambdadropping thus require one to compute Def/Use paths: • for lambdalifting: each of the functions occurring in the path of a free variable is passed this variable as a parameter; • for lambdadropping: parameters which are used in the same scope as their definition do not need to be passed along in their path. A program whose blocks have no free variables is scopeinsensitive. Its blocks are then free to float (for lambdalifting) or to sink (for lambdadropping) along the vertices of the scope tree. Preprint submitted to Elsevier Preprint 2 May 2001 To summarize: lambda lifting � � recursive� � equations block block floating sinking lambda scopeinsensitive � � program dropping parameter parameter lifting dropping blockstructured program Our primary application is partial evaluation. Indeed, many partial evaluators for procedural programs operate on recursive equations. To this end, they lambdalift source programs in a preprocessing phase. But often, partial evaluators [automatically] produce residual recursive equations with dozens of parameters, which most compilers do not handle efficiently. We solve this critical problem by lambdadropping residual programs in a postprocessing phase, which significantly improves both their compile time and their run time. To summarize: source blockstructured lambdalifting source recursive