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.

A polymorphic, constraint-based type inference algorithm for an object-oriented language is defined. A generalized form of type, polymorphic recursively constrained types, are inferred. These types are expressive enough for typing objects, since they generalize recursive types and F-bounded polymorphism. The well-known tradeoff between inheritance and subtyping is mitigated by the type inference mechanism. Soundness and completeness of type inference are established. 1 Introduction Type inference, the process of automatically inferring type information from untyped programs, is originally due to Hindley and Milner [16]. These ideas have found their way into some recent innovative programming languages, including Standard ML [17]. The type inference problem for object-oriented languages is a challenging one: even simple object-oriented programs require quite advanced features to be present in the type system. One of the main sources of difficulty lies with binary methods, such as an a...

While class-based object-oriented programming languages provide a flexible mechanism for re-using and managing related pieces of code, they typically lack linguistic facilities for specifying a uniform extension of many classes with one set of fields and methods. As a result, programmers are unable to express certain abstractions over classes. In this paper we develop a model of class-to-class functions that we refer to as mixins. A mixin function maps a class to an extended class by adding or overriding fields and methods. Programming with mixins is similar to programming with single inheritance classes, but mixins more directly encourage programming to interfaces. The paper develops these ideas within the context of Java. The results are 1. an intuitive model of an essential Java subset; 2. an extension that explains and models mixins; and 3. type soundness theorems for these languages. 1 Organizing Programs with Functions and Classes Object-oriented programming languages offer classes, inheritance, and overriding to parameterize over program pieces for management purposes and re-use. Functional programming languages provide various flavors of functional abstractions for the same purpose. The latter model was developed from a well-known, highly developed mathematical theory. The former grew in response to the need to manage large programs and to re-use as many components as possible. Each form of parameterization is useful for certain situations. With higherorder functions, a programmer can easily define many functions that share a similar core but differ in a few details. As many language designers and programmers readily acknowledge, however, the functional approach to parameterization is best used in situations with a relatively small number of parameters. When ...

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

Programming languages offer a variety of constructs to support code reuse. For example, functional languages provide function constructs for encapsulating expressions to be used in multiple contexts. Similarly, object-oriented languages provide class (or class-like) constructs for encapsulating sets of definitions that are easily adapted for new programs. Despite the variety and abundance of such programming constructs, however, existing languages are ill-equipped to support component programming with reusable software components. Component programming differs from other forms of reuse in its emphasis on the independent development and deployment of software components. In its ideal form, component programming means building programs from off-the-shelf components that are supplied by a software-components industry. This model suggests a strict separation between the producer and consumer of a component. The separation, in turn, implies separate compilation for components, allowing a pr...

. 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...

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].

We are developing a static type system for object-oriented languages that strives to guarantee statically and completely the absence of certain large classes of run-time errors, to enable polymorphic abstractions to be written and typechecked once separately from any current or future instantiations, and to avoid forcing code to be written unnaturally due to static type system limitations. The type system supports bounded parametric polymorphism, where the bounds on type variables can be expressed using a mixture of recursive subtype and signature constraints; this kind of bounding supports F-bounded polymorphism, Theta-style where clauses, and covariant and contravariant type parameters as special cases. The type system coexists with many advanced language features, including multi-methods, independent inheritance and subtyping, mutable and immutable state, first-class lexically-scoped functions, and mixed statically and dynamically typed code. We have implemented this type system in...

A report on the workshop Foundations of ObjectOriented Languages, Paris, July 1994. 1 Introduction In Paris on July 1--2 1994, researchers gathered at the second workshop of a series of NSF and ESPRITsponsored workshops to discuss the foundations of object-oriented (OO) programming languages. This series of workshops is organized by Kim Bruce and Giuseppe Longo. The previous edition was held in Stanford and has been reported in [7]. This year's workshop was held in the Conservatoire National des Arts et M'etiers and organized by the Laboratoire d'Informatique de l'Ecole Normale Sup'erieure; local arrangements were handled by Roberto Bellucci and Giuseppe Castagna. Participation was by invitation only (see the appendix). The purpose of this workshop was to exchange ideas about the latest research in the semantics of OO programming languages. The workshop consisted of several presentations and some discussion. A lively email discussion also developed shortly after the workshop about bi...