Introduction to generalized type systems

This thesis presents a new algorithm for Normalisation by Evaluation for different type theories. This algorithm is later used to define a type-checking algorithm and to prove other meta-theoretical results about predicative type systems.

ThŁse de Doctorat, UniversitØ de Turin, 1996

2008

We show how programming language semantics and definitions of their corresponding type systems can both be written in a single framework amenable to proofs of soundness. The framework is based on full rewriting logic (not to be confused with context reduction or term rewriting), where rules can match anywhere in a term (or configuration).

Lecture Notes in Computer Science, 2002

In this paper we study the addition of parameters to typed -calculus with definitions. We show that the resulting systems have nice properties and illustrate that parameters allow for a better fine-tuning of the strength of type systems as well as staying closer to type systems used in practice in theorem provers and programming languages.

2012

We extend Pure Type Systems with a function turning each term M of type A into a dummy M of the same type ( ⋅ is not an identity, in that M ≠ M ). Intuitively, a dummy represents an unknown, canonical object of the given type: dummies are opaque (cannot be internally inspected), and irrelevant in the sense that dummies of a same type are convertible to each other. This latter condition makes convertibility in PTS with dummies (DPTS) stronger than usual, hence raising not trivial consistency issues. DPTS offer an alternative approach to (proof) irrelevance, tagging irrelevant information at the level of terms and not of types, and avoiding the annoying syntactical duplication of products, abstractions and applications into an explicit and an implicit version, typical of systems like ICC * .

Theoretical Computer Science, 1997

This paper is concerned with the foundations of an extension of pure type systems by abstract data types, hence the name of Abstract Dutu Type Systems. ADTS generalize inductive types as they are defined in the calculus of constructions, by providing definitions of functions by pattern matching on the one hand, and relations among constructors of the inductive type on the other. It also generalizes the first-order framework of abstract data types by providing function types and higher-order equations. The first half of the paper describes the framework of ADTS, while the second half investigates cases where ADTS are strongly normalizing. This is shown to be the case for the polymorphic lambda calculus (with possibly subtypes) enriched by higher-order algebraic rules obeying a strong generalization of primitive recursion of higher type that we call the general schema. This covers in particular the case of inductive types whose constructors do not have functional arguments. We conjecture that this result holds true for all calculi of the so-called Barendregt's cube. On the other hand, the definition of a schema for the higher-order rules allowing for more general inductive types is left open.

Electronic Notes in Theoretical Computer Science, 1998

This article explores the use of types constrained by the de nition of functions of given types. This notion supports both overloading and a form of subtyping, and is related to Haskell type classes and System O. We study an extension of the Damas-Milner system, in which o verloaded functions can be de ned. The inference system presented uses a context-independent o verloading policy, speci ed by m e a n s of a predicate used in a single inference rule. The treatment of overloading is less restrictive t h a n in similar systems. Type annotations are not required, but can be used to simplify inferred types. The work motivates the use of constrained types as parameters of other, higher-order types.

Journal of Functional Programming, 2008

Linear typing schemes can be used to guarantee non-interference and so the soundness of in-place update with respect to a functional semantics. But linear schemes are restrictive in practice, and more restrictive than necessary to guarantee soundness of in-place update. This limitation has prompted research into static analysis and more sophisticated typing disciplines to determine when in-place update may be safely used, or to combine linear and non-linear schemes. Here we contribute to this direction by defining a new typing scheme that better approximates the semantic property of soundness of in-place update for a functional semantics. We begin from the observation that some data is used only in a "read-only" context, after which it may be safely re-used before being destroyed. Formalising the in-place update interpretation in a machine model semantics allows us to refine this observation, motivating three usage aspects apparent from the semantics that are used to annotate function argument types. The aspects are (1) used destructively, (2) used read-only but shared with result, and (3) used read-only and not shared with the result. The main novelty is aspect (2) that allows a linear value to be safely read and even aliased with a result of a function without being consumed. This novelty makes our type system more expressive than previous systems for functional languages in the literature. The system remains simple and intuitive, but it enjoys a strong soundness property whose proof is non-trivial. Moreover, our analysis features principal types and feasible type reconstruction, as shown in (Konecny, 2003b).

Citeseer, 1999

In this thesis we study some object-oriented mechanisms from the type system perspective. Our starting point is the axiomatic model of Fisher, Honsell and Mitchell, the Lambda Calculus of Objects. Following the path of recent researches on the topic, we show how some object-based language features can be happily modeled within some functional calculi, proved sound with respect to the message-not-understood error. Then, we approach the more complicated problem of modeling class constructs, presenting two proposals and discussing their respective qualities and drawbacks, together with some future directions we would like to follow to try to better understand classbased languages. precious comments and all of the discussions we had together on objects. A special thank goes to Betti Venneri (University of Firenze), for her encouragement since she has been the supervisor for my master thesis when she was still in Torino. My gratitude goes then to my external referees, Giuseppe Castagna (ENS, Paris) and Sophia Drossopoulou (Imperial College, London), for their kindness in accepting to read my manuscript and for their precious suggestions that helped me improving the presentation of my work. Last but not least, I would like to mention all the people I met during my academic path that made my life easier with their friendship and their support (following again the temporal order in which I met them for the rst time

The Journal of Symbolic Logic, 2001

Pure Type Systems. PTSs, introduced as a generalisation of the type systems of Barendregt's lambda-cube, provide a foundation for actual proof assistants, aiming at the mechanic verification of formal proofs. In this paper we consider simplifications of some of the rules of PTSs. This is of independent interest for PTSs as this produces more flexible PTS-like systems, but it will also help, in a later paper, to bridge the gap between PTSs and systems of Illative Combinatory Logic.