Advanced Topics In Types And Programming Languages

The study of type systems for programming languages now touches many areas of computer science, from language design and implementation to software engineering, network security, databases, and analysis of concurrent and distributed systems. This book offers accessible introductions to key ideas in the field, with contributions by experts on each topic. The topics covered include precise type analyses, which extend simple type systems to give them a better grip on the run time behavior of systems; type systems for low-level languages; applications of types to reasoning about computer programs; type theory as a framework for the design of sophisticated module systems; and advanced techniques in ML-style type inference. Advanced Topics in Types and Programming Languages builds on Benjamin Pierce's Types and Programming Languages (MIT Press, 2002); most of the chapters should be accessible to readers familiar with basic notations and techniques of operational semantics and type systems -- the material covered in the first half of the earlier book. Advanced Topics in Types and Programming Languages can be used in the classroom and as a resource for professionals. Most chapters include exercises, ranging in difficulty from quick comprehension checks to challenging extensions, many with solutions.

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

[2]  N. Rescher.  Review: Moh Shaw-Kwei, The Deduction Theorems and Two New Logical Systems , 1952 .

[3]  J. Lambek.  The Mathematics of Sentence Structure , 1958 .

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

[5]  Douglas T. Ross.  The AED free storage package , 1967, CACM.

[6]  John C. Reynolds,et al.  Automatic computation of data set definitions , 1968, IFIP Congress.

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

[8]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

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

[10]  Niklaus Wirth,et al.  Systematic Programming: An Introduction , 1974 .

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

[12]  Robert E. Tarjan,et al.  Efficiency of a Good But Not Linear Set Union Algorithm , 1972, JACM.

[13]  C. A. R. Hoare,et al.  Proof of correctness of data representation , 1975, Language Hierarchies and Interfaces.

[14]  Mike Paterson,et al.  Linear unification , 1976, STOC '76.

[15]  Alberto Martelli,et al.  Unification in linear time and space: a structured presentation , 1976 .

[16]  Jacob T. Schwartz,et al.  Optimization of Very High Level Languages - I. Value Transmission and Its Corollaries , 1975, Comput. Lang..

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

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

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

[20]  Robert E. Tarjan,et al.  Applications of Path Compression on Balanced Trees , 1979, JACM.

[21]  Rod M. Burstall,et al.  HOPE: An experimental applicative language , 1980, LISP Conference.

[22]  Alberto Martelli,et al.  An Efficient Unification Algorithm , 1982, TOPL.

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

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

[25]  David B. MacQueen.  Modules for standard ML , 1984, LFP '84.

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

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

[28]  John C. Mitchell,et al.  Coercion and type inference , 1984, POPL.

[29]  P. Medawar.  A view from the left , 1984, Nature.

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

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

[32]  Niklaus Wirth,et al.  Programming in Modula-2 , 1985, Texts and Monographs in Computer Science.

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

[34]  L. Cardelli.  A Polymorphic λ-calculus with Type:Type , 1986 .

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

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

[37]  Thierry Coquand,et al.  An Analysis of Girard's Paradox , 1986, LICS.

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

[39]  Christine Mohring,et al.  Algorithm Development in the Calculus of Constructions , 1986, Logic in Computer Science.

[40]  John Cartmell,et al.  Generalised algebraic theories and contextual categories , 1986, Ann. Pure Appl. Log..

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

[42]  David K. Gifford,et al.  Integrating functional and imperative programming , 1986, LFP '86.

[43]  Marko C. J. D. van Eekelen,et al.  CLEAN: A language for functional graph writing , 1987, FPCA.

[44]  Joannes M. Lucassen.  Types and Effects Towards the Integration of Functional and Imperative Programming. , 1987 .

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

[46]  Olin Shivers,et al.  Control flow analysis in scheme , 1988, PLDI '88.

[47]  M. Tofte.  Operational Semantics and Polymorphic Type Inference , 1988 .

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

[49]  John C. Mitchell,et al.  Abstract types have existential type , 1988, TOPL.

[50]  Peter Buneman,et al.  Type inference in a database programming language , 1988, LISP and Functional Programming.

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

[52]  David K. Gifford,et al.  Polymorphic effect systems , 1988, POPL '88.

