We present a simple extension of typed -calculus where functions can be overloaded by putting different "branches of code" together. When the function is applied, the branch to execute is chosen according to a particular selection rule which depends on the type of the argument. The crucial feature of the present approach is that the branch selection depends on the "run-time type" of the argument, which may differ from its compile-time type, because of the existence of a subtyping relation among types. Hence overloading cannot be eliminated by a static analysis of code, but is an essential feature to be dealt with during computation. We obtain in this way a type-dependent calculus, which differs from the various -calculi where types do not play any role during computation. We prove Confluence and a generalized Subject-Reduction theorem for this calculus. We prove Strong Normalization for a "stratified" subcalculus. The definition of this calculus is guided by the understand...

Abstract. How close are we to a world where every paper on programming languages is accompanied by an electronic appendix with machinechecked proofs? We propose an initial set of benchmarks for measuring progress in this area. Based on the metatheory of System F<:, a typed lambda-calculus with second-order polymorphism, subtyping, and records, these benchmarks embody many aspects of programming languages that are challenging to formalize: variable binding at both the term and type levels, syntactic forms with variable numbers of components (including binders), and proofs demanding complex induction principles. We hope that these benchmarks will help clarify the current state of the art, provide a basis for comparing competing technologies, and motivate further research. 1

. We present a method for providing semantic interpretations for languages with a type system featuring inheritance polymorphism. Our approach is illustrated on an extension of the language Fun of Cardelli and Wegner, which we interpret via a translation into an extended polymorphic lambda calculus. Our goal is to interpret inheritances in Fun via coercion functions which are definable in the target of the translation. Existing techniques in the theory of semantic domains can be then used to interpret the extended polymorphic lambda calculus, thus providing many models for the original language. This technique makes it possible to model a rich type discipline which includes parametric polymorphism and recursive types as well as inheritance. A central difficulty in providing interpretations for explicit type disciplines featuring inheritance in the sense discussed in this paper arises from the fact that programs can type-check in more than one way. Since interpretations follow the type...

There are situations in programmingwhere some dynamic typing is needed, even in the presence of advanced static type systems. We investigate the interplay of dynamic types with other advanced type constructions, discussing their integration into languages with explicit polymorphism (in the style of system F ), implicit polymorphism (in the style of ML), abstract data types, and subtyping.

representing the official policies, either expressed or implied, of the U.S. Government.

The combination of higher-order subtyping with intersection types yields a typed model of object-oriented programming with multiple inheritance [11]. The target calculus, F ! , a natural generalization of Girard's system F ! with intersection types and bounded polymorphism, is of independent interest, and is our subject of study. Our main contribution is the proof that subtyping in F ! is decidable. This yields as a corollary the decidability of subtyping in F ! , its intersection free fragment, because the F ! subtyping system is a conservative extension of that of F ! . The calculus presented in [8] has no reductions on types. In the F ! subtyping system the presence of fi-conversion -- an extension of fi-conversion with distributivity laws -- drastically increases the complexity of proving the decidability of the subtyping relation. Our proof consists of, firstly, defining an algorithmic presentation of the subtyping system of F ! , secondly, proving that th...

this paper (Compagnoni, Intersection Types and Bounded Polymorphism 3 1994; Compagnoni, 1995) has been used in a type-theoretic model of object-oriented multiple inheritance (Compagnoni & Pierce, 1996). Related calculi combining restricted forms of intersection types with higher-order polymorphism and dependent types have been studied by Pfenning (Pfenning, 1993). Following a more detailed discussion of the pure systems of intersections and bounded quantification (Section 2), we describe, in Section 3, a typed -calculus called F ("Fmeet ") integrating the features of both. Section 4 gives some examples illustrating this system's expressive power. Section 5 presents the main results of the paper: a prooftheoretic analysis of F 's subtyping and typechecking relations leading to algorithms for checking subtyping and for synthesizing minimal types for terms. Section 6 discusses semantic aspects of the calculus, obtaining a simple soundness proof for the typing rules by interpreting types as partial equivalence relations; however, another proof-theoretic result, the nonexistence of least upper bounds for arbitrary pairs of types, implies that typed models may be more difficult to construct. Section 7 offers concluding remarks. 2. Background

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