Recent years have seen the development of several foundational models for statically typed object-oriented programming. But despite their intuitive similarity, di erences in the technical machinery used to formulate the various proposals have made them di cult to compare. Using the typed lambda-calculus F! as a common basis, we nowo er a detailed comparison of four models: (1) a recursive-record encoding similar to the ones used by Cardelli [Car84],

We describe an object calculus that allows both extension of objects and full width subtyping (hiding arbitrary components). In contrast to other proposals, the types of our calculus do not mention "missing " methods. To avoid type unsoundness, the calculus mediates all interaction with objects via "dictionaries" that resemble the method dispatch tables in conventional implementations. Private fields and methods can be modeled and enforced by scoping restrictions: forgetting a field or method through subsumption makes it private. We prove that the type system is sound, give a variant which allows covariant self types, and give some examples of the expressiveness of the calculus. 1 Introduction One of the most important principles of software engineering is information hiding: the ability to build and enforce data or procedural abstractions in order to make programs readable and maintainable. Most object-oriented programming languages provide direct support for information hiding. Clas...

Abstract not found

This paper presents an imperative object calculus designed to support class-based programming via a combination of extensible objects and encapsulation. This calculus simplifies the language presented in [17] in that, like C++ and Java, it chooses to support an imperative semantics instead of method specialization. We show how Java-style classes and "mixins" may be coded in this calculus, prove a type soundness theorem (via a subject reduction property), and give a sound and complete typing algorithm.

Abstract not found

In a call-by-value language, representing objects as recursive records requires using an unsafe fixpoint. We design, for a core language including extensible records, a type system which rules out unsafe recursion and still supports the reconstruction of a principal type. We illustrate the expressive power of this language with respect to object-oriented programming by introducing a sub-language for "mixin-based" programming.

Using a set-theoretic model of predicate transformers and ordered data types, we give a total-correctness semantics for a typed higher-order imperative programming language that includes record extension, local variables, and proceduretype variables and parameters. The language includes infeasible speci cation constructs, for a calculus of re nement. Procedures may have global variables, subject to mild syntactic restrictions to avoid the semantic complications of Algol-like languages. The semantics is used to validate simple proof rules for non-interference, type extension, and calls of procedure variables and constants.

Abstract not found

We study a variant of System F that integrates and generalizes several existing proposals for calculi with structural typing rules. To the usual type constructors (!, \Theta, All, Some, Rec) we add a number of type destructors, each internalizing a useful fact about the subtyping relation. For example, in F with products every closed subtype of a product S\ThetaT must itself be a product S 0 \ThetaT 0 with S 0 !:S and T 0 !:T. We internalise this observation by introducing type destructors .1 and .2 and postulating an equivalence T = j T.1\ThetaT.2 whenever T !: U\ThetaV (including, for example, when T is a variable). In other words, every subtype of a product type literally is a product type, modulo j-conversion. Adding type destructors provides a clean solution to the problem of polymorphic update without introducing new term formers, new forms of polymorphism, or quantification over type operators. We illustrate this by giving elementary presentations of two well-known e...

The problem of defining and checking a subtype relation between recursive types was studied in [3] for a first order type system, but for second order systems, which combine subtyping and parametric polymorphism, only negative results are known [17].