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 right-hand 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 call-by-need implementation to avoid repeated evaluation of subexpressions. A well-known 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 case-by-case basis than...

This paper shows how the Improvement Theorem---a semantic condition

Many type inference and program analysis systems include notions of subtyping and parametric polymorphism. When used together, these two features induce equivalences that allow types to be simplified by eliminating quantified variables. Eliminating variables both improves the readability of types and the performance of algorithms whose complexity depends on the number of type variables. We present an algorithm for simplifying quantified types in the presence of subtyping and prove it is sound and complete for non-recursive and recursive types.

We develop a theory of statically typed object-oriented languages. It represents classes as labeled, regular trees, types as finite sets of classes, and subclassing as a partial order on trees. We show that our subclassing order strictly generalizes inheritance, and that a novel genericity mechanism arises as an order-theoretic complement. This mechanism, called class substitution, is pragmatically useful and can be implemented efficiently.

Structural Operational Semantics (SOS) is a widely used formalism for specifying the computational meaning of programs, and is commonly used in specifying the semantics of functional languages. Despite this widespread use there has been relatively little work on the imetatheoryj for such semantics. As a consequence the operational approach to reasoning is considered ad hoc since the same basic proof techniques and reasoning tools are reestablished over and over, once for each operational semantics speciøcation. This paper develops some metatheory for a certain class of SOS language speciøcations for functional languages. We deøne a rule format, Globally Deterministic SOS (gdsos), and establish some proof principles for reasoning about equivalence which are sound for all languages which can be expressed in this format. More speciøcally, if the SOS rules for the operators of a language conform to the syntax of the gdsos format, then ffl a syntactic analogy of continuity holds, which rel...

Type inference can be phrased as constraint-solving over types. We consider an implicitly typed language equipped with recursive types, multiple inheritance, 1st order parametric polymorphism, and assignments. Type correctness is expressed as satisfiability of a possibly infinite collection of (monotonic) inequalities on the types of variables and expressions. A general result about systems of inequalities over semilattices yields a solvable form. We distinguish between deciding typability (the existence of solutions) and type inference (the computation of a minimal solution). In our case, both can be solved by means of nondeterministic finite automata; unusually, the two problems have different complexities: polynomial vs. exponential time.

A general method for the inference of recursive functions (programs) from examples of computations is described. It is based on the so called algebraic semantics of recursive program schemes and in this paper mainly applied to the representation and induction of infinite concepts and recursive action sequences (which are of importance for problem solving and hierarchical planning). Additionally, the use of recursive program schemes leads to a new principle of generalization in the sense that families of structures or classes of programs could be treated simultaneously and that already existing solutions of old problems could be transferred to new problems which have to be solved. 1.

An improvement theory is a variant of the standard theories of observational approximation (or equivalence) in which the basic observations made of a functional program's execution include some intensionalinformation about, for example, the program's computational cost. One program is an improvement of another if its execution is more efficient in any program context. In this article we give an overview of our work on the theory and applications of improvement. Applications include reasoning about time properties of functional programs, and proving the correctness of program transformation methods. We also introduce a new application, in the form of some bisimulationlike proof techniques for equivalence, with something of the flavour of Sangiorgi's "bisimulation up-to expansion and context".

.We study properties of rewrite systems that are not necessarily terminating, but allow instead for trans#nite derivations that have a limit. In particular, we give conditions for the existence of a limit and for its uniqueness and relate the operational and algebraic semantics of in#nitary theories. We also consider su#cient completeness of hierarchical systems. Is there no limit? ---Job 16:3 1. Introduction Rewrite systems are sets of directed equations used to compute by repeatedly replacing equal terms in a given formula, as long as possible. For one approach to their use in computing, see #23#. The theory of rewriting is an outgrowth of the study of the lambda calculus and combinatory logic, and # Preliminary versions #6, 7# of ideas in this paper were presented at the Sixteenth ACM Symposium on Principles of Programming Languages, Austin, TX #January 1989# and at the Sixteenth EATCS International Colloquium on Automata, Languages and Programming, Stresa, Italy #July 1989#. ...

A system of hierarchical, fully recursive types in a truly imperative language allows program fragments written for small types to be reused for all larger types. To exploit this property to enable type-safe hierarchical procedures, it is necessary to impose a static requirement on procedure calls. We introduce an example language and prove the existence of a sound requirement which preserves static correctness while allowing hierarchical procedures. This requirement is further shown to be optimal, in the sense that it imposes as few restrictions as possible. This establishes the theoretical basis for a general type hierarchy with static type checking, which enables 1st order polymorphism combined with multiple inheritance and specialization in a language with assignments. We extend the results to include opaque types. An opaque version of a type is different from the original but has the same values and the same order relations to other types. The opaque types allow a mo...