[53]  Yves Lafont.  The Linear Abstract Machine (Corrigenda) , 1988, Theor. Comput. Sci..

[54]  Thomas Ehrhard.  A categorical semantics of constructions , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[55]  John C. Mitchell,et al.  ML with extended pattern matching and subtypes , 1988, LISP and Functional Programming.

[56]  Ryan Stansifer,et al.  Type inference with subtypes , 1988, POPL '88.

[57]  Michael J. Maher,et al.  Unification Revisited , 1988, Foundations of Deductive Databases and Logic Programming..

[58]  Luca Cardelli,et al.  Phase Distinctions in Type Theory , 1988 .

[59]  Butler W. Lampson,et al.  Pebble, a Kernel Language for Modules and Abstract Data Types , 1988, Inf. Comput..

[60]  Luca Cardelli,et al.  The Modula–3 type system , 1989, POPL '89.

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

[62]  Pierre Jouvelot,et al.  Reasoning about continuations with control effects , 1989, PLDI '89.

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

[64]  Kevin Knight,et al.  Unification: a multidisciplinary survey , 1989, CSUR.

[65]  John C. Reynolds,et al.  Syntactic Control of Inference, Part 2 , 1989, ICALP.

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

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

[68]  Peter Buneman,et al.  Static type inference for parametric classes , 1989, OOPSLA '89.

[69]  Philip Wadler,et al.  Theorems for free! , 1989, FPCA.

[70]  Peter Sestoft,et al.  Replacing function parameters by global variables , 1989, FPCA.

[71]  Eugenio Moggi,et al.  Computational lambda-calculus and monads , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

[72]  Jens Palsberg,et al.  Type substitution for object-oriented programming , 1990, OOPSLA/ECOOP '90.

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

[74]  David R. Hanson.  Fast allocation and deallocation of memory based on object lifetimes , 1990, Softw. Pract. Exp..

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

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

[77]  Claude Kirchner,et al.  Syntactic theories and unification , 1990, [1990] Proceedings. Fifth Annual IEEE Symposium on Logic in Computer Science.

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

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

[80]  Pavel Curtis.  Constrained qualification in polymorphic type analysis , 1990 .

[81]  William Pugh,et al.  Two-directional record layout for multiple inheritance , 1990, PLDI '90.

[82]  William R. Cook,et al.  Mixin-based inheritance , 1990, OOPSLA/ECOOP '90.

[83]  Jerzy Tiuryn,et al.  ML Typability is DEXTIME-Complete , 1990, CAAP.

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

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

[86]  Pierre Jouvelot,et al.  Polymorphic type, region and effect inference , 1992, Journal of Functional Programming.

[87]  Marko C. J. D. van Eekelen,et al.  Concurrent Clean , 1991, PARLE.

[88]  Harry G. Mairson,et al.  Unification and ML-Type Reconstruction , 1991, Computational Logic - Essays in Honor of Alan Robinson.

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

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

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

[92]  Niklaus Wirth,et al.  Pascal User Manual and Report , 1991, Springer New York.

[93]  John C. Mitchell,et al.  On the Equivalence of Data Representations , 1991, Artificial and Mathematical Theory of Computation.

[94]  Carolyn L. Talcott,et al.  1 Equivalence in Functional Languages with E ectsIan , 2007 .

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

[96]  Matthias Felleisen,et al.  Parameter-passing and the lambda calculus , 1991, POPL '91.

[97]  Olin Shivers,et al.  Control-flow analysis of higher-order languages of taming lambda , 1991 .

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

[99]  John C. Mitchell,et al.  Type inference with simple subtypes , 1991, Journal of Functional Programming.

[100]  Robert Harper,et al.  Type Checking with Universes , 1991, Theor. Comput. Sci..

[101]  T. Streicher.  Semantics of Type Theory , 1991, Progress in Theoretical Computer Science.

[102]  T. Coquand.  An algorithm for testing conversion in type theory , 1991 .

[103]  Robert Hieb,et al.  The Revised Report on the Syntactic Theories of Sequential Control and State , 1992, Theor. Comput. Sci..

[104]  Patrick Lincoln,et al.  Linear logic , 1992, SIGA.

[105]  Didier Rémy.  Syntactic theories and the algebra of record terms , 1992 .

