Results 1  10
of
215
A Syntactic Approach to Type Soundness
 INFORMATION AND COMPUTATION
, 1992
"... We present a new approach to proving type soundness for Hindley/Milnerstyle polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory logic to programming languages, and (2) the use of rewriting techniques for the specification of the la ..."
Abstract

Cited by 634 (25 self)
 Add to MetaCart
(Show Context)
We present a new approach to proving type soundness for Hindley/Milnerstyle polymorphic type systems. The keys to our approach are (1) an adaptation of subject reduction theorems from combinatory logic to programming languages, and (2) the use of rewriting techniques for the specification of the language semantics. The approach easily extends from polymorphic functional languages to imperative languages that provide references, exceptions, continuations, and similar features. We illustrate the technique with a type soundness theorem for the core of Standard ML, which includes the first type soundness proof for polymorphic exceptions and continuations.
Abstract Models of Memory Management
, 1995
"... Most specifications of garbage collectors concentrate on the lowlevel algorithmic details of how to find and preserve accessible objects. Often, they focus on bitlevel manipulations such as "scanning stack frames," "marking objects," "tagging data," etc. While these d ..."
Abstract

Cited by 95 (18 self)
 Add to MetaCart
(Show Context)
Most specifications of garbage collectors concentrate on the lowlevel algorithmic details of how to find and preserve accessible objects. Often, they focus on bitlevel manipulations such as "scanning stack frames," "marking objects," "tagging data," etc. While these details are important in some contexts, they often obscure the more fundamental aspects of memory management: what objects are garbage and why? We develop a series of calculi that are just lowlevel enough that we can express allocation and garbage collection, yet are sufficiently abstract that we may formally prove the correctness of various memory management strategies. By making the heap of a program syntactically apparent, we can specify memory actions as rewriting rules that allocate values on the heap and automatically dereference pointers to such objects when needed. This formulation permits the specification of garbage collection as a relation that removes portions of the heap without affecting the outcome of the evaluation. Our highlevel approach allows us to specify in a compact manner a wide variety of memory management techniques, including standard tracebased garbage collection (i.e., the family of copying and mark/sweep collection algorithms), generational collection, and typebased, tagfree collection. Furthermore, since the definition of garbage is based on the semantics of the underlying language instead of the conservative approximation of inaccessibility, we are able to specify and prove the idea that type inference can be used to collect some objects that are accessible but never used.
On perfect supercompilation
 Journal of Functional Programming
, 1996
"... We extend positive supercompilation to handle negative as well as positive information. This is done by instrumenting the underlying unfold rules with a small rewrite system that handles constraints on terms, thereby ensuring perfect information propagation. We illustrate this by transforming a na ..."
Abstract

Cited by 93 (3 self)
 Add to MetaCart
We extend positive supercompilation to handle negative as well as positive information. This is done by instrumenting the underlying unfold rules with a small rewrite system that handles constraints on terms, thereby ensuring perfect information propagation. We illustrate this by transforming a naively specialised string matcher into an optimal one. The presented algorithm is guaranteed to terminate by means of generalisation steps.
Once Upon a Type
 In Functional Programming Languages and Computer Architecture
, 1995
"... A number of useful optimisations are enabled if we can determine when a value is accessed at most once. We extend the HindleyMilner type system with uses, yielding a typeinference based program analysis which determines when values are accessed at most once. Our analysis can handle higherorder fun ..."
Abstract

Cited by 90 (2 self)
 Add to MetaCart
A number of useful optimisations are enabled if we can determine when a value is accessed at most once. We extend the HindleyMilner type system with uses, yielding a typeinference based program analysis which determines when values are accessed at most once. Our analysis can handle higherorder functions and data structures, and admits principal types for terms. Unlike previous analyses, we prove our analysis sound with respect to callbyneed reduction. Callbyname reduction does not provide an accurate model of how often a value is used during lazy evaluation, since it duplicates work which would actually be shared in a real implementation. Our type system can easily be modified to analyse usage in a callbyvalue language. 1 Introduction This paper describes a method for determining when a value is used at most once. Our method is based on a simple modification of the HindleyMilner type system. Each type is labelled to indicate whether the corresponding value is used at most onc...
Models of Sharing Graphs: A Categorical Semantics of let and letrec
, 1997
"... To my parents A general abstract theory for computation involving shared resources is presented. We develop the models of sharing graphs, also known as term graphs, in terms of both syntax and semantics. According to the complexity of the permitted form of sharing, we consider four situations of sha ..."
Abstract

Cited by 75 (9 self)
 Add to MetaCart
(Show Context)
To my parents A general abstract theory for computation involving shared resources is presented. We develop the models of sharing graphs, also known as term graphs, in terms of both syntax and semantics. According to the complexity of the permitted form of sharing, we consider four situations of sharing graphs. The simplest is firstorder acyclic sharing graphs represented by letsyntax, and others are extensions with higherorder constructs (lambda calculi) and/or cyclic sharing (recursive letrec binding). For each of four settings, we provide the equational theory for representing the sharing graphs, and identify the class of categorical models which are shown to be sound and complete for the theory. The emphasis is put on the algebraic nature of sharing graphs, which leads us to the semantic account of them. We describe the models in terms of the notions of symmetric monoidal categories and functors, additionally with symmetric monoidal adjunctions and traced
Total Correctness by Local Improvement in the Transformation of Functional Programs
 ACM Transactions on Programming Languages and Systems
