Results 1  10
of
255
Computational Interpretations of Linear Logic
 Theoretical Computer Science
, 1993
"... We study Girard's Linear Logic from the point of view of giving a concrete computational interpretation of the logic, based on the CurryHoward isomorphism. In the case of Intuitionistic Linear Logic, this leads to a refinement of the lambda calculus, giving finer control over order of evaluation an ..."
Abstract

Cited by 280 (3 self)
 Add to MetaCart
We study Girard's Linear Logic from the point of view of giving a concrete computational interpretation of the logic, based on the CurryHoward isomorphism. In the case of Intuitionistic Linear Logic, this leads to a refinement of the lambda calculus, giving finer control over order of evaluation and storage allocation, while maintaining the logical content of programs as proofs, and computation as cutelimination.
The Revised Report on the Syntactic Theories of Sequential Control and State
 Theoretical Computer Science
, 1992
"... The syntactic theories of control and state are conservative extensions of the v calculus for equational reasoning about imperative programming facilities in higherorder languages. Unlike the simple v calculus, the extended theories are mixtures of equivalence relations and compatible congruen ..."
Abstract

Cited by 255 (36 self)
 Add to MetaCart
The syntactic theories of control and state are conservative extensions of the v calculus for equational reasoning about imperative programming facilities in higherorder languages. Unlike the simple v calculus, the extended theories are mixtures of equivalence relations and compatible congruence relations on the term language, which significantly complicates the reasoning process. In this paper we develop fully compatible equational theories of the same imperative higherorder programming languages. The new theories subsume the original calculi of control and state and satisfy the usual ChurchRosser and Standardization Theorems. With the new calculi, equational reasoning about imperative programs becomes as simple as reasoning about functional programs. 1 The syntactic theories of control and state Most calculusbased programming languages provide imperative programming facilities such as assignment statements, exceptions, and continuations. Typical examples are ML [16], Schem...
A FormulaeasTypes Notion of Control
 In Conference Record of the Seventeenth Annual ACM Symposium on Principles of Programming Languages
, 1990
"... The programming language Scheme contains the control construct call/cc that allows access to the current continuation (the current control context). This, in effect, provides Scheme with firstclass labels and jumps. We show that the wellknown formulaeastypes correspondence, which relates a constr ..."
Abstract

Cited by 240 (0 self)
 Add to MetaCart
The programming language Scheme contains the control construct call/cc that allows access to the current continuation (the current control context). This, in effect, provides Scheme with firstclass labels and jumps. We show that the wellknown formulaeastypes correspondence, which relates a constructive proof of a formula ff to a program of type ff, can be extended to a typed Idealized Scheme. What is surprising about this correspondence is that it relates classical proofs to typed programs. The existence of computationally interesting "classical programs"  programs of type ff, where ff holds classically, but not constructively  is illustrated by the definition of conjunctive, disjunctive, and existential types using standard classical definitions. We also prove that all evaluations of typed terms in Idealized Scheme are finite.
The Lazy Lambda Calculus
 Research Topics in Functional Programming
, 1990
"... Introduction The commonly accepted basis for functional programming is the calculus; and it is folklore that the calculus is the prototypical functional language in puri ed form. But what is the calculus? The syntax is simple and classical; variables, abstraction and application in the pure cal ..."
Abstract

Cited by 239 (3 self)
 Add to MetaCart
Introduction The commonly accepted basis for functional programming is the calculus; and it is folklore that the calculus is the prototypical functional language in puri ed form. But what is the calculus? The syntax is simple and classical; variables, abstraction and application in the pure calculus, with applied calculi obtained by adding constants. The further elaboration of the theory, covering conversion, reduction, theories and models, is laid out in Barendregt's already classical treatise [Bar84]. It is instructive to recall the following crux, which occurs rather early in that work (p. 39): Meaning of terms: rst attempt The meaning of a term is its normal form (if it exists). All terms without normal forms are identi ed. This proposal incorporates such a simple and natural interpretation of the calculus as
A Foundation for Actor Computation
 Journal of Functional Programming
, 1998
"... We present an actor language which is an extension of a simple functional language, and provide a precise operational semantics for this extension. Actor configurations represent open distributed systems, by which we mean that the specification of an actor system explicitly takes into account the in ..."
Abstract

Cited by 222 (51 self)
 Add to MetaCart
