Zena M. Ariola

A call-by-need lambda calculus

The mismatch between the operational semantics of the lambda calculus and the actual behavior of implementations is a major obstacle for compiler writers. They cannot explain the behavior of their evaluator in terms of source level syntax, and they cannot easily compare distinct implementations of different lazy strategies. In this paper we derive an equational characterization of call-by-need and prove it correct with respect to the original lambda calculus. The theory is a strictly smaller theory than the lambda calculus. Immediate applications of the theory concern the correctness proofs of a number of implementation strategies, e.g., the call-by-need continuation passing transformation and the realization of sharing via assignments.

EQUATIONAL TERM GRAPH REWRITING

We present an equational framework for term graph rewriting with cycles. The usual notion of homomorphism is phrased in terms of the notion of bisimulation, which is well-known in process algebra and concurrency theory. Specifically, a homomorphism is a functional bisimulation. We prove that the bisimilarity class of a term graph, partially ordered by functional bisimulation, is a complete lattice. It is shown how Equational Logic induces a notion of copying and substitution on term graphs, or systems of recursion equations, and also suggests the introduction of hidden or nameless nodes in a term graph. Hidden nodes can be used only once. The general framework of term graphs with copying is compared with the more restricted copying facilities embodied in the μ-rule. Next, orthogonal term graph rewrite systems, also in the presence of copying and hidden nodes, are shown to be confluent.

Cyclic Lambda Calculi

We precisely characterize a class of cyclic lambda-graphs, and then give a sound and complete axiomatization of the terms that represent a given graph. The equational axiom system is an extension of lambda calculus with the letrec construct. In contrast to current theories, which impose restrictions on where the rewriting can take place, our theory is very liberal, e.g., it allows rewriting under lambda-abstractions and on cycles. As shown previously, the reduction theory is non-confluent. We thus introduce an approximate notion of confluence. Using this notion we define the infinite normal form or Levy-Longo tree of a cyclic term. We show that the infinite normal form defines a congruence on the set of terms. We relate our cyclic lambda calculus to the traditional lambda calculus and to the infinitary lambda calculus. Since most implementations of non-strict functional languages rely on sharing to avoid repeating computations, we develop a variant of our calculus that enforces the sharing of computations and show that the two calculi are observationally equivalent. For reasoning about strict languages we develop a call-by-value variant of the sharing calculus. We state the difference between strict and non-strict computations in terms of different garbage collection rules. We relate the call-by-value calculus to Moggis computational lambda calculus and to Hasegawas calculus.

Skew confluence and the lambda calculus with letrec

Abstract We present an extension of the lambda calculus with the letrec construct. In contrast to current theories, which impose restrictions on where the rewriting can take place, our theory is very liberal, e.g., it allows rewriting under lambda abstractions and on cycles. As shown previously, the reduction theory is non-confluent. Thus, we searched for and found a new property that resembles confluence and that is equivalent to uniqueness of infinite normal forms: skew confluence. This notion is based on the intuition that some terms are better than others and that terms reduce to better terms. It states that if a term reduces to two other terms, the second of those terms can always be reduced to a term that is better than the first. Using skew confluence we define the infinite normal form of a term and show that the infinite normal form defines a congruence on the set of terms. We relate the lambda calculus plus letrec to the plain lambda calculus and to one of the infinitary lambda calculi. We also present a variant of our calculus, which follows the tradition of the explicit substitution calculi.

Properties of a first-order functional language with sharing

A calculus and a model for a first-order functional language with sharing is presented. In most implementations of functional languages, argument subexpressions in a function application are shared to avoid their repeated evaluation. Recursive functions are typically implemented using graphs with cycles. Compilers for these languages sometimes employ non-left-linear and left-cyclic rules for optimizations. A graph rewriting system (GRS) to address these concerns is developed. It is shown that a GRS without interfering rules is confluent. Along the lines of Levys term model for the λ-calculus, a semantics of such a GRS is also presented. An application of the term model to compiler optimizations is discussed.

A type-theoretic foundation of continuations and prompts

There is a correspondence between classical logic and programming language calculi with first-class continuations. With the addition of control delimiters (prompts), the continuations become composable and the calculi are believed to become more expressive. We formalise that the addition of prompts corresponds to the addition of a single dynamically-scoped variable modelling the special top-level continuation. From a type perspective, the dynamically-scoped variable requires effect annotations. From a logic perspective, the effect annotations can be understood in a standard logic extended with the dual of implication, namely subtraction.

Correctness of monadic state: an imperative call-by-need calculus

The extension of Haskell with a built-in state monad combines mathematical elegance with operational efficiency: ¿Semantically, at the source language level, constructs that act on the state are viewed as functions that pass an explicit store data structure around. ¿Operationally, at the implementation level, constructs that act on the state are viewed as statements whose evaluation has the side-effect of updating the implicit global store in place.There are several unproven conjectures that the two views are consistent.Recently, we have noted that the consistency of the two views is far from obvious: all it takes for the implementation to become unsound is one judiciously-placed beta-step in the optimization phase of the compiler. This discovery motivates the current paper in which we formalize and show the correctness of the implementation of monadic state.For the proof, we first design a typed call-by-need language that models the intermediate language of the compiler, together with a type-preserving compilation map. Second, we show that the compilation is semantics-preserving by proving that the compilation of every source axiom yields an observational equivalence of the target language. Because of the wide semantic gap between the source and target languages, we perform this last step using an additional intermediate language.The imperative call-by-need ¿-Calculus is of independent interest for reasoning about system-level Haskell code providing services such as memo-functions, generation of new names, etc., and is the starting point for reasoning about the space usage of Haskell programs.

Order-of-evaluation analysis for destructive updates in strict functional languages with flat aggregates

The aggregate update problem in functional languages is concerned with detecting cases where a functional array or record update operation can be implemented destructively in constant time. Previous work on this moblem has as. sumed a fixed order of evaluation of expressions. In this paper we devise a practical analysis, for first order strict functional languages with flat aggregates, that derives a good order of evaluation for making the updates destructive. We show that for programs with no aliasing, our analysis is more precise than Hudak’s abstract reference counting [16], even if the fixed order of evaluation assumed by Hudak happens to be the right order. We also show that our analysis algorithm runs in polynomial time, and in close to linear time for typical programs. To the best of our knowledge, all previous algorithms of this kind require exponential time.

P-TAC: a parallel intermediate language

P-TAC is an intermediate-level language designed to capture the sharing of computation. It is a more suitable internal language for functional language compilers than the X-calculus or combinators, especially for compiler optimize, tions. Using P-TAC, a proof for the confluence of Id, a higher-order functional language augmented with I-structures? is given. Using the notion of observational congruence the correctness of some compiler optimizations is shown.

A proof-theoretic foundation of abortive continuations

Abstract We give an analysis of various classical axioms and characterize a notion of minimal classical logic that enforces Peirce’s law without enforcing Ex Falso Quodlibet. We show that a “natural” implementation of this logic is Parigot’s classical natural deduction. We then move on to the computational side and emphasize that Parigot’s λμ corresponds to minimal classical logic. A continuation constant must be added to λμ to get full classical logic. The extended calculus is isomorphic to a syntactical restriction of Felleisen’s theory of control that offers a more expressive reduction semantics. This isomorphic calculus is in correspondence with a refined version of Prawitz’s natural deduction.