Types and programming languages: the next generation

A type system is a syntactic method for automatically checking the absence of certain erroneous behaviors by classifying program phrases according to the kinds of values they compute. The study of type systems -- and of programming languages from a type-theoretic perspective -- has important applications in software engineering, language design, high-performance compilers, and security.This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages. The approach is pragmatic and operational; each new concept is motivated by programming examples and the more theoretical sections are driven by the needs of implementations. Each chapter is accompanied by numerous exercises and solutions, as well as a running implementation, available via the Web. Dependencies between chapters are explicitly identified, allowing readers to choose a variety of paths through the material.The core topics include the untyped lambda-calculus, simple type systems, type reconstruction, universal and existential polymorphism, subtyping, bounded quantification, recursive types, kinds, and type operators. Extended case studies develop a variety of approaches to modeling the features of object-oriented languages.

[1]  Gottlob Frege,et al.  Begriffsschrift, eine der arithmetischen nachgebildete Formelsprache des reinen Denkens , 1879 .

[2]  G. B. M..  Principia Mathematica , 1911, Nature.

[3]  M. Schönfinkel.  Über die Bausteine der mathematischen Logik , 1924 .

[4]  A. Church.  An Unsolvable Problem of Elementary Number Theory , 1936 .

[5]  Alonzo Church,et al.  A formulation of the simple theory of types , 1940, Journal of Symbolic Logic.

[6]  A. Church.  The calculi of lambda-conversion , 1941 .

[7]  B. Rosser.  Church Alonzo. The calculi of lambda-conversion . Annals of Mathematics studies, no. 6. Lithoprinted. Princeton University Press, Princeton 1941, 77 pp. , 1941 .

[8]  A. Tarski.  A LATTICE-THEORETICAL FIXPOINT THEOREM AND ITS APPLICATIONS , 1955 .

[9]  Haskell B. Curry,et al.  Combinatory Logic, Volume I , 1959 .

[10]  Revised report on the algorithmic language ALGOL 60 , 1963, Comput. J..

[11]  P. J. Landin.  The Mechanical Evaluation of Expressions , 1964, Comput. J..

[12]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[13]  J. Heijenoort.  From Frege To Gödel , 1967 .

[14]  William W. Tait,et al.  Intensional interpretations of functionals of finite type I , 1967, Journal of Symbolic Logic.

[15]  C. A. Meredith,et al.  Calculi of Pure Strict Implication , 1969 .

[16]  William A. Howard,et al.  The formulae-as-types notion of construction , 1969 .

[17]  Rod M. Burstall,et al.  Proving Properties of Programs by Structural Induction , 1969, Comput. J..

[18]  James H. Morris,et al.  Lambda-calculus models of programming languages. , 1969 .

[19]  R. Hindley.  The Principal Type-Scheme of an Object in Combinatory Logic , 1969 .

[20]  J. Y. Girard,et al.  Interpretation fonctionelle et elimination des coupures dans l'aritmetique d'ordre superieur , 1972 .

[21]  Patrick J. Hayes,et al.  Computation and Deduction , 1973, MFCS.

[22]  Annabelle McIver,et al.  Programming Methodology , 1974, Lecture Notes in Computer Science.

[23]  John C. Reynolds,et al.  Towards a theory of type structure , 1974, Symposium on Programming.

[24]  P. Martin-Löf.  An Intuitionistic Theory of Types: Predicative Part , 1975 .

[25]  H. Friedman.  Equality between functionals , 1975 .

[26]  M. Arbib,et al.  Arrows, Structures, and Functors: The Categorical Imperative , 1975 .

[27]  W. Tait.  A realizability interpretation of the theory of species , 1975 .

[28]  Craig Schaffert,et al.  Abstraction mechanisms in CLU , 1977, Commun. ACM.

[29]  G.D. Plotkin,et al.  LCF Considered as a Programming Language , 1977, Theor. Comput. Sci..

[30]  Peter Aczel,et al.  An Introduction to Inductive Definitions , 1977 .

[31]  R. Gandy.  The Simple Theory of Types , 1977 .

[32]  John McCarthy,et al.  History of LISP , 1978, SIGP.

[33]  Marvin H. Solomon,et al.  Type definitions with parameters , 1978, POPL.

[34]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[35]  Mariangiola Dezani-Ciancaglini,et al.  A new type assignment for λ-terms , 1978, Arch. Math. Log..

[36]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[37]  John C. Reynolds,et al.  Syntactic control of interference , 1978, POPL.

[38]  R. Scheifler.  A DENOTATIONAL SEMANTICS OF CLU , 1978 .

[39]  John F. Wakerly,et al.  The programming language PASCAL , 1979, Microprocessors and microsystems.

[40]  John W. Backus,et al.  The history of FORTRAN I, II, and III , 1978, SIGP.

[41]  Richard J. Lipton,et al.  Social processes and proofs of theorems and programs , 1977, POPL.

[42]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[43]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[44]  G. Pottinger,et al.  A type assignment for the strongly normalizable |?-terms , 1980 .

[45]  F. Dick.  A survey of the project Automath , 1980 .

[46]  Jan Willem Klop,et al.  Combinatory reduction systems , 1980 .

[47]  John C. Reynolds,et al.  Using category theory to design implicit conversions and generic operators , 1980, Semantics-Directed Compiler Generation.

[48]  David Park,et al.  Concurrency and Automata on Infinite Sequences , 1981, Theoretical Computer Science.

[49]  Robin Milner,et al.  Principal type-schemes for functional programs , 1982, POPL '82.

[50]  John C. Reynolds,et al.  Types, Abstraction and Parametric Polymorphism , 1983, IFIP Congress.

[51]  C. Pollard,et al.  Center for the Study of Language and Information , 2022 .

