We develop a formal, type-theoretic account of the basic mechanisms of object-oriented programming: encapsulation, message passing, subtyping, and inheritance. By modeling object encapsulation in terms of existential types instead of the recursive records used in other recent studies, we obtain a substantial simplification both in the model of objects and in the underlying typed -calculus.

We develop an imperative calculus that provides a formal model for both single and mixin inheritance. By introducing classes and mixins as the basic object-oriented constructs in a -calculus with records and references, we obtain a system with an intuitive operational semantics. New

We propose a new approach to adding objects to Standard ML (SML) based on explicit declarations of object types, object constructors, and subtyping relationships, with a generalization of the SML case statement to a "typecase" on object types. The language, called Object ML (OML), has a type system that conservatively extends the SML type system, preserves sound static typing, and permits type inference. The type system sacrifices some of the expressiveness found in recently proposed schemes, but has the virtue of simplicity. We give examples of how features found in other object-oriented languages can be emulated in OML, discuss the formal properties of OML, and describe some implementation issues. Keywords: Programming language design, object-oriented programming, functional programming, Standard ML. 1 Introduction A fundamental tension of language design is "keeping the language small" versus "providing support for common idioms. " This fundamental tension can be seen clearly in S...

It is widely agreed that recursive types are inherent in the static typing of the essential mechanisms of objectoriented programming: encapsulation, message passing, subtyping, and inheritance. We demonstrate here that modeling object encapsulation in terms of existential types yields a substantially more straightforward explanation of these features in a simpler calculus without recursive types. 1 Introduction Static type systems for object-oriented programming languages have progressed significantly in the past decade. The line of research begun by Cardelli [11] and continued by Cardelli [18, 17, 14, 13], Mitchell [32, 10, 33], Bruce [8, 5, 7], and others [31, 39, 21, 10, 23, 20, 19, 26, 29, 44, 45, 46] has culminated in type-theoretic accounts [6, 14] of many of the features of languages like Smalltalk [28]. Our goal here is to reformulate the essential mechanisms of these accounts using a simpler type theory: we give a complete model of encapsulation, message passing, subtyping, ...

A well-known shortcoming of the object model of Simula and Smalltalk is the inability to deal cleanly with methods that require access to the internal state of more than one object at a time. Recent language designs have therefore extended the basic object model with notions such as friends' methods and protected features, which allow external access to the internal state of objects but limit the scope in which such access can be used. We show that a variant of this idea can be added to any type-theoretic model of the basic object-oriented mechanisms (encapsulation, message passing, and inheritance), using a construction based on Cardelli and Wegner's partially abstract types, a refinement of Mitchell and Plotkin's type-theoretic treatment of abstract types.

System F≤ is an extension of second-order typed lambda calculus, where a subtype hierarchy among types is defined, and bounded second-order lambda abstraction is allowed. This language is a basis for much of the current research on integration of typed functional languages with subtypes and inheritance. An algorithm to perform type checking for F≤ expressions has been known since the language Fun was defined. The algorithm has been proved complete, by the author and P.-L. Curien, which means that it is a semi-decision procedure for the type-checking problem. In this paper we show that this algorithm is not a decision procedure, by exhibiting a term which makes it diverge. This result was the basis of Pierce's proof of undecidability of typing for F≤. We study the behavior of the algorithm to show that our diverging judgement is in some sense contained in any judgement which makes the algorithm diverge. On the basis of this result, and of other results in the paper, we claim that the c...

We present an imperative calculus for a class-based language. By introducing classes as the basic object-oriented construct in a -calculus with records and references, we obtain a system with an intuitive operational semantics. Objects are instantiated from classes and represented by records. The type system for objects uses only functional, record, and reference types, and there is a clean separation between subtyping and inheritance. We demonstrate that the calculus is sound and suciently expressive to model advanced language features such as inheritance with method rede nition, multi-level encapsulation, and modular object construction.

The Curry--Howard isomorphism, a fundamental property shared by many type theories, establishes a direct correspondence between programs and proofs. This suggests that the same structuring principles that ease programming be used to simplify proving as well. To exploit object-oriented structuring mechanisms for verification, we extend the object-model of Pierce and Turner, based on the higher order typed -calculus F ! , with a proof component. By enriching the (functional) signature of objects with a specification, the methods and their correctness proofs are packed together in the objects. The uniform treatment of methods and proofs gives rise in a natural way to object-oriented proving principles --- including inheritance of proofs, late binding of proofs, and encapsulation of proofs --- as analogues to object-oriented programming principles. We have used Lego, a type-theoretic proof checker, to explore the feasibility of this approach. In particular, we have verified a small hier...

There are now several type-theoretic models for object-oriented languages based on higherorder polymorphic lambda-calculi [Bru92, Bru93, CCH 89, CHC90, Mit90, PT93]. It has been claimed that these models can be extended straightforwardly to handle objects with mutable state. Following a suggestion of Didier R'emy, we verify this claim for the model proposed in [PT93].