[106]  Martin Odersky.  Observers for Linear Types , 1992, ESOP.

[107]  Alexander Aiken,et al.  Solving systems of set constraints , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

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

[109]  Xavier Leroy,et al.  Polymorphic typing of an algorithmic language , 1992 .

[110]  Henry G. Baker,et al.  Lively linear Lisp: “look ma, no garbage!” , 1992, SIGP.

[111]  Jerzy Tiuryn.  Subtype inequalities , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

[112]  John C. Mitchell,et al.  On the type structure of standard ML , 1993, TOPL.

[113]  Alley Stoughton,et al.  Studying the Fully Abstract Model of PCF within its Continuous Function Model , 1993, TLCA.

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

[115]  Andrew M. Pitts,et al.  Observable Properties of Higher Order Functions that Dynamically Create Local Names, or What's new? , 1993, MFCS.

[116]  Thorsten Altenkirch,et al.  Constructions, inductive types and strong normalization , 1993, CST.

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

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

[119]  Barbara Liskov,et al.  A history of CLU , 1993, HOPL-II.

[120]  Robert Wahbe,et al.  Efficient software-based fault isolation , 1994, SOSP '93.

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

[122]  Hubert Comon-Lundh.  Constraints in Term Algebras (Short Survey) , 1993, AMAST.

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

[124]  Benjamin C. Pierce,et al.  Object-oriented programming without recursive types , 1993, POPL '93.

[125]  Erik Barendsen,et al.  Conventional and Uniqueness Typing in Graph Rewrite Systems , 1993, FSTTCS.

[126]  Daniel Leivant,et al.  Stratified functional programs and computational complexity , 1993, POPL '93.

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

[128]  Sjaak Smetsers,et al.  Partially Strict Non-Recursive Data Types , 1993, J. Funct. Program..

[129]  Jerzy Tiuryn,et al.  The Undecidability of the Semi-unification Problem , 1993, Inf. Comput..

[130]  Jerzy Tiuryn,et al.  Type Reconstruction with Recursive Types and Atomic Subtyping , 1993, TAPSOFT.

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

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

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

[134]  Pierre Jouvelot,et al.  The Type and Effect Discipline , 1994, Inf. Comput..

[135]  Nevin Heintze,et al.  Set-based analysis of ML programs , 1994, LFP '94.

[136]  Healfdene Goguen.  A typed operational semantics for type theory , 1994 .

[137]  van Dt Diederik Daalen.  The Language Theory of Automath: Chapter I, Sections 1–5 (Introduction) , 1994 .

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

[139]  Benjamin Werner,et al.  Une Théorie des Constructions Inductives , 1994 .

[140]  Rolf Adams,et al.  The cost of selective recompilation and environment processing , 1994, TSEM.

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

[142]  Robert Cartwright,et al.  A practical soft type system for scheme , 1997, TOPL.

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

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

[145]  Fritz Henglein,et al.  Polymorphic Binding-Time Analysis , 1994, ESOP.

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

[147]  Mads Tofte,et al.  A Semantics for Higher-Order Functors , 1994, ESOP.

[148]  Flemming Nielson,et al.  Higher-order concurrent programs with finite communication topology (extended abstract) , 1994, POPL '94.

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

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

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

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

[153]  Geoffrey Smith,et al.  Principal Type Schemes for Functional Programs with Overloading and Subtyping , 1994, Sci. Comput. Program..

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

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

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

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

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

[159]  Jens Palsberg,et al.  A type system equivalent to flow analysis , 1995, TOPL.

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

[161]  Atsushi Ohori,et al.  A polymorphic record calculus and its compilation , 1995, TOPL.

[162]  Nevin Heintze.  Control-Flow Analysis and Type Systems , 1995, SAS.

[163]  Jacques Garrigue,et al.  A Label-Selective Lambda-Calculus with Optional Arguments and its Compilation Method , 1995 .

[164]  Xavier Leroy,et al.  Applicative functors and fully transparent higher-order modules , 1995, POPL '95.

[165]  Andrew D. Gordon.  Bisimilarity as a theory of functional programming , 1995, MFPS.

[166]  Alexander Aiken,et al.  Better static memory management: improving region-based analysis of higher-order languages , 1995, PLDI '95.