[52]  Lambert G. L. T. Meertens,et al.  Incremental polymorphic type checking in B , 1983, POPL '83.

[53]  Bruno Courcelle,et al.  Fundamental Properties of Infinite Trees , 1983, Theor. Comput. Sci..

[54]  Daniel Leivant,et al.  Polymorphic type inference , 1983, POPL '83.

[55]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[56]  Alan Mycroft,et al.  Polymorphic Type Schemes and Recursive Definitions , 1984, Symposium on Programming.

[57]  John C. Reynolds,et al.  Polymorphism is not Set-Theoretic , 1984, Semantics of Data Types.

[58]  James Hook,et al.  Understanding Russell- A First Attempt , 1984, Semantics of Data Types.

[59]  Luca Cardelli,et al.  A Semantics of Multiple Inheritance , 1984, Inf. Comput..

[60]  Gordon D. Plotkin,et al.  An ideal model for recursive polymorphic types , 1984, Inf. Control..

[61]  Butler W. Lampson,et al.  A Kernel Language for Abstract Data Types and Modules , 1984, Semantics of Data Types.

[62]  Lennart Augustsson,et al.  A compiler for lazy ML , 1984, LFP '84.

[63]  John Mitchell,et al.  Type Inference and Type Containment , 1984, Semantics of Data Types.

[64]  John C. Reynolds,et al.  Three Approaches to Type Structure , 1985, TAPSOFT, Vol.1.

[65]  R. Statman.  Equality between Functionals Revisited , 1985 .

[66]  John C. Mitchell,et al.  Second-Order Logical Relations (Extended Abstract) , 1985, Logic of Programs.

[67]  Per Martin-Löf,et al.  Constructive mathematics and computer programming , 1984 .

[68]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[69]  T. Coquand.  Une théorie des constructions , 1985 .

[70]  Gerald J. Sussman,et al.  Structure and interpretation of computer programs , 1985, Proceedings of the IEEE.

[71]  John C. Mitchell,et al.  Abstract types have existential types , 1985, POPL.

[72]  Alan J. Demers,et al.  Data types are values , 1985, ACM Trans. Program. Lang. Syst..

[73]  H. Boehm.  Partial polymorphic type inference is undecidable , 1985, 26th Annual Symposium on Foundations of Computer Science (sfcs 1985).

[74]  Luca Cardelli,et al.  Typechecking Dependent Types and Subtypes , 1986, Foundations of Logic and Functional Programming.

[75]  Matthias Felleisen,et al.  The Little Schemer , 1986 .

[76]  Dominique Clément,et al.  A simple applicative language: mini-ML , 1986, LFP '86.

[77]  Mitchell Wand,et al.  A scheme for a higher-level semantic algebra , 1986 .

[78]  Mitchell Wand.  Finding the source of type errors , 1986, POPL '86.

[79]  J. Roger Hindley,et al.  Introduction to combinators and λ-calculus , 1986, Acta Applicandae Mathematicae.

[80]  Rance Cleaveland,et al.  Implementing mathematics with the Nuprl proof development system , 1986 .

[81]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[82]  David A. Schmidt,et al.  Denotationaisemantics: a methodology for language development , 1986 .

[83]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[84]  David B. MacQueen.  Using dependent types to express modular structure , 1986, POPL '86.

[85]  Randall B. Smith,et al.  SELF: The power of simplicity , 1987, OOPSLA '87.

[86]  Gilles Kahn,et al.  Natural Semantics , 1987, STACS.

[87]  Douglas James Howe.  Automating reasoning in an implementation of constructive type theory , 1988 .

[88]  Luca Cardelli,et al.  Basic Polymorphic Typechecking , 1987, Sci. Comput. Program..

[89]  Mitchell Wand,et al.  Complete Type Inference for Simple Objects , 1987, LICS.

[90]  Andrew M. Pitts,et al.  Polymorphism is Set Theoretic, Constructively , 1987, Category Theory and Computer Science.

[91]  John C. Reynolds,et al.  Preliminary design of the programming language Forsythe , 1988 .

[92]  Thierry Coquand,et al.  The Calculus of Constructions , 1988, Inf. Comput..

[93]  M. Wand,et al.  Corrigendum: complete type interference for simple objects , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[94]  John C. Mitchell,et al.  The essence of ML , 1988, POPL '88.

[95]  Frank Pfenning,et al.  Partial polymorphic type inference and higher-order unification , 1988, LISP and Functional Programming.

[96]  Dale A. Miller,et al.  AN OVERVIEW OF PROLOG , 1988 .

[97]  Amy P. Felty,et al.  Lambda-Prolog: An Extended Logic Programming Language , 1988, CADE.

[98]  Simon Martini.  Bounded quantifiers have interval models , 1988, LFP '88.

[99]  Stefan Kaes,et al.  Parametric Overloading in Polymorphic Programming Languages , 1988, ESOP.

[100]  Uday S. Reddy,et al.  Objects as closures: abstract semantics of object-oriented languages , 1988, LISP and Functional Programming.

[101]  Samuel N. Kamin.  Inheritance in smalltalk-80: a denotational definition , 1988, POPL '88.

[102]  Kim B. Bruce,et al.  A modest model of records, inheritance and bounded quantification , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[103]  Luca Cardelli,et al.  Structural subtyping and the notion of power type , 1988, POPL '88.

[104]  Daniel G. Bobrow,et al.  Common Lisp Object System Specification X2JI3 Document 88-002R , 1988 .

[105]  Frank Pfenning,et al.  Elf: a language for logic definition and verified metaprogramming , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[106]  Andrew M. Pitts.  Non-trivial Power Types Can't Be Subtypes of Polymorphic Types , 1989, LICS.

[107]  Felice Cardone,et al.  Relational Semantics for Recursive Types and Bounded Quantification , 1989, ICALP.

