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.

PolyTOIL is a new statically-typed polymorphic object-oriented programming language that is provably type-safe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the type-checking rules, we have obtained a language that is very expressive while supporting modular type-checking of classes. The matching relation on types, which is related to F-bounded quanti cation, is used both in stating type-checking rules and expressing the bounds on type parameters for polymorphism. The design of PolyTOIL is based on a careful formal de nition of type-checking rules and semantics.

In order to illuminate the fundamental concepts involved in object-oriented programming languages, we describe the design of TOOPL, a paradigmatic, statically-typed, functional, object-oriented programming language which supports classes, objects, methods, hidden instance variables, subtypes, and inheritance. It has proven to be quite difficult to design such a language which has a secure type system. A particular problem with statically type checking object-oriented languages is designing type-checking rules which ensure that methods provided in a superclass will continue to be type correct when inherited in a subclass. The type-checking rules for TOOPL have this feature, enabling library suppliers to provide only the interfaces of classes with actual executable code, while still allowing users to safely create subclasses. In order to achieve greater expressibility while retaining type-safety, we choose to separate the inheritance and subtyping hierarchy in the language. The design of...

This paper addresses the problem of designing an object-oriented programming language with an effective type inference mechanism. Recently developed programming languages including Standard ML and Haskell incorporate type inference as a core component of the language. However, type inference has yet to achieve practical application to object-oriented programming languages. We strongly feel the core type features necessary to model object-oriented programming with type inference include a notion of subtyping [CW85], and a notion of "recursively constrained polymorphism," a generalization of F-bounded polymorphism [CHC90, CCH

. This paper presents an untyped object calculus that reflects the capabilities of so-called delegation-based object-oriented languages. A type inference system allows static detection of errors, such as message not understood, while at the same time allowing the type of an inherited method to be specialized to the type of the inheriting object. The main advance over previous work is the provision for subtyping in the presence of delegation primatives. This is achieved by distinguishing a prototype, whose methods may be extended or replaced, from an object, which only responds to messages for which it already has methods. An advantage of this approach is that we have full subtyping without restricting the "runtime " use of inheritance. Type soundness is proved using operational semantics and an analysis of typing derivations. 1 Introduction There are two basic forms of object-oriented languages, the most common of which is class-based. In these languages, which include C [Str86, ES9...

. In this paper we give semantics to Loop, an expressive typed object-oriented programming language with updatable instance variables. Loop has a rich type system that allows for the typing of methods operating over an open-ended "self " type. We prove the type system given is sound; i.e., well-typed programs do not experience "message not understood" errors. The semantics of Loop is given by a translation into a state-based language, Soop, that contains reference cells, records, and a form of F-bounded polymorphic type. Keywords: Object-oriented programming, type systems, state in programming 1. Introduction Developing full and faithful type systems for object-oriented programming languages is a well-known and difficult research problem. To frame the problem we desire a static type system that preserves all of the classic features of (untyped) class-based OOP, including treatment of two particularly difficult issues: binary methods and object subsumption. Significant steps have rece...

Important strides toward developing expressive yet semantically sound type systems for object-oriented programming languages have recently been made by Cook, Bruce, Mitchell, and others. This paper focusses on how the theoretical work using F-bounded quantification may be brought more into the realm of actual language implementations while preserving rigorous soundness properties. We simultaneously address three of the more significant problems: adding a notion of global state, proving type-checking is decidable, and integrating the more widely implemented view that subclasses correspond to subtypes with the F-bounded view. 1 Introduction Developing expressive yet semantically sound type systems for object-oriented programming languages is a well-known and difficult research problem. Many workable solutions are possible, but there has as of yet been no universally accepted solution to the problem. To frame the problem we desire a static type system that preserves all of the classic ...

We develop an imperative calculus of objects that is both tiny and expressive. Our calculus provides a minimal setting in which to study the operational semantics and the typing rules of object-oriented languages. We prove type soundness using a simple subject-reduction approach.

This paper addresses the issue of giving a formal semantics to an object-oriented programming and specification language. Object-oriented constructs considered are objects with attributes and methods, encapsulation of attributes, subtyping, bounded type parameters, classes, and inheritance. Classes are distinguished from object types. Besides usual imperative statements, specification statements are included. Specification statements allow changes of variables to be described by a predicate. They are abstract in the sense that they are non-executable. Specification statements may appear in method bodies of classes, leading to abstract classes. The motivation for this approach is that abstract classes can be used for problem -oriented specification in early stages and later refined to efficient implementations. Various refinement calculi provide laws for procedural and data refinement, which can be used here for class refinement. This paper, however, focuses on the semantics of object-o...

This thesis describes the language PolyTOIL, a type-safe, polymorphic, object-oriented programming language. PolyTOIL is an extension of the object-oriented language TOIL, also developed at Williams College. The extensions to TOIL include support for bounded and unbounded parametric polymorphism. It is relatively unusual in using a "matching" relationship rather than subtyping to determine constraints on type arguments. Subtype polymorphism (through substitution) and inheritance are also features, though the subtype and inheritance hierarchies are not identified. A PolyTOIL interpreter has been implemented in ML and can be used to run PolyTOIL programs. Contents 1 Introduction 1 2 The Object-Oriented Paradigm 3 3 Polymorphism 8 3.1 Implicit and Explicit Polymorphism . . . . . . . . . . . . . . . . . . . . . . 8 3.2 Subtyping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3.3 Unconstrained Genericity . . . . . . . . . . . . . . . . . . . . . . . . . . . ....