[167]  Fritz Henglein,et al.  Polymorphic Recursion and Subtype Qualifications: Polymorphic Binding-Time Analysis in Polynomial Time , 1995, SAS.

[168]  Carolyn L. Talcott,et al.  A Variable Typed Logic of Effects , 1995, Inf. Comput..

[169]  Jens Palsberg.  Efficient Inference of Object Types , 1995, Inf. Comput..

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

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

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

[173]  Douglas J. Howe.  Proving Congruence of Bisimulation in Functional Programming Languages , 1996, Inf. Comput..

[174]  Flemming Nielson,et al.  From CML to its Process Algebra , 1996, Theor. Comput. Sci..

[175]  Xavier Leroy,et al.  A syntactic theory of type generativity and sharing , 1996, Journal of Functional Programming.

[176]  Jerzy Tiuryn,et al.  Satisfiability of Inequalities in a Poset , 1996, Fundam. Informaticae.

[177]  Frank Pfenning,et al.  A linear logical framework , 1996, Proceedings 11th Annual IEEE Symposium on Logic in Computer Science.

[178]  Carolyn L. Talcott,et al.  From Operational Semantics to Domain Theory , 1996, Inf. Comput..

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

[180]  Benedict R. Gaster,et al.  A Polymorphic Type System for Extensible Records and Variants , 1996 .

[181]  Robert Harper,et al.  Typed closure conversion , 1996, POPL '96.

[182]  Frank Yellin,et al.  The Java Virtual Machine Specification , 1996 .

[183]  Mark P. Jones,et al.  Using parameterized signatures to express modular structure , 1996, POPL '96.

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

[185]  Natarajan Shankar,et al.  PVS: Combining Specification, Proof Checking, and Model Checking , 1996, FMCAD.

[186]  Lars Birkedal,et al.  From region inference to von Neumann machines via region representation inference , 1996, POPL '96.

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

[188]  Christian Mossin,et al.  Flow analysis of typed higher-order programs , 1996, Technical report / University of Copenhagen / Datalogisk institut.

[189]  Andrew M. Pitts,et al.  Relational Properties of Domains , 1996, Inf. Comput..

[190]  Christoph Zenger,et al.  Indexed Types , 1997, Theoretical Computer Science.

[191]  Kresten Krab Thorup.  Genericity in Java with Virtual Types , 1997, ECOOP.

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

[193]  ScienceYale UniversityNew Haven.  An Overview of the Flint/ml Compiler , 1997 .

[194]  Didier Rémy,et al.  Extending ML with Semi-Explicit Higher-Order Polymorphism , 1997, TACS.

[195]  Stephan Merz,et al.  Type checking higher-order polymorphic multi-methods , 1997, POPL '97.

[196]  Wiebe van der Hoek,et al.  First steps in modal logic , 1997 .

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

[198]  Luca Cardelli,et al.  Program fragments, linking, and modularization , 1997, POPL '97.

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

[200]  Joachim Niehren,et al.  Inclusion Constraints over Non-empty Sets of Trees , 1997, TAPSOFT.

[201]  David B. MacQueen,et al.  The Definition of Standard ML (Revised) , 1997 .

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

[203]  George C. Necula,et al.  Efficient Representation and Validation of Logical Proofs , 1997, LICS 1997.

[204]  Jakob Rehof.  Minimal typings in atomic subtyping , 1997, POPL '97.

[205]  Martin Hofmann,et al.  A Mixed Modal/Linear Lambda Calculus with Applications to Bellantoni-Cook Safe Recursion , 1997, CSL.

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

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

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

[209]  Robbert van Renesse,et al.  Building Adaptive Systems Using Ensemble , 1998, Softw. Pract. Exp..

[210]  Davide Ancona,et al.  A theory of mixin modules: basic and derived operators , 1998, Mathematical Structures in Computer Science.

[211]  Martin Müller,et al.  Type Inference for First-Class Messages with Feature Constraints , 2000, Int. J. Found. Comput. Sci..

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

[213]  Claudio V. Russo.  Types for Modules , 2004, Electronic Notes in Theoretical Computer Science.

[214]  Zhong Shao,et al.  Implementing typed intermediate languages , 1998, ICFP '98.

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