[108]  William R. Cook,et al.  Interfaces for strongly-typed object-oriented programming , 1989, OOPSLA '89.

[109]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[110]  Chris Reade,et al.  Elements of functional programming , 1989, International computer science series.

[111]  John C. Mitchell,et al.  Higher-order modules and the phase distinction , 1989, POPL '90.

[112]  J. Palsberg,et al.  A denotational semantics of inheritance and its correctness , 1989, OOPSLA '89.

[113]  Didier Rémy,et al.  Type checking records and variants in a natural extension of ML , 1989, POPL '89.

[114]  Brian A. Davey,et al.  An Introduction to Lattices and Order , 1989 .

[115]  Luca Cardelli,et al.  Typeful Programming , 1989, Formal Description of Programming Concepts.

[116]  Martín Abadi,et al.  Explicit substitutions , 1989, POPL '90.

[117]  Harry G. Mairson.  Deciding ML typability is complete for deterministic exponential time , 1989, POPL '90.

[118]  William R. Cook,et al.  A denotational semantics of inheritance , 1989 .

[119]  Christine Paulin-Mohring,et al.  Extracting ω's programs from proofs in the calculus of constructions , 1989, POPL '89.

[120]  John C. Mitchell.  Toward a typed foundation for method specialization and inheritance , 1989, POPL '90.

[121]  Egidio Astesiano,et al.  Inductive and Operational Semantics , 1989, Formal Description of Programming Concepts.

[122]  Martín Abadi,et al.  Dynamic typing in a statically-typed language , 1989, POPL '89.

[123]  John C. Mitchell,et al.  F-bounded quantification for object-oriented programming , 1989 .

[124]  William R. Cook,et al.  Inheritance is not subtyping , 1989, POPL '90.

[125]  David K. Gifford,et al.  Type reconstruction with first-class polymorphic values , 1989, PLDI '89.

[126]  Philip Wadler,et al.  How to make ad-hoc polymorphism less ad hoc , 1989, POPL '89.

[127]  J. Girard,et al.  Proofs and types , 1989 .

[128]  Hans-Juergen Boehm.  Type inference in the presence of type abstraction , 1989, PLDI '89.

[129]  J. Gallier.  On Girard's "Candidats de Reductibilité" , 1989 .

[130]  Jerzy Tiuryn,et al.  Type Inference Problems: A Survey , 1990, MFCS.

[131]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[132]  Gérard Huet,et al.  Logical Foundations of Functional Programming , 1990 .

[133]  John C. Mitchell,et al.  Type Systems for Programming Languages , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[134]  Robin Milner,et al.  Definition of standard ML , 1990 .

[135]  Luca Cardelli,et al.  Abstract Types and the Dot Notation , 1990, Programming Concepts and Methods.

[136]  Robin Milner,et al.  Commentary on standard ML , 1990 .

[137]  Luca Cardelli,et al.  A semantic basis for quest , 1990, Journal of Functional Programming.

[138]  Mads Tofte,et al.  Type Inference for Polymorphic References , 1990, Inf. Comput..

[139]  Bengt Nordström,et al.  Programming in Martin-Lo¨f's type theory: an introduction , 1990 .

[140]  Hendrik Pieter Barendregt,et al.  Functional Programming and Lambda Calculus , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[141]  William R. Cook,et al.  Object-Oriented Programming Versus Abstract Data Types , 1990, REX Workshop.

[142]  Lorenzo Peña y Gonzalo,et al.  Quiddities: an intermittently philosophical dictionary , 1990 .

[143]  D. Rémy.  Algebres touffues. Application au typage polymorphe des objets enregistrements dans les langages fonctionnels , 1990 .

[144]  Andre Scedrov,et al.  Functorial Polymorphism , 1990, Theor. Comput. Sci..

[145]  Jerzy Tiuryn,et al.  The undecidability of the semi-unification problem , 1990, STOC '90.

[146]  Hendrik Pieter Barendregt,et al.  Introduction to generalized type systems , 1991, Journal of Functional Programming.

[147]  P. Wadler.  Is there a use for linear logic? , 1991, PEPM '91.

[148]  Benjamin C. Pierce,et al.  Basic category theory for computer scientists , 1991, Foundations of computing.

[149]  Claude Kirchner,et al.  Solving Equations in Abstract Algebras: A Rule-Based Survey of Unification , 1991, Computational Logic - Essays in Honor of Alan Robinson.

[150]  Joyce L. Vedral,et al.  Functional Programming Languages and Computer Architecture , 1989, Lecture Notes in Computer Science.

[151]  Alan Robinson,et al.  Computational Logic - Essays in Honor of Alan Robinson , 1991, Computational Logic - Essays in Honor of Alan Robinson.

[152]  Luca Cardelli,et al.  Operations on records , 1989, Mathematical Structures in Computer Science.

[153]  Robin Milner,et al.  Co-Induction in Relational Semantics , 1991, Theor. Comput. Sci..

[154]  Simon Thompson,et al.  Type theory and functional programming , 1991, International computer science series.

[155]  Benjamin C. Pierce,et al.  A record calculus based on symmetric concatenation , 1991, POPL '91.

[156]  Xavier Leroy,et al.  Polymorphic type inference and assignment , 1991, POPL '91.

[157]  Pierre Jouvelot,et al.  Algebraic reconstruction of types and effects , 1991, POPL '91.

[158]  John G. Hosking,et al.  Multi-Methods in a Statically-Typed Programming Language , 1991, ECOOP.

[159]  Mitchell Wand,et al.  Type inference for record concatenation and multiple inheritance , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[160]  Kim B. Bruce.  The Equivalence of Two Semantic Definitions for Inheritance in Object-Oriented Languages , 1991, MFPS.