We present an actor language which is an extension of a simple functional language, and provide a precise operational semantics for this extension. Actor configurations represent open distributed systems, by which we mean that the specification of an actor system explicitly takes into account the interface with external components. We study the composability of such systems. We define and study various notions of testing equivalence on actor expressions and configurations. The model we develop provides fairness. An important result is that the three forms of equivalence, namely, convex, must, and may equivalences, collapse to two in the presence of fairness. We further develop methods for proving laws of equivalence and provide example proofs to illustrate our methodology.
Standard ML of New Jersey
 Third Int'l Symp. on Prog. Lang. Implementation and Logic Programming
, 1991
"... The Standard ML of New Jersey compiler has been under development for five years now. We have developed a robust and complete environment for Standard ML that supports the implementation of large software systems and generates efficient code. The compiler has also served as a laboratory for developi ..."
Abstract

Cited by 195 (14 self)
 Add to MetaCart
The Standard ML of New Jersey compiler has been under development for five years now. We have developed a robust and complete environment for Standard ML that supports the implementation of large software systems and generates efficient code. The compiler has also served as a laboratory for developing novel implementation techniques for a sophisticated type and module system, continuation based code generation, efficient pattern matching, and concurrent programming features.
Typed closure conversion
 In Proceedings of the 23th Symposium on Principles of Programming Languages (POPL
, 1996
"... The views and conclusions contained in this document are those of the authors and should not be interpreted as representing o cial policies, either expressed or implied, of the Advanced Research Projects Agency or the U.S. Government. Any opinions, ndings, and conclusions or recommendations expresse ..."
Abstract

Cited by 154 (22 self)
 Add to MetaCart
The views and conclusions contained in this document are those of the authors and should not be interpreted as representing o cial policies, either expressed or implied, of the Advanced Research Projects Agency or the U.S. Government. Any opinions, ndings, and conclusions or recommendations expressed in this material are those of the We study the typing properties of closure conversion for simplytyped and polymorphiccalculi. Unlike most accounts of closure conversion, which only treat the untypedcalculus, we translate welltyped source programs to welltyped target programs. This allows later compiler phases to take advantage of types for representation analysis and tagfree garbage collection, and it facilitates correctness proofs. Our account of closure conversion for the simplytyped language takes advantage of a simple model of objects by mapping closures to existentials. Closure conversion for the polymorphic language requires additional type machinery, namely translucency in the style of Harper and Lillibridge's module calculus, to express the type of a closure.
A Linearly Typed Assembly Language
 In Workshop on Types in Compilation
"... Today's typesafe lowlevel languages rely on garbage collection to recycle heapallocated objects safely. We present LTAL, a safe, lowlevel, yet simple language that "stands on its own": it guarantees safe execution within a fixed memory space, without relying on external runtime support. We demo ..."
Abstract

Cited by 145 (35 self)
 Add to MetaCart
Today's typesafe lowlevel languages rely on garbage collection to recycle heapallocated objects safely. We present LTAL, a safe, lowlevel, yet simple language that "stands on its own": it guarantees safe execution within a fixed memory space, without relying on external runtime support. We demonstrate the expressiveness of LTAL by giving a typepreserving compiler for the functional core of ML. But this independence comes at a steep price: LTAL's type system imposes a draconian discipline of linearity that ensures that memory can be reused safely, but prohibits any useful kind of sharing. We present the results of experiments with a prototype LTAL system that show just how high the price of linearity can be.
Efficient Compilation of Lazy Evaluation
 SIGPLAN NOTICES
, 1984
"... This paper describes the principles underlying an efficient implementation of a lazy functional language, compiling to code for ordinary computers. It is based on combinatorlike graph reduction: the user defined functions are used as rewrite rules in the graph. Each function is compiled into an ins ..."
Abstract

Cited by 121 (8 self)
 Add to MetaCart
This paper describes the principles underlying an efficient implementation of a lazy functional language, compiling to code for ordinary computers. It is based on combinatorlike graph reduction: the user defined functions are used as rewrite rules in the graph. Each function is compiled into an instruction sequence for an abstract graph reduction machine, called the Gmachine, the code reduces a function application graph to its value. The Gmachine instructions are then translated into target code. Speed improvements by almost two orders of magnitude over previous lazy evaluators have been measured; we provide some performance figures.