[216]  George C. Necula,et al.  The design and implementation of a certifying compiler , 1998, PLDI.

[217]  Amr Sabry,et al.  What is a purely functional language? , 1998, Journal of Functional Programming.

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

[219]  Morten V. Christiansen,et al.  Region-Based Memory Management in Java , 1998 .

[220]  Yasuhiko Minamide,et al.  A functional representation of data structures with a hole , 1998, POPL '98.

[221]  Mads Torgersen.  Virtual types are statically safe , 1998 .

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

[223]  Jean-Yves Girard,et al.  Light Linear Logic , 1998, Inf. Comput..

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

[225]  Joachim Niehren,et al.  The first-order theory of ordering constraints over feature trees , 1998, Proceedings. Thirteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.98CB36226).

[226]  Benedict R. Gaster.  Records, variants and qualified types , 1998 .

[227]  Andrew M. Pitts.  Existential Types: Logical Relations and Operational Equivalence , 1998, ICALP.

[228]  Erik Poll.  Expansion Postponement for Normalising Pure Type Systems , 1998, J. Funct. Program..

[229]  Susumu Nishimura,et al.  Static typing for dynamic messages , 1998, POPL '98.

[230]  Martin Elsman,et al.  Programming with regions in the ml kit (for version 4) , 1998 .

[231]  David Walker,et al.  Stack-based typed assembly language , 1998, Journal of Functional Programming.

[232]  Philip Wadler,et al.  The marriage of effects and monads , 1998, ICFP '98.

[233]  Frank Pfenning,et al.  Algorithms for Equality and Unification in the Presence of Notational Definitions , 1998, Proof Search in Type-Theoretic Languages@CADE.

[234]  Olivier Danvy.  Functional Unparsing , 1998, J. Funct. Program..

[235]  George C. Necula,et al.  Compiling with proofs , 1998 .

[236]  Zhong Shao.  Typed cross-module compilation , 1998, ICFP '98.

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

[238]  Naoki Kobayashi.  Quasi-linear types , 1999, POPL '99.

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

[240]  Mark P. Jones,et al.  Typing Haskell in Haskell , 1999 .

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

[242]  Andrew D. Gordon.  Operational equivalences for untyped and polymorphic object calculi , 1999 .

[243]  Flemming Nielson,et al.  Principles of Program Analysis , 1999, Springer Berlin Heidelberg.

[244]  Amr Sabry,et al.  Monadic encapsulation in ML , 1999, ICFP '99.

[245]  John C. Reynolds,et al.  Intuitionistic reasoning about shared mutable data structure , 1999 .

[246]  Simon L. Peyton Jones,et al.  Once upon a polymorphic type , 1999, POPL '99.

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

[248]  Simon Peyton Jones,et al.  Lightweight Extensible Records for Haskell , 1999 .

[249]  C. Talcott,et al.  Reasoning about functions with effects , 1999 .

[250]  Transparent Modules with Fully Syntactic Signatures , 1999, ICFP.

[251]  Andrew W. Appel,et al.  Hierarchical modularity , 1999, TOPL.

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

[253]  Zhong Shao.  Transparent modules with fully syntatic signatures , 1999, ICFP '99.

[254]  Karl Crary.  A simple proof technique for certain parametricity results , 1999, ICFP '99.

[255]  Martin Sulzmann,et al.  Hindley/Milner style type systems in constraint form , 1999 .

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

[257]  Martin Hofmann,et al.  Linear types and non-size-increasing polynomial time computation , 1999, Proceedings. 14th Symposium on Logic in Computer Science (Cat. No. PR00158).

[258]  Peter W. O'Hearn,et al.  The Logic of Bunched Implications , 1999, Bulletin of Symbolic Logic.

[259]  Frank Pfenning,et al.  Natural Deduction for Intuitionistic Non-communicative Linear Logic , 1999, TLCA.

[260]  Philip Wadler,et al.  Operational Interpretations of Linear Logic , 1999, Theor. Comput. Sci..

[261]  Flemming Nielson,et al.  Type and effect systems - behaviours for concurrency , 1999 .

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

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

[264]  Glynn Winskel,et al.  Relational Reasoning about Functions and Nondeterminism , 1999 .

