Type systems based on intersection types have been studied extensively in recent years, both as tools for the analysis of the pure -calculus and, more recently, as the basis for practical programming languages. The dual notion, union types, also appears to have practical interest. For example, by refining types ordinarily considered as atomic, union types allow a restricted form of abstract interpretation to be performed during typechecking. The addition of second-order polymorphic types further increases the power of the type system, allowing interesting variants of many common datatypes to be encoded in the "pure" fragment with no type or term constants. This report summarizes a preliminary investigation of the expressiveness of a programming language combining intersection types, union types, and polymorphism.

Record types are an important tool for programming and are essential in objectoriented calculi. Dependent record types are proven to be very useful for program specification and verification. Unfortunately, all known embedding of the dependent record type in the type theory had some imperfections. In this paper we present a new type constructor, dependent intersection, i.e., the intersection of two types, where the second type may depend on elements of the first one (do not confuse it with the intersection of a family of types). This new type constructor allows us to define dependent records in a very simple way.

The operation of expansion on typings was introduced at the end of the 1970s by Coppo, Dezani, and Venneri for reasoning about the possible typings of a term when using intersection types. Until recently, it has remained somewhat mysterious and unfamiliar, even though it is essential for carrying out compositional type inference. The fundamental idea of expansion is to be able to calculate the effect on the final judgement of a typing derivation of inserting a use of the intersection-introduction typing rule at some (possibly deeply nested) position, without actually needing to build the new derivation.

Although systems with intersection types have many unique capabilities, there has never been a fully satisfactory explicitly typed system with intersection types. We introduce and prove the basic properties of # , a typed #-calculus with branching types and types with quantification over type selection parameters. The new system # an explicitly typed system with the same expressiveness as a system with intersection types. Typing derivations in # use branching types to squash together what would be separate parallel derivations in earlier systems with intersection types.

Abstract. We illustrate the concepts of sessions and session types as they have been developed in the setting of the π-calculus. Motivated by the goal of obtaining a formalisation closer to existing standards and aiming at their enhancement and strengthening, several extensions of the original core system have been proposed, which we survey together with the embodying of sessions into functional and object-oriented languages, as well as some implementations.

In this thesis we explore the question of how to represent programming data structures in a constructive type theory. The basic data structures in programing languages are records and objects. Most known papers treat such data structure as primitive. That is, they add new primitive type constructors and supporting axioms for records and objects. This approach is not satisfactory. First of all it complicates a type theory a lot. Second, the validity of the new axioms is not easily established. As we will see the naive choice of axioms can lead to contradiction even in the simplest cases. We will show that records and objects can be defined in a powerful enough type theory. We will also show how to use these type constructors to define abstract data structure. BIOGRAPHICAL SKETCH Alexei Kopylov was born in Moscow State University on April 2, 1974. His parents were students in the Department of Mathematics and Mechanics there. First year of his life Alexei lived in a student dormitory in the main building of the Moscow State University. Then his parents moved to Chernogolovka, a cozy scientific town near Moscow. Alexei returned to Moscow State University as a student in 1991. Five years later he graduated from the Department of Mathematics and Mechanics and entered the graduate school of the same Department.

Type systems based on the concept of intersection types [3, 4, 5] have been extensively studied in recent years, both as tools for the analysis of the pure -calculus and, more recently, as the basis for practical programming languages such as Forsythe [16].

We show how to use intersection types for building models of a #-calculus enriched with recursive terms, whose intended meaning is of minimal fixed points. As a by-product we prove an interesting consistency result.

These lecture notes intend to introduce to the subject of lambda calculus and types. A special focus is on the use of inductive denitions. The ultimate goal of the course is an advanced treatment of inductive types. Contents 1 Overview 2 2 Introduction to Inductive Denitions 4 3 Lambda Calculus 13 3.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.2 Pure Untyped Lambda Calculus . . . . . . . . . . . . . . . . . . 15 4 Conuence 19 5 Weak and Strong Normalization 27 6 Simple and Intersection Types 33 6.1 Simply-Typed Lambda Calculus . . . . . . . . . . . . . . . . . . 34 6.2 Lambda Calculus with Intersection Types . . . . . . . . . . . . . 36 6.3 Strong Normalization of Typable Terms . . . . . . . . . . . . . . 39 6.4 Typability of Strongly Normalizing Terms . . . . . . . . . . . . . 41 7 Parametric Polymorphism 41 7.1 Strong Normalization of Typable Terms . . . . . . . . . . . . . . 44 7.1.1 Saturated Sets . . . . . . . . . . . . . . . . . . . . . ....

Abstract not found