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

The calculus of higher order subtyping, known as F ω ≤ , a higher-order polymorphic λ-calculus with subtyping, is expressive enough to serve as core calculus for typed object-oriented languages. The versions considered in the literature usually support only pointwise subtyping of type operators, where two types S U and T U are in subtype relation, if S and T are. In the widely cited, unpublished note [Car90], Cardelli presents F ω ≤ in a more general form going beyond pointwise subtyping of type applications in distinguishing between monotone and antimonotone operators. Thus, for instance, T U1 is a subtype of T U2, if U1 ≤ U2 and T is a monotone operator. My thesis extends F ω ≤ by polarized application, it explores its proof theory, establishing decidability of polarized F ω ≤. The inclusion of polarized application rules leads to an interdependence of the subtyping and the kinding system. This contrasts with pure F ω ≤ , where subtyping depends on kinding but not vice versa. To retain decidability of the system, the equal-bounds subtyping rule for all-types is rephrased in the polarized setting as a mutual-subtype requirement of the upper bounds.

The standard formulation of bounded quantification, system F , is difficult to work with and lacks important syntactic properties, such as decidability. More tractable variants have been studied, but those studied so far either exclude significant classes of useful programs or lack a compelling semantics. We propose

We study an extension of the second-order calculus of bounded quantification, System F , with bounded existential types. Surprisingly, the most natural formulation of this extension lacks the important minimal typing property of F , which ensures that the set of types possessed by a typeable term can be characterized by a single least element. We consider alternative formulations and give an algorithm computing minimal types for the slightly weaker Kernel Fun variant of F . 1 Introduction F is a typed lambda-calculus combining subtyping and second-order bounded quantification [4, 5, 7, 3]. Besides its utility as a vehicle for theoretical investigations, it has come to be seen as a good basis for the design of programming languages incorporating subtyping and polymorphism. The extension of F with bounded existential quantifiers to support programming with abstract data types is commonly regarded as a straightforward task; indeed, in a sense, pure F already contains bounded existentials...

Traditional class and object encodings are difficult to use in practical type-preserving compilers because of the complexity of the encodings. We propose a simple typed intermediate language for compiling object-oriented languages and prove its soundness. The key ideas are to preserve lightweight notions of classes and objects instead of compiling them away and to separate name-based subclassing from structure-based subtyping. The language can express standard implementation techniques for both dynamic dispatch and runtime type tests. It has decidable type checking even with subtyping between quantified types with different bounds. Because of its simplicity, the language is a more suitable starting point for a practical type-preserving compiler than traditional encoding techniques.

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

Pict is a programming language in the ML tradition, formed by adding high-level derived forms and a powerful static type system to a tiny core language. The core, Milner's pi-calculus, has been used as a theoretical foundation for a broad class of concurrent computations. The goal in Pict is to identify idioms that arise naturally when these primitives are used to build working programs --- idioms such as basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a useful partial type inference algorithm. This is a tutorial introduction to Pict, with examples and exercises. Consumer Safety Warning Pict is an evolving language design and the current implementation is experimental software. You are welcome to use Pict in...

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 introduce new modal logical calculi that describe subtyping properties of Cartesian product and disjoint union type constructors as well as mutually-recursive types defined using those type constructors. Basic Logic of Subtyping S extends classical propositional logic by two new binary modalities ⊗ and ⊕. An interpretation of S is a function that maps standard connectives into set-theoretical operations (intersection, union, and complement) and modalities into Cartesian product and disjoint union type constructors. This allows S to capture many subtyping properties of the above type constructors. We also consider logics Sρ and S ω ρ that incorporate into S mutually-recursive types over arbitrary and well-founded universes correspondingly. The main results are completeness of the above three logics with respect to appropriate type universes. In addition, we prove Cut elimination theorem for S and establish decidability of S and S ω ρ.

Abstract. F is a typed λ-calculus with subtyping and It is routine to develop an algorithm to check the subtyping bounded polymorphism. Typechecking for F is known to property of Kernel F, but subtyping for Full F has turned be undecidable, because the subtyping relation on types is out to be surprisingly complex. Curien and Ghelli [5] gave undecidable. Fµ is an extension of F with recursive types. an algorithm for checking subtyping, with a correctness proof In this paper, we show how symbolic labelled transition system techniques from concurrency theory can be used to rea-provided by Ghelli [7]. Later, Ghelli [9] showed that this algorithm is not guaranteed to terminate. Pierce [14] showed son about subtyping for Fµ. We provide a symbolic labelled that Ghelli’s example of nontermination can be generalized transition system for Fµ types, together with an an appro- to code a Turing machine, and so subtyping (and hence typepriate notion of simulation, which coincides with the existing checking) for F is undecidable. coinductive definition of subtyping. We then provide a ‘simulation up to ’ technique for proving subtyping, for which there Subtyping and recursive types. Recursive types are a is a simple model checking algorithm. The algorithm is more common programming language feature, typified by ML’s powerful than the usual one for F, for example it terminates construct. Amadio and Cardelli [17] investi-on Ghelli’s canonical example of nontermination. gated the relationship between subtyping and recursive types. 1