[265]  Joe B. Wells,et al.  Typability and Type Checking in System F are Equivalent and Undecidable , 1999, Ann. Pure Appl. Log..

[266]  I. Stark,et al.  Operational reasoning for functions with local state , 1999 .

[267]  Claudio V. Russo.  Non-dependent Types for Standard ML Modules , 1999, PPDP.

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

[269]  Manuel Fähndrich,et al.  Bane: a library for scalable constraint-based program analysis , 1999 .

[270]  David A. McAllester.  On the complexity analysis of static analyses , 1999, JACM.

[271]  George C. Necula,et al.  Translation validation for an optimizing compiler , 2000, PLDI '00.

[272]  Andrew M. Pitts,et al.  Operational Semantics and Program Equivalence , 2000, APPSEM.

[273]  Henning Makholm,et al.  Region-based Memory Management in Prolog Master's Thesis March 2000 , 2000 .

[274]  Greg Restall,et al.  An Introduction to Substructural Logics , 2000 .

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

[276]  David Walker,et al.  Alias Types for Recursive Data Structures , 2000, Types in Compilation.

[277]  Thomas W. Reps,et al.  Interconvertibility of a class of set constraints and context-free-language reachability , 2000, Theor. Comput. Sci..

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

[279]  Jakob Rehof,et al.  Scalable context-sensitive flow analysis using instantiation constraints , 2000, PLDI '00.

[280]  François Pottier,et al.  A Versatile Constraint-Based Type Inference System , 2000, Nord. J. Comput..

[281]  Fred B. Schneider,et al.  Enforceable security policies , 2000, TSEC.

[282]  R. Harper,et al.  Singleton kinds and singleton types , 2000 .

[283]  P. Cheng,et al.  Implementing the TILT Internal Language , 2000 .

[284]  Andrew W. Appel,et al.  A semantic model of types and machine instructions for proof-carrying code , 2000, POPL '00.

[285]  Henning Makholm,et al.  Region-Based Memory Management in Prolog , 2000 .

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

[287]  Martin Hofmann.  Safe recursion with higher types and BCK-algebra , 2000, Ann. Pure Appl. Log..

[288]  Frank Pfenning,et al.  Efficient resource management for linear logic proof search , 1996, Theor. Comput. Sci..

[289]  David Walker,et al.  Typed memory management via static capabilities , 2000, TOPL.

[290]  Helmut Schwichtenberg,et al.  Higher type recursion, ramification and polynomial time , 2000, Ann. Pure Appl. Log..

[291]  Claudio V. Russo,et al.  Operational Properties of Lily, a Polymorphic Linear Lambda Calculus with Recursion , 2001, HOOTS.

[292]  P. Hudak,et al.  A general framework for hindley/milner type systems with constraints , 2000 .

[293]  George C. Necula,et al.  A certifying compiler for Java , 2000, PLDI '00.

[294]  Conor McBride,et al.  Dependently typed functional programs and their proofs , 2000 .

[295]  Peter Thiemann,et al.  Syntactic Type Soundness for the Region Calculus , 2001, HOOTS.

[296]  Jacques Garrigue,et al.  Code reuse through polymorphic variants , 2000 .

[297]  Eric Eide,et al.  Knit: component composition for systems software , 2000, OSDI.

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

[299]  François Pottier,et al.  Simplifying Subtyping Constraints: A Theory , 2001, Inf. Comput..

[300]  Jacques Garrigue.  Simple Type Inference for Structural Polymorphism , 2001, APLAS.

[301]  Andrew D. Gordon,et al.  Authenticity by typing for security protocols , 2001, Proceedings. 14th IEEE Computer Security Foundations Workshop, 2001..

[302]  Andrew W. Appel,et al.  Type-preserving garbage collectors , 2001, POPL '01.

[303]  Joachim Niehren,et al.  Non-structural subtype entailment in automata theory , 2003, Inf. Comput..

[304]  Robert DeLine,et al.  Enforcing high-level protocols in low-level software , 2001, PLDI '01.

[305]  Zhong Shao,et al.  Principled scavenging , 2001, PLDI '01.

[306]  Cristiano Calcagno.  Stratified operational semantics for safety and correctness of the region calculus , 2001, POPL '01.

