Reynolds' Parametricity Theorem (also known as the Abstraction Theorem), a result concerning the model theory of the second order polymorphic typed -calculus (F 2 ), has recently been used by Wadler to prove some unusual and interesting properties of programs. We present a purely syntactic version of the Parametricity Theorem, showing that it is simply an example of formal theorem proving in second order minimal logic over a first order equivalence theory on -terms. We analyze the use of parametricity in proving program equivalences, and show that structural induction is still required: parametricity is not enough. As in Leivant's transparent presentation of Girard's Representation Theorem for F 2 , we show that algorithms can be extracted from the proofs, such that if a -term can be proven parametric, we can synthesize from the proof an "equivalent" parametric -term that is moreover F 2 -typable. Given that Leivant showed how proofs of termination, based on inductive data types and s...

this paper was completed, the metatheory of this system has been studied in much greater detail by Compagnoni [ Compagnoni, 1994, Compagnoni, 1995 ] . A type system combining intersection types with a powerful form of polymorphism is of independent interest. Reynolds [ 1988 ] has argued that intersection types can form the basis of elegant language designs. But his Forsythe language has only a first-order type system, and thus lacks some of the expressive possibilities of polymorphic languages like ML. Our work represents a step toward a synthesis of these styles of language design. The following section shows some examples of multiple inheritance using a simple highlevel syntax. Section 3, the core of the paper, defines the -calculus F

Abstract. With Java 5 and C # 2.0, first-order parametric polymorphism was introduced in mainstream object-oriented programming languages under the name of generics. Although the first-order variant of generics is very useful, it also imposes some restrictions: it is possible to abstract over a type, but the resulting type constructor cannot be abstracted over. This can lead to code duplication. We removed this restriction in Scala, by allowing type constructors as type parameters and abstract types. This paper presents the design and implementation of the resulting type constructor polymorphism. It combines type constructor polymorphism with implicit parameters to yield constructs similar to, and at times more expressive than, Haskell’s constructor type classes. The paper also studies interactions with other object-oriented language constructs, and discusses the gains in expressiveness. 1

Combining intersection types with higher-order subtyping yields a typed model of object-oriented programming with multiple inheritance. Objects, message passing, subtyping, and inheritance appear as programming idioms in a typed -calculus, a modelling technique that facilitates experimentation and helps in distinguishing between essential aspects of the object-oriented style ---encapsulation and subtype polymorphism, which are directly reflected in the low-level type system --- and useful but inessential programming idioms such as inheritance. The target calculus, a natural generalization of system F ! with intersection types, is of independent interest. We establish basic structural properties and give a proof of type soundness using a simple semantics based on partial equivalence relations.

The purpose of this thesis is to investigate a type system for databases and object-oriented programming and to design a statically typed programming language for these applications. Such a language should ideally have a static type system that supports: • polymorphism and static type inference, • rich data structures and operations to represent various data models for databases including the relational model and more recent complex object models, • central features of object-oriented programming including user definable class hierarchies, multiple inheritance, and data abstraction, • the notion of extents and object-identities for object-oriented databases. Without a proper formalism, it is not obvious that the construction of such a type system is possible. This thesis attempts to construct one such formalism and proposes a programming language that uniformly integrate all of the above features. The specific contributions of this thesis include: • A simple semantics for ML polymorphism and axiomatization of the equational theory of ML. • A uniform generalization of the relational model to arbitrary complex database objects that

Abstract. Generics are a very popular feature of contemporary OO languages, such as Java, C # or Scala. Their support for genericity is lacking, however. The problem is that they only support abstracting over proper types, and not over generic types. This limitation makes it impossible to, e.g., define a precise interface for Iterable, a core abstraction in Scala’s collection API. We implemented “type constructor polymorphism ” in Scala 2.5, which solves this problem at the root, thus greatly reducing the duplication of type signatures and code. 1

System F-bounded is a second order typed lambda calculus, where the basic features of object-oriented languages can be naturally modelled. F-bounded extends the better known system F , in a way that provides an immediate solution for the treatment of the so-called "binary methods". Although more powerful than F and also quite natural, system F-bounded has only been superficially studied from a foundational perspective and many of its essential properties have been conjectured but never proved in the literature. The aim of this paper is to give a solid foundation to F-bounded , by addressing and proving the key properties of the system. In particular transitivity elimination, completeness of the type checking semi-algorithm, the subject reduction property for fij reduction, conservativity with respect to system F and antisymmetry of a "full" subsystem are considered, and various possible formulations for system F-bounded are compared. Finally a semantic interpretation of sy...

The concepts of the basic entities, i.e., objects, object classes, object types, etc., in the type hierarchy of object-oriented languages are revisited. The notion of object reuse is defined and elaborated. We show that while object classes are useful in object description and creation, the class-is-type principle which is used in many object-oriented languages is inadequate for object reuse. We also show that parameterized types and generic functions are better served by using kind-bounded qualification than universal qualification and other mechanisms. Keywords: Object reuse, software integration, objects, classes, types, kinds, class-is-type principle, parameterized types, generic functions, kind-bounded polymorphism 1

The incremental approach to modular monadic semantics constructs complex monads by using monad transformers to add computational features to a preexisting monad. A complication of this approach is that the operations associated to the pre-existing monad need to be lifted to the new monad. In a companion paper by Jaskelioff, the lifting problem has been addressed in the setting of system F ω. Here, we recast and extend those results in a category-theoretic setting. We abstract and generalize from monads to monoids (in a monoidal category), and from monad transformers to monoid transformers. The generalization brings more simplicity and clarity, and opens the way for lifting of operations with applicability beyond monads. Key words: Monad, Monoid, Monoidal Category

this document that certain implications are not based on a well stated formal theory but require a certain amount of hand-waving.