Paola Giannini

Fickle: Dynamic Object Re-classification

Re-classification changes at run-time the class membership of an object while retaining its identity. We suggest language features for object re-classification, which could extend an imperative, typed, classbased, object-oriented language.We present our proposal through the language Fickle. The imperative features combined with the requirement for a static and safe type system provided the main challenges. We develop a type and effect system for Fickle and prove its soundness with respect to the operational semantics. In particular, even though objects may be re-classified across classes with different members, they will never attempt to access nonexisting members.

More dynamic object reclassification: Fickle p

Reclassification changes the class membership of an object at run-time while retaining its identity. We suggest language features for object reclassification, which extend an imperative, typed, class-based, object-oriented language.We present our proposal through the language Fickle⋄⋄. The imperative features, combined with the requirement for a static and safe type system, provided the main challenges. We develop a type and effect system for Fickle⋄⋄ and prove its soundness with respect to the operational semantics. In particular, even though objects may be reclassified across classes with different members, there will never be an attempt to access nonexisting members.

Characterization of typings in polymorphic type discipline

Polymorphic type discipline for lambda -calculus is an extension of H.B. Currys (1969) classical functionality theory, in which types can be universally quantified. An algorithm that, given a term M, builds a set of constraints, is satisfied. Moreover, all the typings for M (if any) are built from the set of constraints by substitutions. Using the set of constraints, some properties of polymorphic type discipline are proved.<<ETX>>

A Complete Type Inference Algorithm for Simple Intersection Types

In this paper we present a decidable restriction of the intersection type discipline, obtained by combining intersection and universal quantification over types. The system, which has a notion of principal type, is a proper extension of the ML type system. A sound and complete type checking algorithm is presented and proved correct.

Refinement Types for Program Analysis

In this paper we introduce a system for the detection and elimination of dead code in typed functional programs. The main application of this method is the optimization of programs extracted from proofs in logical frameworks but it could be used as well in the elimination of dead code determined by program specialization. Our algorithm is based on a type inference system suitable for reasoning about dead code information. This system relays on refinement types which allow to exploit the type structure of the language for the investigation of program properties. The detection of dead code is obtained via type inference, which can be performed in an efficient and complete way, by reducing it to the solution of a system of inequalities between type variables. A key feature of our method is that program analysis can be performed in a strictly incremental way. Even though the language considered in the paper is a simply typed λ-calculus we can generalize our approach to polymorphic languages like ML. Although focused on dead code elimination our type inference method can also be applied to the investigation of other program properties like binding time and strictness. Some hints on these applications are given.

A Decidable Intersection Type System based on Relevance

In this paper we introduce a notion of “relevance” for type assignment systems including intersection types. We define a relevant system which is an extension of a particular rank 2 intersection system and of the polymorphic type discipline limited to rank 2. We study some of its properties and finally state the decidability of type inference providing an algorithm which is sound and complete.

Principal Types and Unification for Simple Intersection Type Systems

In this paper we introduce a decidable restriction of the intersection type discipline. The restriction is based on a uniform principle rather than on a notion of rank. For this system we give a type checking algorithm that we prove to be sound and complete. An extended language of types with labelled intersections and intersection schemes is needed to describe the principal type of terms which turns out to be unique module a set of equations between labels. The unification algorithm far labelled types, that extends first order unification, could be used as a basis to define inference algorithms for other (more powerful) systems with intersection.

A type safe state abstraction for coordination in J ava -like languages

The state of a concurrent object, intended as some abstraction over the values of the fields of the object, usually determines its coordination behavior. Therefore, state is always in the programmer’s mind, even though implicitly. We suggest a feature for Java-like languages, which makes the state of a concurrent object explicit and supports the expression of the object’s behavior depending on the state it is currently in. Namely, an object will be in one of the states declared in its class. The state determines the presence of fields and methods. State transition statements explicitly change the state of an object, and thus change the availability of fields and methods. When a thread calls a method which is declared in the object’s class but absent from its current state, it waits, until the state of the object changes to a state which does contain that method. This directly expresses coordination. We claim that this feature makes it easier to understand and develop concurrent programs, and substantiate our claim through the discussion of some popular examples of concurrent programs written using this feature.We develop a type and effect system, which guarantees that, during execution of a method invoked on a concurrent object

Strictness, totality, and non-standard-type inference

{\tt o}