[161]  John C. Reynolds,et al.  The Coherence of Languages with Intersection Types , 1991, TACS.

[162]  Mario Coppo,et al.  Type Inference with Recursive Types: Syntax and Semantics , 1991, Inf. Comput..

[163]  Thierry Coquand,et al.  Inheritance as Implicit Coercion , 1991, Inf. Comput..

[164]  Luca Cardelli,et al.  Subtyping recursive types , 1991, POPL '91.

[165]  Giuseppe Longo,et al.  Categories, types and structures - an introduction to category theory for the working computer scientist , 1991, Foundations of computing.

[166]  Ryu Hasegawa.  Parametricity of Extensionally Collapsed Term Models of Polymorphism and Their Categorical Properties , 1991, TACS.

[167]  Lawrence C. Paulson,et al.  ML for the working programmer , 1991 .

[168]  Greg Nelson,et al.  Systems programming in modula-3 , 1991 .

[169]  Frank Pfenning,et al.  Refinement types for ML , 1991, PLDI '91.

[170]  Luca Cardelli,et al.  An Extension of System F with Subtyping , 1991, TACS.

[171]  J. S. Hodas.  Lolli: An Extension of λProlog with Linear Context Management , 1992 .

[172]  Simon Peyton Jones,et al.  Implementing functional languages , 1992 .

[173]  CastagnaGiuseppe,et al.  A calculus for overloaded functions with subtyping , 1992 .

[174]  Luca Cardelli,et al.  Modula-3 Report (revised) , 1992 .

[175]  B. Pierce.  Programming with intersection types and bounded polymorphism , 1992 .

[176]  Benjamin C. Pierce,et al.  Bounded quantification is undecidable , 1992, POPL '92.

[177]  Andrew K. Wright.  Typing References by Effect Inference , 1992, ESOP.

[178]  Mitchell Wand,et al.  Essentials of programming languages , 2008 .

[179]  Didier Rémy,et al.  Typing record concatenation for free , 1992, POPL '92.

[180]  QingMing Ma,et al.  Parametricity as subtyping , 1992, POPL '92.

[181]  Didier Rémy,et al.  Projective ML , 1992, LFP '92.

[182]  Giorgio Ghelli,et al.  Coherence of Subsumption, Minimum Typing and Type-Checking in F<= , 1992, Math. Struct. Comput. Sci..

[183]  John C. Mitchell,et al.  PER models of subtyping, recursive types and higher-order polymorphism , 1992, POPL '92.

[184]  Giuseppe Castagna,et al.  A calculus for overloaded functions with subtyping , 1992, LFP '92.

[185]  Craig Chambers,et al.  Object-Oriented Multi-Methods in Cecil , 1992, ECOOP.

[186]  Martín Abadi,et al.  Formal parametric polymorphism , 1993, POPL '93.

[187]  Craig Chambers,et al.  The cecil language: specification and rationale , 1993 .

[188]  Luca Cardelli.  An implementation of F , 1993 .

[189]  Ulrich Berger,et al.  Program Extraction from Normalization Proofs , 2006, Stud Logica.

[190]  Furio Honsell,et al.  A framework for defining logics , 1993, JACM.

[191]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[192]  Jerzy Tiuryn,et al.  Type reconstruction in the presence of polymorphic recursion , 1993, TOPL.

[193]  John C. Reynolds,et al.  On Functors Expressible in the Polymorphic Typed Lambda Calculus , 1993, Inf. Comput..

[194]  J. B. Wells.  Typability and type checking in the second-order Λ-calculus are equivalent and undecidable (Preliminary Draft) , 1993 .

[195]  Glynn Winskel,et al.  The formal semantics of programming languages - an introduction , 1993, Foundation of computing series.

[196]  Ramesh Viswanathan,et al.  Standard ML-NJ weak polymorphism and imperative constructs , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[197]  Fritz Henglein,et al.  Type inference with polymorphic recursion , 1993, TOPL.

[198]  Benjamin C. Pierce,et al.  Statically typed friendly functions via partially abstract types , 1993 .

[199]  Alexander Aiken,et al.  Type inclusion constraints and type inference , 1993, FPCA '93.

[200]  Martín Abadi,et al.  A Logic for Parametric Polymorphism , 1993, TLCA.

[201]  Robin Milner,et al.  The Polyadic π-Calculus: a Tutorial , 1993 .

[202]  Roy L. Crole,et al.  Categories for Types , 1994, Cambridge mathematical textbooks.

[203]  James McKinna,et al.  Checking Algorithms for Pure Type Systems , 1994, TYPES.

[204]  Jean Gallier,et al.  Constructive Logics Part I: A Tutorial on Proof Systems and Typed gamma-Calculi , 1993, Theor. Comput. Sci..

[205]  Frank Pfenning,et al.  On the Undecidability of Partial Polymorphic Type Reconstruction , 1993, Fundam. Informaticae.

[206]  Bengt Nordström,et al.  The ALF Proof Editor and Its Proof Engine , 1994, TYPES.

[207]  Giorgio Ghelli.  Recursive Types Are not Conservative over F , 1993, TLCA.

[208]  Carl A. Gunter.  Semantics of programming languages: structures and techniques , 1993, Choice Reviews Online.

[209]  Davide Sangiorgi,et al.  Typing and subtyping for mobile processes , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[210]  Jens Palsberg,et al.  Efficient recursive subtyping , 1992, POPL '93.

[211]  Andrew W. Appel,et al.  Hash-consing Garbage Collection , 1993 .

[212]  John C. Mitchell,et al.  A lambda calculus of objects and method specialization , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[213]  Xavier Leroy,et al.  Dynamics in ML , 1991, Journal of Functional Programming.

[214]  Luca Cardelli,et al.  Extensible records in a pure calculus of subtyping , 1994 .