[307]  Jakob Rehof,et al.  A Behavioral Module System for the Pi-Calculus , 2001, SAS.

[308]  Josef Svenningsson,et al.  Constraint Abstractions , 2001, PADO.

[309]  Atsushi Igarashi,et al.  A generic type system for the Pi-calculus , 2001, POPL '01.

[310]  Frank Pfenning,et al.  A judgmental reconstruction of modal logic , 2001, Mathematical Structures in Computer Science.

[311]  John John Gough,et al.  Compiling for the .NET Common Language Runtime , 2001 .

[312]  Andrew W. Appel,et al.  Foundational proof-carrying code , 2001, Proceedings 16th Annual IEEE Symposium on Logic in Computer Science.

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

[314]  Jens Palsberg,et al.  Type-based analysis and applications , 2001, PASTE '01.

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

[316]  Jakob Rehof,et al.  Type-base flow analysis: from polymorphic subtyping to CFL-reachability , 2001, POPL '01.

[317]  Lars Birkedal,et al.  A constraint-based region inference algorithm , 2001, Theor. Comput. Sci..

[318]  Andrew D. Gordon,et al.  Typing a multi-language intermediate code , 2001, POPL '01.

[319]  Davide Sangiorgi,et al.  The Pi-Calculus - a theory of mobile processes , 2001 .

[320]  On Regions and Linear Types , 2001, ICFP.

[321]  Claudio V. Russo.  Recursive Structures for Standard ML , 2001, ICFP.

[322]  François Pottier.  A Semi-Syntactic Soundness Proof for HM(X) , 2001 .

[323]  David Gay,et al.  Language support for regions , 2001, PLDI '01.

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

[325]  Ralph Loader.  Finitary PCF is not decidable , 2001, Theor. Comput. Sci..

[326]  Fritz Henglein,et al.  A direct approach to control-flow sensitive region-based memory management , 2001, PPDP '01.

[327]  Andrew D. Gordon,et al.  Ðð Blockinøöóòò Aeóøø× Ò Ìììóööøø Blockin Blockinð Óñôùøøö Ë Blockin , 2007 .

[328]  Joe B. Wells,et al.  The Essence of Principal Typings , 2002, ICALP.

[329]  James Cheney,et al.  Cyclone: A Safe Dialect of C , 2002, USENIX Annual Technical Conference, General Track.

[330]  Jonathan P. Seldin,et al.  CURRY’S ANTICIPATION OF THE TYPES USED IN PROGRAMMING LANGUAGES , 2002 .

[331]  Peter Thiemann,et al.  Syntactic Type Soundness Results for the Region Calculus , 2002, Inf. Comput..

[332]  Martin Hofmann,et al.  Another Type System for In-Place Update , 2002, ESOP.

[333]  Alexandre Frey.  Satisfying subtype inequalities in polynomial space , 2002, Theor. Comput. Sci..

[334]  Alexander Aiken,et al.  Flow-sensitive type qualifiers , 2002, PLDI '02.

[335]  Konstantinos Sagonas,et al.  On Enabling the WAM with Region Support , 2002, ICLP.

[336]  Patricia Johann.  A Generalization of Short-Cut Fusion and its Correctness Proof , 2002, High. Order Symb. Comput..

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

[338]  Daniel Bonniot.  Type-checking multi-methods in ML (A modular approach) , 2002 .

[339]  James Cheney,et al.  Region-based memory management in cyclone , 2002, PLDI '02.

[340]  Benjamin C. Pierce,et al.  Types and programming languages: the next generation , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[341]  Judicaël Courant.  Strong Normalization with Singleton Types , 2002, Electron. Notes Theor. Comput. Sci..

[342]  Joachim Niehren,et al.  The first-order theory of subtyping constraints , 2002, POPL '02.

[343]  Christian Skalka,et al.  Syntactic Type Soundness for HM(X) , 2002, Electron. Notes Theor. Comput. Sci..

[344]  Flemming Nielson,et al.  A Succinct Solver for ALFP , 2002, Nord. J. Comput..

[345]  Jakob Rehof,et al.  Conformance Checking for Models of Asynchronous Message Passing Software , 2002, CAV.

[346]  Sagar Chaki,et al.  Types as models: model checking message-passing programs , 2002, POPL '02.