, 1996
"... ion. A common form of transformation, which is easily justified by appealing to reversibility, is abstraction. The abstraction transformation lifts some instances of subexpressions from the righthand sides of a set of definitions and replaces them with function calls for some new functions. The ab ..."
Abstract

Cited by 68 (6 self)
 Add to MetaCart
(Show Context)
ion. A common form of transformation, which is easily justified by appealing to reversibility, is abstraction. The abstraction transformation lifts some instances of subexpressions from the righthand sides of a set of definitions and replaces them with function calls for some new functions. The abstraction process can be used in conjunction with a callbyneed implementation to avoid repeated evaluation of subexpressions. A wellknown example is Hughes' supercombinator abstraction [Hughes 1982]. Another form of abstraction which is common in program transformation is syntactic generalization in which an expression e is replaced by a function call g e 1 : : : e n , where g is a new function defined by g x 1 : : : xn \Delta = e 0 , such that e j e 0 f e 1 : : : e n= x 1 : : : xn g. General statements about abstractions and their correctness are notationally rather complex. In practice we have found it is easier to appeal to a reversibility argument on a casebycase basis than...
A Reflection on CallbyValue
 ACM Transactions on Programming Languages and Systems
, 1996
"... This article is a revised and extended version of a paper that appeared in the ACM SIGPLAN International Conference on Functional Programming (Philadelphia, Pa.), 1996. Work started while the first author was at Chalmers University, and the second author was at University of Glasgow. Authors' a ..."
Abstract

Cited by 66 (6 self)
 Add to MetaCart
(Show Context)
This article is a revised and extended version of a paper that appeared in the ACM SIGPLAN International Conference on Functional Programming (Philadelphia, Pa.), 1996. Work started while the first author was at Chalmers University, and the second author was at University of Glasgow. Authors' addresses: A. Sabry, University of Oregon, Department of Computer and Information Science, Eugene, OR 97403; P. Wadler, Bell Laboratories, Lucent Technologies, 700 Mountain Avenue, Room 2T304, Murray Hill, NJ 079740636. Permission to make digital/hard copy of all or part of this material without fee is granted provided that the copies are not made or distributed for profit or commercial advantage, the ACM copyright/server notice, the title of the publication, and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery, Inc. (ACM). To copy otherwise, to republish, to post on servers, or to redistribute to lists requires prior specific permission and/or a fee. c fl 1997 ACM 01640925/97/09000111 $03.50
A Core Calculus of Classes and Mixins
, 1999
"... We develop an imperative calculus that provides a formal model for both single and mixin inheritance. By introducing classes and mixins as the basic objectoriented constructs in a calculus with records and references, we obtain a system with an intuitive operational semantics. New ..."
Abstract

Cited by 57 (16 self)
 Add to MetaCart
We develop an imperative calculus that provides a formal model for both single and mixin inheritance. By introducing classes and mixins as the basic objectoriented constructs in a calculus with records and references, we obtain a system with an intuitive operational semantics. New
The CallbyNeed Lambda Calculus
 Journal of Functional Programming
, 1994
"... We present a calculus that captures the operational semantics of callbyneed. The callbyneed lambda calculus is confluent, has a notion of standard reduction, and entails the same observational equivalence relation as the callbyname calculus. The system can be formulated with or without explici ..."
Abstract

Cited by 57 (3 self)
 Add to MetaCart
(Show Context)
We present a calculus that captures the operational semantics of callbyneed. The callbyneed lambda calculus is confluent, has a notion of standard reduction, and entails the same observational equivalence relation as the callbyname calculus. The system can be formulated with or without explicit let bindings, admits useful notions of marking and developments, and has a straightforward operational interpretation. Introduction The correspondence between callbyvalue lambda calculi and strict functional languages (such as the pure subset of Standard ML) is quite good; the correspondence between callby name lambda calculi and lazy functional languages (such as Miranda or Haskell) is not so good. Callbyname reevaluates an argument each time it is used, a prohibitive expense. Thus, many lazy languages are implemented using the callbyneed mechanism proposed by Wadsworth (1971), which overwrites an argument with its value the first time it is evaluated, avoiding the need for any s...
Observable sharing for functional circuit description
 In Asian Computing Science Conference
, 1999
"... Pure functional programming languages have been proposed as a vehicle to describe, simulate and manipulate circuit specifications. We propose an extension to Haskell to solve a standard problem when manipulating data types representing circuits in a lazy functional language. The problem is that cir ..."
Abstract

Cited by 53 (3 self)
 Add to MetaCart
Pure functional programming languages have been proposed as a vehicle to describe, simulate and manipulate circuit specifications. We propose an extension to Haskell to solve a standard problem when manipulating data types representing circuits in a lazy functional language. The problem is that circuits are finite graphs  but viewing them as an algebraic (lazy) datatype makes them indistinguishable from potentially infinite regular trees. However, implementations of Haskell do indeed represent cyclic structures by graphs. The problem is that the sharing of nodes that creates such cycles is not observable by any function which traverses such a structure. In this paper we propose an extension to callbyneed languages which makes graph sharing observable. The extension is based on non updatable reference cells and an equality test (sharing detection) on this type. We show that this simple and practical extension has wellbehaved semantic properties, which means that many typical sourcetosource program transformations, such as might be performed by a compiler, are still valid in the presence of this extension.