We introduce a new compile-time notion of type subsumption based on type simulation. We show how to apply this static subsumption relation to support a more intuitive, object oriented approach to generic programming of reusable, high performance container types. As a first step towards an efficient implementation of the resulting type system in a compiler we present a novel algorithm for bidirectional type inference over arbitrary syntax graphs. The algorithm uses the new static type subsumption relation to compress the data that has to be stored for each node in the typeflow graph. During typeflow analysis this means that the set of types for a given node can be symbolically represented using antichains instead of using bitvectors or some other explicit set representation. This results in a typing algorithm that is both flexible and precise and shows good performance on representative instances.
It was found independently by Hindley @cite_9 and Milner @cite_12 that polymorphic types were useful for structuring programs. Since the early contributions of Hindley and Milner many alternatives and extensions to their approach have been suggested in the literature @cite_5 @cite_16 @cite_18 @cite_1 @cite_6 @cite_15 .
@cite_18 @cite_9 @cite_1 @cite_6 @cite_5 @cite_15 @cite_16 @cite_12
2022019286 1963705166 1598913101 2055292912 2084788336 2152787740 2166822586 2003145055
Dealing with polymorphism in the presence of imperative features is a long-standing open problem for Hindley-Milner type systems. A widely adopted approach is the value restriction, which inhibits polymorphic generalisation and unfairly rejects various programs that cannot go wrong. We consider abstract interpretation as a tool for constructing safe and precise type systems, and investigate how to derive store-based types by abstract interpretation. We propose store-based types as a type discipline that holds potential for interesting and flexible alternatives to the value restriction. Starting from a denotational semantics of the eager untyped lambda-calculus with explicit runtime errors, the standard collecting semantics is defined as specifying the strongest program properties. By a first abstraction, a new sound type collecting semantics is derived in compositional fix-point form. Then by successive (semi-dual) Galois connection based abstractions, type systems and or type inference algorithms are designed as abstract semantics or abstract interpreters approximating the type collecting semantics. This leads to a hierarchy of type systems, which is part of the lattice of abstract interpretations of the untyped lambda-calculus. This hierarchy includes two new � la Church Curry polytype systems. Abstractions of this polytype semantics lead to classical Milner Mycroft and Damas Milner polymorphic type schemes, Church Curry monotypes and Hindley principal typing algorithm. This shows that types are abstract interpretations. Many type inference and program analysis systems include notions of subtyping and parametric polymorphism. When used together, these two features induce equivalences that allow types to be simplified by eliminating quantified variables. Eliminating variables both improves the readability of types and the performance of algorithms whose complexity depends on the number of type variables. We present an algorithm for simplifying quantified types in the presence of subtyping and prove it is sound and complete for non-recursive and recursive types. We also show that an extension of the algorithm is sound but not complete for a type language with intersection and union types, as well as for a language of constrained types. A polymorphic, constraint-based type inference algorithm for an object-oriented language is defined. A generalized form of type, polymorphic recursively constrained types, are inferred. These types are expressive enough for typing objects, since they generalize recursive types and F-bounded polymorphism. The well-known tradeoff between inheritance and subtyping is mitigated by the type inference mechanism. Soundness and completeness of type inference are established. Part 1 Introduction: model programming languages lambda notation equations, reduction and semantics types and type systems notation and mathematical conventions set-theoretic background syntax and semantics induction. Part 2 The language PCF: syntax of PCF PCF programmes and their semantics PCF reduction and symbolic interpreters PCF programming examples, expressive power and limitations variations and extensions of PCF. Part 3 Universal algebra and algebraic data types: preview of algebraic specification algebras, signatures and terms equations, soundness and completeness homomorphisms and initiality algebraic data types rewrite systems. Part 4 Simply-typed lambda calculus: types terms proof systems Henkin models, soundness and completeness. Part 5 Models of typed lambda calculus: domain-theoretic models and fixed points fixed-point induction computational adequacy and full abstraction recursion-theoretic models partial equivalence relations and recursion. Part 6 Imperative programmes: while programmes operational semantics denotational semantics before-after assertions about while programmes semantics of additional programme constructs. Part 7 Categories and recursive types: Cartesian closed categories Kripke lambda models and functor categories domain models of recursive types. Part 8 Logical relations: introduction to logical relations logical relations over applicative structures proof-theoretic results partial surjections and specific models representation independence generalizations of logical relations. Part 9 Polymorphism and modularity: predicative polymorphic calculus impredicative polymorphism data abstraction and existential types general products, sums and programme modules. Part 10 subtyping and related concepts: simply typed lambda calculus with subtyping records, semantic models of subtyping recursive types and a record model of objects polymorphism with subtype constraints. Part 11 Type inference: introduction to type inference type inference for lambda xxx with type variables type inference with polymorphic declarations. This paper presents a new bisimulation theory for parametric polymorphism which enables straight forward co-inductive proofs of program equivalences involving existential types. The theory is an instance of typed normal form bisimulation and demonstrates the power of this recent framework for modeling typed lambda calculi as labelled transition systems.We develop our theory for a continuation-passing style calculus, Jump-With-Argument, where normal form bisimulation takes a simple form. We equip the calculus with both existential and recursive types. An "ultimate pattern matching theorem" enables us to define bisimilarity and we show it to be a congruence. We apply our theory to proving program equivalences, type isomorphisms and genericity. The aim of this work is largely a practical one. A widely employed style of programming, particularly in structure-processing languages which impose no discipline of types, entails defining procedures which work well on objects of a wide variety. We present a formal type discipline for such polymorphic procedures in the context of a simple programming language, and a compile time type-checking algorithm w which enforces the discipline. A Semantic Soundness Theorem (based on a formal semantics for the language) states that well-type programs cannot “go wrong” and a Syntactic Soundness Theorem states that if fl accepts a program then it is well typed. We also discuss extending these results to richer languages; a type-checking algorithm based on w is in fact already implemented and working, for the met alanguage ML in the Edinburgh LCF system, This paper presents an introduction to a calculus of binary multirelations, which can model both angelic and demonic kinds of non-determinism. The isomorphism between up-closed multirelations and monotonic predicate transformers allows a different view of program transformation, and program transformation calculations using multirelations are easier to perform in some circumstances. Multirelations are illustrated by modelling both kinds of nondeterministic behaviour in games and resource-sharing protocols.