[215]  Samuel N. Kamin,et al.  Two semantic models of object-oriented languages , 1994 .

[216]  Ian Mackie,et al.  Lilac: a functional programming language based on linear logic , 1994, Journal of Functional Programming.

[217]  Adriana B. Compagnoni,et al.  Decidability of Higher-Order Subtyping with Intersection Types , 1994, CSL.

[218]  Xavier Leroy,et al.  Manifest types, modules, and separate compilation , 1994, POPL '94.

[219]  R. Pollack.  The Theory of LEGO A Proof Checker for the Extended Calculus of Constructions , 1994 .

[220]  Andrew Kennedy,et al.  Dimension Types , 1994, ESOP.

[221]  Fritz Henglein,et al.  Dynamic Typing: Syntax and Proof Theory , 1994, Sci. Comput. Program..

[222]  Jeffrey D. Ullman.  Elements of ML programming , 1994 .

[223]  Robert Harper,et al.  A Simplified Account of Polymorphic References , 1994, Inf. Process. Lett..

[224]  Kim B. Bruce.  A paradigmatic object-oriented programming language: Design, static typing and semantics , 1994, Journal of Functional Programming.

[225]  Gary T. Leavens,et al.  Typechecking and modules for multi-methods , 1994, OOPSLA 1994.

[226]  Martin Odersky,et al.  Polymorphic type inference and abstract data types , 1994, TOPL.

[227]  Benjamin C. Pierce,et al.  Simple type-theoretic foundations for object-oriented programming , 1994, Journal of Functional Programming.

[228]  Benjamin C. Pierce,et al.  Higher-Order Subtyping , 1994, Theor. Comput. Sci..

[229]  Jacques Garrigue,et al.  The Typed Polymorphic Label-Selective lambda-Calculus. , 1994 .

[230]  Martín Abadi,et al.  Subtyping and parametricity , 1994, Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science.

[231]  Didier Rémy,et al.  Programming Objects with ML-ART, an Extension to ML with Abstract and Record Types , 1994, TACS.

[232]  Martin Hofmann,et al.  A unifying type-theoretic framework for objects , 1994, Journal of Functional Programming.

[233]  John C. Reynolds.  User-defined types and procedural data structures as complementary approaches to data abstraction , 1994 .

[234]  John C. Mitchell,et al.  A type system for prototyping languages , 1994, POPL '94.

[235]  Zhaohui Luo,et al.  Computation and reasoning - a type theory for computer science , 1994, International series of monographs on computer science.

[236]  John C. Mitchell,et al.  Theoretical aspects of object-oriented programming: types, semantics, and language design , 1994, Choice Reviews Online.

[237]  Mark P. Jones.  Qualified Types: Theory and Practice , 1994 .

[238]  Radha Jagadeesan,et al.  Full Abstraction for PCF , 1994, Inf. Comput..

[239]  de Ng Dick Bruijn,et al.  Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem , 1972 .

[240]  Mark Lillibridge,et al.  A type-theoretic approach to higher-order modules with sharing , 1994, POPL '94.

[241]  Jerzy Tiuryn,et al.  An analysis of ML typability , 1994, JACM.

[242]  Erik Poll,et al.  Pure Type Systems with Definitions , 1994, LFCS.

[243]  Matthias Felleisen,et al.  A Syntactic Approach to Type Soundness , 1994, Inf. Comput..

[244]  Mark P. Jones,et al.  ML Typing, Explicit Polymorphism and Qualified Types , 1994, TACS.

[245]  David A. Schmidt.  The structure of typed programming languages , 1994, Foundations of computing series.

[246]  Jens Palsberg,et al.  Object-oriented type systems , 1994, Wiley professional computing.

[247]  Mitchell Wand.  Type inference for objects with instance variables and inheritance , 1994 .

[248]  David Aspinall,et al.  Subtyping with Singleton Types , 1994, CSL.

[249]  Harry G. Mairson,et al.  The Complexity of Type Inference for Higher-Order Typed lambda Calculi , 1994, J. Funct. Program..

[250]  Franz Baader,et al.  Unification theory , 1986, Decis. Support Syst..

[251]  Frank Pfenning,et al.  Elf: A Meta-Language for Deductive Systems (System Descrition) , 1994, CADE.

[252]  Andrew D. Gordon.  A Tutorial on Co-induction and Functional Programming , 1994, Functional Programming.

[253]  Susumu Hayashi.  Singleton, Union and Intersection Types for Program Extraction , 1994, Inf. Comput..

[254]  R. Kent Dybvig,et al.  The Scheme Programming Language , 1995 .

[255]  T. Jim.  Rank 2 Type Systems and Recursive Definitions , 1995 .

[256]  Giorgio Ghelli,et al.  Divergence of F< Type Checking , 1995, Theor. Comput. Sci..

[257]  Luca Cardelli,et al.  On Binary Methods , 1995, Theory Pract. Object Syst..

[258]  J.F.A.K. van Benthem,et al.  Language in Action: Categories, Lambdas and Dynamic Logic , 1997 .

[259]  Philip Wadler,et al.  Once upon a type , 1995, FPCA '95.

[260]  Robert Harper,et al.  Compiling polymorphism using intensional type analysis , 1995, POPL '95.

[261]  Matthias Felleisen,et al.  Abstract models of memory management , 1995, FPCA '95.

[262]  Pierre Lescanne,et al.  Explicit Substitutions with de Bruijn's Levels , 1995, RTA.

[263]  Marinus J. Plasmeijer,et al.  CLEAN: a programming environment based on term graph rewriting , 1995, SEGRAGRA.

[264]  Suresh Jagannathan,et al.  Effective Flow Analysis for Avoiding Run-Time Checks , 1995, SAS.

