Results 1  10
of
210
A Natural Semantics for Lazy Evaluation
, 1993
"... We define an operational semantics for lazy evaluation which provides an accurate model for sharing. The only computational structure we introduce is a set of bindings which corresponds closely to a heap. The semantics is set at a considerably higher level of abstraction than operational semantics f ..."
Abstract

Cited by 210 (3 self)
 Add to MetaCart
We define an operational semantics for lazy evaluation which provides an accurate model for sharing. The only computational structure we introduce is a set of bindings which corresponds closely to a heap. The semantics is set at a considerably higher level of abstraction than operational semantics for particular abstract machines, so is more suitable for a variety of proofs. Furthermore, because a heap is explicitly modelled, the semantics provides a suitable framework for studies about space behaviour of terms under lazy evaluation.
Compiling Standard ML to Java bytecodes
 IN THIRD ACM SIGPLAN INTERNATIONAL CONFERENCE ON FUNCTIONAL PROGRAMMING
, 1998
"... ..."
The Polymorphic Picalculus: Theory and Implementation
, 1995
"... We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a su ..."
Abstract

Cited by 107 (0 self)
 Add to MetaCart
We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a suitable foundation for the type system of a concurrent programming language. The second half of the dissertation considers how to implement the πcalculus efficiently, starting with an abstract machine for πcalculus and finally presenting a compilation of πcalculus to C. We start the dissertation by presenting a simple, structural type system for πcalculus, and then, after proving the soundness of our type system, show how to infer principal types for πterms. This simple type system can be extended to include useful typetheoretic constructions such as recursive types and higherorder polymorphism. Higherorder polymorphism is important, since it gives us the ability to implement abstract datatypes in a typesafe manner, thereby providing a greater degree of modularity for πcalculus programs. The functional computational paradigm plays an important part in many programming languages. It is wellknown that the πcalculus can encode functional computation. We go further and show that the type structure of λterms is preserved by such encodings, in the sense that we can relate the type of a λterm to the type of its encoding in the πcalculus. This means that a πcalculus programming language can genuinely support typed functional programming as a special case. An efficient implementation of πcalculus is necessary if we wish to consider πcalculus as an operational foundation for concurrent programming. We first give a simple abstract machine for πcalculus and prove it correct. We then show how this abstract machine inspires a simple, but efficient, compilation of πcalculus to C (which now forms the basis of the Pict programming language implementation).
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 89 (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...
A transformationbased optimiser for Haskell
, 1998
"... Many compilers do some of their work by means of correctnesspreserving, and hopefully performanceimproving, program transformations. The Glasgow Haskell Compiler (GHC) takes this idea of "compilation by transformation" as its warcry, trying to express as much as possible of the compilat ..."
Abstract

Cited by 87 (12 self)
 Add to MetaCart
Many compilers do some of their work by means of correctnesspreserving, and hopefully performanceimproving, program transformations. The Glasgow Haskell Compiler (GHC) takes this idea of "compilation by transformation" as its warcry, trying to express as much as possible of the compilation process in the form of program transformations. This paper reports on our practical experience of the transformational approach to compilation, in the context of a substantial compiler.
A Compiled Implementation of Strong Reduction
"... Motivated by applications to proof assistants based on dependent types, we develop and prove correct a strong reducer and b equivalence checker for the lcalculus with products, sums, and guarded fixpoints. Our approach is based on compilation to the bytecode of an abstract machine performing weak ..."
Abstract

Cited by 82 (5 self)
 Add to MetaCart
Motivated by applications to proof assistants based on dependent types, we develop and prove correct a strong reducer and b equivalence checker for the lcalculus with products, sums, and guarded fixpoints. Our approach is based on compilation to the bytecode of an abstract machine performing weak reductions on nonclosed terms, derived with minimal modifications from the ZAM machine used in the Objective Caml bytecode interpreter, and complemented by a recursive "read back" procedure. An implementation in the Coq proof assistant demonstrates important speedups compared with the original interpreterbased implementation of strong reduction in Coq.
Deriving a Lazy Abstract Machine
 Journal of Functional Programming
, 1997
"... Machine Peter Sestoft Department of Mathematics and Physics Royal Veterinary and Agricultural University Thorvaldsensvej 40, DK1871 Frederiksberg C, Denmark Email: sestoft@dina.kvl.dk Version 6 of March 13, 1996 Abstract We derive a simple abstract machine for lazy evaluation of the lambda cal ..."
Abstract

Cited by 77 (2 self)
 Add to MetaCart
Machine Peter Sestoft Department of Mathematics and Physics Royal Veterinary and Agricultural University Thorvaldsensvej 40, DK1871 Frederiksberg C, Denmark Email: sestoft@dina.kvl.dk Version 6 of March 13, 1996 Abstract We derive a simple abstract machine for lazy evaluation of the lambda calculus, starting from Launchbury's natural semantics. Lazy evaluation here means nonstrict evaluation with sharing of argument evaluation, that is, callbyneed. The machine we derive is a lazy version of Krivine's abstract machine, which was originally designed for callbyname evaluation. We extend it with datatype constructors and base values, so the final machine implements all dynamic aspects of a lazy functional language. 1 Introduction The development of an efficient abstract machine for lazy evaluation usually starts from either a graph reduction machine or an environment machine. Graph reduction machines perform substitution by rewriting the term graph, that is, the program itself...
C: A Portable Assembly Language That Supports Garbage Collection
 IN INTERNATIONAL CONFERENCE ON PRINCIPLES AND PRACTICE OF DECLARATIVE PROGRAMMING
, 1999
"... For a compiler writer, generating good machine code for a variety of platforms is hard work. One might try to reuse a retargetable code generator, but code generators are complex and difficult to use, and they limit one's choice of implementation language. One might try to use C as a portabl ..."
Abstract

Cited by 70 (22 self)
 Add to MetaCart
For a compiler writer, generating good machine code for a variety of platforms is hard work. One might try to reuse a retargetable code generator, but code generators are complex and difficult to use, and they limit one's choice of implementation language. One might try to use C as a portable assembly language, but C limits the compiler writer's flexibility and the performance of the resulting code. The wide use of C, despite these drawbacks, argues for a portable assembly language. C is a new language designed expressly for this purpose. The use
From ML to Ada: Stronglytyped Language Interoperability via Source Translation
, 1993
"... We describe a system that supports sourcelevel integration of MLlike functional language code with ANSI C or Ada83 code. The system works by translating the functional code into typecorrect, "vanilla" C or Ada; it offers simple, efficient, typesafe interoperation between new functiona ..."
Abstract

Cited by 66 (3 self)
 Add to MetaCart
We describe a system that supports sourcelevel integration of MLlike functional language code with ANSI C or Ada83 code. The system works by translating the functional code into typecorrect, "vanilla" C or Ada; it offers simple, efficient, typesafe interoperation between new functional code components and "legacy" thirdgenerationlanguage components. Our translator represents a novel synthesis of techniques including userparameterized specification of primitive types and operators; removal of polymorphism by code specialization; removal of higherorder functions using closure datatypes and interpretation; and aggressive optimization of the resulting firstorder code, which can be viewed as encoding the result of a closure analysis. Programs remain fully typed at every stage of the translation process, using only simple, standard type systems. Target code runs at speeds comparable to the output of current optimizing ML compilers, even though handicapped by a conservative garbage collector.
Implementing Typed Intermediate Languages
, 1998
"... Recent advances in compiler technology have demonstrated the benefits of using strongly typed intermediate languages to compile richly typed source languages (e.g., ML). A typepreserving compiler can use types to guide advanced optimizations and to help generate provably secure mobile code. Types, u ..."
Abstract

Cited by 64 (16 self)
 Add to MetaCart
(Show Context)
Recent advances in compiler technology have demonstrated the benefits of using strongly typed intermediate languages to compile richly typed source languages (e.g., ML). A typepreserving compiler can use types to guide advanced optimizations and to help generate provably secure mobile code. Types, unfortunately, are very hard to represent and manipulate efficiently; a naive implementation can easily add exponential overhead to the compilation and execution of a program. This paper describes our experience with implementing the FLINT typed intermediate language in the SML/NJ production compiler. We observe that a typepreserving compiler will not scale to handle large types unless all of its typepreserving stages preserve the asymptotic time and space usage in representing and manipulating types. We present a series of novel techniques for achieving this property and give empirical evidence of their effectiveness.