We develop an imperative calculus of objects. Its main type constructor is the one for object types, which incorporate variance annotations and Self types. A subtyping relation between object types supports object subsumption. The type system for objects relies on unusual but beneficial assumptions about the possible subtypes of an object type. With the addition of polymorphism, the calculus can express classes and inheritance.

After two decades of effort, type inference for dynamically typed languages scales to programs of a few tens of thousands of lines of code, but no further. For larger programs, this paper proposes using a kind of demand-driven analysis where the number of active goals is carefully restricted. To achieve this restriction, the algorithm occasionally prunes goals by giving them solutions that are trivially true and thus require no further subgoals to be solved; the previous subgoals of a newly pruned goal may often be discarded from consideration, reducing the total number of active goals. A specific algorithm DDP is described which uses this approach. An experiment on DDP shows that it infers precise types for roughly 30 % to 45 % of the variables in a program with hundreds of thousands of lines; the percentage varies with the choice of pruning threshold, a parameter of the algorithm. The time required varies from an average of one-tenth of one second per variable to an unknown maximum, again depending on the pruning threshold. These data suggest that 50 and 2000 are both good choices of pruning threshold, depending on whether speed or precision is more important.

Abstract. Restricting polymorphism to values is now the standard way to obtain soundness in ML-like programming languages with imperative features. While this solution has undeniable advantages over previous approaches, it forbids polymorphism in many cases where it would be sound. We use a subtyping based approach to recover part of this lost polymorphism, without changing the type algebra itself, and this has significant applications. 1

We develop an imperative calculus of objects that is both tiny and expressive. Our calculus provides a minimal setting in which to study the operational semantics and the typing rules of object-oriented languages. We prove type soundness using a simple subject-reduction approach.

. We develop a formal proof of the ML type inference algorithm, within the Coq proof assistant. We are much concerned with methodology and reusability of such a mechanization. This proof is also necessary to hope the certification of a complete ML compiler in the future. In this paper we present the Coq formalization of the typing system and its inference algorithm. We establish formally the correctness and the completeness of the type inference algorithm with respect to the typing rules of the language. We describe and comment the mechanized proofs. 1. Introduction Our goal is to realize a verified formal proof of the ML type inference algorithm, within the Coq proof assistant. Though this algorithm has been proved since quite a long time, this proof had never been mechanized entirely up to now. Simultaneously and independently of our work, D. Nazareth and T. Nipkow have carried out such a formal verification in the theorem prover Isabelle/HOL for simply-typed -terms [11] and then ...

Abstract. We verify within the Coq proof assistant that ML typing is sound with respect to the dynamic semantics. We prove this property in the framework of a big step semantics and also in the framework of a reduction semantics. For that purpose, we use a syntax-directed version of the typing rules: we prove mechanically its equivalence with the initial type system provided by Damas and Milner. This work is complementary to the certification of the ML type inference algorithm done previously by the author and Valérie Ménissier-Morain. 1

ion Functional Language Layer Loops and Procedures Application Layer Library Layer Figure 1: The Layered Design of the Id Language. imperative data-structures (I-structures and M-structures [2, 3]) that cater to imperative styles of programming. Id is a layered language by design (see Figure 1). The primitive I-structure and Mstructure datatypes are the basic memory synchronization mechanisms in the Id kernel language, and are used to represent all higher level data-structures such as arrays, lists, tuples and user-defined algebraic types. Special syntactic constructs, such as list and array comprehensions and pattern matching, are also compiled into primitive operations on kernel datatypes. Several Id libraries provide the desired functionality for these higher level data-structures. While this design helps to keep the language kernel very small and efficient, it becomes very important to clearly define and enforce the type and data abstractions between the layers so that polymorphic,...

We reflect on our experiences from work on the design and semantic underpinnings of Extended ML, a specification language which supports the specification and formal development of Standard ML programs. Our aim is to isolate problems and issues that are intrinsic to the general enterprise of designing a specification language for use with a given programming language. Consequently the lessons learned go far beyond our original aim of designing a specification language for ML.