[265]  John C. Mitchell,et al.  The Development of Type Systems for Object-Oriented Languages , 1995, Theory Pract. Object Syst..

[266]  Matthias Felleisen,et al.  A call-by-need lambda calculus , 1995, POPL '95.

[267]  Aarne Ranta.  Type-Theoretical Grammar , 1995 .

[268]  Martin Hofmann,et al.  Positive subtyping , 1995, POPL '95.

[269]  Martín Abadi,et al.  Dynamic typing in polymorphic languages , 1995, Journal of Functional Programming.

[270]  Scott F. Smith,et al.  Type inference for recursively constrained types and its application to OOP , 1995, MFPS.

[271]  Andrew K. Wright.  Simple imperative polymorphism , 1995, LISP Symb. Comput..

[272]  Olivier Danvy,et al.  Type-directed partial evaluation , 1995, POPL '96.

[273]  Frank Pfenning,et al.  A modal analysis of staged computation , 1996, POPL '96.

[274]  Frank Pfenning,et al.  The Practice of Logical Frameworks , 1996, CAAP.

[275]  Trevor Jim.  What are principal typings and what are they good for? , 1996, POPL '96.

[276]  Scott F. Smith,et al.  Subtyping Constrained Types , 1996, SAS.

[277]  Simon Thompson,et al.  Haskell: The Craft of Functional Programming , 1996 .

[278]  Gang Chen,et al.  Subtyping Parametric and Dependent Types , 1996 .

[279]  Lawrence S. Moss,et al.  Vicious circles - on the mathematics of non-wellfounded phenomena , 1996, CSLI lecture notes series.

[280]  Martín Abadi,et al.  An interpretation of objects and object types , 1996, POPL '96.

[281]  François Pottier,et al.  Simplifying subtyping constraints , 1996, ICFP '96.

[282]  Carl A. Gunter,et al.  Reference counting as a computational interpretation of linear logic , 1996, Journal of Functional Programming.

[283]  John C. Mitchell,et al.  Classes = Objects + Data Abstraction , 1996 .

[284]  Ken Arnold,et al.  The Java Programming Language , 1996 .

[285]  Claude Kirchner,et al.  Unification via Explicit Substitutions: The Case of Higher-Order Patterns , 1996, JICSLP.

[286]  Simon L. Peyton Jones,et al.  Type classes in Haskell , 1994, TOPL.

[287]  Martin Odersky,et al.  Putting type annotations to work , 1996, POPL '96.

[288]  Robert Harper.  A Note on "A Simplified Account of Polymorphic References" , 1996, Inf. Process. Lett..

[289]  Rafael Dueire Lins,et al.  Garbage collection: algorithms for automatic dynamic memory management , 1996 .

[290]  John C. Mitchell,et al.  Foundations for programming languages , 1996, Foundation of computing series.

[291]  John C. Mitchell,et al.  Type systems for object-oriented programming languages , 1996 .

[292]  Martín Abadi,et al.  On subtyping and matching , 1995, TOPL.

[293]  George C. Necula,et al.  Safe kernel extensions without run-time checking , 1996, OSDI '96.

[294]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[295]  Zoltan Somogyi,et al.  The Execution Algorithm of Mercury, an Efficient Purely Declarative Logic Programming Language , 1996, J. Log. Program..

[296]  David Aspinall,et al.  Subtyping dependent types , 1996, Proceedings 11th Annual IEEE Symposium on Logic in Computer Science.

[297]  Martín Abadi,et al.  Syntactic considerations on recursive types , 1996, Proceedings 11th Annual IEEE Symposium on Logic in Computer Science.

[298]  C. Barry Jay,et al.  Shape Checking of Array Programs , 1996 .

[299]  Andrew Shalit,et al.  The Dylan Reference Manual: The Definitive Guide to the New Object-Oriented Dynamic Language , 1996 .

[300]  Matthias Felleisen,et al.  A little Java, a few patterns , 1997 .

[301]  Twan Laan.  The evolution of type theory in logic and mathematics , 1997 .

[302]  Giorgio Ghelli.  Termination of System F-bounded: A Complete Proof , 1997, Inf. Comput..

[303]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[304]  B. Pierce,et al.  Local Type Argument Synthesis with Bounded Quantification , 1997 .

[305]  M. Felleisen,et al.  on the Principles of Programming Languages , 1997 .

[306]  T. Jim,et al.  Type inference in systems of recursive types with subtyping , 1997 .

[307]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

[308]  Kim B. Bruce,et al.  Subtyping Is Not a Good "Match" for Object-Oriented Languages , 1997, ECOOP.

[309]  Matthias Felleisen,et al.  Componential set-based analysis , 1997, TOPL.

[310]  A. Compagnoni,et al.  Decidability of Higher-Order Subtyping via Logical Relations , 1997 .

[311]  M. Lillibridge.  Translucent Sums: A Foundation for Higher-Order Module Systems , 1997 .

[312]  Mads Tofte,et al.  Region-based Memory Management , 1997, Inf. Comput..

[313]  Robert O'Callahan,et al.  Lackwit: A Program Understanding Tool Based on Type Inference , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[314]  Benjamin C. Pierce,et al.  Intersection types and bounded polymorphism , 1993, Mathematical Structures in Computer Science.

[315]  Rowan Davies.  Refinement-Type Checker for Standard ML , 1997, AMAST.

[316]  Fritz Henglein,et al.  Coinductive Axiomatization of Recursive Type Equality and Subtyping , 1998, Fundam. Informaticae.

[317]  Andrew C. Myers,et al.  Parameterized types for Java , 1997, POPL '97.

[318]  Martin Hofmann,et al.  Syntax and semantics of dependent types , 1997 .

[319]  Andrew M. Pitts,et al.  Parametric polymorphism and operational equivalence , 2000, Mathematical Structures in Computer Science.