[347]  Jacques Garrigue.  Relaxing the Value Restriction , 2002, APLAS.

[348]  Robert DeLine,et al.  Adoption and focus: practical linear types for imperative programming , 2002, PLDI '02.

[349]  Atsushi Igarashi,et al.  Foundations for Virtual Types , 1999, Inf. Comput..

[350]  Atsushi Igarashi,et al.  Resource usage analysis , 2002, POPL '02.

[351]  Davide Ancona,et al.  A calculus of module systems , 2002, J. Funct. Program..

[352]  Martin Elsman,et al.  Combining region inference and garbage collection , 2002, PLDI '02.

[353]  Tom Hirschowitz,et al.  Mixin modules in a call-by-value setting , 2002, TOPL.

[354]  Andrew D. Gordon,et al.  Types and effects for asymmetric cryptographic protocols , 2002, Proceedings 15th IEEE Computer Security Foundations Workshop. CSFW-15.

[355]  David Walker,et al.  The logical approach to stack typing , 2003, TLDI '03.

[356]  Frank Pfenning,et al.  A type theory for memory allocation and data layout , 2003, POPL '03.

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

[358]  Jaakko Järvi,et al.  A comparative study of language support for generic programming , 2003, OOPSLA '03.

[359]  Martin Odersky,et al.  A Nominal Theory of Objects with Dependent Types , 2003, ECOOP.

[360]  Viktor Kuncak,et al.  Structural subtyping of non-recursive types is decidable , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[361]  Andrew W. Appel,et al.  Mechanisms for secure modular programming in Java , 2003, Softw. Pract. Exp..

[362]  David McAllester.  A logical algorithm for ML type inference , 2003 .

[363]  Cormac Flanagan,et al.  A type and effect system for atomicity , 2003, PLDI.

[364]  Alexander Aiken,et al.  Checking and inferring local non-aliasing , 2003, PLDI '03.

[365]  Vincent Simonet,et al.  Type Inference with Structural Subtyping: A Faithful Formalization of an Efficient Constraint Solver , 2003, APLAS.

[366]  David Walker,et al.  Reasoning about hierarchical storage , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[367]  Thierry Coquand,et al.  A Logical Framework with Dependently Typed Records , 2003, Fundam. Informaticae.

[368]  P. Wegner.  Lambda calculus , 2003 .

[369]  F. Pottier.  A constraint-based presentation and generalization of rows , 2003, 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings..

[370]  Karl Crary,et al.  Toward a foundational typed assembly language , 2003, POPL '03.

[371]  François Pottier,et al.  Information flow inference for ML , 2003, TOPL.

[372]  Peter W. O'Hearn.  On bunched typing , 2003, J. Funct. Program..

[373]  Peter Thiemann,et al.  Polymorphic specialization for ML , 2004, TOPL.

[374]  Jérôme Vouillon,et al.  Semantic types: a fresh look at the ideal model for types , 2004, POPL '04.

[375]  Zhong Shao,et al.  A Syntactic Approach to Foundational Proof-Carrying Code , 2004, Journal of Automated Reasoning.

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

[377]  Robert Cartwright,et al.  Soft typing , 2004, SIGP.

[378]  Scott F. Smith,et al.  A systematic approach to static access control , 2001, TOPL.

[379]  Jens Palsberg,et al.  Type inference with non-structural subtyping , 2005, Formal Aspects of Computing.

[380]  Donald Sannella,et al.  Toward formal development of programs from algebraic specifications: Parameterisation revisited , 1992, Acta Informatica.

[381]  Benjamin C. Pierce,et al.  A bisimulation for type abstraction and recursion , 2005, POPL '05.

[382]  Stephen A. Cook,et al.  A new recursion-theoretic characterization of the polytime functions , 1992, STOC '92.

[383]  Frank Pfenning,et al.  On equivalence and canonical forms in the LF type theory , 2001, TOCL.

[384]  Riccardo Pucella,et al.  Phantom types and subtyping , 2002, Journal of Functional Programming.

[385]  Greg Restall,et al.  Relevant and substructural logics , 2006, Logic and the Modalities in the Twentieth Century.

[386]  Robert Harper,et al.  Extensional equivalence and singleton types , 2006, TOCL.