[320]  Giuseppe Castagna,et al.  Object-Oriented Programming A Unified Foundation , 1997, Progress in Theoretical Computer Science.

[321]  Hugo Herbelin,et al.  The Coq proof assistant : reference manual, version 6.1 , 1997 .

[322]  George C. Necula,et al.  Safe, Untrusted Agents Using Proof-Carrying Code , 1998, Mobile Agents and Security.

[323]  Frank Pfenning,et al.  Eliminating array bound checking through dependent types , 1998, PLDI.

[324]  Nissim Francez,et al.  Basic simple type theory , 1998 .

[325]  Matthias Felleisen,et al.  Units: cool modules for HOT languages , 1998, PLDI.

[326]  K. Rustan M. Leino,et al.  Extended static checking , 1998, PROCOMET.

[327]  Martin Steffen,et al.  Polarized higher-order subtyping , 1998 .

[328]  Andrew W. Appel,et al.  Modern Compiler Implementation in ML , 1997 .

[329]  P. Cameron.  Naïve set theory , 1998 .

[330]  Didier Rémy,et al.  Objective ML: An Effective Object-Oriented Extension to ML , 1998, Theory Pract. Object Syst..

[331]  Tobias Nipkow,et al.  Javalight is type-safe—definitely , 1998, POPL '98.

[332]  Peter Lee,et al.  Modal types as staging specifications for run-time code generation , 1998, CSUR.

[333]  James Riely,et al.  Resource Access Control in Systems of Mobile Agents , 2002, HLCL.

[334]  Gerald J. Sussman,et al.  Scheme: A Interpreter for Extended Lambda Calculus , 1998, High. Order Symb. Comput..

[335]  Karl Crary,et al.  Intensional polymorphism in type-erasure semantics , 1998, ICFP '98.

[336]  Viviana Bono,et al.  An Imperative, First-Order Calculus with Object Extension , 1998, ECOOP.

[337]  Martin Odersky,et al.  Making the future safe for the past: adding genericity to the Java programming language , 1998, OOPSLA '98.

[338]  Lennart Augustsson,et al.  Cayenne—a language with dependent types , 1998, ICFP '98.

[339]  Kwangkeun Yi,et al.  Proofs about a folklore let-polymorphic type inference algorithm , 1998, TOPL.

[340]  Katherine A. Yelick,et al.  Titanium: A High-performance Java Dialect , 1998, Concurr. Pract. Exp..

[341]  Jens Palsberg,et al.  From polyvariant flow information to intersection and union types , 1998, POPL '98.

[342]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[343]  Benjamin C. Pierce,et al.  Bounded Existentials and Minimal Typing , 1998, Theor. Comput. Sci..

[344]  Benjamin C. Pierce,et al.  Local type inference , 1998, POPL '98.

[345]  John C. Mitchell,et al.  On the Relationship Between Classes, Objects, and Data Abstraction , 1998, Theory Pract. Object Syst..

[346]  Lars Birkedal,et al.  A region inference algorithm , 1998, TOPL.

[347]  Robert Cartwright,et al.  Compatible genericity with run-time types for the Java programming language , 1998, OOPSLA '98.

[348]  Xavier Leroy,et al.  Security properties of typed applets , 1998, POPL '98.

[349]  Peter W. O'Hearn,et al.  Syntactic Control of Interference Revisited , 1999, Theor. Comput. Sci..

[350]  Vitaly Shmatikov,et al.  A Core Calculus of Classes and Mixins , 1999, ECOOP.

[351]  Karl Crary,et al.  What is a recursive module? , 1999, PLDI '99.

[352]  Frank Pfenning,et al.  Dependent types in practical programming , 1999, POPL '99.

[353]  Assaf J. Kfoury,et al.  Principality and decidable type inference for finite-rank intersection types , 1999, POPL '99.

[354]  Martín Abadi,et al.  A core calculus of dependency , 1999, POPL '99.

[355]  Jan Zwanenburg,et al.  Pure Type Systems with Subtyping , 1999, TLCA.

[356]  Robert Hieb,et al.  Revised 5 Report on the Algorithmic Language , 1999 .

[357]  Don Syme,et al.  Proving Java Type Soundness , 1999, Formal Syntax and Semantics of Java.

[358]  Luca Cardelli,et al.  Comparing Object Encodings , 1997, Inf. Comput..

[359]  Vitaly Shmatikov,et al.  A Core Calculus of Classes and Objects , 1999, MFPS.

[360]  Paolo Baldan,et al.  Basic Theory of F-Bounded Quantification , 1999, Inf. Comput..

[361]  B. Pierce,et al.  How Good Is Local Type Inference , 1999 .

[362]  S. Thompson,et al.  The Craft of Functional Programming , 1999 .

[363]  Andrzej Filinski,et al.  A Semantic Account of Type-Directed Partial Evaluation , 1999, PPDP.

[364]  Matthias Felleisen,et al.  A Programmer's Reduction Semantics for Classes and Mixins , 1999, Formal Syntax and Semantics of Java.

[365]  Martin Odersky,et al.  Type Inference with Constrained Types , 1999, Theory Pract. Object Syst..

[366]  Dario Colazzo,et al.  Subtyping recursive types in kernel Fun , 1999, Proceedings. 14th Symposium on Logic in Computer Science (Cat. No. PR00158).

[367]  Peter Buneman,et al.  Union Types for Semistructured Data , 1999, DBPL.

[368]  Zhong Shao,et al.  Representing Java classes in a typed intermediate language , 1999, ICFP '99.

[369]  Robin Milner,et al.  Communicating and mobile systems - the Pi-calculus , 1999 .

[370]  Neal Glew.  Type dispatch for named hierarchical types , 1999, ICFP '99.

[371]  MorrisettGreg,et al.  From system F to typed assembly language , 1999 .

[372]  Relating Typability and Expressiveness in Finite-Rank Intersection Type Systems (Extended Abstract) , 1999, ICFP.

[373]  Sarfraz Khurshid,et al.  Is the Java Type System Sound? , 1999, Theory Pract. Object Syst..

[374]  Jim Waldo,et al.  The Jini Specification , 1999 .

[375]  John H. Reppy,et al.  The design of a class mechanism for Moby , 1999, PLDI '99.

[376]  Martín Abadi,et al.  Secrecy by typing in security protocols , 1999, JACM.

[377]  Benjamin C. Pierce,et al.  Linearity and the pi-calculus , 1999, TOPL.

[378]  Fritz Henglein,et al.  AnnoDomini in Practice: A Type-Theoretic Approach to the Year 2000 Problem , 1999, TLCA.

[379]  G. Plotkin,et al.  Proof, language, and interaction: essays in honour of Robin Milner , 2000 .

[380]  Chang Liu,et al.  Term rewriting and all that , 2000, SOEN.

[381]  David Walker,et al.  Alias Types , 2000, ESOP.

[382]  Robert Harper,et al.  Abstract 1 Introduction , 2022 .

[383]  C.-H. Luke Ong,et al.  On Full Abstraction for PCF: I, II, and III , 2000, Inf. Comput..

[384]  Benjamin C. Pierce,et al.  Regular expression types for XML , 2000, TOPL.

[385]  Benjamin C. Pierce,et al.  XDuce: A Typed XML Processing Language (Preliminary Report) , 2000, WebDB.

[386]  Srinivas Nedunuri.  The functional approach to programming , 2000, SOEN.

[387]  Christopher Wille.  Presenting C , 2000 .

[388]  Martin Odersky,et al.  Functional Nets , 2000, ESOP.

[389]  Robert Harper,et al.  A type-theoretic interpretation of standard ML , 2000, Proof, Language, and Interaction.

[390]  Jérôme Vouillon.  Conception et realisation d'une extension du langage ml avec des objets , 2000 .

[391]  Giovanni Sommaruga.  History and philosophy of constructive type theory , 2000, Synthese library.

[392]  Benjamin C. Pierce,et al.  Pict: a programming language based on the Pi-Calculus , 2000, Proof, Language, and Interaction.

[393]  François Pessaux,et al.  Type-based analysis of uncaught exceptions , 2000, TOPL.

[394]  Peter Claussen.  Theories of programming languages , 2000, SOEN.

[395]  Martin Odersky,et al.  Colored local type inference , 2001, POPL '01.

[396]  Jérôme Vouillon.  Combining subsumption and binary methods: an object calculus with views , 2001, POPL '01.

[397]  C. Zenger,et al.  Nested Types , 2001 .

[398]  Benjamin C. Pierce,et al.  Logical Relations for Encryption , 2001, J. Comput. Secur..

[399]  Philip Wadler,et al.  The Girard-Reynolds isomorphism , 2001, Inf. Comput..

[400]  Peter W. O'Hearn,et al.  BI as an assertion language for mutable data structures , 2001, POPL '01.

[401]  Robert Harper,et al.  A dependently typed assembly language , 2001, ICFP '01.

[402]  Thomas Studer,et al.  Constructive Foundations for Featherweight Java , 2001, Proof Theory in Computer Science.

[403]  Andrzej Filinski,et al.  Normalization by Evaluation for the Computational Lambda-Calculus , 2001, TLCA.

[404]  Philip Wadler,et al.  A Recipe for Raw Types , 2001 .

[405]  Philip Wadler,et al.  Featherweight Java: a minimal core calculus for Java and GJ , 2001, TOPL.

[406]  Frank Pfenning,et al.  Logical Frameworks , 2001, Handbook of Automated Reasoning.

[407]  Bart Jacobs,et al.  Categorical Logic and Type Theory , 2001, Studies in logic and the foundations of mathematics.

[408]  John Launchbury,et al.  Static types for dynamic documents , 2001 .

[409]  Zhong Shao,et al.  Type-preserving compilation of Featherweight Java , 2002, TOPL.

[410]  Benjamin C. Pierce,et al.  Recursive subtyping revealed , 2000, Journal of Functional Programming.

[411]  Kim B. Bruce.  Foundations of object-oriented languages - types and semantics , 2002 .

[412]  Atsushi Igarashi,et al.  On Inner Classes , 2002, Inf. Comput..

[413]  Martin Hofmann,et al.  Type Destructors , 2002, Inf. Comput..

[414]  Karl Crary,et al.  A type system for higher-order modules , 2003, POPL '03.

[415]  Benjamin C. Pierce,et al.  TinkerType: a language for playing with formal systems , 2003, Journal of Functional Programming.

[416]  Adriana B. Compagnoni,et al.  Typed operational semantics for higher-order subtyping , 2003, Inf. Comput..

[417]  J. V. Evra.  :The Search for Mathematical Roots, 1870–1940: Logics, Set Theories, and the Foundations of Mathematics from Cantor through Russell to Gödel , 2003 .

[418]  J. E. L. Peck,et al.  Revised report on the algorithmic language ALGOL 68 , 2004, Acta Informatica.

[419]  J. Ferreirós.  From Frege to Gödel. A Source Book in Mathematical Logic, 1879¿1931: By Jean van Heijenoort. Cambridge, MA (Harvard University Press). 1967; new paperback edn., 2002. 664 pages, 1 halftone. ISBN: 0-674-32449-8. $27.95 , 2004 .

[420]  Gordon D. Plotkin,et al.  A structural approach to operational semantics , 2004, J. Log. Algebraic Methods Program..

[421]  Peter Lee,et al.  TIL: a type-directed, optimizing compiler for ML , 2004, SIGP.