diff --git a/doc/Makefile b/doc/Makefile index 43c1cad72c278964d7dd028911ccbf6778b54686..fe30460bcbc59c1e5abb9ed8f0418a9afddd0679 100644 --- a/doc/Makefile +++ b/doc/Makefile @@ -11,6 +11,8 @@ ML := $(shell ls ../test/*.ml | grep -v processed) PROCESSED := $(patsubst %.ml,%.processed.ml,$(ML)) %.pdf: %.tex $(SOURCES) $(ML) $(PROCESSED) + pdflatex $* + bibtex $* pdflatex $* pdflatex $* diff --git a/doc/english.bib b/doc/english.bib new file mode 100644 index 0000000000000000000000000000000000000000..f01713b956ac2d08930589f9e80cc81005f5eda7 --- /dev/null +++ b/doc/english.bib @@ -0,0 +1,14517 @@ +@String{acmp = "ACM Press"} + +@String{acsac = "Annual Computer Security Applications Conference"} + +@String{acta = "Acta Informatica"} + +@String{afp = "Advanced Functional Programming"} + +@String{amast = "International Conference on Algebraic Methodology and + Software Technology (AMAST)"} + +@String{ams = "American Mathematical Society"} + +@String{ap = "Academic Press"} + +@String{apal = "Annals of Pure and Applied Logic"} + +@String{aplas = "Asian Symposium on Programming Languages and Systems + (APLAS)"} + +@String{asian = "Asian Computer Science Conference ({ASIAN})"} + +@String{aw = "Addison-Wesley"} + +@String{cacm = "Communications of the {ACM}"} + +@String{cade = "International Conference on Automated Deduction + (CADE)"} + +@String{carleton = "Carleton Scientific"} + +@String{cassis = "Construction and Analysis of Safe, Secure and + Interoperable Smart devices (CASSIS)"} + +@String{cav = "Computer Aided Verification (CAV)"} + +@String{cc = "Compiler Construction (CC)"} + +@String{cdcs = "International Conference on Distributed Computing + Systems (CDCS)"} + +@String{cj = "Computer Journal"} + +@String{computer = "Computer"} + +@String{concur = "International Conference on Concurrency Theory + (CONCUR)"} + +@String{cpp = "Certified Programs and Proofs (CPP)"} + +@String{csfw = "{IEEE} Computer Security Foundations Workshop"} + +@String{csl = "Computer Science Logic"} + +@String{cup = "Cambridge University Press"} + +@String{dac = "Design Automation Conference (DAC)"} + +@String{decsrc = "Digital Equipment Corporation, Systems Research + Center"} + +@String{dls = "Symposium on Dynamic Languages"} + +@String{dspg = "Domain-Specific Program Generation (DSPG)"} + +@String{ecoop = "European Conference on Object-Oriented Programming + (ECOOP)"} + +@String{ellis = "Ellis Horwood"} + +@String{elsevier = "Elsevier Science"} + +@String{entcs = "Electronic Notes in Theoretical Computer Science"} + +@String{esop = "European Symposium on Programming (ESOP)"} + +@String{esorics = "European Symposium on Research in Computer Security"} + +@String{eurosys = "EuroSys"} + +@String{fac = "Formal Aspects of Computing"} + +@String{fics = "International workshop on Fixed Points in Computer + Science (FICS)"} + +@String{flops = "Functional and Logic Programming"} + +@String{fm = "Formal Methods (FM)"} + +@String{fmco = "Formal Methods for Components and Objects"} + +@String{fmsd = "Formal Methods in System Design"} + +@String{fool = "Foundations of Object-Oriented Languages (FOOL)"} + +@String{fopara = "Foundational and Practical Aspects of Resource + Analysis"} + +@String{fosad = "Foundations of Security Analysis and Design"} + +@String{fossacs = "Foundations of Software Science and Computation + Structures ({FOSSACS})"} + +@String{fpca = "Functional Programming Languages and Computer + Architecture (FPCA)"} + +@String{fse = "Workshop on Foundations of Software Engineering"} + +@String{fsttcs = "Foundations of Software Technology and Theoretical + Computer Science (FSTTCS)"} + +@String{ftfjp = "Formal Techniques for {Java}-like Programs"} + +@String{fundamenta = "Fundamenta Informaticæ"} + +@String{gcse = "Generative and Component-Based Software Engineering"} + +@String{gpce = "Generative Programming and Component Engineering + (GPCE)"} + +@String{hav = "Heap Analysis and Verification (HAV)"} + +@String{hilt = "ACM SIGAda Annual Conference on High Integrity + Language Technology (HILT)"} + +@String{hlcl = "High-Level Concurrent Languages (HLCL)"} + +@String{hoots = "Higher Order Operational Techniques in Semantics + (HOOTS)"} + +@String{hopl = "History of Programming Languages"} + +@String{hosc = "Higher-Order and Symbolic Computation"} + +@String{hotpar = "USENIX Conference on Hot Topics in Parallelism + (HotPar)"} + +@String{hs = "Haskell symposium"} + +@String{hw = "Haskell workshop"} + +@String{ic = "Information and Computation"} + +@String{icalp = "International Colloquium on Automata, Languages and + Programming"} + +@String{icfem = "International Conference on Formal Engineering Methods + (ICFEM)"} + +@String{icfp = "International Conference on Functional Programming + (ICFP)"} + +@String{iclp = "International Conference on Logic Programming (ICLP)"} + +@String{icse = "International Conference on Software Engineering + ({ICSE})"} + +@String{ictl = "International Conference on Temporal Logic (ICTL)"} + +@String{ie = "InterEditions"} + +@String{ifiptcs = "IFIP International Conference on Theoretical Computer + Science (TCS)"} + +@String{ifl = "Implementation of Functional Languages (IFL)"} + +@String{ijcai = "International Joint Conferences on Artificial + Intelligence"} + +@String{ijfcs = "International Journal of Foundations of Computer + Science"} + +@String{ipl = "Information Processing Letters"} + +@String{issta = "International Symposium on Software Testing and + Analysis (ISSTA)"} + +@String{ist = "Information and Software Technology"} + +@String{ita = "Informatique théorique et applications"} + +@String{itp = "Interactive Theorem Proving (ITP)"} + +@String{itrs = "Workshop on Intersection Types and Related Systems + (ITRS)"} + +@String{jacm = "Journal of the {ACM}"} + +@String{jar = "Journal of Automated Reasoning"} + +@String{jfla = "Journées Françaises des Langages Applicatifs (JFLA)"} + +@String{jfp = "Journal of Functional Programming"} + +@String{jlap = "Journal of Logic and Algebraic Programming"} + +@String{jlc = "Journal of Logic and Computation"} + +@String{jlp = "Journal of Logic Programming"} + +@String{jot = "Journal of Object Technology"} + +@String{jsc = "Journal of Symbolic Computation"} + +@String{jucs = "Journal of Universal Computer Science"} + +@String{kluwer = "Kluwer"} + +@String{lfm = "Workshop on Logical Frameworks and Meta-Languages + (LFM)"} + +@String{lfp = "ACM Symposium on Lisp and Functional Programming + (LFP)"} + +@String{lics = "Logic in Computer Science (LICS)"} + +@String{lipics = "{Leibniz} International Proceedings in Informatics"} + +@String{lmcs = "Logical Methods in Computer Science"} + +@String{lnai = "Lecture Notes in Artificial Intelligence"} + +@String{lncs = "Lecture Notes in Computer Science"} + +@String{lola = "Workshop on Syntax and Semantics of Low Level + Languages"} + +@String{loplas = "ACM Letters on Programming Languages and Systems"} + +@String{lpar = "Logic for Programming Artificial Intelligence and + Reasoning (LPAR)"} + +@String{lsc = "Lisp and Symbolic Computation"} + +@String{merlin = "ACM Workshop on Mechanized Reasoning about Languages + with Variable Binding"} + +@String{mfcs = "International Symposium on Mathematical Foundations of + Computer Science"} + +@String{mfps = "Mathematical Foundations of Programming Semantics"} + +@String{mitp = "MIT Press"} + +@String{ml = "ACM Workshop on ML"} + +@String{mlapp = "ACM Workshop on ML and its Applications"} + +@String{mpc = "Mathematics of Program Construction (MPC)"} + +@String{mscs = "Mathematical Structures in Computer Science"} + +@String{msfp = "ACM SIGPLAN Workshop on Mathematically Structured + Functional Programming (MSFP)"} + +@String{ndss = "Internet Society Symposium on Network and Distributed + System Security"} + +@String{nfm = "{NASA} Formal Methods (NFM)"} + +@String{njc = "Nordic Journal of Computing"} + +@String{notices = "{ACM} {SIGPLAN} Notices"} + +@String{nspw = "New Security Paradigms Workshop"} + +@String{onward = "{ACM} Symposium on New Ideas in Programming and + Reflections on Software (Onward!)"} + +@String{oopsla = "Object-Oriented Programming, Systems, Languages, and + Applications (OOPSLA)"} + +@String{oopslacomp = "Companion to Object-Oriented Programming, Systems, + Languages, and Applications (OOPSLA)"} + +@String{padl = "Practical Aspects of Declarative Languages (PADL)"} + +@String{palgrave = "Palgrave Macmillan"} + +@String{pcc = "International Workshop on Proof-Carrying Code (PCC)"} + +@String{pepm = "{ACM} Workshop on Evaluation and Semantics-Based + Program Manipulation ({PEPM})"} + +@String{pi = "Proceedings in Informatics"} + +@String{pieee = "Proceedings of the IEEE"} + +@String{pldi = "{Programming Language Design and Implementation + (PLDI)}"} + +@String{plilp = "Programming Languages: Implementations, Logics, and + Programs (PLILP)"} + +@String{plpv = "Programming Languages Meets Program Verification + (PLPV)"} + +@String{popl = "Principles of Programming Languages ({POPL})"} + +@String{ppcp = "International Workshop on Principles and Practice of + Constraint Programming (PPCP)"} + +@String{ppdp = "Principles and Practice of Declarative Programming + (PPDP)"} + +@String{prentice = "Prentice Hall"} + +@String{rairo = "RAIRO Theoretical Informatics and Applications"} + +@String{rta = "Rewriting Techniques and Applications (RTA)"} + +@String{saig = "International Workshop on Semantics, Applications, and + Implementation of Program Generation (SAIG)"} + +@String{sas = "Static Analysis Symposium (SAS)"} + +@String{scp = "Science of Computer Programming"} + +@String{siamjc = "SIAM Journal on Computing"} + +@String{sigops = "ACM Operating Systems Review"} + +@String{snapl = "Summit on Advances in Programming Languages (SNAPL)"} + +@String{soda = "Symposium on Discrete Algorithms (SODA)"} + +@String{sp = "{IEEE} Symposium on Security and Privacy (S\&P)"} + +@String{spe = "Software: Practice and Experience"} + +@String{springer = "Springer"} + +@String{stoc = "ACM Symposium on Theory of Computing"} + +@String{sttt = "Software Tools for Technology Transfer"} + +@String{surveys = "{ACM} Computing Surveys"} + +@String{tacas = "Tools and Algorithms for Construction and Analysis of + Systems (TACAS)"} + +@String{tacs = "International Symposium on Theoretical Aspects of + Computer Software (TACS)"} + +@String{tams = "Transactions of the American Mathematical Society"} + +@String{taoop = "Theoretical Aspects Of Object-Oriented Programming: + Types, Semantics and Language Design"} + +@String{tapos = "Theory and Practice of Object Systems"} + +@String{tapsoft = "Theory and Practice of Software Development + ({TAPSOFT})"} + +@String{tcs = "Theoretical Computer Science"} + +@String{tcsconf = "IFIP International Conference on Theoretical Computer + Science (TCS)"} + +@String{tfp = "Trends in Functional Programming (TFP)"} + +@String{tic = "Types in Compilation (TIC)"} + +@String{tissec = "ACM Transactions on Information and System Security"} + +@String{tlca = "Typed Lambda Calculi and Applications (TLCA)"} + +@String{tldi = "Types in Language Design and Implementation (TLDI)"} + +@String{tocl = "ACM Transactions on Computational Logic"} + +@String{tods = "ACM Transactions on Database Systems"} + +@String{toplas = "ACM Transactions on Programming Languages and + Systems"} + +@String{tose = "IEEE Transactions on Software Engineering"} + +@String{tphol = "Theorem Proving in Higher Order Logics (TPHOLs)"} + +@String{types = "Types for Proofs and Programs"} + +@String{vmcai = "Verification, Model Checking and Abstract + Interpretation (VMCAI)"} + +@String{vstte = "Verified Software: Theories, Tools and Experiments"} + +@String{wgp = "Workshop on Generic Programming"} + +@String{wollic = "Workshop on Logic, Language, Information and + Computation (WoLLIC)"} + +@String{wrla = "International Workshop on Rewriting Logic and its + Applications (WRLA)"} + +@String{wsa = "International Workshop on Static Analysis (WSA)"} + +@String{wwv = "Workshop on Automated Specification and Verification + of Web Systems"} + +@InProceedings{abadi-blanchet-01, + author = "Martín Abadi and Bruno Blanchet", + title = "Secrecy Types for Asymmetric Communication", + booktitle = fossacs, + year = "2001", + volume = "2030", + series = lncs, + publisher = springer, + pages = "25--41", + URL = "http://www.di.ens.fr/~blanchet/publications/AbadiBlanchetFOSSACS01.html", +} + +@Article{abadi-cardelli-94, + author = "Mart{\'\i}n Abadi and Luca Cardelli", + title = "A Theory of Primitive Objects: Untyped and First-Order + Systems", + journal = ic, + year = "1996", + volume = "125", + number = "2", + pages = "78--102", + URL = "http://research.microsoft.com/Users/luca/Papers/PrimObj1stOrder.pdf", +} + +@Article{abadi-cardelli-94b, + author = "Mart{\'\i}n Abadi and Luca Cardelli", + title = "A Theory of Primitive Objects: Second-Order Systems", + journal = scp, + year = "1995", + volume = "25", + number = "2--3", + pages = "81--116", + URL = "http://research.microsoft.com/Users/luca/Papers/PrimObj2ndOrder.pdf", +} + +@InProceedings{abadi-dcc-99, + title = "A Core Calculus of Dependency", + author = "Martín Abadi and Anindya Banerjee and Nevin Heintze + and Jon G. Riecke", + booktitle = popl, + year = "1999", + pages = "147--160", + URL = "http://www.soe.ucsc.edu/~abadi/Papers/flowpopl.ps", +} + +@InProceedings{abadi-fiore-96, + author = "Mart{\'\i}n Abadi and Marcelo P. Fiore", + title = "Syntactic Considerations on Recursive Types", + booktitle = lics, + pages = "242--252", + year = "1996", + URL = "http://www.soe.ucsc.edu/~abadi/Papers/rec.ps", +} + +@InProceedings{abadi-lampson-levy-96, + title = "Analysis and Caching of Dependencies", + author = "Martín Abadi and Butler Lampson and Jean-Jacques + Lévy", + pages = "83--91", + booktitle = icfp, + year = "1996", + URL = "http://www.soe.ucsc.edu/~abadi/Papers/make-preprint.ps", +} + +@Article{abadi-pierce-plotkin-91, + author = "Martín Abadi and Benjamin Pierce and Gordon Plotkin", + title = "Faithful Ideal Models for Recursive Polymorphic + Types", + journal = "International Journal of Foundations of Computer + Science", + volume = "2", + number = "1", + year = "1991", + pages = "1--21", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/ideals.ps", +} + +@Article{abel-04, + author = "Andreas Abel", + title = "Termination Checking with Types", + journal = rairo, + year = "2004", + volume = "38", + number = "4", + pages = "277--319", + URL = "http://www2.tcs.ifi.lmu.de/~abel/rairo04.pdf", +} + +@InProceedings{abel-haskell-05, + author = "Andreas Abel and Marcin Benke and Ana Bove and John + Hughes and Ulf Norell", + title = "Verifying {Haskell} programs using constructive type + theory", + booktitle = hw, + year = "2005", + pages = "62--73", + URL = "http://www.tcs.informatik.uni-muenchen.de/~abel/haskell05.pdf", +} + +@InProceedings{abel-miniagda-10, + author = "Andreas Abel", + title = "{MiniAgda}: Integrating Sized and Dependent Types", + booktitle = "Workshop on Partiality And Recursion in Interactive + Theorem Provers (PAR)", + year = "2010", + URL = "http://www2.tcs.ifi.lmu.de/~abel/par10.pdf", +} + +@Article{abramsky-91, + author = "Samson Abramsky", + title = "Domain Theory in Logical Form", + journal = apal, + year = "1991", + volume = "51", + pages = "1--77", + URL = "http://web.comlab.ox.ac.uk/oucl/work/samson.abramsky/dtlf.ps.gz", +} + +@InProceedings{abramsky-honda-mccusker-98, + author = "Samson Abramsky and Kohei Honda and Guy McCusker", + title = "A fully abstract game semantics for general + references", + booktitle = lics, + pages = "334--344", + year = "1998", + URL = "http://web.comlab.ox.ac.uk/people/Samson.Abramsky/lics98.ps.gz", +} + +@Article{achten-plasmeijer-95, + author = "Peter Achten and Marinus J. Plasmeijer", + title = "The Ins and Outs of {Clean} {I/O}", + journal = jfp, + volume = "5", + number = "1", + year = "1995", + pages = "81--110", + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.17.935", +} + +@TechReport{agerholm-examples-94, + author = "Sten Agerholm", + title = "{LCF} Examples in {HOL}", + institution = "BRICS", + year = "1994", + number = "RS-94-18", + URL = "http://www.brics.dk/RS/94/18/BRICS-RS-94-18.ps.gz", +} + +@TechReport{agerholm-holcpo-94, + author = "Sten Agerholm", + title = "A {HOL} Basis for Reasoning about Functional + Programs", + institution = "BRICS", + year = "1994", + number = "RS-94-44", + URL = "http://www.brics.dk/RS/94/44/BRICS-RS-94-44.ps.gz", +} + +@PhdThesis{ahmed-04, + author = "Amal Jamil Ahmed", + title = "Semantics of Types for Mutable State", + school = "Princeton University", + year = "2004", + URL = "http://www.cs.indiana.edu/~amal/ahmedsthesis.pdf", +} + +@InProceedings{ahmed-appel-virga-02, + author = "Amal J. Ahmed and Andrew W. Appel and Roberto Virga", + title = "A Stratified Semantics of General References + Embeddable in Higher-Order Logic", + booktitle = lics, + pages = "75--86", + year = "2002", + URL = "http://www.cs.princeton.edu/sip/pub/stratified-lics02.pdf", +} + +@InProceedings{ahmed-blume-08, + author = "Amal Ahmed and Matthias Blume", + title = "Typed closure conversion preserves observational + equivalence", + booktitle = icfp, + year = "2008", + pages = "157--168", + URL = "http://ttic.uchicago.edu/~amal/papers/tccpoe.pdf", +} + +@InProceedings{ahmed-dreyer-rossberg-09, + author = "Amal Ahmed and Derek Dreyer and Andreas Rossberg", + title = "State-dependent representation independence", + booktitle = popl, + year = "2009", + pages = "340--353", + URL = "http://ttic.uchicago.edu/~amal/papers/sdri.pdf", +} + +@InProceedings{ahmed-fluet-morrisett-05, + author = "Amal J. Ahmed and Matthew Fluet and Greg Morrisett", + title = "A step-indexed model of substructural state", + booktitle = icfp, + year = "2005", + pages = "78--91", + URL = "http://www.cs.rit.edu/~mtf/research/substruct-state/ICFP05/icfp05.pdf", +} + +@Article{ahmed-semantic-tal-10, + author = "Amal Ahmed and Andrew W. Appel and Christopher D. + Richards and Kedar N. Swadi and Gang Tan and Daniel C. + Wang", + title = "Semantic foundations for typed assembly languages", + journal = toplas, + volume = "32", + number = "3", + year = "2010", + URL = "http://www.cs.princeton.edu/~appel/papers/sftal.pdf", +} + +@Book{aho-86, + author = "Alfred V. Aho and Ravi Sethi and Jeffrey D. Ullman", + title = "Compilers: Principles, Techniques, and Tools", + publisher = aw, + year = "1986", +} + +@Book{aho-89, + author = "Alfred Aho and Ravi Sethi and Jeffrey Ullman", + title = "Compilateurs: principes, techniques et outils", + publisher = ie, + year = "1989", +} + +@Book{aho-hopcroft-ullman-74, + author = "Alfred V. Aho and John E. Hopcroft and Jeffrey D. + Ullman", + title = "The Design and Analysis of Computer Algorithms", + publisher = aw, + year = "1974", +} + +@Book{aho-hopcroft-ullman-83, + author = "Alfred V. Aho and John E. Hopcroft and Jeffrey D. + Ullman", + title = "Data Structures and Algorithms", + year = "1983", + publisher = aw, +} + +@Article{aho-optim-72, + author = "Alfred V. Aho and Jeffrey D. Ullman", + title = "Optimization of {LR(k)} parsers", + journal = "Journal of Computer and System Sciences", + volume = "6", + number = "6", + pages = "573--602", + year = "1972", + URL = "http://www.sciencedirect.com/science/article/pii/S002200007280031X", +} + +@Book{aho-ullman-72, + author = "Alfred V. Aho and Jeffrey D. Ullman", + title = "The theory of parsing, translation, and compiling", + year = "1972", + publisher = prentice, + URL = "http://portal.acm.org/citation.cfm?id=SERIES11430.578789", +} + +@Article{aho-ullman-73, + author = "Alfred V. Aho and Jeffrey D. Ullman", + title = "A Technique for Speeding up {LR(k)} Parsers", + journal = siamjc, + volume = "2", + number = "2", + pages = "106--127", + year = "1973", + URL = "http://dx.doi.org/10.1137/0202010", +} + +@Article{aiken-bane-98, + author = "Alexander Aiken and Manuel Fähndrich and Jeffrey S. + Foster and Zhendong Su", + title = "A Toolkit for Constructing Type- and Constraint-Based + Program Analyses", + journal = lncs, + volume = "1473", + pages = "76--96", + year = "1998", + URL = "http://theory.stanford.edu/~aiken/publications/papers/tic98.pdf", +} + +@Article{aiken-faehndrich-levien-95, + author = "Alexander Aiken and Manuel F{\"a}hndrich and Raph + Levien", + title = "Better static memory management: improving + region-based analysis of higher-order languages", + journal = notices, + volume = "30", + number = "6", + pages = "174--185", + year = "1995", + URL = "http://www.eecs.berkeley.edu/Pubs/TechRpts/1995/CSD-95-866.pdf", +} + +@InProceedings{aiken-faehndrich-mixed-97, + author = "Alexander S. Aiken and Manuel F{\"a}hndrich", + title = "Program Analysis Using Mixed Term and Set + Constraints", + pages = "114--126", + booktitle = sas, + year = "1997", + URL = "http://theory.stanford.edu/~aiken/publications/papers/sas97.pdf", +} + +@TechReport{aiken-faehndrich-scale-96, + number = "CSD-96-917", + institution = "University of California, Berkeley", + title = "Making Set-Constraint Based Program Analyses Scale", + year = "1996", + author = "Alexander S. Aiken and Manuel F{\"a}hndrich", + URL = "http://research.microsoft.com/pubs/67469/scw96.pdf", +} + +@TechReport{aiken-faehndrich-subtyping-96, + number = "CSD-96-898", + institution = "University of California, Berkeley", + title = "Subtyping Polymorphic Constrained Types", + year = "1996", + author = "Alexander S. Aiken and Manuel F{\"a}hndrich", +} + +@Misc{aiken-illyria, + author = "Alexander S. Aiken", + title = "The {Illyria} system", + year = "1994", + URL = "http://http.cs.berkeley.edu:80/~aiken/Illyria-demo.html", +} + +@Article{aiken-intro-99, + author = "Alexander Aiken", + title = "Introduction to Set Constraint-Based Program + Analysis", + journal = scp, + year = "1999", + volume = "35", + pages = "79--111", + URL = "http://theory.stanford.edu/~aiken/publications/papers/scp99.pdf", +} + +@TechReport{aiken-palsberg-wimmers-optimal-96, + number = "CSD-96-909", + institution = "University of California, Berkeley", + title = "Optimal Representations of Polymorphic Types with + Subtyping", + year = "1996", + pages = "31", + author = "Alexander S. Aiken and Edward L. Wimmers and Jens + Palsberg", + URL = "http://digitalassets.lib.berkeley.edu/techreports/ucb/text/CSD-96-909.pdf", +} + +@InProceedings{aiken-wimmers-92, + author = "Alexander S. Aiken and Edward L. Wimmers", + title = "Solving Systems of Set Constraints", + pages = "329--340", + booktitle = lics, + year = "1992", + URL = "http://theory.stanford.edu/~aiken/publications/papers/lics92.pdf", +} + +@InProceedings{aiken-wimmers-93, + author = "Alexander S. Aiken and Edward L. Wimmers", + booktitle = fpca, + publisher = acmp, + title = "Type Inclusion Constraints and Type Inference", + year = "1993", + pages = "31--41", + URL = "http://theory.stanford.edu/~aiken/publications/papers/fpca93.pdf", +} + +@InProceedings{aiken-wimmers-lakshman-94, + author = "Alexander S. Aiken and Edward L. Wimmers and T. K. + Lakshman", + booktitle = popl, + title = "Soft Typing with Conditional Types", + year = "1994", + pages = "163--173", + URL = "http://theory.stanford.edu/~aiken/publications/papers/popl94.pdf", +} + +@InProceedings{aldrich-borrowing-12, + title = "A type system for borrowing permissions", + author = "Karl Naden and Robert Bocchino and Jonathan Aldrich + and Kevin Bierhoff", + booktitle = popl, + year = "2012", + pages = "557--570", + URL = "http://cs.cmu.edu/afs/cs.cmu.edu/Web/People/kbn/pubs/poplBorrowing.pdf", +} + +@InProceedings{aldrich-objects-13, + author = "Jonathan Aldrich", + title = "The power of interoperability: why objects are + inevitable", + booktitle = onward, + year = "2013", + pages = "101--116", + URL = "http://www.cs.cmu.edu/~aldrich/papers/objects-essay.pdf", +} + +@Unpublished{aldrich-plaid-10, + author = "Jonathan Aldrich", + title = "Resource-Based Programming in {Plaid}", + note = "Fun Ideas and Thoughts", + year = "2010", + URL = "http://www.cs.cmu.edu/~aldrich/papers/pldi-fit10.pdf", +} + +@InProceedings{aldrich-typestate-09, + author = "Jonathan Aldrich and Joshua Sunshine and Darpan Saini + and {Zacha\-ry} Sparks", + title = "Typestate-Oriented Programming", + booktitle = oopslacomp, + pages = "1015--1022", + year = "2009", + URL = "http://www.cs.cmu.edu/~aldrich/papers/onward2009-state.pdf", +} + +@InProceedings{alias-types-00, + author = "Frederick Smith and David Walker and Greg Morrisett", + title = "Alias Types", + booktitle = esop, + pages = "366--381", + year = "2000", + volume = "1782", + series = lncs, + publisher = springer, + URL = "http://www.cs.cornell.edu/talc/papers/alias.pdf", +} + +@InProceedings{almeida-97, + author = "Paulo S{\'e}rgio Almeida", + title = "Balloon Types: Controlling Sharing of State in Data + Types", + booktitle = ecoop, + year = "1997", + pages = "32--59", + publisher = springer, + series = lncs, + volume = "1241", + URL = "http://gsd.di.uminho.pt/publications/gsd-1997-04/file/at_download", +} + +@Article{alstrup-al-14, + author = "Stephen Alstrup and Mikkel Thorup and Inge Li G{\o}rtz + and Theis Rauhe and Uri Zwick", + title = "Union-Find with Constant Time Deletions", + journal = "{ACM} Transactions on Algorithms", + volume = "11", + number = "1", + pages = "6:1--6:28", + year = "2014", + URL = "http://doi.acm.org/10.1145/2636922", +} + +@InProceedings{altenkirch-pisigma-10, + author = "Thorsten Altenkirch and Nils Anders Danielsson and + Andres L{\"o}h and Nicolas Oury", + title = "{$\Pi$}{$\Sigma$}: Dependent Types Without the Sugar", + booktitle = flops, + pages = "40--55", + year = "2010", + publisher = springer, + series = lncs, + volume = "6009", + URL = "http://www.cs.nott.ac.uk/~txa/publ/pisigma-new.pdf", +} + +@InProceedings{altenkirch-reus-99, + author = "Thorsten Altenkirch and Bernhard Reus", + title = "Monadic Presentations of Lambda Terms Using + Generalized Inductive Types", + booktitle = csl, + year = "1999", + pages = "453--468", + publisher = springer, + series = lncs, + volume = "1683", + URL = "http://www.cs.nott.ac.uk/~txa/publ/csl99.pdf", +} + +@Article{amadio-cardelli-93, + author = "Roberto M. Amadio and Luca Cardelli", + title = "Subtyping Recursive Types", + journal = toplas, + volume = "15", + number = "4", + pages = "575--631", + year = "1993", + URL = "http://research.microsoft.com/Users/luca/Papers/SRT.pdf", +} + +@InProceedings{amadio-regis-gianas-11, + author = "Roberto Amadio and Yann R{\'{e}}gis{-}Gianas", + title = "Certifying and Reasoning on Cost Annotations of + Functional Programs", + booktitle = fopara, + pages = "72--89", + year = "2011", + series = lncs, + volume = "7177", + publisher = springer, + URL = "https://hal.inria.fr/inria-00629473v1", +} + +@Article{amadio-regis-gianas-13, + title = "Certifying and reasoning about cost annotations of + functional programs", + author = "Roberto Amadio and Yann R{\'e}gis-Gianas", + URL = "https://hal.inria.fr/inria-00629473", + journal = hosc, + year = "2013", +} + +@InProceedings{america-rutten-88, + author = "Pierre America and Jan Rutten", + title = "Solving reflexive domain equations in a category of + complete metric spaces", + booktitle = mfps, + pages = "254--288", + year = "1988", + volume = "298", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-19020-1_13", +} + +@Article{amighi-15, + author = "Afshin Amighi and Christian Haack and Marieke Huisman + and Clément Hurlin", + title = "Permission-based separation logic for multithreaded + {Java} programs", + journal = lmcs, + year = "2015", + volume = "11", + number = "1", + pages = "1--66", + URL = "http://arxiv.org/abs/1411.0851", +} + +@InProceedings{amin-essence-16, + author = "Nada Amin and Samuel Gr{\"{u}}tter and Martin Odersky + and Tiark Rompf and Sandro Stucki", + title = "The Essence of Dependent Object Types", + booktitle = "A List of Successes That Can Change the World -- + Essays Dedicated to {Philip Wadler} on the Occasion of + His 60th Birthday", + series = lncs, + volume = "9600", + publisher = springer, + pages = "249--272", + year = "2016", + URL = "https://infoscience.epfl.ch/record/215280/files/paper_1.pdf", +} + +@Article{andersen-94, + author = "Henrik Reif Andersen", + title = "Model checking and {Boolean} graphs", + journal = tcs, + volume = "126", + number = "1", + year = "1994", + pages = "3--30", + URL = "http://dx.doi.org/10.1016/0304-3975(94)90266-6", +} + +@Article{anderson-eve-horning-73, + author = "T. Anderson and J. Eve and J. J. Horning", + title = "Efficient ${LR}(1)$ parsers", + journal = acta, + year = "1973", + volume = "2", + pages = "12--39", + URL = "http://dx.doi.org/10.1007/BF00571461", +} + +@Book{andrews-00, + author = "Gregory R. Andrews", + title = "Foundations of Multithreaded, Parallel, and + Distributed Programming", + publisher = aw, + year = "2000", +} + +@Book{andrews-86, + author = "Peter B. Andrews", + title = "An introduction to mathematical logic and type theory: + to truth through proof", + year = "1986", + publisher = ap, +} + +@Article{andrews-reitman-80, + author = "Gregory R. Andrews and Richard P. Reitman", + title = "An Axiomatic Approach to Information Flow in + Programs", + journal = toplas, + volume = "2", + number = "1", + pages = "56--76", + year = "1980", +} + +@Book{antlr, + author = "Terence Parr", + title = "The Definitive {ANTLR 4} Reference, 2nd edition", + year = "2013", + publisher = "Pragmatic Bookshelf", +} + +@InProceedings{antonopoulos-14, + author = "Timos Antonopoulos and Nikos Gorogiannis and Christoph + Haase and Max I. Kanovich and Jo{\"{e}}l Ouaknine", + title = "Foundations for Decision Problems in Separation Logic + with General Inductive Predicates", + booktitle = fossacs, + pages = "411--425", + year = "2014", + series = lncs, + volume = "8412", + publisher = springer, + URL = "http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/AGHKO-fossacs14.pdf", +} + +@InProceedings{aponte-dicosmo-96, + author = "Maria-Virginia Aponte and Roberto {Di Cosmo}", + title = "Type isomorphisms for module signatures", + year = "1996", + booktitle = plilp, + publisher = springer, + series = lncs, + volume = "1140", + pages = "334--346", + URL = "http://dx.doi.org/10.1007/3-540-61756-6_95", +} + +@Book{appel-92, + author = "Andrew W. Appel", + title = "Compiling with Continuations", + publisher = cup, + year = "1992", + URL = "http://www.cambridge.org/9780521033114", +} + +@Article{appel-jim-97, + author = "Andrew W. Appel and Trevor Jim", + title = "Shrinking lambda expressions in linear time", + journal = jfp, + volume = "7", + number = "5", + year = "1997", + pages = "515--540", + URL = "http://www.research.att.com/~trevor/papers/shrinking.ps.gz", +} + +@InProceedings{appel-major-07, + author = "Andrew W. Appel and Paul-Andr\'{e} Melli\`{e}s and + Christopher D. Richards and J\'{e}r\^{o}me Vouillon", + title = "A very modal model of a modern, major, general type + system", + booktitle = popl, + year = "2007", + pages = "109--122", + URL = "http://www.cs.princeton.edu/~appel/papers/modalmodel.pdf", +} + +@Book{appel-tiger-98, + author = "Andrew Appel", + title = "Modern Compiler Implementation in {ML}", + publisher = cup, + year = "1998", + URL = "http://www.cs.princeton.edu/~appel/modern/ml/", +} + +@InProceedings{appel-verismall-11, + author = "Andrew W. Appel", + title = "{VeriSmall}: Verified {Smallfoot} Shape Analysis", + booktitle = cpp, + year = "2011", + pages = "231--246", + publisher = springer, + series = lncs, + volume = "7086", + URL = "http://www.cs.princeton.edu/~appel/papers/verismall.pdf", +} + +@InProceedings{appel-vst-11, + author = "Andrew W. Appel", + title = "Verified Software Toolchain", + booktitle = esop, + pages = "1--17", + year = "2011", + series = lncs, + volume = "6602", + publisher = springer, + URL = "https://www.cs.princeton.edu/~appel/papers/vst.pdf", +} + +@Article{apt-81, + author = "Krzysztof R. Apt", + title = "Ten Years of {Hoare's} Logic: {A} Survey---Part {I}", + journal = toplas, + volume = "3", + number = "4", + year = "1981", + pages = "431--483", + URL = "http://doi.acm.org/10.1145/357146.357150", +} + +@Article{ariola-klop-95, + author = "Zena M. Ariola and Jan Willem Klop", + title = "Equational term graph rewriting", + journal = fundamenta, + volume = "26", + number = "3--4", + year = "1996", + pages = "207--240", + URL = "http://www.cwi.nl/ftp/CWIreports/AP/CS-R9552.ps.Z", +} + +@Article{arnold-crubille-88, + author = "Andr{\'e} Arnold and Paul Crubillé", + title = "A Linear Algorithm to Solve Fixed-Point Equations on + Transition Systems", + journal = ipl, + volume = "29", + number = "2", + year = "1988", + pages = "57--66", + URL = "http://dx.doi.org/10.1016/0020-0190(88)90029-4", +} + +@Article{arnold-nivat-80, + author = "André Arnold and Maurice Nivat", + year = "1980", + journal = fundamenta, + volume = "3", + number = "4", + pages = "181--205", + title = "{T}he Metric Space of Infinite Trees. {A}lgebraic And + Topological Properties", +} + +@InProceedings{asai-kameyama-07, + author = "Kenichi Asai and Yukiyoshi Kameyama", + title = "Polymorphic Delimited Continuations", + booktitle = aplas, + pages = "239--254", + year = "2007", + series = lncs, + volume = "4807", + publisher = springer, + URL = "http://logic.cs.tsukuba.ac.jp/~kam/paper/aplas07.pdf", +} + +@Misc{astree, + author = "Patrick Cousot and Radhia Cousot and Jérôme Feret and + Antoine Miné and Xavier Rival", + title = "The {Astrée} Static Analyzer", + year = "2011", + note = "\url{http://www.astree.ens.fr/}", + URL = "http://www.astree.ens.fr/", +} + +@Article{atkey-09, + author = "Robert Atkey", + title = "Parameterised Notions of Computation", + journal = jfp, + year = "2009", + volume = "19", + number = "3--4", + pages = "355--376", + URL = "http://homepages.inf.ed.ac.uk/ratkey/paramnotions-jfp.pdf", +} + +@Article{atkey-11, + title = "Amortised Resource Analysis with Separation Logic", + author = "Robert Atkey", + year = "2011", + journal = lmcs, + volume = "7", + number = "2:17", + URL = "http://bentnib.org/amortised-sep-logic-journal.pdf", +} + +@InProceedings{atkey-amortised-10, + author = "Robert Atkey", + title = "Amortised Resource Analysis with Separation Logic", + booktitle = esop, + pages = "85--103", + year = "2010", + volume = "6012", + series = lncs, + publisher = springer, + URL = "http://personal.cis.strath.ac.uk/~raa/amortised-sep-logic.pdf", +} + +@InProceedings{atkey-hoas-09, + author = "Robert Atkey", + title = "Syntax for free: representing syntax with binding + using parametricity", + booktitle = tlca, + pages = "35--49", + year = "2009", + volume = "5608", + series = lncs, + publisher = springer, + URL = "https://personal.cis.strath.ac.uk/~raa/syntaxforfree.pdf", +} + +@InProceedings{atkey-lindley-yallop-09, + author = "Robert Atkey and Sam Lindley and Jeremy Yallop", + title = "Unembedding Domain-Specific languages", + booktitle = hs, + pages = "37--48", + year = "2009", + URL = "http://personal.cis.strath.ac.uk/~raa/unembedding.pdf", +} + +@InProceedings{augustsson-93, + author = "Lennart Augustsson", + title = "Implementing {Haskell} Overloading", + booktitle = fpca, + pages = "65--73", + year = "1993", + URL = "http://dl.acm.org/citation.cfm?id=165191", +} + +@Book{autebert-94, + author = "Jean-Michel Autebert", + title = "Théorie des langages et des automates", + publisher = "Masson", + year = "1994", +} + +@InCollection{autebert-97, + author = "Jean-Michel Autebert and Jean Berstel and Luc + Boasson", + booktitle = "Handbook of Formal Languages", + title = "Context-Free Languages and Push-Down Automata", + publisher = springer, + year = "1997", + volume = "1", + pages = "111--174", + URL = "http://www-igm.univ-mlv.fr/~berstel/Articles/CFLPDA.ps.gz", +} + +@InProceedings{ayache-amadio-regis-gianas-12, + author = "Nicholas Ayache and Roberto M. Amadio and Yann + R{\'{e}}gis{-}Gianas", + title = "Certifying and Reasoning on Cost Annotations in {C} + Programs", + booktitle = "Formal Methods for Industrial Critical Systems", + pages = "32--46", + year = "2012", + series = lncs, + volume = "7437", + publisher = springer, + URL = "https://hal.inria.fr/hal-00702665", +} + +@InProceedings{aycock-horspool-00, + author = "John Aycock and Nigel Horspool", + title = "Simple Generation of Static Single-Assignment Form", + booktitle = cc, + year = "2000", + volume = "1781", + series = lncs, + publisher = springer, + URL = "http://pages.cpsc.ucalgary.ca/~aycock/papers/ssa.ps", +} + +@InProceedings{aydemir-08, + author = "Brian Aydemir and Arthur Chargu{\'e}raud and {Benjamin + C.} Pierce and Randy Pollack and Stephanie Weirich", + booktitle = popl, + title = "Engineering Formal Metatheory", + year = "2008", + pages = "3--15", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/binders.pdf", +} + +@Article{baker-77, + author = "Henry G. {Baker,Jr.}", + title = "List Processing in Real Time on a Serial Computer", + journal = cacm, + volume = "21", + number = "4", + year = "1978", + pages = "280--294", + URL = "http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.468.2631&rep=rep1&type=pdf", +} + +@InProceedings{baker-conquer-90, + author = "Henry G. Baker", + title = "Unify and conquer (Garbage, Updating, Aliasing, + \ldots) in Functional Languages", + booktitle = lfp, + year = "1990", + pages = "218--226", + URL = "http://home.pipeline.com/~hbaker1/Share-Unify.ps.gz", +} + +@InProceedings{balabonski-pottier-protzenko-mezzo-14, + author = "Thibaut Balabonski and François Pottier and Jonathan + Protzenko", + title = "Type Soundness and Race Freedom for {Mezzo}", + booktitle = "Proceedings of the 12th International Symposium on + Functional and Logic Programming (FLOPS 2014)", + year = "2014", + series = lncs, + publisher = springer, + volume = "8475", + pages = "253--269", + URL = "http://gallium.inria.fr/~fpottier/publis/bpp-mezzo.pdf", +} + +@Article{balabonski-pottier-protzenko-mezzo-journal-16, + author = "Thibaut Balabonski and François Pottier and Jonathan + Protzenko", + title = "The Design and Formalization of {Mezzo}, a + Permission-Based Programming Language", + journal = toplas, + volume = "38", + number = "4", + pages = "14:1--14:94", + year = "2016", + URL = "http://gallium.inria.fr/~fpottier/publis/bpp-mezzo-journal.pdf", +} + +@InProceedings{balat-dicosmo-fiore-02, + author = "Vincent Balat and Roberto {Di Cosmo} and Marcelo + Fiore", + title = "Remarks on Isomorphisms in Typed Lambda Calculi with + Empty and Sum Type", + booktitle = lics, + year = "2002", + URL = "http://www.cl.cam.ac.uk/~mpf23/papers/Types/remarks.ps.gz", +} + +@InProceedings{banatre-bryce-lemetayer-94, + author = "Jean-Pierre Banâtre and Ciarán Bryce and Daniel {Le + Métayer}", + title = "Compile-time detection of information flow in + sequential programs", + booktitle = esorics, + year = "1994", + publisher = springer, + pages = "55--74", + series = lncs, + volume = "875", + URL = "ftp://ftp.irisa.fr/local/lande/dlm-esorics94.ps.Z", +} + +@InProceedings{banerjee-heintze-riecke-01, + author = "Anindya Banerjee and Nevin Heintze and Jon G. Riecke", + title = "Design and Correctness of Program Transformations + based on Control-flow Analysis", + booktitle = tacs, + pages = "420--447", + year = "2001", + volume = "2215", + series = lncs, + publisher = springer, + URL = "http://www.cis.ksu.edu/~ab/Publications/pcfa.ps.gz", +} + +@InProceedings{banerjee-heintze-riecke-99, + author = "Anindya Banerjee and Nevin Heintze and Jon G. Riecke", + title = "Region Analysis and the Polymorphic Lambda Calculus", + booktitle = lics, + year = "1999", + pages = "88--97", + URL = "http://www.cs.ucla.edu/~palsberg/tba/papers/banerjee-heintze-riecke-lics99.pdf", +} + +@TechReport{banerjee-naumann-01, + author = "Anindya Banerjee and David A. Naumann", + title = "A Simple Semantics and Static Analysis for {Java} + Security", + institution = "Stevens Institute of Technology", + number = "2001-1", + year = "2001", + URL = "http://guinness.cs.stevens-tech.edu/~naumann/publications/tr2001.ps", +} + +@InProceedings{banerjee-naumann-05, + author = "Anindya Banerjee and David A. Naumann", + title = "State based ownership, reentrance, and encapsulation", + booktitle = ecoop, + pages = "387--411", + year = "2005", + volume = "3586", + series = lncs, + publisher = springer, + URL = "https://guinness.cs.stevens-tech.edu/~naumann/publications/ecoop.pdf", +} + +@InProceedings{banerjee-naumann-csfw-02, + author = "Anindya Banerjee and David Naumann", + title = "Secure Information Flow and Pointer Confinement in a + {Java}-like Language", + booktitle = csfw, + pages = "253--267", + year = "2002", + URL = "http://www.cs.stevens-tech.edu/~naumann/publications/csfw15.ps", +} + +@InProceedings{banerjee-naumann-popl-02, + author = "Anindya Banerjee and David A. Naumann", + title = "Representation Independence, Confinement, and Access + Control", + booktitle = popl, + year = "2002", + pages = "166--177", + URL = "http://guinness.cs.stevens-tech.edu/~naumann/publications/BanerjeeNaumann.ps", +} + +@TechReport{barber-dill-96, + author = "Andrew Barber", + title = "Dual Intuitionistic Linear Logic", + institution = "Laboratory for Foundations of Computer Science, School + of Informatics at the University of Edinburgh", + year = "1996", + number = "ECS-LFCS-96-347", + URL = "http://www.lfcs.inf.ed.ac.uk/reports/96/ECS-LFCS-96-347/", +} + +@Book{barendregt, + author = "Henk P. Barendregt", + title = "The Lambda Calculus, Its Syntax and Semantics", + publisher = elsevier, + year = "1984", + URL = "http://www.elsevier.com/wps/find/bookdescription.cws_home/501727/description", +} + +@InCollection{barendregt-90, + author = "Henk P. Barendregt", + title = "Functional Programming and Lambda Calculus", + booktitle = "Handbook of Theoretical Computer Science", + pages = "321--363", + publisher = elsevier, + year = "1990", + editor = "J. Van Leeuwen", +} + +@InProceedings{barendsen-smesters-95, + author = "Erik Barendsen and Sjaak Smetsers", + title = "Uniqueness Type Inference", + booktitle = plilp, + year = "1995", + pages = "189--206", + publisher = springer, + series = lncs, + volume = "982", + URL = "http://dx.doi.org/10.1007/BFb0026821", +} + +@InProceedings{barnett-pure-04, + author = "Mike Barnett and David A. Naumann and Wolfram Schulte + and Qi Sun", + title = "99.44\% pure: Useful Abstractions in Specifications", + booktitle = ftfjp, + year = "2004", + URL = "http://www.cs.ru.nl/ftfjp/2004/Purity.pdf", +} + +@InProceedings{barnett-spec-04, + author = "Mike Barnett and K. Rustan M. Leino and Wolfram + Schulte", + title = "The {Spec\#} programming system: An overview", + booktitle = cassis, + year = "2004", + volume = "3362", + pages = "49--69", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/~leino/papers/krml136.pdf", +} + +@Article{barrett-00, + author = "Chris Barrett and Riko Jacob and Madhav Marathe", + title = "Formal Language Constrained Path Problems", + journal = siamjc, + year = "2000", + volume = "30", + number = "3", + pages = "809--837", + URL = "http://www.brics.dk/~rjacob/Publications/regpath.ps.gz", + alturl = "http://epubs.siam.org/sam-bin/getfile/SICOMP/articles/33771.pdf", +} + +@TechReport{bartels-96, + author = "Frank Bartels and Friedrich von Henke and Holger + Pfeifer and Harald Rue{\ss}", + title = "Mechanizing Domain Theory", + institution = "Universit{\"a}t Ulm, Fakult{\"a}t f{\"u}r Informatik", + year = "1996", + number = "96-10", + type = "Ulmer Informatik-Berichte", + URL = "http://www.csl.sri.com/users/ruess/papers/Fixpoints/fixpoints-domains3.ps.gz", +} + +@InProceedings{barthwal-norrish-09, + author = "Aditi Barthwal and Michael Norrish", + title = "Verified, Executable Parsing", + booktitle = esop, + year = "2009", + pages = "160--174", + series = lncs, + publisher = springer, + volume = "5502", + URL = "http://users.cecs.anu.edu.au/~aditi/esop09_submission_16.pdf", +} + +@InProceedings{bartoletti-al-01, + author = "Massimo Bartoletti and Pierpaolo Degano and GianLuigi + Ferrari", + title = "Static Analysis for Stack Inspection", + booktitle = "International Workshop on Concurrency and + Coordination", + series = entcs, + volume = "54", + publisher = elsevier, + year = "2001", +} + +@Article{bauer-pretnar-13, + author = "Andrej Bauer and Matija Pretnar", + title = "An Effect System for Algebraic Effects and Handlers", + journal = lmcs, + volume = "10", + number = "4", + year = "2014", + URL = "https://arxiv.org/pdf/1306.6316.pdf", +} + +@Article{beaven-stansifer-93, + author = "Mike Beaven and Ryan Stansifer", + title = "Explaining type errors in polymorphic languages", + journal = "ACM Letters on Programming Languages and Systems", + volume = "2", + number = "4", + pages = "17--30", + year = "1993", + URL = "http://www.cs.fit.edu/~ryan/papers/explain.ps.gz", +} + +@InProceedings{bell-08, + author = "C. J. Bell and Robert Dockins and Aquinas Hobor and + Andrew W. Appel and David Walker", + title = "Comparing Semantic and Syntactic Methods in Mechanized + Proof Frameworks", + booktitle = pcc, + year = "2008", + URL = "http://www.cs.princeton.edu/~rdockins/pubs/semsyn.pdf", +} + +@InProceedings{bell-bellegarde-hook-97, + author = "Jeffrey M. Bell and Françoise Bellegarde and James + Hook", + title = "Type-driven Defunctionalization", + booktitle = icfp, + year = "1997", + URL = "http://doi.acm.org/10.1145/258949.258953", +} + +@TechReport{bell-lapadula-75, + author = "D. E. Bell and Leonard J. LaPadula", + title = "Secure Computer Systems: Unified Exposition and + {Multics} Interpretation", + year = "1975", + number = "MTR-2997", + institution = "The {MITRE} Corp.", + URL = "http://niatec.info/pdf/bell76.pdf", +} + +@InProceedings{bengtson-12, + author = "Jesper Bengtson and Jonas Braband Jensen and Lars + Birkedal", + title = "Charge! {A} Framework for Higher-Order Separation + Logic in {Coq}", + booktitle = itp, + pages = "315--331", + year = "2012", + URL = "http://cs.au.dk/~birke/papers/charge-conf.pdf", +} + +@InProceedings{berdine-calcagno-ohearn-05, + author = "Josh Berdine and Cristiano Calcagno and Peter W. + O'Hearn", + title = "Symbolic Execution with Separation Logic", + booktitle = aplas, + year = "2005", + publisher = springer, + series = lncs, + volume = "3780", + pages = "52--68", + URL = "http://www.dcs.qmul.ac.uk/~berdine/papers/execution.pdf", +} + +@InProceedings{berdine-decidable-fragment-04, + author = "Josh Berdine and Cristiano Calcagno and Peter W. + O'Hearn", + title = "A Decidable Fragment of Separation Logic", + booktitle = fsttcs, + year = "2004", + pages = "97--109", + publisher = springer, + series = lncs, + volume = "3328", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/unroll_collapse.pdf", +} + +@Article{berdine-linear-continuations-02, + author = "Josh Berdine and Peter W. O'Hearn and Uday S. Reddy + and Hayo Thielecke", + title = "Linear Continuation-Passing", + journal = hosc, + year = "2002", + volume = "15", + number = "2--3", + pages = "181--208", + URL = "http://www.cs.bham.ac.uk/~hxt/research/LinCP.pdf", +} + +@InProceedings{berdine-ohearn-06, + author = "Josh Berdine and Peter W. O'Hearn", + title = "Strong Update, Disposal, and Encapsulation in Bunched + Typing", + booktitle = mfps, + series = entcs, + publisher = elsevier, + volume = "158", + year = "2006", + pages = "81--98", + URL = "http://research.microsoft.com/pubs/73584/bil.pdf", +} + +@InProceedings{berger-honda-yoshida-05, + author = "Martin Berger and Kohei Honda and Nobuko Yoshida", + title = "A logical analysis of aliasing in imperative + higher-order functions", + booktitle = icfp, + year = "2005", + pages = "280--293", + URL = "http://doi.acm.org/10.1145/1086365.1086401", +} + +@InProceedings{bergeron-al-00, + author = "M. Debbabi and E. Giasson and B. Ktari and F. Michaud + and N. Tawbi", + title = "Secure Self-Certified {COTS}", + booktitle = "IEEE International Workshop on Enterprise Security + (WETICE'00)", + year = "2000", + URL = "http://www.ift.ulaval.ca/~lsfm/lsfm_eng/Publications/wetice2000_2.pdf", +} + +@Unpublished{bernstein-stark-95, + author = "K. Bernstein and E. W. Stark", + title = "Debugging Type Errors", + year = "1995", + URL = "http://bsd7.starkhome.cs.sunysb.edu/~stark/REPORTS/debugtype.ps.gz", + note = "Unpublished", +} + +@InProceedings{berthomieu-sagazan-95, + author = "Bernard Berthomieu and Camille {le Moniès de + Sagazan}", + title = "A Calculus of Tagged Types, with applications to + process languages", + booktitle = "Workshop on Types for Program Analysis", + pages = "1--15", + year = "1995", + URL = "http://www.laas.fr/~bernard/lcs/papers/tpa95.ps.gz", +} + +@Article{besson-al-01, + author = "Frédéric Besson and Thomas P. Jensen and Daniel {Le + Métayer} and Tommy Thorn", + title = "Model Checking Security Properties of Control Flow + Graphs", + journal = "Journal of Computer Security", + volume = "9", + number = "3", + year = "2001", + pages = "217--250", + URL = "http://www.irisa.fr/lande/jensen/jcs.pdf", +} + +@InProceedings{besson-al-02, + author = "Frédéric Besson and Thomas {de Grenier de Latour} and + Thomas Jensen", + title = "Secure Calling Contexts for Stack Inspection", + pages = "76--87", + booktitle = ppdp, + year = "2002", + URL = "http://www.irisa.fr/lande/jensen/ppdp02.pdf", +} + +@Article{bhamidipaty-proebsting-98, + author = "Achyutram Bhamidipaty and Todd A. Proebsting", + title = "Very Fast {YACC}-Compatible Parsers (For Very Little + Effort)", + journal = spe, + year = "1998", + volume = "28", + number = "2", + pages = "181--190", + URL = "http://www.cs.arizona.edu/people/todd/papers/TR95-09.ps", +} + +@InProceedings{bhargavan-fournet-gordon-10, + author = "Karthik Bhargavan and Cédric Fournet and Andy Gordon", + title = "Modular Verification of Security Protocol Code by + Typing", + booktitle = popl, + pages = "445--456", + year = "2010", + URL = "http://moscova.inria.fr/~karthik/pubs/modular-verification-of-security-protocols-by-typing-popl10.pdf", +} + +@InProceedings{bhat-cleaveland-96, + author = "Girish Bhat and Rance Cleaveland", + title = "Efficient Local Model-Checking for Fragments of the + Modal $\mu$-Calculus", + booktitle = tacas, + pages = "107--126", + year = "1996", + volume = "1055", + series = lncs, + publisher = springer, + URL = "http://www.cs.umd.edu/~rance/publications/papers/tacas96a.ps.gz", +} + +@InProceedings{biere-bmc-99, + author = "Armin Biere and Alessandro Cimatti and Edmund Clarke + and Yunshan Zhu", + title = "Symbolic Model Checking Without {BDDs}", + booktitle = tacas, + pages = "193--207", + year = "1999", + volume = "1579", + series = lncs, + publisher = springer, + URL = "http://www.inf.ethz.ch/personal/biere/papers/BiereCimattiClarkeZhu-TACAS99.pdf", +} + +@InProceedings{bierhoff-aldrich-07, + author = "Kevin Bierhoff and Jonathan Aldrich", + title = "Modular typestate checking of aliased objects", + booktitle = oopsla, + year = "2007", + pages = "301--320", + URL = "http://www.cs.cmu.edu/~kbierhof/papers/typestate-verification.pdf", +} + +@InProceedings{bierhoff-beckman-aldrich-09, + author = "Kevin Bierhoff and Nels E. Beckman and Jonathan + Aldrich", + title = "Practical {API} Protocol Checking with Access + Permissions", + booktitle = ecoop, + year = "2009", + pages = "195--219", + publisher = springer, + series = lncs, + volume = "5653", + URL = "http://www.cs.cmu.edu/~kbierhof/papers/permission-practice.pdf", +} + +@InProceedings{biering-05, + author = "Bodil Biering and Lars Birkedal and Noah Torp-Smith", + title = "{BI} Hyperdoctrines and Higher-Order Separation + Logic", + booktitle = esop, + year = "2005", + pages = "233--247", + publisher = springer, + series = lncs, + volume = "3444", + URL = "http://www.itu.dk/people/noah/papers/hyperdocs.pdf", +} + +@Article{bird-hughes-87, + author = "Richard S. Bird and John Hughes", + title = "The alpha-beta Algorithm: An Exercise in Program + Transformation", + journal = ipl, + volume = "24", + number = "1", + year = "1987", + pages = "53--57", + URL = "http://dx.doi.org/10.1016/0020-0190(87)90198-0", +} + +@InProceedings{bird-meertens-98, + author = "Richard Bird and Lambert Meertens", + title = "Nested Datatypes", + booktitle = mpc, + pages = "52--67", + year = "1998", + volume = "1422", + series = lncs, + publisher = springer, + URL = "ftp://ftp.kestrel.edu/pub/papers/meertens/nest5.ps", +} + +@Article{bird-paterson-99, + title = "{de Bruijn} Notation as a Nested Datatype", + author = "Richard Bird and Ross Paterson", + URL = "http://dx.doi.org/10.1017/S0956796899003366", + journal = jfp, + volume = "9", + number = "1", + pages = "77--91", + year = "1999", +} + +@TechReport{birkedal-alii-93, + author = "Lars Birkedal and Nick Rothwell and Mads Tofte and + David N. Turner", + semno = "D-181", + title = "The {ML} Kit (Version 1)", + institution = "Department of Computer Science, University of + Copenhagen", + year = "1993", + number = "DIKU 93/14", + URL = "http://www.it-c.dk/research/mlkit/", +} + +@Article{birkedal-hoframe-06, + author = "Lars Birkedal and Noah Torp-Smith and Hongseok Yang", + title = "Semantics of separation-logic typing and higher-order + frame rules for {Algol}-like languages", + journal = lmcs, + year = "2006", + volume = "2", + number = "5", + URL = "http://arxiv.org/pdf/cs.LO/0610081", +} + +@Unpublished{birkedal-nakano-10, + author = "Lars Birkedal and Jan Schwinghammer and Kristian + Støvring", + title = "A Metric Model of Lambda Calculus with Guarded + Recursion", + note = "Presented at FICS 2010", + year = "2010", + URL = "http://www.itu.dk/~birkedal/papers/nakano-conf.pdf", +} + +@InProceedings{birkedal-popl-11, + author = "Lars Birkedal and Bernhard Reus and Jan Schwinghammer + and Kristian Støvring and Jacob Thamsborg and Hongseok + Yang", + title = "Step-indexed {Kripke} models over recursive worlds", + booktitle = popl, + pages = "119--132", + year = "2011", + URL = "http://www.eecs.qmul.ac.uk/~hyang/paper/popl11-long.pdf", +} + +@InProceedings{birkedal-stovring-thamsborg-09, + author = "Lars Birkedal and Kristian St{\o}vring and Jacob + Thamsborg", + title = "Realizability Semantics of Parametric Polymorphism, + General References, and Recursive Types", + booktitle = fossacs, + pages = "456--470", + year = "2009", + volume = "5504", + series = lncs, + publisher = springer, + URL = "http://www.itu.dk/~birkedal/papers/parametricity-state-metric-conf.pdf", +} + +@Article{birkedal-stovring-thamsborg-10, + author = "Lars Birkedal and Kristian St{\o}vring and Jacob + Thamsborg", + title = "Realisability Semantics of Parametric Polymorphism, + General References, and Recursive Types", + journal = mscs, + year = "2010", + volume = "20", + number = "4", + pages = "655--703", + URL = "http://www.itu.dk/~birkedal/papers/parametricity-state-metric-journal.pdf", +} + +@TechReport{birkedal-stovring-thamsborg-solution-09, + author = "Lars Birkedal and Kristian St{\o}vring and Jacob + Thamsborg", + title = "The category-theoretic solution of recursive + metric-space quations", + institution = "IT University of Copenhagen", + year = "2009", + number = "ITU-2009-119", + URL = "http://www.itu.dk/~birkedal/papers/ITU-TR-2009-119.pdf", +} + +@Article{birkedal-tofte-01, + author = "Lars Birkedal and Mads Tofte", + title = "A constraint-based region inference algorithm", + journal = tcs, + year = "2001", + volume = "258", + pages = "299--392", + URL = "http://www.itu.dk/people/birkedal/papers/conria.ps.gz", +} + +@Unpublished{birrell-03, + author = "Andrew D. Birrell", + title = "An Introduction to Programming with {C\#} Threads", + note = "Manuscript", + year = "2003", + URL = "http://birrell.org/andrew/papers/ThreadsCSharp.pdf", +} + +@Manual{bison, + title = "Bison", + author = "Charles Donnelly and Richard Stallman", + year = "2015", + URL = "http://www.gnu.org/software/bison/manual/", +} + +@PhdThesis{biswas-97, + school = "University of Pennsylvania", + title = "Dynamic Slicing in Higher-Order Programming + Languages", + year = "1997", + pages = "151", + author = "Sandip K. Biswas", +} + +@InProceedings{blelloch-greiner-95, + author = "Guy E. Blelloch and John Greiner", + title = "Parallelism in Sequential Functional Languages", + booktitle = fpca, + pages = "226--237", + year = "1995", + URL = "http://www.cs.cmu.edu/afs/cs.cmu.edu/project/scandal/public/papers/fpca-pal.ps.gz", +} + +@Article{bobot-why3-15, + author = "Fran{\c{c}}ois Bobot and Jean-Christophe + Filli{\^{a}}tre and Claude March{\'{e}} and Andrei + Paskevich", + title = "Let's verify this with {Why3}", + journal = sttt, + volume = "17", + number = "6", + pages = "709--727", + year = "2015", + URL = "https://hal.inria.fr/hal-00967132/", +} + +@InProceedings{bocchino-09, + author = "Robert L. {Bocchino Jr.} and Vikram S. Adve and Sarita + V. Adve and Marc Snir", + title = "Parallel Programming Must Be Deterministic by + Default", + booktitle = hotpar, + year = "2009", + pages = "1--6", + URL = "http://dpj.cs.illinois.edu/DPJ/Publications_files/DPJ-HotPar-2009.pdf", +} + +@InCollection{bocchino-13, + author = "Robert L. {Bocchino Jr.}", + title = "Alias Control for Deterministic Parallelism", + editor = "Dave Clarke and James Noble and Tobias Wrigstad", + booktitle = "Aliasing in Object-Oriented Programming. Types, + Analysis and Verification", + pages = "156--195", + year = "2013", + URL = "http://dx.doi.org/10.1007/978-3-642-36946-9_7", + series = lncs, + volume = "7850", + publisher = springer, +} + +@InProceedings{bocchino-adve-11, + author = "Robert L. {Bocchino Jr.} and Vikram S. Adve", + title = "Types, Regions, and Effects for Safe Programming with + Object-Oriented Parallel Frameworks", + booktitle = ecoop, + pages = "306--332", + year = "2011", + series = lncs, + volume = "6813", + publisher = springer, + URL = "http://rob-bocchino.net/Professional/Publications_files/DPJ-ECOOP-2011-Frameworks.pdf", +} + +@InProceedings{bocchino-dpj-09, + author = "Robert L. {Bocchino Jr.} and Vikram S. Adve and Danny + Dig and Sarita V. Adve and Stephen Heumann and Rakesh + Komuravelli and Jeffrey Overbey and Patrick Simmons and + Hyojin Sung and Mohsen Vakilian", + title = "A type and effect system for deterministic parallel + {Java}", + booktitle = oopsla, + pages = "97--116", + year = "2009", + URL = "http://rob-bocchino.net/Professional/Publications_files/Bocchino-OOPSLA-2009.pdf", +} + +@InProceedings{bocchino-safe-11, + author = "Robert L. {Bocchino Jr.} and Stephen Heumann and Nima + Honarmand and Sarita V. Adve and Vikram S. Adve and + Adam Welc and Tatiana Shpeisman", + title = "Safe nondeterminism in a deterministic-by-default + parallel language", + booktitle = popl, + pages = "535--548", + year = "2011", + URL = "http://rob-bocchino.net/Professional/Publications_files/Bocchino-POPL-2011.pdf", +} + +@InProceedings{bodei-al-99, + author = "Chiara Bodei and Pierpaolo Degano and Flemming Nielson + and Hanne Riis Nielson", + title = "Static Analysis of Processes for No Read-Up and No + Write-Down", + booktitle = fossacs, + year = "1999", + volume = "1578", + series = lncs, + publisher = springer, + pages = "120--134", + URL = "http://www.di.unipi.it/~chiara/publ-40/BDNN99.ps", +} + +@Article{boehm-adve-12, + author = "Hans-J. Boehm and Sarita V. Adve", + title = "You don't know jack about shared variables or memory + models", + journal = cacm, + volume = "55", + number = "2", + year = "2012", + pages = "48--54", + URL = "http://doi.acm.org/10.1145/2076450.2076465", +} + +@InProceedings{bonniot-02, + author = "Daniel Bonniot", + title = "Type-checking multi-methods in {ML} (a modular + approach)", + booktitle = fool, + year = "2002", + URL = "http://gallium.inria.fr/~bonniot/bonniot02.ps", +} + +@PhdThesis{boquist-99, + author = "Urban Boquist", + title = "Code Optimisation Techniques for Lazy Functional + Languages", + school = "Chalmers University of Technology", + year = "1999", + URL = "http://www.cs.uu.nl/docs/vakken/macc/boquist.pdf", +} + +@Article{boreale-sangiorgi-98, + author = "Michele Boreale and Davide Sangiorgi", + title = "A fully abstract semantics for causality in the + $\pi$-calculus", + journal = acta, + volume = "35", + number = "5", + pages = "353--400", + year = "1998", + URL = "http://link.springer.de/link/service/journals/00236/papers/8035005/80350353.pdf", +} + +@InProceedings{borgstrom-chen-swamy-11, + author = "Johannes Borgström and Juan Chen and and Nikhil + Swamy", + title = "Verified Stateful Programs with Substructural State + and {Hoare} Types", + booktitle = plpv, + year = "2011", + URL = "http://research.microsoft.com/pubs/135430/plpv11k-borgstrom.pdf", +} + +@InProceedings{bornat-00, + author = "Richard Bornat", + title = "Proving Pointer Programs in {Hoare} Logic", + booktitle = mpc, + year = "2000", + pages = "102--126", + publisher = springer, + series = lncs, + volume = "1837", + URL = "http://www.cs.mdx.ac.uk/staffpages/r_bornat/papers/MPC2000.pdf", +} + +@InProceedings{bornat-permission-accounting-05, + author = "Richard Bornat and Cristiano Calcagno and Peter + O'Hearn and Matthew Parkinson", + title = "Permission accounting in separation logic", + booktitle = popl, + year = "2005", + pages = "259--270", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/permissions_paper.pdf", +} + +@InProceedings{bouajjani-esparza-maler-97, + author = "Ahmed Bouajjani and Javier Esparza and Oded Maler", + title = "Reachability Analysis of Pushdown Automata: + Application to Model-Checking", + booktitle = concur, + pages = "135--150", + year = "1997", + URL = "http://www-verimag.imag.fr/~maler/Papers/pda.pdf", + series = lncs, + volume = "1243", + publisher = springer, +} + +@Unpublished{boudol-castellani-01, + author = "Gérard Boudol and Ilaria Castellani", + title = "Non-interference for concurrent programs and thread + systems", + year = "2001", + note = "To appear", + URL = "ftp://ftp-sop.inria.fr/mimosa/personnel/gbo/non-interf-threads.ps.gz", +} + +@Article{boudol-stratified-regions, + author = "Gérard Boudol", + title = "Typing termination in a higher-order concurrent + imperative language", + journal = ic, + year = "2009", + note = "To appear", + URL = "ftp://ftp-sop.inria.fr/mimosa/personnel/gbo/ttiahocil.pdf", +} + +@InProceedings{boulme-07, + author = "Sylvain Boulmé", + title = "Intuitionistic Refinement Calculus", + booktitle = tlca, + year = "2007", + pages = "54--69", + volume = "4583", + series = lncs, + publisher = springer, + URL = "http://www-lsr.imag.fr/users/Sylvain.Boulme/horefinement/dsm.pdf", +} + +@Misc{bound, + author = "Edward Kmett", + title = "Bound", + howpublished = "Blog post", + year = "2014", + URL = "https://www.fpcomplete.com/user/edwardk/bound", +} + +@TechReport{bourdoncle-merz-96, + author = "François Bourdoncle and Stephan Merz", + title = "On the integration of functional programming, + class-based object-oriented programming, and + multi-methods", + institution = "Centre de Mathématiques Appliquées, Ecole des Mines de + Paris", + year = "1996", + type = "Research Report", + number = "26", + URL = "http://www.loria.fr/~merz/papers/mlsub.html", +} + +@InProceedings{bourdoncle-merz-97, + author = "François Bourdoncle and Stephan Merz", + title = "Type Checking Higher-Order Polymorphic Multi-Methods", + booktitle = popl, + year = "1997", + pages = "302--315", + URL = "http://www.exalead.com/Francois.Bourdoncle/popl97.html", +} + +@InProceedings{boyapati-lee-rinard-02, + author = "Chandrasekhar Boyapati and Robert Lee and Martin + Rinard", + title = "Ownership types for safe programming: preventing data + races and deadlocks", + booktitle = oopsla, + year = "2002", + pages = "211--230", + URL = "http://doi.acm.org/10.1145/582419.582440", +} + +@InProceedings{boyapati-liskov-shrira-03, + author = "Chandrasekhar Boyapati and Barbara Liskov and Liuba + Shrira", + title = "Ownership types for object encapsulation", + booktitle = popl, + year = "2003", + pages = "213--223", + URL = "http://www.pmg.lcs.mit.edu/~chandra/publications/popl03.pdf", +} + +@Article{boyland-burying-01, + author = "John Boyland", + title = "Alias burying: Unique variables without destructive + reads", + journal = scp, + year = "2001", + volume = "31", + number = "6", + pages = "533--553", + URL = "http://www.cs.uwm.edu/faculty/boyland/papers/unique-preprint.ps", +} + +@InProceedings{boyland-fractions-03, + author = "John Boyland", + title = "Checking Interference with Fractional Permissions", + booktitle = sas, + year = "2003", + series = lncs, + publisher = springer, + volume = "2694", + pages = "55--72", + URL = "http://www.cs.uwm.edu/~boyland/papers/permissions.pdf", +} + +@Article{boyland-nesting-10, + author = "John Tang Boyland", + title = "Semantics of fractional permissions with nesting", + journal = toplas, + volume = "32", + number = "6", + pages = "22:1--22:33", + year = "2010", + URL = "http://dx.doi.org/10.1145/1749608.1749611", +} + +@InProceedings{boyland-noble-retert-01, + author = "John Boyland and James Noble and William Retert", + title = "Capabilities for Sharing: {A} Generalisation of + Uniqueness and Read-Only", + booktitle = ecoop, + pages = "2--27", + year = "2001", + series = lncs, + volume = "2072", + publisher = springer, + URL = "http://www.cs.uwm.edu/~boyland/papers/capability.ps", +} + +@InProceedings{boyland-retert-05, + author = "John Tang Boyland and William Retert", + title = "Connecting Effects and Uniqueness with Adoption", + booktitle = popl, + year = "2005", + pages = "283--295", + URL = "http://www.cs.uwm.edu/~boyland/papers/connecting2.pdf", +} + +@InProceedings{bracha-cook-90, + author = "Gilad Bracha and William Cook", + title = "Mixin-based inheritance", + booktitle = oopsla, + pages = "303--311", + year = "1990", + URL = "http://www.bracha.org/oopsla90.ps", +} + +@TechReport{bracha-lindstrom-91, + author = "Gilad Bracha and Gary Lindstrom", + title = "Modularity Meets Inheritance", + institution = "University of Utah", + year = "1991", + number = "UUCS-91-017", + URL = "http://www.bracha.org/modularity-meets-inheritance.ps", +} + +@Book{bradley-manna-07, + author = "Aaron R. Bradley and Zohar Manna", + title = "The Calculus of Computation", + publisher = springer, + year = "2007", + URL = "http://www.springerlink.com/content/wv0127/?p=77473ec707e949ae8856c880fe4e7649&pi=0", +} + +@InProceedings{braibant-pous-11, + author = "Thomas Braibant and Damien Pous", + title = "Tactics for Reasoning Modulo {AC} in {Coq}", + booktitle = cpp, + year = "2011", + pages = "167--182", + publisher = springer, + series = lncs, + volume = "7086", + URL = "http://arxiv.org/abs/1106.4448", +} + +@Article{brandis-mossenbock-94, + author = "Marc M. Brandis and Hanspeter Mössenböck", + title = "Single-pass generation of static single-assignment + form for structured languages", + journal = toplas, + volume = "16", + number = "6", + year = "1994", + pages = "1684--1698", + URL = "ftp://ftp.ssw.uni-linz.ac.at/pub/Papers/Moe94.ps.gz", +} + +@Article{brandt-henglein-98, + author = "Michael Brandt and Fritz Henglein", + year = "1998", + title = "Coinductive axiomatization of recursive type equality + and subtyping", + journal = fundamenta, + pages = "309--338", + volume = "33", + URL = "ftp://ftp.diku.dk/diku/semantics/papers/D-353.ps.gz", +} + +@Article{breazu-tannen-91, + author = "Val Breazu-Tannen and Thierry Coquand and Carl A. + Gunter and Andre Scedrov", + title = "Inheritance as Implicit Coercion", + journal = ic, + year = "1991", + volume = "93", + number = "1", + pages = "172--221", + URL = "http://seclab.uiuc.edu/cgunter/publications/documents/Breazu-TannenCGS91.pdf", +} + +@InProceedings{brookes-04, + author = "Stephen D. Brookes", + title = "A Semantics for Concurrent Separation Logic", + booktitle = concur, + year = "2004", + pages = "16--34", + publisher = springer, + series = lncs, + volume = "3170", + URL = "http://dx.doi.org/10.1007/978-3-540-28644-8_2", +} + +@Article{brookes-ohearn-16, + author = "Stephen Brookes and Peter W. O'Hearn", + title = "Concurrent separation logic", + journal = "{SIGLOG} News", + volume = "3", + number = "3", + pages = "47--65", + year = "2016", + URL = "http://siglog.hosting.acm.org/wp-content/uploads/2016/07/siglog_news_9.pdf#page=49", +} + +@InProceedings{brotherston-cyclic-11, + author = "James Brotherston and Dino Distefano and Rasmus + Lerchedahl Petersen", + title = "Automated Cyclic Entailment Proofs in Separation + Logic", + booktitle = cade, + year = "2011", + pages = "131--146", + publisher = springer, + series = lncs, + volume = "6803", + URL = "http://www.eecs.qmul.ac.uk/~rusmus/articles/Cyclic.pdf", +} + +@TechReport{bruce-alii-binary-methods, + key = "Bruce, {\em et al.}", + author = "Kim Bruce and Luca Cardelli and Giuseppe Castagna and + The Hopkins Object Group and Gary T. Leavens and + Benjamin Pierce", + title = "On Binary Methods", + year = "1995", + institution = "Department of Computer Science, Iowa State + University", + number = "95-08a", + URL = "ftp://ftp.cs.iastate.edu/pub/techreports/TR95-08/TR.ps.Z", +} + +@Article{bruce-cardelli-pierce-99, + author = "Kim B. Bruce and Luca Cardelli and Benjamin C. + Pierce", + title = "Comparing Object Encodings", + journal = ic, + year = "1999", + volume = "155", + number = "1/2", + pages = "108--133", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/compobj.ps", +} + +@Article{bruce-dicosmo-longo-92, + author = "Kim Bruce and Roberto {Di Cosmo} and Giuseppe Longo", + title = "Provable isomorphisms of types", + journal = mscs, + year = "1992", + volume = "2", + number = "2", + pages = "231--247", + URL = "http://www.dicosmo.org/Articles/MSCS.dvi", +} + +@Unpublished{bugliesi-affine-15, + author = "Michele Bugliesi and Stefano Calzavara and Fabienne + Eigner and Matteo Maffei", + title = "Affine Refinement Types for Secure Distributed + Programming", + note = "To appear", + year = "2015", + URL = "http://www.sps.cs.uni-saarland.de/affine-rcf/resources/long.pdf", +} + +@InProceedings{bugliesi-crafa-dynamic-99, + author = "Michele Bugliesi and Silvia Crafa", + title = "Object Calculi for Dynamic Messages", + booktitle = fool, + year = "1999", +} + +@Article{bugliesi-pericas-02, + author = "Michele Bugliesi and Santiago M. + Peric{\'a}s-Geertsen", + title = "Type Inference for Variant Object Types", + journal = ic, + year = "2002", + volume = "177", + number = "1", + pages = "2--27", + URL = "http://www.dsi.unive.it/~michele/Papers/PS/SplitTypes-ic02.ps.gz", +} + +@Article{buisse-11, + author = "Alexandre Buisse and Lars Birkedal and Kristian + St{\o}vring", + title = "A Step-Indexed {Kripke} Model of Separation Logic for + Storable Locks", + journal = entcs, + volume = "276", + year = "2011", + pages = "121--143", + URL = "http://www.itu.dk/~birkedal/papers/locks.pdf", +} + +@InProceedings{bulwahn-08, + author = "Lukas Bulwahn and Alexander Krauss and Florian + Haftmann and Levent Erk{\"{o}}k and John Matthews", + title = "Imperative Functional Programming with + {Isabelle/HOL}", + booktitle = tphol, + pages = "134--149", + year = "2008", + series = lncs, + volume = "5170", + publisher = springer, + URL = "http://www21.in.tum.de/~krauss/imperative/imperative.pdf", +} + +@Article{buneman-ohori-96, + author = "Peter Buneman and Atsushi Ohori", + title = "Polymorphism and Type Inference in Database + Programming", + journal = tods, + year = "1996", + volume = "21", + number = "1", + pages = "30--76", + URL = "http://www.jaist.ac.jp/~ohori/research/tods96.pdf", +} + +@InProceedings{burstall-hope-80, + author = "R. M. Burstall and D. B. MacQueen and D. T. Sannella", + title = "{HOPE}: An experimental applicative language", + booktitle = lfp, + year = "1980", + pages = "136--143", + URL = "http://portal.acm.org/citation.cfm?id=802799", +} + +@Article{cai-paige-89, + author = "Jiazhen Cai and Robert Paige", + title = "Program derivation by fixed point computation", + journal = scp, + volume = "11", + number = "3", + year = "1989", + pages = "197--261", + URL = "http://cs.nyu.edu/paige/papers/fixpoint.ps", +} + +@InProceedings{caires-seco-13, + author = "Lu\'{\i}s Caires and Jo{\~a}o Costa Seco", + title = "The type discipline of behavioral separation", + booktitle = popl, + year = "2013", + pages = "275--286", + URL = "http://dx.doi.org/10.1145/2429069.2429103", +} + +@InProceedings{cakeml-new-16, + author = "Yong Kiam Tan and Magnus O. Myreen and Ramana Kumar + and Anthony C. J. Fox and Scott Owens and Michael + Norrish", + title = "A new verified compiler backend for {CakeML}", + booktitle = icfp, + pages = "60--73", + year = "2016", + URL = "https://cakeml.org/icfp16.pdf", +} + +@Article{calcagno-02, + author = "Cristiano Calcagno and Simon Helsen and Peter + Thiemann", + title = "Syntactic Type Soundness Results for the Region + Calculus", + journal = ic, + year = "2002", + volume = "173", + number = "2", + pages = "199--221", + URL = "http://www.dcs.qmw.ac.uk/~ccris/ftp/iac_calhelthi.pdf", +} + +@InProceedings{calcagno-11, + author = "Cristiano Calcagno and Dino Distefano", + title = "Infer: An Automatic Program Verifier for Memory Safety + of {C} Programs", + booktitle = nfm, + pages = "459--465", + year = "2011", + series = lncs, + volume = "6617", + publisher = springer, + URL = "http://www.eecs.qmul.ac.uk/~ddino/papers/nasa-infer.pdf", +} + +@InProceedings{calcagno-15, + author = "Cristiano Calcagno and Dino Distefano and + J{\'{e}}r{\'{e}}my Dubreil and Dominik Gabi and Pieter + Hooimeijer and Martino Luca and Peter W. O'Hearn and + Irene Papakonstantinou and Jim Purbrick and Dulma + Rodriguez", + title = "Moving Fast with Software Verification", + booktitle = nfm, + pages = "3--11", + year = "2015", + series = lncs, + volume = "9058", + publisher = springer, + URL = "https://research.facebook.com/publications/moving-fast-with-software-verification/", +} + +@Article{calcagno-closed-03, + author = "Cristiano Calcagno and Eugenio Moggi and Tim Sheard", + title = "Closed Types for a Safe Imperative {MetaML}", + journal = jfp, + year = "2003", + volume = "13", + number = "3", + pages = "545--571", + URL = "http://dx.doi.org/10.1017/S0956796802004598", +} + +@InProceedings{calcagno-distefano-ohearn-yang-09, + author = "Cristiano Calcagno and Dino Distefano and Peter W. + O'Hearn and Hongseok Yang", + title = "Compositional shape analysis by means of + bi-abduction", + booktitle = popl, + year = "2009", + pages = "289--300", + URL = "http://www.doc.ic.ac.uk/~ccris/ftp/popl09.pdf", +} + +@Article{calcagno-distefano-ohearn-yang-11, + author = "Cristiano Calcagno and Dino Distefano and Peter W. + O'Hearn and Hongseok Yang", + title = "Compositional Shape Analysis by Means of + Bi-Abduction", + journal = jacm, + volume = "58", + number = "6", + year = "2011", + URL = "http://www.doc.ic.ac.uk/~ccris/ftp/jacm-abduction.pdf", +} + +@InProceedings{calcagno-distefano-vafeiadis-09, + author = "Cristiano Calcagno and Dino Distefano and Viktor + Vafeiadis", + title = "Bi-abductive Resource Invariant Synthesis", + booktitle = aplas, + year = "2009", + pages = "259--274", + publisher = springer, + series = lncs, + volume = "5904", + URL = "http://www.eecs.qmul.ac.uk/~ddino/papers/resinvariant.pdf", +} + +@InProceedings{calcagno-inference-04, + author = "Cristiano Calcagno and Eugenio Moggi and Walid Taha", + title = "{ML}-Like Inference for Classifiers", + booktitle = esop, + year = "2004", + pages = "79--93", + series = lncs, + volume = "2986", + publisher = springer, + URL = "http://www.doc.ic.ac.uk/~ccris/ftp/esop04.pdf", +} + +@InProceedings{calcagno-local-07, + author = "Cristiano Calcagno and Peter W. O'Hearn and Hongseok + Yang", + title = "Local Action and Abstract Separation Logic", + booktitle = lics, + year = "2007", + pages = "366--378", + URL = "http://www.doc.ic.ac.uk/~ccris/ftp/asl-short.pdf", +} + +@InProceedings{calcagno-yang-ohearn-01, + author = "Cristiano Calcagno and Hongseok Yang and Peter W. + O'Hearn", + title = "Computability and Complexity Results for a Spatial + Assertion Language for Data Structures", + booktitle = aplas, + pages = "289--300", + year = "2001", + URL = "http://www.cs.ox.ac.uk/people/hongseok.yang/paper/decidability.ps", +} + +@Misc{caml-light, + author = "Xavier Leroy and Damien Doligez and Michel Mauny and + Pierre Weis", + title = "The {Caml} {Light} system, release 0.75", + year = "2002", + URL = "http://caml.inria.fr/", +} + +@InCollection{cardelli-97, + author = "Luca Cardelli", + title = "Type Systems", + booktitle = "The Computer Science and Engineering Handbook", + publisher = "CRC Press", + year = "1997", + editor = "Allen B. Tucker", + pages = "2208--2236", + URL = "http://research.microsoft.com/Users/luca/Papers/TypeSystems.pdf", +} + +@Article{cardelli-basic-87, + author = "Luca Cardelli", + title = "Basic polymorphic typechecking", + journal = scp, + year = "1987", + volume = "8", + number = "2", + pages = "147--172", + URL = "http://research.microsoft.com/Users/luca/Papers/BasicTypechecking.pdf", +} + +@TechReport{cardelli-extensible-94, + author = "Luca Cardelli and Florian Matthes and Martín Abadi", + title = "Extensible syntax with lexical scoping", + institution = decsrc, + year = "1994", + type = "Research Report", + number = "121", + URL = "http://gatekeeper.dec.com/pub/compaq/SRC/research-reports/SRC-121.ps.gz", +} + +@Article{cardelli-longo-91, + author = "Luca Cardelli and Giuseppe Longo", + title = "A semantic basis for {Quest}", + journal = jfp, + year = "1991", + volume = "1", + number = "4", + pages = "417--458", + URL = "http://research.microsoft.com/Users/luca/Papers/QuestSem.pdf", +} + +@InCollection{cardelli-mitchell-records-91, + author = "Luca Cardelli and John Mitchell", + title = "Operations on Records", + booktitle = taoop, + publisher = mitp, + editor = "Carl A. Gunter and John C. Mitchell", + year = "1994", + URL = "http://research.microsoft.com/Users/luca/Papers/Records.pdf", +} + +@Article{cardelli-multiple-88, + author = "Luca Cardelli", + title = "A Semantics of Multiple Inheritance", + journal = ic, + volume = "76", + number = "2/3", + year = "1988", + pages = "138--164", + URL = "http://research.microsoft.com/Users/luca/Papers/Inheritance.pdf", +} + +@Misc{cardelli-quest-91, + author = "Luca Cardelli", + title = "The {Quest} Language and System", + year = "1991", + URL = "http://research.microsoft.com/Users/luca/Notes/QuestManual.pdf", +} + +@InProceedings{cardelli-typeful-89, + author = "Luca Cardelli", + title = "Typeful programming", + booktitle = "Formal Description of Programming Concepts", + year = "1989", + series = "IFIP State of the Art Reports Series", + publisher = springer, + URL = "http://research.microsoft.com/Users/luca/Papers/TypefulProg.pdf", +} + +@Article{cardelli-wegner-85, + author = "Luca Cardelli and Peter Wegner", + title = "On Understanding Types, Data Abstraction, and + Polymorphism", + journal = surveys, + volume = "17", + number = "4", + pages = "471--522", + year = "1985", + URL = "http://research.microsoft.com/Users/luca/Papers/OnUnderstanding.pdf", +} + +@Article{cardone-02, + author = "Felice Cardone", + title = "A coinductive completeness proof for the equivalence + of recursive types", + journal = tcs, + volume = "275", + number = "1--2", + year = "2002", + pages = "575--587", + URL = "http://dx.doi.org/10.1016/S0304-3975(01)00298-5", + publisher = elsevier, +} + +@Article{cardone-coppo-91, + author = "Felice Cardone and Mario Coppo", + title = "Type inference with recursive types: syntax and + semantics", + journal = ic, + volume = "92", + number = "1", + year = "1991", + pages = "48--80", + URL = "http://dx.doi.org/10.1016/0890-5401(91)90020-3", +} + +@InProceedings{carette-finally-tagless-07, + author = "Jacques Carette and Oleg Kiselyov and Chung-chieh + Shan", + title = "Finally Tagless, Partially Evaluated", + booktitle = aplas, + year = "2007", + pages = "222--238", + publisher = springer, + series = lncs, + volume = "4807", + URL = "http://okmij.org/ftp/papers/tagless-final-APLAS.pdf", +} + +@Article{carette-gauss-05, + author = "Jacques Carette", + title = "{Gaussian} Elimination: a case study in efficient + genericity with {MetaOCaml}", + journal = scp, + year = "2005", + volume = "62", + number = "1", + pages = "3--24", + URL = "http://www.cas.mcmaster.ca/~carette/publications/ge.pdf", +} + +@InProceedings{carlier-04, + author = "Sébastien Carlier and Jeff Polakow and J. B. Wells and + A. J. Kfoury", + title = "{System E}: Expansion variables for flexible typing + with linear and non-linear types and intersection + types", + booktitle = esop, + year = "2004", + series = lncs, + publisher = springer, + URL = "http://www.macs.hw.ac.uk/~jbw/papers/Carlier+Polakow+Wells+Kfoury:System-E:ESOP-2004.pdf", +} + +@TechReport{carlier-wells-04, + author = "Sébastien Carlier and J. B. Wells", + title = "Type inference with expansion variables and + intersection types in {System E} and an exact + correspondence with $\beta$-reduction", + institution = "Heriot-Watt University", + year = "2004", + number = "HW-MACS-TR-0012", + URL = "http://www.macs.hw.ac.uk:8080/techreps/docs/files/HW-MACS-TR-0012.pdf", +} + +@Misc{cartwright-notes-00, + author = "Robert Cartwright", + title = "Notes on Object-Oriented Program Design", + URL = "http://www.cs.rice.edu/~cork/book/", + year = "2000", +} + +@InProceedings{castagna-ampersand-93, + author = "Giuseppe Castagna", + title = "${F}_{\leq}^{\&}$ : integrating parametric and ``ad + hoc'' second order polymorphism", + booktitle = "International Workshop on Database Programming + Languages", + year = "1993", + publisher = springer, + series = "Workshops in Computing", +} + +@Article{castagna-contravariance-95, + author = "Giuseppe Castagna", + title = "Covariance and Contravariance: Conflict without a + Cause", + journal = toplas, + volume = "17", + number = "3", + pages = "431--447", + year = "1995", + URL = "ftp://ftp.ens.fr/pub/di/users/castagna/covariance.ps.Z", +} + +@InProceedings{castagna-frisch-05, + author = "Giuseppe Castagna and Alain Frisch", + title = "A gentle introduction to semantic subtyping", + booktitle = ppdp, + year = "2005", + pages = "198--199", + URL = "http://www.pps.univ-paris-diderot.fr/~gc/papers/icalp-ppdp05.pdf", +} + +@InProceedings{cejtin-al-00, + author = "Henry Cejtin and Suresh Jagannathan and Stephen + Weeks", + title = "Flow-directed Closure Conversion for Typed Languages", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "1782", + pages = "56--71", + year = "2000", + URL = "http://mlton.org/papers/00-esop.ps.gz", +} + +@InProceedings{cerco, + author = "Roberto M. Amadio and Nicholas Ayache and + Fran{\c{c}}ois Bobot and Jaap Boender and Brian + Campbell and Ilias Garnier and Antoine Madet and James + McKinna and Dominic P. Mulligan and Mauro Piccolo and + Randy Pollack and Yann R{\'{e}}gis{-}Gianas and Claudio + Sacerdoti Coen and Ian Stark and Paolo Tranquilli", + title = "Certified Complexity ({CerCo})", + booktitle = fopara, + pages = "1--18", + year = "2014", + series = lncs, + publisher = springer, + volume = "8552", + URL = "http://dx.doi.org/10.1007/978-3-319-12466-7_1", +} + +@Misc{cfml, + author = "Arthur Charguéraud", + title = "The {CFML} tool and library", + howpublished = "\url{http://www.chargueraud.org/softs/cfml/}", + year = "2016", +} + +@TechReport{chambers-leavens-96, + author = "Craig Chambers and Gary T. Leavens", + title = "{BeCecil}, a Core Object-Oriented Language with Block + Structure and Multimethods: Semantics and Typing", + institution = "University of Washington", + year = "1996", + number = "UW-CSE-96-12-02", + URL = "ftp://ftp.cs.washington.edu/pub/chambers/BeCecil.ps.gz", +} + +@Misc{chameleon, + author = "Andreas Rossberg and Peter J. Stuckey and Martin + Sulzmann and Jeremy Wazny", + title = "The {Chameleon} language", + URL = "http://taichi.ddns.comp.nus.edu.sg/taichiwiki/ChameleonHomePage", +} + +@InProceedings{chang-rival-08, + author = "Bor-Yuh Evan Chang and Xavier Rival", + title = "Relational inductive shape analysis", + booktitle = popl, + year = "2008", + pages = "247--260", + URL = "http://xisa.cs.colorado.edu/papers/popl08-relational.pdf", +} + +@PhdThesis{chargueraud-10, + author = "Arthur Charguéraud", + title = "Characteristic Formulae for Mechanized Program + Verification", + school = "Université Paris 7", + year = "2010", + URL = "http://www.chargueraud.org/research/2010/thesis/thesis_final.pdf", +} + +@InProceedings{chargueraud-10-cfml, + author = "Arthur Chargu{\'e}raud", + title = "Program Verification Through Characteristic Formulae", + booktitle = icfp, + year = "2010", + pages = "321--332", + URL = "http://www.chargueraud.org/research/2010/cfml/main.pdf", +} + +@InProceedings{chargueraud-11-cfml, + author = "Arthur Chargu{\'e}raud", + title = "Characteristic Formulae for the Verification of + Imperative Programs", + booktitle = icfp, + year = "2011", + pages = "418--430", + URL = "http://www.chargueraud.org/research/2011/cfml/main.pdf", +} + +@Misc{chargueraud-cfml, + author = "Arthur Charguéraud", + title = "Characteristic Formulae for the Verification of + Imperative Programs", + year = "2013", + note = "Unpublished. + \url{http://www.chargueraud.org/research/2013/cf/cf.pdf}", +} + +@Article{chargueraud-ln-11, + author = "Arthur Chargu{\'e}raud", + title = "The Locally Nameless Representation", + year = "2012", + journal = jar, + volume = "49", + number = "3", + pages = "363--408", + URL = "http://www.chargueraud.org/arthur/research/2009/ln/main.pdf", +} + +@InProceedings{chargueraud-pottier-08, + author = "Arthur Charguéraud and François Pottier", + title = "Functional Translation of a Calculus of Capabilities", + booktitle = icfp, + year = "2008", + pages = "213--224", + URL = "http://gallium.inria.fr/~fpottier/publis/chargueraud-pottier-capabilities.pdf", +} + +@InProceedings{chargueraud-pottier-15, + author = "Arthur Charguéraud and François Pottier", + title = "Machine-Checked Verification of the Correctness and + Amortized Complexity of an Efficient Union-Find + Implementation", + booktitle = itp, + year = "2015", + volume = "9236", + series = lncs, + publisher = springer, + pages = "137--153", + URL = "http://gallium.inria.fr/~fpottier/publis/chargueraud-pottier-uf.pdf", +} + +@TechReport{chen-al-99, + author = "Martin Odersky and Christoph Zenger and Matthias + Zenger and Gang Chen", + title = "A Functional View Of Join", + institution = "University of South Australia", + year = "1999", + number = "ACRC-99-016", + URL = "http://www.christoph-zenger.de/papers/tr-acrc-99-016.ps.gz", +} + +@InProceedings{chen-crash-16, + author = "Haogang Chen and Daniel Ziegler and Tej Chajed and + Adam Chlipala and M. Frans Kaashoek and Nickolai + Zeldovich", + title = "Using {Crash Hoare logic} for certifying the {FSCQ} + file system", + booktitle = sosp, + pages = "18--37", + year = "2015", + URL = "https://people.csail.mit.edu/nickolai/papers/chen-fscq.pdf", +} + +@InProceedings{chen-hudak-97, + author = "Chih-Ping Chen and Paul Hudak", + title = "Rolling your own mutable {ADT}---a connection between + linear types and monads", + booktitle = popl, + year = "1997", + pages = "54--66", + URL = "http://www.cs.yale.edu/homes/hudak-paul/hudak-dir/popl97.ps", +} + +@InProceedings{chen-shi-xi-04, + author = "Chiyan Chen and Rui Shi and Hongwei Xi", + title = "A Typeful Approach to Object-Oriented Programming with + Multiple Inheritance", + booktitle = padl, + publisher = springer, + series = lncs, + volume = "3057", + year = "2004", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/OBJwMI/OBJwMI.pdf", +} + +@InProceedings{chen-tarditi-05, + author = "Juan Chen and David Tarditi", + title = "A simple typed intermediate language for + object-oriented languages", + booktitle = popl, + year = "2005", + pages = "38--49", + URL = "http://research.microsoft.com/pubs/59934/lilc_popl05.pdf", +} + +@InProceedings{chen-xi-05, + author = "Chiyan Chen and Hongwei Xi", + title = "Combining Programming with Theorem Proving", + booktitle = icfp, + year = "2005", + pages = "66--77", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/icfp05.pdf", +} + +@InProceedings{chen-xi-icfp-03, + author = "Chiyan Chen and Hongwei Xi", + title = "Meta-Programming through Typeful Code Representation", + booktitle = icfp, + year = "2003", + pages = "275--286", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/icfp03.pdf", +} + +@InProceedings{chen-xi-pepm-03, + author = "Chiyan Chen and Hongwei Xi", + title = "Implementing Typeful Program Transformations", + booktitle = pepm, + year = "2003", + pages = "20--28", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/pepm03.pdf", +} + +@InProceedings{cheney-05, + author = "James Cheney", + title = "Scrap your nameplate", + booktitle = icfp, + year = "2005", + URL = "http://homepages.inf.ed.ac.uk/jcheney/publications/cheney05icfp.pdf", +} + +@InProceedings{cheney-hinze-02, + author = "James Cheney and Ralf Hinze", + title = "A lightweight implementation of generics and + dynamics", + booktitle = hw, + year = "2002", + URL = "http://www.cs.cornell.edu/people/jcheney/papers/Dynamic-final.pdf", +} + +@TechReport{cheney-hinze-03, + author = "James Cheney and Ralf Hinze", + title = "First-Class Phantom Types", + institution = "Cornell University", + year = "2003", + number = "1901", + URL = "http://techreports.library.cornell.edu:8081/Dienst/UI/1.0/Display/cul.cis/TR2003-1901", +} + +@InProceedings{cheney-urban-04, + author = "James Cheney and Christian Urban", + title = "{$\alpha$Prolog}: {A} Logic Programming Language with + Names, Binding and $\alpha$-equivalence", + booktitle = iclp, + pages = "269--283", + year = "2004", + volume = "3132", + series = lncs, + publisher = springer, + URL = "http://www.cs.cornell.edu/people/jcheney/papers/alpnba.pdf", +} + +@InProceedings{cheng-blelloch-01, + author = "Perry Cheng and Guy E. Blelloch", + title = "A Parallel, Real-Time Garbage Collector", + booktitle = pldi, + pages = "125--136", + year = "2001", + URL = "https://www.cs.cmu.edu/~guyb/papers/gc2001.pdf", +} + +@Article{chin-khoo-01, + author = "Wei-Ngan Chin and Siau-Cheng Khoo", + title = "Calculating Sized Types", + journal = hosc, + volume = "14", + number = "2--3", + year = "2001", + pages = "261--300", + publisher = kluwer, + URL = "http://dx.doi.org/10.1023/A:1012996816178", +} + +@InProceedings{chitil-01, + author = "Olaf Chitil", + title = "Compositional Explanation of Types and Algorithmic + Debugging of Type Errors", + booktitle = icfp, + pages = "193--204", + year = "2001", + URL = "http://www-users.cs.york.ac.uk/~olaf/PUBLICATIONS/explainTypes.ps.gz", +} + +@InProceedings{chlipala-07, + author = "Adam Chlipala", + title = "A certified type-preserving compiler from lambda + calculus to assembly language", + booktitle = pldi, + year = "2007", + pages = "54--65", + URL = "http://www.cs.berkeley.edu/~adamc/papers/CtpcPLDI07/CtpcPLDI07.pdf", +} + +@InProceedings{chlipala-08, + author = "Adam Chlipala", + title = "Parametric higher-order abstract syntax for mechanized + semantics", + booktitle = icfp, + year = "2008", + pages = "143--156", + URL = "http://adam.chlipala.net/papers/PhoasICFP08/PhoasICFP08.pdf", +} + +@InProceedings{chlipala-15, + author = "Adam Chlipala", + title = "From Network Interface to Multithreaded Web + Applications: {A} Case Study in Modular Program + Verification", + booktitle = popl, + pages = "609--622", + year = "2015", + URL = "http://adam.chlipala.net/papers/BedrockPOPL15/BedrockPOPL15.pdf", +} + +@InProceedings{chlipala-bedrock-13, + author = "Adam Chlipala", + title = "The {Bedrock} structured programming system: combining + generative metaprogramming and {Hoare} logic in an + extensible program verifier", + booktitle = icfp, + pages = "391--402", + year = "2013", + URL = "http://adam.chlipala.net/papers/BedrockICFP13/BedrockICFP13.pdf", +} + +@Book{chlipala-cpdt-13, + author = "Adam Chlipala", + title = "Certified Programming and Dependent Types", + publisher = mitp, + year = "2013", + URL = "http://adam.chlipala.net/cpdt/", +} + +@InProceedings{chlipala-ynot-09, + author = "Adam Chlipala and Gregory Malecha and Greg Morrisett + and Avraham Shinnar and Ryan Wisnesky", + title = "Effective interactive proofs for higher-order + imperative programs", + booktitle = icfp, + year = "2009", + pages = "79--90", + URL = "http://ynot.cs.harvard.edu/papers/icfp09.pdf", +} + +@PhdThesis{choppella-02, + author = "Venkatesh Choppella", + title = "Unification Source-tracking with Application to + Diagnosis of Type Inference", + school = "Indiana University", + year = "2002", + URL = "http://www.cs.indiana.edu/cgi-bin/techreports/TRNNN.cgi?trnum=TR566", +} + +@InProceedings{chrzaszcz-98, + author = "Jacek Chrzaszcz", + title = "Polymorphic Subtyping Without Distributivity", + booktitle = mfcs, + pages = "346--355", + year = "1998", + series = lncs, + volume = "1450", + publisher = springer, + URL = "http://www.mimuw.edu.pl/~chrzaszc/papers/Chrzaszcz_Polymorphic-subtyping-without-distributivity.ps.gz", +} + +@Article{clarke-79, + author = "Edmund Clarke", + title = "Programming Language Constructs for Which It Is + Impossible To Obtain Good {Hoare} Axiom Systems", + journal = jacm, + volume = "26", + number = "1", + year = "1979", + pages = "129--147", + URL = "http://doi.acm.org/10.1145/322108.322121", +} + +@InProceedings{clarke-drossopoulou-02, + author = "Dave Clarke and Sophia Drossopoulou", + title = "Ownership, encapsulation and the disjointness of type + and effect", + booktitle = oopsla, + year = "2002", + pages = "292--310", + URL = "http://pubs.doc.ic.ac.uk/ownershipAndEffects/ownershipAndEffects.ps", +} + +@InProceedings{clarke-noble-potter-01, + author = "David G. Clarke and James Noble and John Potter", + title = "Simple Ownership Types for Object Containment", + booktitle = ecoop, + year = "2001", + pages = "53--76", + publisher = springer, + series = lncs, + volume = "2072", + URL = "http://www.cs.washington.edu/education/courses/cse590p/00wi/simple.pdf", +} + +@InProceedings{clarke-potter-noble-98, + author = "David G. Clarke and John M. Potter and James Noble", + title = "Ownership types for flexible alias protection", + booktitle = oopsla, + year = "1998", + pages = "48--64", + URL = "http://doi.acm.org/10.1145/286936.286947", +} + +@InCollection{clarke-survey-13, + author = "Dave Clarke and Johan {\"O}stlund and Ilya Sergey and + Tobias Wrigstad", + title = "Ownership Types: {A} Survey", + booktitle = "Aliasing in Object-Oriented Programming. Types, + Analysis and Verification", + year = "2013", + pages = "15--58", + publisher = springer, + series = lncs, + volume = "7850", + URL = "http://dx.doi.org/10.1007/978-3-642-36946-9_3", +} + +@InProceedings{clarke-wrigstad-03, + author = "Dave Clarke and Tobias Wrigstad", + title = "External Uniqueness Is Unique Enough", + booktitle = ecoop, + year = "2003", + pages = "176--200", + publisher = springer, + series = lncs, + volume = "2743", + URL = "https://lirias.kuleuven.be/bitstream/123456789/203436/1/euiue.pdf", +} + +@InProceedings{cleaveland-steffen-91, + author = "Rance Cleaveland and Bernhard Steffen", + title = "A linear-time model-checking algorithm for the + alternation-free modal mu-calculus", + booktitle = cav, + pages = "48--58", + year = "1991", + volume = "575", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-55179-4_6", +} + +@InProceedings{clement-despeyroux-kahn-86, + author = "Dominique Cl{\'e}ment and Jo{\"e}lle Despeyroux and + Thierry Despeyroux and Gilles Kahn", + title = "A simple applicative language: Mini-{ML}", + booktitle = lfp, + year = "1986", + pages = "13--27", +} + +@InProceedings{clements-felleisen-03, + author = "John Clements and Matthias Felleisen", + title = "A Tail-Recursive Semantics for Stack Inspections", + booktitle = esop, + pages = "22--37", + year = "2003", + volume = "2618", + series = lncs, + publisher = springer, + URL = "http://www.ccs.neu.edu/scheme/pubs/esop2003-cf.ps.gz", +} + +@InProceedings{clochard-filliatre-paskevich-15, + title = "How to avoid proving the absence of integer + overflows", + author = "Martin Clochard and Jean-Christophe Filli{\^a}tre and + Andrei Paskevich", + URL = "https://hal.inria.fr/hal-01162661", + booktitle = vstte, + year = "2015", + pages = "94--109", + series = lncs, + volume = "9593", + publisher = springer, +} + +@InProceedings{clochard-marche-paskevich-14, + author = "Martin Clochard and Claude March{\'{e}} and Andrei + Paskevich", + title = "Verified programs with binders", + booktitle = plpv, + pages = "29--40", + year = "2014", + URL = "https://hal.inria.fr/hal-00913431", +} + +@InProceedings{coblenz-16, + author = "Michael J. Coblenz and Joshua Sunshine and Jonathan + Aldrich and Brad A. Myers and Sam Weber and Forrest + Shull", + title = "Exploring language support for immutability", + booktitle = icse, + pages = "736--747", + year = "2016", + URL = "http://www.cs.cmu.edu/~aldrich/papers/icse16-immutability.pdf", +} + +@Article{cohen-search-06, + author = "Albert Cohen and Sébastien Donadio and Maria-Jesus + Garzaran and Christoph Herrmann and Oleg Kiselyov and + David Padua", + title = "In search of a program generator to implement generic + transformations for high-performance computing", + journal = scp, + year = "2006", + volume = "62", + number = "1", + pages = "25--46", + URL = "http://www-rocq.inria.fr/~acohen/publications/CDGHKP06.ps.gz", +} + +@InProceedings{cohen-vcc-09, + author = "Ernie Cohen and Markus Dahlweid and Mark A. Hillebrand + and Dirk Leinenbach and Michal Moskal and Thomas Santen + and Wolfram Schulte and Stephan Tobies", + title = "{VCC}: {A} Practical System for Verifying Concurrent + {C}", + booktitle = tphol, + year = "2009", + pages = "23--42", + publisher = springer, + series = lncs, + volume = "5674", + URL = "http://research.microsoft.com/apps/pubs/default.aspx?id=117859", +} + +@InProceedings{colazzo-ghelli-99, + author = "Dario Colazzo and Giorgio Ghelli", + title = "Subtyping Recursive Types in {Kernel Fun}", + booktitle = lics, + pages = "137--146", + year = "1999", +} + +@TechReport{collins-shao-02, + author = "Gregory D. Collins and Zhong Shao", + title = "Intensional Analysis of Higher-Kinded Recursive + Types", + institution = "Yale University", + year = "2002", + number = "YALEU/DCS/TR-1240", + URL = "http://flint.cs.yale.edu/flint/publications/collins02-ita-tr.pdf", +} + +@InProceedings{colmerauer-84, + author = "Alain Colmerauer", + title = "Equations and Inequations on Finite and Infinite + Trees", + booktitle = "International Conference on Fifth Generation Computer + Systems (FGCS)", + pages = "85--99", + year = "1984", +} + +@Article{color, + author = "Frédéric Blanqui and Adam Koprowski", + title = "{CoLoR}: a Coq library on well-founded rewrite + relations and its application to the automated + verification of termination certificates", + journal = mscs, + year = "2011", + volume = "21", + number = "4", + pages = "827--859", + URL = "https://who.rocq.inria.fr/Frederic.Blanqui/papers/mscs11.pdf", +} + +@InProceedings{comon-93, + author = "Hubert Comon", + title = "Constraints in Term Algebras (Short Survey)", + booktitle = amast, + year = "1993", + publisher = springer, + series = "Workshops in Computing", + URL = "http://www.lsv.ens-cachan.fr/~comon/ftp.articles/amast93.ps", +} + +@Article{comon-lescanne-89, + author = "Hubert Comon and Pierre Lescanne", + title = "Equational Problems and Disunification", + journal = jsc, + year = "1989", + volume = "7", + pages = "371--425", + URL = "http://perso.ens-lyon.fr/pierre.lescanne/PUBLICATIONS/jsc-diseq.pdf", +} + +@Misc{compcert, + author = "Xavier Leroy", + title = "The {CompCert C} compiler", + year = "2015", + howpublished = "\url{http://compcert.inria.fr/}", +} + +@InProceedings{conchon-filliatre-07, + author = "Sylvain Conchon and Jean{-}Christophe + Filli{\^{a}}tre", + title = "A persistent union-find data structure", + booktitle = ml, + pages = "37--46", + year = "2007", + URL = "https://www.lri.fr/~filliatr/puf/", +} + +@Book{conchon-filliatre-ocaml-14, + author = "Sylvain Conchon et Jean-Christophe Filliâtre", + title = "Apprendre à programmer avec {OCaml}: Algorithmes et + structures de données", + publisher = "Eyrolles", + year = "2014", + URL = "http://programmer-avec-ocaml.lri.fr/", +} + +@InProceedings{conchon-kanig-lescuyer-08, + author = "Sylvain Conchon and Johannes Kanig and Stéphane + Lescuyer", + title = "\textsc{Sat-Micro}: petit mais costaud!", + booktitle = jfla, + year = "2008", + URL = "http://www.lri.fr/~conchon/publis/conchon-jfla08.ps", +} + +@InProceedings{conchon-le-fessant-99, + title = "Jocaml: Mobile Agents for {Objective-Caml}", + author = "Sylvain Conchon and Fabrice Le Fessant", + booktitle = "International Symposium on Agent Systems and + Applications and International Symposium on Mobile + Agents (ASA/MA)", + year = "1999", + pages = "22--29", + URL = "http://para.inria.fr/~conchon/publis/conchon-lefessant-asama99.ps.gz", +} + +@InProceedings{conchon-pottier-01, + author = "Sylvain Conchon and François Pottier", + title = "{JOIN(X)}: Constraint-Based Type Inference for the + Join-Calculus", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "2028", + pages = "221--236", + year = "2001", + URL = "http://gallium.inria.fr/~fpottier/publis/conchon-fpottier-esop01.ps.gz", +} + +@TechReport{considine-00, + author = "Jeffrey Considine", + title = "Efficient Hash-Consing of Recursive Types", + institution = "Boston University", + year = "2000", + number = "2000-006", + URL = "http://www.cs.bu.edu/techreports/pdf/2000-006-hashconsing-recursive-types.pdf", +} + +@InProceedings{cook-09, + author = "William R. Cook", + title = "On understanding data abstraction, revisited", + booktitle = oopsla, + year = "2009", + pages = "557--572", + URL = "http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf", +} + +@InProceedings{cook-71, + author = "Stephen A. Cook", + title = "The Complexity of Theorem-Proving Procedures", + booktitle = stoc, + year = "1971", + pages = "151--158", + URL = "http://doi.acm.org/10.1145/800157.805047", +} + +@InProceedings{cook-tractable-11, + author = "Byron Cook and Christoph Haase and Jo{\"{e}}l Ouaknine + and Matthew J. Parkinson and James Worrell", + title = "Tractable Reasoning in a Fragment of Separation + Logic", + booktitle = concur, + pages = "235--249", + year = "2011", + series = lncs, + volume = "6901", + publisher = springer, + URL = "http://www.cs.ox.ac.uk/files/4048/sl.pdf", +} + +@TechReport{cooper-harvey-kennedy-04, + author = "Keith D. Cooper and Timothy J. Harvey and Ken + Kennedy", + title = "Iterative Data-flow Analysis, Revisited", + institution = "Rice University", + year = "2004", + number = "TR04-432", + URL = "http://www.cs.rice.edu/~harv/my_papers/worklist.pdf", +} + +@Article{coppo-dezani-80, + author = "Mario Coppo and Mariangiola Dezani-Ciancaglini", + title = "An extension of the basic functionality theory for the + $\lambda$-calculus", + journal = "Notre Dame J. Formal Logic", + year = "1980", + volume = "21", + number = "4", + pages = "685--693", +} + +@Manual{coq, + author = "{The {Coq} development team}", + title = "The {Coq} Proof Assistant", + year = "2016", + URL = "http://coq.inria.fr/", +} + +@Book{coqart, + author = "Yves Bertot and Pierre Cast{\'{e}}ran", + title = "Interactive Theorem Proving and Program Development -- + {Coq'Art}: The Calculus of Inductive Constructions", + series = "Texts in Theoretical Computer Science. An {EATCS} + Series", + publisher = springer, + year = "2004", + URL = "https://www.labri.fr/perso/casteran/CoqArt/coqartF.pdf", +} + +@InProceedings{coquand-86, + author = "Thierry Coquand", + title = "An analysis of {Girard}'s paradox", + booktitle = lics, + pages = "227--236", + year = "1986", + URL = "http://hal.inria.fr/docs/00/07/60/23/PDF/RR-0531.pdf", +} + +@Book{cormen-en, + author = "Thomas H. Cormen and Charles E. Leiserson and Ronald + L. Rivest and Clifford Stein", + title = "Introduction to Algorithms (Third Edition)", + publisher = "MIT Press", + year = "2009", + URL = "http://mitpress.mit.edu/catalog/item/ + default.asp?ttype=2&tid=11866", +} + +@Book{cormen-fr, + author = "Thomas H. Cormen and Charles E. Leiserson and Ronald + L. Rivest and Clifford Stein", + title = "Algorithmique (Troisième Édition)", + publisher = "Dunod", + year = "2010", + series = "Sciences Sup", + URL = "http://www.dunod.com/informatique-multimedia/fondements-de-linformatique/algorithmique/algorithmique", + note = "Traduction française", +} + +@Article{courcelle-fundamental-trees, + title = "Fundamental Properties of Infinite Trees", + author = "Bruno Courcelle", + pages = "95--169", + journal = tcs, + year = "1983", + volume = "25", + number = "2", +} + +@InCollection{cousot-90, + author = "Patrick Cousot", + title = "Methods and Logics for Proving Programs", + booktitle = "Formal Models and Semantics", + series = "Handbook of Theoretical Computer Science", + publisher = elsevier, + year = "1990", + pages = "841--993", + volume = "B", + chapter = "15", + URL = "http://www.di.ens.fr/~cousot/publications.www/Cousot-HTCS-vB-FMS-c15-p843--993-1990.pdf.gz", +} + +@InProceedings{cousot-cousot-77, + author = "Patrick Cousot and Radhia Cousot", + title = "Abstract interpretation: a unified lattice model for + static analysis of programs by construction or + approximation of fixpoints", + pages = "238--252", + booktitle = popl, + year = "1977", + URL = "http://www.di.ens.fr/~cousot/publications.www/CousotCousot-POPL-77-ACM-p238--252-1977.pdf", +} + +@Article{cousot-cousot-constructive-79, + author = "Patrick Cousot and Radhia Cousot", + title = "Constructive Versions of {Tarski}'s Fixed Point + Theorems", + journal = "Pacific Journal of Mathematics", + volume = "81", + number = "1", + pages = "43--57", + year = "1979", + URL = "http://www.di.ens.fr/~cousot/publications.www/CousotCousot-PacJMath-82-1-1979.pdf", +} + +@InProceedings{cousot-gentle-09, + author = "Patrick Cousot and Radhia Cousot", + title = "A gentle introduction to formal verification of + computer systems by abstract interpretation", + booktitle = "Logics and Languages for Reliability and Security", + series = "{NATO} Science Series {III}: Computer and Systems + Sciences", + editor = "J.~Esparza and O.~Grumberg and M.~Broy", + publisher = "IOS Press", + year = "2010", + pages = "1--29", + URL = "http://www.di.ens.fr/~cousot/COUSOTpapers/MARKTOBERDORF-09.shtml", +} + +@InProceedings{cousot-sba-95, + author = "Patrick Cousot and Radhia Cousot", + title = "Formal Language, Grammar and Set-Constraint-Based + Program Analysis by Abstract Interpretation", + pages = "170--181", + booktitle = fpca, + publisher = acmp, + year = "1995", +} + +@InProceedings{coutts-07, + author = "Duncan Coutts and Roman Leshchinskiy and Don Stewart", + title = "Stream fusion: from lists to streams to nothing at + all", + booktitle = icfp, + pages = "315--326", + year = "2007", + URL = "http://dx.doi.org/10.1145/1291151.1291199", +} + +@InProceedings{crank-felleisen-91, + author = "Erik Crank and Matthias Felleisen", + title = "Parameter-Passing and the Lambda Calculus", + booktitle = popl, + pages = "233--244", + year = "1991", + URL = "http://www.ccs.neu.edu/scheme/pubs/popl91-cf.ps.gz", +} + +@TechReport{crary-99, + author = "Karl Crary", + title = "Simple, Efficient Object Encoding using Intersection + Types", + institution = "Carnegie Mellon University", + year = "1999", + number = "CMU-CS-99-100", + URL = "http://www-2.cs.cmu.edu/~crary/papers/1999/orei/orei.ps.gz", +} + +@InProceedings{crary-cc-99, + author = "Karl Crary and David Walker and Greg Morrisett", + title = "Typed Memory Management in a Calculus of + Capabilities", + booktitle = popl, + pages = "262--275", + year = "1999", + URL = "http://www.cs.cornell.edu/talc/papers/capabilities.pdf", +} + +@Article{crary-intensional-02, + author = "Karl Crary and Stephanie Weirich and Greg Morrisett", + title = "Intensional Polymorphism in Type Erasure Semantics", + journal = jfp, + year = "2002", + volume = "12", + number = "6", + pages = "567--600", + URL = "http://www-2.cs.cmu.edu/~crary/papers/2002/typepass/typepass.ps", +} + +@InProceedings{crary-intensional-98, + author = "Karl Crary and Stephanie Weirich and Greg Morrisett", + title = "Intensional Polymorphism in Type-Erasure Semantics", + booktitle = icfp, + pages = "301--313", + year = "1998", + URL = "http://www.cis.upenn.edu/~sweirich/papers/typepass/typepass.ps", +} + +@PhdThesis{crary-phd-98, + author = "Karl Crary", + title = "Type-Theoretic Methodology for Practical Programming + Languages", + school = "Cornell University", + year = "1998", + URL = "http://www.cs.cmu.edu/~crary/papers/1998/thesis/thesis.ps.gz", +} + +@InProceedings{crary-weirich-00, + author = "Karl Crary and Stephanie Weirich", + title = "Resource bound certification", + booktitle = popl, + year = "2000", + pages = "184--198", + URL = "http://www.cs.cornell.edu/talc/papers/resource_bound/res.pdf", +} + +@InProceedings{crary-weirich-99, + author = "Karl Crary and Stephanie Weirich", + title = "Flexible Type Analysis", + booktitle = icfp, + pages = "233--248", + year = "1999", + URL = "http://www-2.cs.cmu.edu/~crary/papers/1999/lx/lx.ps.gz", +} + +@PhdThesis{cretin-14, + author = "Julien Cretin", + title = "Erasable coercions: a unified approach to type + systems", + school = "Université Paris Diderot", + year = "2014", + URL = "http://tel.archives-ouvertes.fr/tel-00940511", +} + +@InProceedings{cretin-remy-12, + author = "Julien Cretin and Didier R{\'e}my", + title = "On the power of coercion abstraction", + booktitle = popl, + year = "2012", + pages = "361--372", + URL = "http://gallium.inria.fr/~remy/coercions/Cretin-Remy:coercions@popl2012.pdf", +} + +@PhdThesis{curtis-90, + author = "Pavel Curtis", + title = "Constrained Quantification in Polymorphic Type + Analysis", + school = "Cornell University", + year = "1990", + URL = "http://www.parc.xerox.com/company/history/publications/bw-ps-gz/csl90-1.ps.gz", +} + +@InProceedings{cyclone-regions-02, + author = "Dan Grossman and Greg Morrisett and Trevor Jim and + Michael Hicks and Yanling Wang and James Cheney", + title = "Region-Based Memory Management in {Cyclone}", + booktitle = pldi, + pages = "282--293", + year = "2002", + URL = "http://www.cs.cornell.edu/projects/cyclone/papers/cyclone-regions.pdf", +} + +@InProceedings{dafny, + author = "K. Rustan M. Leino", + title = "{Dafny}: An Automatic Program Verifier for Functional + Correctness", + booktitle = lpar, + pages = "348--370", + year = "2010", + volume = "6355", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml203.pdf", +} + +@PhdThesis{damas-85, + author = "Luis Damas", + title = "Type Assignment in Programming Languages", + school = "University of Edinburgh", + year = "1985", +} + +@InProceedings{damas-milner-82, + author = "Luis Damas and Robin Milner", + title = "Principal type-schemes for functional programs", + booktitle = popl, + year = "1982", + pages = "207--212", + URL = "http://doi.acm.org/10.1145/582153.582176", +} + +@InProceedings{damm-josko-83, + author = "Werner Damm and Bernhard Josko", + title = "A Sound and Relatively$^*$ Complete Axiomatization of + {Clarke's} Language {L4}", + booktitle = "Logic of Programs", + pages = "161--175", + year = "1983", + volume = "164", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-12896-4_362", +} + +@InProceedings{danielsson-06, + author = "Nils Anders Danielsson and John Hughes and Patrik + Jansson and Jeremy Gibbons", + title = "Fast and loose reasoning is morally correct", + booktitle = popl, + year = "2006", + pages = "206--217", + URL = "http://web.comlab.ox.ac.uk/oucl/work/jeremy.gibbons/publications/fast+loose.pdf", +} + +@InProceedings{danielsson-08, + author = "Nils Anders Danielsson", + title = "Lightweight Semiformal Time Complexity Analysis for + Purely Functional Data Structures", + booktitle = popl, + year = "2008", + URL = "http://www.cse.chalmers.se/~nad/publications/danielsson-popl2008.pdf", +} + +@InProceedings{danielsson-altenkirch-10, + author = "Nils Anders Danielsson and Thorsten Altenkirch", + title = "Subtyping, Declaratively", + booktitle = mpc, + year = "2010", + pages = "100--118", + publisher = springer, + series = lncs, + volume = "6120", + URL = "http://www.cse.chalmers.se/~nad/publications/danielsson-altenkirch-subtyping.pdf", +} + +@InProceedings{danner-13, + author = "Norman Danner and Jennifer Paykin and James S. Royer", + title = "A static cost analysis for a higher-order language", + booktitle = plpv, + pages = "25--34", + year = "2013", + URL = "http://cis.upenn.edu/~jpaykin/papers/danner_PLPV_2013.pdf", +} + +@TechReport{danvy-98, + author = "Olivier Danvy", + title = "Functional Unparsing", + institution = "BRICS", + year = "1998", + number = "RS-98-12", + URL = "http://www.brics.dk/RS/98/12/", +} + +@TechReport{danvy-nielsen-01, + author = "Olivier Danvy and Lasse R. Nielsen", + title = "Defunctionalization at Work", + year = "2001", + institution = "BRICS", + number = "RS-01-23", + URL = "http://www.brics.dk/RS/01/23/", +} + +@InProceedings{danvy-nielsen-ppdp-01, + author = "Olivier Danvy and Lasse R. Nielsen", + title = "Defunctionalization at Work", + pages = "162--174", + booktitle = ppdp, + year = "2001", + URL = "http://doi.acm.org/10.1145/773184.773202", +} + +@Article{danvy-pearl-98, + author = "Olivier Danvy", + title = "Functional Unparsing", + journal = jfp, + year = "1998", + volume = "8", + number = "6", + pages = "621--625", + URL = "http://dx.doi.org/10.1017/S0956796898003104", +} + +@PhdThesis{dao-00, + author = "Thi Bich Hanh Dao", + title = "{R}ésolution de contraintes du premier ordre dans la + théorie des arbres finis ou infinis", + school = "Université de la Méditerranée", + year = "2000", + URL = "http://www.univ-orleans.fr/SCIENCES/LIFO/Members/dao/papers/ts4dec.ps.gz", +} + +@TechReport{davies-05, + author = "Rowan Davies", + title = "Practical Refinement-Type Checking", + institution = "School of Computer Science, Carnegie Mellon + University", + year = "2005", + number = "CMU-CS-05-110", + URL = "http://reports-archive.adm.cs.cmu.edu/anon/2005/CMU-CS-05-110.pdf", +} + +@InProceedings{davies-pfenning-00, + author = "Rowan Davies and Frank Pfenning", + title = "Intersection types and computational effects", + booktitle = icfp, + year = "2000", + pages = "198--208", + URL = "http://www.cs.cmu.edu/~fp/papers/icfp00.pdf", +} + +@Article{davis-logemann-loveland-62, + author = "Martin Davis and George Logemann and Donald Loveland", + title = "A machine program for theorem-proving", + journal = cacm, + volume = "5", + number = "7", + year = "1962", + pages = "394--397", + URL = "http://doi.acm.org/10.1145/368273.368557", +} + +@Article{davis-putnam-60, + author = "Martin Davis and Hilary Putnam", + title = "A Computing Procedure for Quantification Theory", + journal = jacm, + volume = "7", + number = "3", + year = "1960", + pages = "201--215", + URL = "http://doi.acm.org/10.1145/321033.321034", +} + +@Article{de-bruijn-72, + author = "Nicolaas G. de Bruijn", + title = "Lambda-Calculus Notation with Nameless Dummies: a Tool + for Automatic Formula Manipulation with Application to + the {Church-Rosser} Theorem", + journal = "Indag. Math.", + volume = "34", + number = "5", + year = "1972", + pages = "381--392", +} + +@InProceedings{delaware-3mt-13, + author = "Benjamin Delaware and Steven Keuchel and Tom + Schrijvers and Bruno C. d. S. Oliveira", + title = "Modular monadic meta-theory", + booktitle = icfp, + year = "2013", + pages = "319--330", + URL = "http://ropas.snu.ac.kr/~bruno/papers/3MT.pdf", +} + +@InProceedings{delaware-mtc-13, + author = "Benjamin Delaware and Bruno C. d. S. Oliveira and Tom + Schrijvers", + title = "Meta-theory à La Carte", + booktitle = popl, + year = "2013", + pages = "207--218", + URL = "http://people.csail.mit.edu/bendy/MTC/MTC.pdf", +} + +@InProceedings{delbianco-nanevski-13, + author = "Germ{\'{a}}n Andr{\'{e}}s Delbianco and Aleksandar + Nanevski", + title = "{Hoare}-style reasoning with (algebraic) + continuations", + booktitle = icfp, + pages = "363--376", + year = "2013", + URL = "http://software.imdea.org/~aleks/papers/callcc/icfp2013.pdf", +} + +@InProceedings{deline-faehndrich-01, + author = "Robert DeLine and Manuel Fähndrich", + title = "Enforcing High-Level Protocols in Low-Level Software", + booktitle = pldi, + pages = "59--69", + year = "2001", + URL = "http://research.microsoft.com/apps/pubs/default.aspx?id=67457", +} + +@InProceedings{deline-faehndrich-04, + author = "Robert DeLine and Manuel Fähndrich", + title = "Typestates for objects", + booktitle = ecoop, + pages = "465--490", + year = "2004", + volume = "3086", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/apps/pubs/default.aspx?id=67463", +} + +@TechReport{deline-faehndrich-fugue-04, + author = "Robert DeLine and Manuel Fähndrich", + title = "The {Fugue} Protocol Checker: Is Your Software + Baroque?", + institution = "Microsoft Research", + year = "2004", + number = "MSR-TR-2004-07", + URL = "http://research.microsoft.com/apps/pubs/default.aspx?id=67458", +} + +@InProceedings{delphin-08, + author = "Adam Poswolsky and Carsten Schürmann", + title = "Practical Programming with Higher-Order Encodings and + Dependent Types", + booktitle = esop, + pages = "93--107", + year = "2008", + volume = "4960", + series = lncs, + publisher = springer, + URL = "http://cs-www.cs.yale.edu/homes/delphin/files/delphinESOP08.pdf", +} + +@Article{delphin-09, + author = "Adam Poswolsky and Carsten Schürmann", + title = "System Description: {Delphin} -- {A} Functional + Programming Language for Deductive Systems", + journal = entcs, + volume = "228", + year = "2009", + pages = "113--120", + URL = "http://www.itu.dk/~carsten/papers/lfmtp-08.pdf", +} + +@Article{dencker-84, + author = "Peter Dencker and Karl Dürre and Johannes Heuft", + title = "Optimization of parser tables for portable compilers", + journal = toplas, + volume = "6", + number = "4", + year = "1984", + pages = "546--572", + URL = "http://doi.acm.org/10.1145/1780.1802", +} + +@Article{denning-77, + author = "Dorothy E. Denning and Peter J. Denning", + title = "Certification of Programs for Secure Information + Flow", + journal = cacm, + volume = "20", + number = "7", + pages = "504--513", + year = "1977", +} + +@Book{denning-82, + author = "Dorothy E. Denning", + title = "Cryptography and Data Security", + publisher = aw, + year = "1982", +} + +@InProceedings{dennis-sat-06, + author = "Greg Dennis and Felix Change and Daniel Jackson", + title = "Modular Verification of Code with {SAT}", + booktitle = issta, + year = "2006", + URL = "http://sdg.csail.mit.edu/pubs/2006/dennis_modular.pdf", +} + +@Article{denny-malloy-10, + author = "Joel E. Denny and Brian A. Malloy", + title = "The {IELR(1)} algorithm for generating minimal {LR(1)} + parser tables for non-{LR(1)} grammars with conflict + resolution", + journal = scp, + volume = "75", + number = "11", + pages = "943--979", + year = "2010", + URL = "http://dx.doi.org/10.1016/j.scico.2009.08.001", +} + +@Article{deremer-pennello-82, + author = "Frank DeRemer and Thomas Pennello", + title = "Efficient Computation of ${LALR}(1)$ Look-Ahead Sets", + journal = toplas, + volume = "4", + number = "4", + year = "1982", + pages = "615--649", + URL = "http://doi.acm.org/10.1145/69622.357187", +} + +@TechReport{deremer-phd-69, + author = "Franklin Lewis DeRemer", + title = "Practical Translators for {LR(k)} Languages", + institution = "Massachusetts Institute of Technology", + year = "1969", + type = "Technical Report", + number = "MIT-LCS-TR-065", + URL = "http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-065.pdf", +} + +@Article{deremer-slr-71, + author = "Franklin L. DeRemer", + title = "Simple ${LR}(k)$ grammars", + journal = cacm, + year = "1971", + volume = "14", + number = "7", + pages = "453--460", + URL = "http://dx.doi.org/10.1145/362619.362625", +} + +@TechReport{detlefs-98, + author = "David L. Detlefs and K. Rustan M. Leino and Greg + Nelson and James B. Saxe", + title = "Extended static checking", + institution = "Compaq SRC", + year = "1998", + type = "Research Report", + number = "159", + URL = "ftp://gatekeeper.research.compaq.com/pub/DEC/SRC/research-reports/SRC-159.pdf", +} + +@TechReport{detlefs-wrestling-98, + author = "David L. Detlefs and K. Rustan M. Leino and Greg + Nelson", + title = "Wrestling with rep exposure", + institution = "SRC", + year = "1998", + type = "Research Report", + number = "156", + URL = "http://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-156.pdf", +} + +@Book{dicosmo-95, + author = "Roberto {Di Cosmo}", + title = "Isomorphisms of types: from $\lambda$-calculus to + information retrieval and language design", + series = "Progress in Theoretical Computer Science", + publisher = "Birkhauser", + year = "1995", + URL = "http://www.pps.jussieu.fr/~dicosmo/Publications/ISObook.html", +} + +@Article{dicosmo-jfp-93, + author = "Roberto {Di Cosmo}", + title = "Deciding Type isomorphisms in a type assignment + framework", + journal = jfp, + year = "1993", + volume = "3", + number = "3", + pages = "485--525", + URL = "http://www.dicosmo.org/Articles/JFP94.dvi", +} + +@Article{dietl-drossopoulou-mueller-11, + author = "Werner Dietl and Sophia Drossopoulou and Peter + M{\"u}ller", + title = "Separating ownership topology and encapsulation with + generic universe types", + journal = toplas, + volume = "33", + number = "6", + year = "2011", + pages = "20", + URL = "http://pm.inf.ethz.ch/publications/getpdf.php?bibname=Own&id=DietlDrossopoulouMueller11.pdf", +} + +@Article{dietl-mueller-05, + author = "Werner Dietl and Peter M{\"u}ller", + title = "Universes: Lightweight Ownership for {JML}", + journal = jot, + year = "2005", + volume = "4", + number = "8", + pages = "5--32", + URL = "http://www.jot.fm/issues/issue_2005_10/article1.pdf", +} + +@Article{dijkstra-59, + author = "E. W. Dijkstra", + title = "A Note on Two Problems in Connection with Graphs", + journal = "Numerische Mathematik", + year = "1959", + volume = "1", + pages = "269--271", +} + +@Article{dijkstra-75, + author = "Edsger W. Dijkstra", + title = "Guarded commands, nondeterminacy and formal derivation + of programs", + journal = "Communications of the ACM", + volume = "18", + number = "8", + year = "1975", + pages = "453--457", + URL = "http://doi.acm.org/10.1145/360933.360975", +} + +@PhdThesis{dimock-02, + author = "Allyn Dimock", + title = "Type- and Flow-Directed Compilation for Specialized + Data Representations", + school = "Harvard University", + year = "2002", + URL = "http://www.cs.uml.edu/~dimock/thesis.ps.gz", +} + +@InProceedings{dimock-al-01, + author = "Allyn Dimock and Ian Westmacott and Robert Muller and + Franklyn Turbak and J. B. Wells", + title = "Functioning without closure: type-safe customized + function representations for {Standard ML}", + booktitle = icfp, + year = "2001", + URL = "http://puma.wellesley.edu/~fturbak/pubs/icfp01.ps", +} + +@InProceedings{dinsdale-young-views-13, + author = "Thomas Dinsdale-Young and Lars Birkedal and Philippa + Gardner and Matthew J. Parkinson and Hongseok Yang", + title = "Views: compositional reasoning for concurrent + programs", + booktitle = popl, + year = "2013", + pages = "287--300", + URL = "http://cs.au.dk/~birke/papers/views.pdf", +} + +@InProceedings{dinsdaleyoung-cap-10, + author = "Thomas Dinsdale-Young and Mike Dodds and Philippa + Gardner and Matthew J. Parkinson and Viktor Vafeiadis", + booktitle = ecoop, + publisher = springer, + title = "Concurrent Abstract Predicates", + series = lncs, + volume = "6183", + year = "2010", + pages = "504--528", + URL = "http://www.cl.cam.ac.uk/~md466/publications/ECOOP.10.concurrent_abstract_predicates.pdf", +} + +@TechReport{dinsdaleyoung-cap-tr-10, + author = "Thomas Dinsdale-Young and Mike Dodds and Philippa + Gardner and Matthew Parkinson and Viktor Vafeiadis", + title = "Concurrent Abstract Predicates", + institution = "University of Cambridge, Computer Laboratory", + year = "2010", + URL = "http://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-777.pdf", +} + +@InProceedings{distefano-parkinson-08, + author = "Dino Distefano and Matthew J. Parkinson", + title = "{jStar}: towards practical verification for {Java}", + booktitle = oopsla, + year = "2008", + pages = "213--226", + URL = "http://www.eecs.qmul.ac.uk/~ddino/papers/oopsla2008.pdf", +} + +@InProceedings{dockins-algebras-09, + author = "Robert Dockins and Aquinas Hobor and Andrew W. Appel", + title = "A Fresh Look at Separation Algebras and Share + Accounting", + booktitle = aplas, + year = "2009", + pages = "161--177", + publisher = springer, + series = lncs, + volume = "5904", + URL = "http://www.cs.princeton.edu/~appel/papers/fresh-sa.pdf", +} + +@InProceedings{dodds-11, + author = "Mike Dodds and Suresh Jagannathan and Matthew J. + Parkinson", + title = "Modular reasoning for deterministic parallelism", + booktitle = popl, + year = "2011", + pages = "259--270", + URL = "http://www.cl.cam.ac.uk/~md466/publications/POPL.11.deterministic_parallelism.pdf", +} + +@InProceedings{dodds-deny-guarantee-09, + author = "Mike Dodds and Xinyu Feng and Matthew J. Parkinson and + Viktor Vafeiadis", + title = "Deny-Guarantee Reasoning", + booktitle = esop, + year = "2009", + pages = "363--377", + publisher = springer, + series = lncs, + volume = "5502", + URL = "http://ttic.uchicago.edu/~feng/research/publications/DG.pdf", +} + +@Article{dodds-sync-16, + author = "Mike Dodds and Suresh Jagannathan and Matthew J. + Parkinson and Kasper Svendsen and Lars Birkedal", + title = "Verifying custom synchronization constructs using + higher-order separation logic", + journal = toplas, + year = "2016", + volume = "28", + number = "2", + URL = "http://dx.doi.org/10.1145/2818638", +} + +@InProceedings{donnelly-xi-05, + author = "Kevin Donnelly and Hongwei Xi", + title = "Combining higher-order abstract syntax with + first-order abstract syntax in {ATS}", + booktitle = merlin, + year = "2005", + pages = "58--63", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/merlin05.pdf", +} + +@Article{dornic-jouvelot-gifford-92, + author = "Vincent Dornic and Pierre Jouvelot and David K. + Gifford", + title = "Polymorphic time systems for estimating program + complexity", + journal = loplas, + volume = "1", + number = "1", + year = "1992", + pages = "33--45", + URL = "http://ropas.snu.ac.kr/lib/dock/DoJoGi1992.pdf", +} + +@InCollection{dowek-01, + author = "Gilles Dowek", + title = "Higher-order unification and matching", + booktitle = "Handbook of Automated Reasoning", + pages = "1009--1062", + publisher = elsevier, + year = "2001", + editor = "J. Alan Robinson and Andrei Voronkov", + URL = "http://www.lix.polytechnique.fr/~dowek/Publi/unification.ps", +} + +@TechReport{dowek-al-95, + author = "Gilles Dowek and Thérèse Hardin and Claude Kirchner", + title = "Higher Order Unification via Explicit Substitutions", + institution = "INRIA", + number = "2709", + year = "1995", + pages = "42", + type = "Research Report", + URL = "http://www.inria.fr/rrrt/rr-2709.html", +} + +@TechReport{dowek-al-98, + author = "Gilles Dowek and Thérèse Hardin and Claude Kirchner + and Frank Pfenning", + title = "Unification via Explicit Substitutions: the Case of + Higher-Order Patterns", + institution = "INRIA", + number = "3591", + year = "1998", + pages = "33", + type = "Research Report", + URL = "http://www.inria.fr/rrrt/rr-3591.html", +} + +@Article{dowling-gallier-84, + author = "William F. Dowling and Jean H. Gallier", + title = "Linear-Time Algorithms for Testing the Satisfiability + of Propositional {Horn} Formulae", + journal = jlp, + volume = "1", + number = "3", + year = "1984", + pages = "267--284", +} + +@Article{downey-sethi-tarjan-80, + author = "Peter J. Downey and Ravi Sethi and Robert Endre + Tarjan", + title = "Variations on the Common Subexpression Problem", + journal = jacm, + year = "1980", + volume = "27", + number = "4", + pages = "758--771", + URL = "http://doi.acm.org/10.1145/322217.322228", +} + +@InProceedings{dreyer-neis-birkedal-10, + author = "Derek Dreyer and Georg Neis and Lars Birkedal", + title = "The impact of higher-order state and control effects + on local relational reasoning", + booktitle = icfp, + pages = "143--156", + year = "2010", + URL = "https://www.mpi-sws.org/~dreyer/papers/stslr/icfp.pdf", +} + +@InProceedings{dubois-menissier-97, + author = "Catherine Dubois and Valérie Ménissier-Morain", + title = "Typage de {ML}: Spécification et preuve en {Coq}", + booktitle = "Actes du GDR Programmation", + year = "1997", + URL = "http://www.irisa.fr/lande/ridoux/GDR_annexe/dubois.ps.gz", +} + +@Article{dubois-menissier-99, + author = "Catherine Dubois and Valérie Ménissier-Morain", + title = "Certification of a Type Inference Tool for {ML}: + {Damas-Milner} within {Coq}", + journal = jar, + year = "1999", + volume = "23", + number = "3--4", + pages = "319--346", + URL = "http://www.ensiie.fr/~dubois/jar_final.pdf", +} + +@Article{duggan-bent-96, + author = "Dominic Duggan and Frederick Bent", + title = "Explaining type inference", + journal = scp, + year = "1996", + volume = "27", + number = "1", +} + +@InProceedings{dussart-henglein-mossin-95, + author = "Dirk Dussart and Fritz Henglein and Christian Mossin", + year = "1995", + title = "Polymorphic Recursion and Subtype Qualifications: + Polymorphic Binding-Time Analysis in Polynomial Time", + booktitle = sas, + publisher = springer, + series = lncs, + volume = "983", + pages = "118--135", + URL = "ftp://ftp.diku.dk/diku/semantics/papers/D-243.dvi.gz", +} + +@Article{dybvig-93, + author = "Kent Dybvig and Robert Hieb and Carl Bruggeman", + title = "Syntactic abstraction in {Scheme}", + journal = lsc, + year = "1993", + volume = "5", + number = "4", + pages = "295--326", + URL = "http://www.cs.indiana.edu/~dyb/pubs/LaSC-5-4-pp295-326.pdf", +} + +@InProceedings{eifrig-smith-trifonov-94, + author = "Jonathan Eifrig and Scott Smith and Valery Trifonov", + title = "Type Inference for Recursively Constrained Types and + its Application to {OOP}", + booktitle = mfps, + series = entcs, + publisher = elsevier, + volume = "1", + year = "1995", + URL = "http://www.cs.jhu.edu/~scott/ftp/ooinfer.ps.gz", +} + +@Article{eifrig-smith-trifonov-95, + author = "Jonathan Eifrig and Scott Smith and Valery Trifonov", + title = "Sound polymorphic type inference for objects", + journal = notices, + volume = "30", + number = "10", + year = "1995", + pages = "169--184", + URL = "http://www.cs.jhu.edu/~scott/ftp/sptio.ps.gz", +} + +@TechReport{elphin-04, + author = "Carsten Schürmann and Adam Poswolsky and Jeffrey + Sarnat", + title = "The $\nabla$-Calculus: Functional programming with + higher-order encodings", + institution = "Yale University", + number = "YALEU/DCS/TR-1272", + year = "2004", + URL = "http://www.cs.yale.edu/~delphin/files/nablaTR.pdf", +} + +@InProceedings{elphin-05, + author = "Carsten Schürmann and Adam Poswolsky and Jeffrey + Sarnat", + title = "The $\nabla$-Calculus: Functional programming with + higher-order encodings", + booktitle = tlca, + pages = "339--353", + year = "2005", + volume = "3461", + series = lncs, + publisher = springer, + URL = "http://www.itu.dk/~carsten/papers/nabla.pdf", +} + +@InProceedings{emerson-lei-86, + author = "E. Allen Emerson and Chin-Laung Lei", + title = "Efficient Model Checking in Fragments of the + Propositional Mu-Calculus", + booktitle = lics, + year = "1986", + pages = "267--278", +} + +@TechReport{emms-leiss-96, + author = "Martin Emms and Hans Lei{\ss}", + title = "Extending the Type Checker for {SML} by Polymorphic + Recursion --- {A} Correctness Proof", + institution = "Centrum f{\"{u}}r Informations- und + Sprachverarbeitung, Universit{\"{a}}t M{\"{u}}nchen", + year = "1996", + number = "96-101", + URL = "http://www.cis.uni-muenchen.de/~leiss/polyrec/polyrec.cisbericht.96-101.ps.gz", +} + +@Book{eopl, + author = "Daniel P. Friedman and Mitchell Wand", + title = "Essentials of Programming Languages, 3rd Edition", + publisher = mitp, + year = "2008", + URL = "http://www.eopl3.com/", +} + +@Unpublished{epigram-05, + author = "Thorsten Altenkirch and Conor McBride and James + McKinna", + title = "Why Dependent Types Matter", + note = "Unpublished", + year = "2005", + URL = "http://www.e-pig.org/downloads/ydtm.pdf", +} + +@Misc{ergo, + author = "Sylvain Conchon and Evelyne Contejean", + title = "The {Alt-Ergo} Automatic Theorem Prover", + note = "\url{http://alt-ergo.lri.fr/}", + year = "2011", + URL = "http://alt-ergo.lri.fr/", +} + +@InProceedings{erlingsson-schneider-00, + author = "{\'U}lfar Erlingsson and Fred B. Schneider", + title = "{IRM} Enforcement of {Java} Stack Inspection", + booktitle = sp, + year = "2000", + pages = "246--255", + URL = "http://csdl.computer.org/comp/proceedings/sp/2000/0665/00/06650246abs.htm", +} + +@InProceedings{erlingsson-schneider-99, + author = "{\'U}lfar Erlingsson and Fred B. Schneider", + title = "{SASI} Enforcement of Security Policies: a + Retrospective", + booktitle = nspw, + pages = "87--95", + year = "1999", + URL = "http://www.cs.cornell.edu/fbs/publications/sasiNSPW.ps", +} + +@InProceedings{esparza-13, + author = "Javier Esparza and Peter Lammich and Ren{\'e} Neumann + and Tobias Nipkow and Alexander Schimpf and Jan-Georg + Smaus", + title = "A Fully Verified Executable {LTL} Model Checker", + booktitle = cav, + pages = "463--478", + year = "2013", + series = lncs, + volume = "8044", + publisher = springer, + URL = "https://www21.in.tum.de/~nipkow/pubs/cav13.pdf", +} + +@InProceedings{esparza-efficient-00, + author = "Javier Esparza and David Hansel and Peter Rossmanith + and Stefan Schwoon", + title = "Efficient Algorithms for Model Checking Pushdown + Systems", + booktitle = cav, + pages = "232--247", + year = "2000", + series = lncs, + volume = "1855", + publisher = springer, + URL = "https://www7.in.tum.de/um/bibdb/esparza/cav00.pdf", +} + +@Misc{f7, + author = "Karthik Bhargavan and Cédric Fournet and Andy Gordon + and Sergio Maffeis and Jesper Bengtson", + title = "The {F7} Typechecker", + note = "\url{http://research.microsoft.com/en-us/projects/f7/}", + year = "2011", + URL = "http://research.microsoft.com/en-us/projects/f7/", +} + +@Misc{facebook-infer, + author = "Cristiano Calcagno and Dino Distefano and Peter + O'Hearn", + title = "Open-sourcing {Facebook Infer}: Identify bugs before + you ship", + howpublished = "\url{https://code.facebook.com/posts/1648953042007882/open-sourcing-facebook-infer-identify-bugs-before-you-ship/}", + year = "2015", +} + +@InProceedings{faehndrich-al-00, + author = "Manuel Fähndrich and Jakob Rehof and Manuvir Das", + title = "Scalable Context-Sensitive Flow Analysis Using + Instantiation Constraints", + booktitle = pldi, + year = "2000", + URL = "http://research.microsoft.com/pubs/67468/pldi00.ps", +} + +@InProceedings{faehndrich-cycles-98, + author = "Manuel Fähndrich and Jeffrey S. Foster and Zhendong Su + and Alexander S. Aiken", + title = "Partial Online Cycle Elimination in Inclusion + Constraint Graphs", + booktitle = pldi, + year = "1998", + pages = "85--96", + URL = "http://research.microsoft.com/pubs/67475/pldi98.pdf", +} + +@InProceedings{faehndrich-deline-02, + author = "Manuel Fähndrich and Robert DeLine", + title = "Adoption and focus: practical linear types for + imperative programming", + booktitle = pldi, + year = "2002", + pages = "13--24", + URL = "http://research.microsoft.com/pubs/67459/pldi02.pdf", +} + +@InProceedings{faehndrich-leino-03, + author = "Manuel Fähndrich and Rustan Leino", + title = "Heap Monotonic Typestates", + booktitle = "International Workshop on Alias Confinement and + Ownership (IWACO)", + year = "2003", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml123.pdf", +} + +@PhdThesis{faehndrich-phd-99, + school = "University of California at Berkeley", + title = "Bane: {A} Library for Scalable Constraint-Based + Program Analysis", + year = "1999", + author = "Manuel Fähndrich", + URL = "http://research.microsoft.com/pubs/67479/thesis-compact.pdf", +} + +@InProceedings{faehndrich-singularity-06, + author = "Manuel Fähndrich and Mark Aiken and Chris Hawblitzel + and Orion Hodson and Galen Hunt and James R. Larus and + Steven Levi", + title = "Language support for fast and reliable message-based + communication in {Singularity OS}", + booktitle = eurosys, + year = "2006", + pages = "177--190", + URL = "http://www.cs.kuleuven.ac.be/conference/EuroSys2006/papers/p177-fahndrich.pdf", +} + +@Article{faxen-02, + author = "Karl-Filip Fax\'{e}n", + title = "A Static Semantics for {Haskell}", + pages = "295--357", + year = "2002", + journal = jfp, + volume = "12", + number = "4--5", + URL = "http://www.it.kth.se/~kff/semantics.ps.gz", +} + +@Article{fecht-seidl-99, + author = "Christian Fecht and Helmut Seidl", + title = "A Faster Solver for General Systems of Equations", + journal = scp, + year = "1999", + volume = "35", + number = "2--3", + pages = "137--162", + URL = "http://www2.in.tum.de/~seidl/papers/final-solver.ps.gz", +} + +@InProceedings{felleisen-flanagan-componential-97, + author = "Cormac Flanagan and Matthias Felleisen", + title = "Componential Set-Based Analysis", + booktitle = pldi, + year = "1997", + pages = "235--248", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/pldi97-ff.ps.gz", +} + +@TechReport{felleisen-flanagan-theory-practice-96, + number = "TR96-266", + institution = "Rice University", + title = "Modular and Polymorphic Set-Based Analysis: Theory and + Practice", + year = "1996", + pages = "48", + author = "Cormac Flanagan and Matthias Felleisen", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/tr96-266.ps.gz", +} + +@PhdThesis{fenton-73, + school = "University of Cambridge", + title = "Information Protection Systems", + year = "1973", + author = "J. S. Fenton", +} + +@Article{fenton-74, + author = "J. S. Fenton", + title = "Memoryless Subsystems", + journal = cj, + volume = "17", + number = "2", + pages = "143--147", + year = "1974", +} + +@Article{fftw-05, + author = "Matteo Frigo and Steven G. Johnson", + title = "The Design and Implementation of {FFTW3}", + journal = pieee, + year = "2005", + volume = "93", + number = "2", + pages = "216--231", + URL = "http://www.fftw.org/fftw-paper-ieee.pdf", +} + +@InProceedings{field-teitelbaum-90, + author = "John Field and Tim Teitelbaum", + title = "Incremental Reduction in the Lambda Calculus", + booktitle = lfp, + year = "1990", + pages = "307--322", +} + +@InProceedings{filinski-99, + author = "Andrzej Filinski", + title = "Representing Layered Monads", + booktitle = popl, + year = "1999", + pages = "175--188", + URL = "http://www.diku.dk/~andrzej/papers/RLM.ps.gz", +} + +@Article{filliatre-00, + author = "Jean-Christophe Filliâtre", + title = "Verification of Non-Functional Programs using + Interpretations in Type Theory", + journal = jfp, + volume = "13", + number = "4", + pages = "709--745", + year = "2003", + URL = "http://www.lri.fr/~filliatr/ftp/publis/jphd.ps.gz", +} + +@InProceedings{filliatre-06, + author = "Jean-Christophe Filli\^atre", + title = "Backtracking iterators", + booktitle = ml, + year = "2006", + pages = "55--62", + URL = "http://www.lri.fr/~filliatr/publis/enum2.ps.gz", +} + +@InProceedings{filliatre-conchon-06, + author = "Jean-Christophe Filli{\^a}tre and Sylvain Conchon", + title = "Type-safe modular hash-consing", + booktitle = ml, + pages = "12--19", + year = "2006", + URL = "https://www.lri.fr/~filliatr/ftp/publis/hash-consing2.pdf", +} + +@Article{filliatre-find-06, + author = "Jean-Christophe Filliâtre", + title = "Formal Proof of a Program: {Find}", + journal = scp, + year = "2006", + volume = "64", + pages = "332--240", + URL = "http://www.lri.fr/~filliatr/ftp/publis/find.ps.gz", +} + +@InProceedings{filliatre-ghost-14, + author = "Jean{-}Christophe Filli{\^{a}}tre and L{\'{e}}on + Gondelman and Andrei Paskevich", + title = "The Spirit of Ghost Code", + booktitle = cav, + pages = "1--16", + year = "2014", + series = lncs, + volume = "8559", + publisher = springer, + URL = "https://hal.archives-ouvertes.fr/hal-00873187/PDF/main.pdf", +} + +@InProceedings{filliatre-letouzey-04, + author = "Jean-Christophe Filliâtre and Pierre Letouzey", + title = "Functors for Proofs and Programs", + booktitle = esop, + pages = "370--384", + year = "2004", + volume = "2986", + series = lncs, + publisher = springer, + URL = "http://www.lri.fr/~filliatr/ftp/publis/fpp.ps.gz", +} + +@InProceedings{filliatre-marche-04, + author = "Jean-Christophe Filliâtre and Claude Marché", + title = "Multi-Prover Verification of {C} Programs", + booktitle = icfem, + year = "2004", + publisher = springer, + series = lncs, + volume = "3308", + pages = "15--29", + URL = "http://www.lri.fr/~filliatr/ftp/publis/caduceus.ps.gz", +} + +@InProceedings{filliatre-pereira-16, + author = "Jean{-}Christophe Filli{\^{a}}tre and M{\'{a}}rio + Pereira", + title = "A Modular Way to Reason About Iteration", + booktitle = nfm, + pages = "322--336", + year = "2016", + series = lncs, + volume = "9690", + publisher = springer, + URL = "https://hal.inria.fr/hal-01281759", +} + +@InProceedings{findler-felleisen-02, + author = "Robert Bruce Findler and Matthias Felleisen", + title = "Contracts for higher-order functions", + booktitle = icfp, + year = "2002", + pages = "48--59", + URL = "http://people.cs.uchicago.edu/~robby/pubs/papers/ho-contracts-icfp2002.pdf", +} + +@Article{fischbach-hannan-02, + author = "Adam Fischbach and John Hannan", + title = "Specification and Correctness of Lambda Lifting", + journal = jfp, + year = "2003", + volume = "13", + number = "3", + pages = "509--543", + URL = "http://dx.doi.org/10.1017/S0956796802004604", +} + +@Article{fisher-mitchell-98, + author = "Kathleen Fisher and John C. Mitchell", + title = "On the Relationship between Classes, Objects and Data + Abstraction", + journal = tapos, + year = "1998", + volume = "4", + number = "1", + pages = "3--25", + URL = "http://www.research.att.com/~kfisher/files/tapos98.ps", +} + +@InProceedings{flanagan-abadi-99, + author = "Cormac Flanagan and Mart\'{\i}n Abadi", + title = "Types for Safe Locking", + booktitle = esop, + year = "1999", + pages = "91--108", + publisher = springer, + series = lncs, + volume = "1576", + URL = "http://users.soe.ucsc.edu/~cormac/papers/esop99.pdf", +} + +@InProceedings{flanagan-al-93, + author = "Cormac Flanagan and Amr Sabry and Bruce F. Duba and + Matthias Felleisen", + title = "The Essence of Compiling with Continuations", + booktitle = pldi, + year = "1993", + pages = "237--247", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/pldi93-fsdf.ps.gz", +} + +@InProceedings{flanagan-al-96, + author = "Cormac Flanagan and Matthew Flatt and Shriram + Krishnamurthi and Stephanie Weirich and Matthias + Felleisen", + year = "1996", + booktitle = pldi, + title = "Catching Bugs in the Web of Program Invariants", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/pldi96-ffkwf.ps.gz", +} + +@PhdThesis{flanagan-effective-97, + school = "Rice University", + title = "Effective Static Debugging via Componential Set-Based + Analysis", + year = "1997", + pages = "164", + author = "Cormac Flanagan", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/thesis-flanagan.ps.gz", +} + +@InProceedings{flanagan-esc-02, + author = "Cormac Flanagan and K. Rustan M. Leino and Mark + Lillibridge and Greg Nelson and James B. Saxe and + Raymie Stata", + title = "Extended Static Checking for {Java}", + booktitle = pldi, + pages = "234--245", + year = "2002", + URL = "http://www.soe.ucsc.edu/~cormac/papers/pldi02.ps", +} + +@InProceedings{flanagan-saxe-01, + author = "Cormac Flanagan and James B. Saxe", + title = "Avoiding exponential explosion: generating compact + verification conditions", + booktitle = popl, + year = "2001", + pages = "193--205", + URL = "http://www.soe.ucsc.edu/~cormac/papers/popl01.ps", +} + +@InProceedings{floyd-67, + author = "R. W. Floyd", + title = "Assigning meanings to programs", + booktitle = "Mathematical Aspects of Computer Science", + series = "Proceedings of Symposia in Applied Mathematics", + volume = "19", + year = "1967", + organization = ams, + pages = "19--32", + URL = "https://people.eecs.berkeley.edu/~necula/Papers/FloydMeaning.pdf", +} + +@InProceedings{fluet-02, + author = "Matthew Fluet and Riccardo Pucella", + title = "Phantom types and subtyping", + booktitle = tcsconf, + pages = "448--460", + year = "2002", + URL = "http://arXiv.org/abs/cs.PL/0403034", +} + +@InProceedings{fluet-al-06, + author = "Matthew Fluet and Greg Morrisett and Amal Ahmed", + title = "Linear Regions Are All You Need", + booktitle = esop, + pages = "7--21", + year = "2006", + volume = "3924", + series = lncs, + publisher = springer, + URL = "http://ttic.uchicago.edu/~fluet/research/substruct-regions/ESOP06/esop06.pdf", +} + +@PhdThesis{fluet-phd-07, + author = "Matthew Fluet", + title = "Monadic and Substructural Type Systems for + Region-Based Memory Management", + school = "Cornell University", + year = "2007", + URL = "http://ttic.uchicago.edu/~fluet/research/thesis/fluet-thesis.single.pdf", +} + +@InProceedings{fluet-pucella-02, + author = "Matthew Fluet and Riccardo Pucella", + title = "Phantom Types and Subtyping", + booktitle = ifiptcs, + pages = "448--460", + year = "2002", + volume = "223", + series = "IFIP Conference Proceedings", + publisher = kluwer, + URL = "http://www.cs.cornell.edu/people/fluet/phantom-subtyping/TCS02/tcs02.ps", +} + +@InProceedings{fluet-pucella-05, + author = "Matthew Fluet and Riccardo Pucella", + title = "Practical Datatype Specializations with Phantom Types + and Recursion Schemes", + booktitle = ml, + year = "2005", + series = entcs, + URL = "http://www.cs.cornell.edu/people/fluet/specializations/MLWRK05/mlwrk05.pdf", +} + +@Article{focardi-gorrieri-95, + author = "Riccardo Focardi and Roberto Gorrieri", + title = "A classification of security properties for process + algebras", + journal = "Journal of Computer Security", + volume = "3", + number = "1", + pages = "5--33", + year = "1995", + URL = "http://www.cs.unibo.it/~gorrieri/Papers/jcsfinal.ps.gz", +} + +@InProceedings{ford-02, + author = "Bryan Ford", + title = "Packrat parsing: simple, powerful, lazy, linear time", + booktitle = icfp, + year = "2002", + pages = "36--47", + URL = "http://www.brynosaurus.com/pub/lang/packrat-icfp02.pdf", +} + +@InProceedings{ford-04, + author = "Bryan Ford", + title = "Parsing expression grammars: a recognition-based + syntactic foundation", + booktitle = popl, + year = "2004", + pages = "111--122", + URL = "http://pdos.csail.mit.edu/~baford/packrat/popl04/peg-popl04.pdf", +} + +@TechReport{foster-aiken-restrict-01, + author = "Jeffrey S. Foster and Alex Aiken", + institution = "University of California, Berkeley", + title = "Checking Programmer-Specified Non-Aliasing", + year = "2001", + number = "UCB//CSD-01-1160", + URL = "http://www.cs.umd.edu/~jfoster/papers/tr01-restrict.pdf", +} + +@InProceedings{foster-flow-sensitive-qualifiers-02, + author = "Jeffrey S. Foster and Tachio Terauchi and Alex Aiken", + title = "Flow-Sensitive Type Qualifiers", + booktitle = pldi, + year = "2002", + pages = "1--12", + URL = "http://www.cs.umd.edu/~jfoster/papers/pldi02.pdf", +} + +@Article{fournet-al-join-03, + author = "Cédric Fournet and Cosimo Laneve and Luc Maranget and + Didier Rémy", + journal = jlap, + title = "Inheritance in the Join Calculus", + volume = "57", + number = "2", + pages = "23--69", + year = "2003", + URL = "http://gallium.inria.fr/~remy/work/ojoin/jojoin.pdf", +} + +@InProceedings{fournet-al-join-97, + author = "Cédric Fournet and Luc Maranget and Cosimo Laneve and + Didier Rémy", + title = "Implicit typing à la {ML} for the join-calculus", + booktitle = concur, + series = lncs, + publisher = springer, + volume = "1243", + pages = "196--212", + year = "1997", + URL = "http://gallium.inria.fr/~remy/ftp/typing-join.pdf", +} + +@InProceedings{fournet-gonthier-96, + author = "Cédric Fournet and Georges Gonthier", + title = "The Reflexive Chemical Abstract Machine and the + Join-Calculus", + booktitle = popl, + pages = "372--385", + year = "1996", + URL = "http://research.microsoft.com/~fournet/papers/reflexive-cham-join-calculus.ps", +} + +@InProceedings{fournet-gordon-02, + author = "Cédric Fournet and Andrew D. Gordon", + title = "Stack Inspection: Theory and Variants", + booktitle = popl, + pages = "307--318", + year = "2002", + URL = "http://research.microsoft.com/~fournet/papers/stack-inspection-theory-and-variants-popl-02.ps", +} + +@Article{fournet-gordon-03, + author = "Cédric Fournet and Andrew D. Gordon", + title = "Stack Inspection: Theory and Variants", + journal = toplas, + year = "2003", + volume = "25", + number = "3", + pages = "360--399", + URL = "http://doi.acm.org/10.1145/641909.641912", +} + +@Article{francalanza-rathke-sassone-2011, + author = "Adrian Francalanza and Julian Rathke and Vladimiro + Sassone", + title = "Permission-Based Separation Logic for Message-Passing + Concurrency", + journal = lmcs, + volume = "7", + number = "3", + year = "2011", + URL = "http://arxiv.org/abs/1106.5128", +} + +@InProceedings{fredman-saks-89, + author = "Michael Fredman and Michael Saks", + title = "The Cell Probe Complexity of Dynamic Data Structures", + pages = "345--354", + booktitle = "Annual Symposium on Theory of Computing ({STOC})", + publisher = "ACM", + year = "1989", + URL = "http://dx.doi.org/10.1145/73007.73040", +} + +@Article{fredman-tarjan-87, + author = "Michael L. Fredman and Robert Endre Tarjan", + title = "Fibonacci heaps and their uses in improved network + optimization algorithms", + journal = jacm, + volume = "34", + number = "3", + year = "1987", + pages = "596--615", + URL = "http://doi.acm.org/10.1145/28869.28874", +} + +@InProceedings{freeman-91, + author = "Tim Freeman and Frank Pfenning", + title = "Refinement types for {ML}", + booktitle = pldi, + pages = "268--277", + year = "1991", + URL = "http://www.cs.cmu.edu/~fp/papers/pldi91.pdf", +} + +@TechReport{fresh-ocaml, + author = "Mark R. Shinwell and Andrew M. Pitts", + year = "2005", + title = "{Fresh Objective Caml} user manual", + institution = "University of Cambridge", + number = "621", + URL = "http://www.cl.cam.ac.uk/TechReports/UCAM-CL-TR-621.pdf", +} + +@PhdThesis{frey-04, + author = "Alexandre Frey", + title = "Approche algébrique du typage d'un langage à la {ML} + avec objets, sous-typage et multi-méthodes", + school = "École des Mines de Paris", + year = "2004", + URL = "http://gallium.inria.fr/~remy/students/alexandre.frey.pdf", +} + +@InProceedings{frey-97, + author = "Alexandre Frey", + title = "Satisfying Subtype Inequalities in Polynomial Space", + booktitle = sas, + series = lncs, + number = "1302", + year = "1997", + pages = "265--277", + publisher = springer, + URL = "http://citeseer.ist.psu.edu/frey97satisfying.html", + alturl = "http://dx.doi.org/10.1016/S0304-3975(00)00314-5", +} + +@InProceedings{frisch-castagna-benzaken-02, + author = "Alain Frisch and Giuseppe Castagna and V{\'e}ronique + Benzaken", + title = "Semantic Subtyping", + booktitle = lics, + year = "2002", + pages = "137--146", + URL = "http://www.cduce.org/papers/lics02.ps.gz", +} + +@Article{frisch-castagna-benzaken-08, + author = "Alain Frisch and Giuseppe Castagna and V{\'e}ronique + Benzaken", + title = "Semantic subtyping: Dealing set-theoretically with + function, union, intersection, and negation types", + journal = jacm, + volume = "55", + number = "4", + year = "2008", + URL = "http://www.pps.univ-paris-diderot.fr/~gc/papers/semantic_subtyping.pdf", +} + +@InProceedings{fstar, + author = "Nikhil Swamy and Juan Chen and C{\'e}dric Fournet and + Pierre-Yves Strub and Karthik Bhargavan and Jean Yang", + title = "Secure distributed programming with value-dependent + types", + booktitle = icfp, + year = "2011", + pages = "266--278", + URL = "http://research.microsoft.com/pubs/150012/icfp-camera-ready.pdf", +} + +@InProceedings{fuh-mishra-88, + author = "You-Chin Fuh and Prateek Mishra", + title = "Type inference with subtypes", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "300", + year = "1988", + pages = "94--114", + URL = "http://dx.doi.org/10.1007/3-540-19027-9_7", +} + +@InProceedings{fuh-mishra-gap-89, + author = "You-Chin Fuh and Prateek Mishra", + title = "Polymorphic Subtype Inference: Closing the + Theory-Practice Gap", + pages = "167--183", + booktitle = tapsoft, + series = lncs, + volume = "352", + publisher = springer, + year = "1989", + URL = "http://dx.doi.org/10.1007/3-540-50940-2_35", +} + +@InProceedings{furuse-03, + author = "Jun Furuse", + title = "Extensional Polymorphism by Flow Graph Dispatching", + booktitle = aplas, + publisher = springer, + series = lncs, + volume = "2895", + year = "2003", + URL = "http://gallium.inria.fr/~furuse/publications/flowgraph.ps.gz", +} + +@PhdThesis{gabbay-01, + author = "Murdoch J. Gabbay", + title = "A Theory of Inductive Definitions with + $\alpha$-Equivalence", + school = "Cambridge University", + year = "2001", + URL = "http://www.macs.hw.ac.uk/~gabbay/papers/thesis.pdf", +} + +@Unpublished{gabbay-04, + author = "Murdoch J. Gabbay", + title = "A General Mathematics of Names in Syntax", + year = "2004", + note = "Submitted for publication", + URL = "http://www.macs.hw.ac.uk/~gabbay/papers/genmns.pdf", +} + +@Article{gabbay-pitts-02, + author = "Murdoch J. Gabbay and Andrew M. Pitts", + title = "A New Approach to Abstract Syntax with Variable + Binding", + journal = fac, + year = "2002", + volume = "13", + number = "3--5", + pages = "341--363", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/newaas/newaas-jv.pdf", + alturl = "http://www.springerlink.com/link.asp?id=epn028x83rqw00qv", +} + +@Article{galil-italiano-91, + author = "Zvi Galil and Giuseppe F. Italiano", + title = "Data Structures and Algorithms for Disjoint Set Union + Problems", + journal = surveys, + volume = "23", + number = "3", + pages = "319--344", + year = "1991", + URL = "http://doi.acm.org/10.1145/116873.116878", +} + +@Article{galler-fischer-64, + author = "Bernard A. Galler and Michael J. Fischer", + title = "An improved equivalence algorithm", + journal = cacm, + volume = "7", + number = "5", + pages = "301--303", + year = "1964", + URL = "http://doi.acm.org/10.1145/364099.364331", +} + +@Article{gapeyev-levin-pierce-00, + author = "Vladimir Gapeyev and Michael Levin and Benjamin + Pierce", + title = "Recursive Subtyping Revealed", + journal = jfp, + volume = "12", + number = "6", + pages = "511--548", + year = "2002", + URL = "http://dx.doi.org/10.1017/S0956796802004318", +} + +@InProceedings{gardner-ntizk-wright-14, + author = "Philippa Gardner and Gian Ntzik and Adam Wright", + title = "Local Reasoning for the {POSIX} File System", + booktitle = esop, + pages = "169--188", + year = "2014", + series = lncs, + volume = "8410", + publisher = springer, + URL = "https://www.doc.ic.ac.uk/~gn408/POSIXFS/esop2014.pdf", +} + +@Book{garey-johnson-79, + author = "Michael R. Garey and David S. Johnson", + title = "Computers and Intractability: {A} Guide to the Theory + of {NP}-Completeness", + year = "1979", + publisher = "W. H. Freeman and Company", +} + +@InProceedings{garrigue-00, + author = "Jacques Garrigue", + title = "Code reuse through polymorphic variants", + booktitle = fse, + year = "2000", + URL = "http://www.math.nagoya-u.ac.jp/~garrigue/papers/variant-reuse.ps.gz", +} + +@InProceedings{garrigue-02, + author = "Jacques Garrigue", + title = "Simple Type Inference for Structural Polymorphism", + booktitle = fool, + year = "2002", + URL = "http://www.math.nagoya-u.ac.jp/~garrigue/papers/structural-inf.ps.gz", +} + +@InProceedings{garrigue-98, + author = "Jacques Garrigue", + title = "Programming with polymorphic variants", + booktitle = ml, + year = "1998", + URL = "http://www.math.nagoya-u.ac.jp/~garrigue/papers/variants.ps.gz", +} + +@TechReport{garrigue-furuse-95, + author = "Jun P. Furuse and Jacques Garrigue", + title = "A label-selective lambda-calculus with optional + arguments and its compilation method", + institution = "Kyoto University", + year = "1995", + type = "RIMS Preprint", + number = "1041", + URL = "http://wwwfun.kurims.kyoto-u.ac.jp/~garrigue/papers/rims-1041.pdf", +} + +@InProceedings{garrigue-relax-04, + author = "Jacques Garrigue", + title = "Relaxing the Value Restriction", + booktitle = flops, + pages = "196--213", + year = "2004", + volume = "2998", + series = lncs, + publisher = springer, + URL = "http://www.math.nagoya-u.ac.jp/~garrigue/papers/morepoly-long.pdf", +} + +@Article{garrigue-remy-99, + author = "Jacques Garrigue and Didier R{\'e}my", + title = "Extending {ML} with Semi-Explicit Higher-Order + Polymorphism", + journal = ic, + year = "1999", + volume = "155", + number = "1", + pages = "134--169", + URL = "http://gallium.inria.fr/~remy/ftp/iandc.pdf", +} + +@InProceedings{garrigue-remy-gadts-13, + author = "Jacques Garrigue and Didier R{\'e}my", + title = "Ambivalent types for principal type inference with + {GADT}s", + booktitle = aplas, + year = "2013", + URL = "http://gallium.inria.fr/~remy/gadts/Garrigue-Remy:gadts@aplas2013.pdf", +} + +@PhdThesis{gaster-98, + author = "Benedict R. Gaster", + title = "Records, variants and qualified types", + school = "University of Nottingham", + year = "1998", + URL = "http://www.cs.nott.ac.uk/Research/fop/gaster-thesis.ps", +} + +@TechReport{gaster-jones-96, + author = "Benedict R. Gaster and Mark P. Jones", + title = "A Polymorphic Type System for Extensible Records and + Variants", + institution = "Department of Computer Science, University of + Nottingham", + year = "1996", + number = "NOTTCS-TR-96-3", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/polyrec.html", +} + +@InProceedings{gauthier-pottier-04, + author = "Nadji Gauthier and François Pottier", + title = "Numbering Matters: First-Order Canonical Forms for + Second-Order Recursive Types", + booktitle = icfp, + URL = "http://gallium.inria.fr/~fpottier/publis/gauthier-fpottier-icfp04.pdf", + year = "2004", + pages = "150--161", +} + +@InProceedings{gay-modular-session-types-10, + author = "Simon J. Gay and Vasco Thudichum Vasconcelos and + Ant{\'o}nio Ravara and Nils Gesbert and Alexandre Z. + Caldeira", + title = "Modular session types for distributed object-oriented + programming", + booktitle = popl, + year = "2010", + pages = "299--312", + URL = "http://www.dcs.gla.ac.uk/~simon/publications/ModularSessionTypes.pdf", +} + +@InProceedings{german-clarke-halpern-83, + author = "Steven German and Edmund Clarke and Joseph Halpern", + title = "Reasoning About Procedures as Parameters", + booktitle = "Logic of Programs", + pages = "206--220", + year = "1983", + volume = "164", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-12896-4_365", +} + +@TechReport{geser-chaotic-94, + author = "Alfons Geser and Jens Knoop and Gerald Lüttgen and + Oliver Rüthing and Bernhard Steffen", + title = "Chaotic fixed point iterations", + institution = "Fakultät für Mathematik und Informatik, Universität + Passau", + year = "1994", + type = "MIP-Bericht", + number = "9403", + URL = "http://citeseer.ist.psu.edu/190778.html", +} + +@Manual{ghc, + author = "The GHC team", + title = "The {Glasgow Haskell} compiler", + year = "2005", + URL = "http://www.haskell.org/ghc/", +} + +@Article{ghelli-divergence-95, + title = "Divergence of {$F_\leq$} type checking", + author = "Giorgio Ghelli", + journal = tcs, + pages = "131--162", + year = "1995", + volume = "139", + number = "1--2", + URL = "ftp://ftp.di.unipi.it/pub/Papers/ghelli/DivergenceFsubTCS95.ps.gz", +} + +@InProceedings{gherghina-structured-11, + author = "Cristian Gherghina and Cristina David and Shengchao + Qin and Wei-Ngan Chin", + title = "Structured Specifications for Better Verification of + Heap-Manipulating Programs", + year = "2011", + pages = "386--401", + booktitle = fm, + publisher = springer, + series = lncs, + volume = "6664", + URL = "http://loris-7.ddns.comp.nus.edu.sg/~project/hip/publications/FM_2011_Case.pdf", +} + +@TechReport{gifford-fx-87, + author = "David K. Gifford and Pierre Jouvelot and John M. + Lucassen and Mark A. Sheldon", + title = "{FX-87} Reference Manual", + institution = "Massachusetts Institute of Technology", + year = "1987", + number = "MIT/LCS/TR-407", +} + +@TechReport{gifford-fx-91, + author = "David K. Gifford and Pierre Jouvelot and Mark A. + Sheldon and James W. O'Toole", + title = "Report on the {FX-91} Programming Language", + institution = "Massachusetts Institute of Technology", + year = "1992", + number = "MIT/LCS/TR-531", + URL = "http://www.psrg.lcs.mit.edu/history/publications.html#fxps", +} + +@PhdThesis{girard-72, + author = "Jean-Yves Girard", + title = "Interprétation fonctionnelle et élimination des + coupures de l'arith\-mé\-ti\-que d'ordre supérieur", + school = "Universit{\'e} Paris 7", + type = "Th\`ese d'\'Etat", + year = "1972", +} + +@Article{girard-87, + author = "Jean-Yves Girard", + title = "Linear logic", + journal = tcs, + year = "1987", + volume = "50", + number = "1", + pages = "1--102", + URL = "http://iml.univ-mrs.fr/~girard/linear.pdf", +} + +@InProceedings{glew-00, + author = "Neal Glew", + title = "An Efficient Class and Object Encoding", + booktitle = oopsla, + pages = "311--324", + year = "2000", + URL = "http://glew.org/nglew/papers/oce-oopsla.ps.gz", +} + +@InProceedings{glew-02, + author = "Neal Glew", + title = "A Theory of Second-Order Trees", + booktitle = esop, + pages = "147--161", + year = "2002", + volume = "2305", + series = lncs, + publisher = springer, + URL = "http://glew.org/nglew/papers/tsot-esop.pdf", +} + +@InProceedings{glew-99, + author = "Neal Glew", + title = "Object Closure Conversion", + booktitle = hoots, + year = "1999", + series = entcs, + volume = "26", + pages = "52--68", + URL = "http://glew.org/nglew/papers/occ-hoots.ps.gz", +} + +@InProceedings{goerdt-85, + author = "Andreas Goerdt", + title = "A {Hoare} Calculus for Functions Defined by Recursion + on Higher Types", + booktitle = "Logic of Programs", + year = "1985", + pages = "106--117", + publisher = springer, + series = lncs, + volume = "193", + URL = "http://dx.doi.org/10.1007/3-540-15648-8_9", +} + +@InProceedings{goguen-meseguer-82, + author = "Joseph Goguen and José Meseguer", + title = "Security policies and security models", + booktitle = sp, + year = "1982", + pages = "11--20", +} + +@InProceedings{gong-97, + author = "Li Gong and Marianne Mueller and Hemma Prafullchandra + and Roland Schemers", + title = "Going Beyond the Sandbox: An Overview of the New + Security Architecture in the {Java Development Kit + 1.2}", + booktitle = "{USENIX} Symposium on Internet Technologies and + Systems", + year = "1997", + pages = "103--112", + URL = "http://secinf.net/uplarticle/10/jdk12arch.ps", +} + +@InProceedings{gong-schemers-98, + author = "Li Gong and Roland Schemers", + title = "Implementing Protection Domains in the {Java} + Development Kit 1.2", + booktitle = ndss, + year = "1998", + URL = "http://www.isoc.org/isoc/conferences/ndss/98/gong.pdf", +} + +@InProceedings{gordon-12, + author = "Colin S. Gordon and Matthew J. Parkinson and Jared + Parsons and Aleks Bromfield and Joe Duffy", + title = "Uniqueness and reference immutability for safe + parallelism", + booktitle = oopsla, + year = "2012", + pages = "21--40", + URL = "http://homes.cs.washington.edu/~csgordon/papers/oopsla12.pdf", +} + +@InProceedings{gordon-melham-96, + author = "Andrew D. Gordon and Tom Melham", + title = "Five Axioms of Alpha-Conversion", + booktitle = tphol, + pages = "173--191", + year = "1996", + volume = "1125", + series = lncs, + publisher = springer, + URL = "http://www.ftp.cl.cam.ac.uk/ftp/papers/adg/hug96.ps.gz", +} + +@InProceedings{gordon-noble-07, + author = "Donald Gordon and James Noble", + title = "Dynamic ownership in a dynamic language", + booktitle = dls, + year = "2007", + pages = "41--52", + URL = "http://doi.acm.org/10.1145/1297081.1297090", +} + +@InProceedings{gotsman-aplas-07, + author = "Alexey Gotsman and Josh Berdine and Byron Cook and + Noam Rinetzky and Mooly Sagiv", + title = "Local Reasoning for Storable Locks and Threads", + booktitle = aplas, + pages = "19--37", + year = "2007", + series = lncs, + volume = "4807", + publisher = springer, + URL = "http://dx.doi.org/10.1007/978-3-540-76637-7_3", +} + +@TechReport{gotsman-storable-07, + author = "Alexey Gotsman and Josh Berdine and Byron Cook and + Noam Rinetzky and Mooly Sagiv", + title = "Local Reasoning for Storable Locks and Threads", + institution = "Microsoft Research", + year = "2007", + number = "MSR-TR-2007-39", + URL = "http://research.microsoft.com/pubs/70427/tr-2007-39.pdf", +} + +@InProceedings{goubault-dim-94, + author = "Jean Goubault", + title = "Inférence d'unités physiques en {ML}", + booktitle = jfla, + pages = "3--20", + year = "1994", +} + +@Article{gries-73, + author = "David Gries", + title = "Describing an Algorithm by {Hopcroft}", + journal = acta, + volume = "2", + pages = "97--109", + year = "1973", + URL = "http://dx.doi.org/10.1007/BF00264025", +} + +@Article{grosch-90, + author = "Josef Grosch", + title = "Efficient and Comfortable Error Recovery in Recursive + Descent Parsers", + journal = "Structured Programming", + volume = "11", + number = "3", + pages = "129--140", + year = "1990", + URL = "http://www.cocolab.com/products/cocktail/doc.pdf/ell.pdf", +} + +@Article{grossman-06, + author = "Dan Grossman", + title = "Quantified Types in an Imperative Language", + journal = toplas, + year = "2006", + volume = "28", + number = "3", + pages = "429--475", + URL = "http://www.cs.washington.edu/homes/djg/papers/qtil.pdf", +} + +@Book{grune-jacobs-08, + author = "Dick Grune and Ceriel J. H. Jacobs", + title = "Parsing techniques: a practical guide, second + edition", + year = "2008", + publisher = springer, + series = "Monographs in computer science", + URL = "http://www.cs.vu.nl/~dick/PT2Ed.html", +} + +@Book{grune-jacobs-90, + author = "Dick Grune and Ceriel J. H. Jacobs", + title = "Parsing techniques: a practical guide", + year = "1990", + publisher = ellis, + URL = "http://www.cs.vu.nl/~dick/PTAPG.html", +} + +@Unpublished{gueneau-cakeml-16, + author = "Arma{\"e}l Gu{\'e}neau and Magnus O. Myreen and Ramana + Kumar and Michael Norrish", + title = "Verified Characteristic Formulae for {CakeML}", + note = "Submitted", + year = "2016", +} + +@Misc{gueneau-pottier-protzenko-13, + author = "Armaël Guéneau and François Pottier and Jonathan + Protzenko", + title = "The ins and outs of iteration in {Mezzo}", + note = "\url{http://goo.gl/NrgKc4}", + year = "2013", + howpublished = "Higher-Order Programming and Effects (HOPE)", +} + +@InProceedings{guillemette-monnier-07, + author = "Louis-Julien Guillemette and Stefan Monnier", + title = "A Type-Preserving Closure Conversion in {Haskell}", + booktitle = hw, + pages = "83--92", + year = "2007", + URL = "http://www.iro.umontreal.ca/~monnier/tcm.pdf", +} + +@InProceedings{guillemette-monnier-08, + author = "Louis-Julien Guillemette and Stefan Monnier", + title = "A Type-Preserving Compiler in {Haskell}", + booktitle = icfp, + year = "2008", + pages = "75--86", + URL = "http://www-etud.iro.umontreal.ca/~guillelj/icfp08.pdf", +} + +@InProceedings{guillemette-vote-08, + author = "Louis-Julien Guillemette and Stefan Monnier", + title = "One Vote for Type Families in {Haskell}!", + booktitle = tfp, + year = "2008", + URL = "http://www-etud.iro.umontreal.ca/~guillelj/tfp08.pdf", +} + +@InProceedings{gundry-10, + author = "Adam Gundry and Conor McBride and James McKinna", + title = "Type inference in context", + booktitle = msfp, + pages = "43--54", + year = "2010", + URL = "https://personal.cis.strath.ac.uk/adam.gundry/type-inference/type-inference-final.pdf", +} + +@PhdThesis{gundry-13, + author = "Adam Gundry", + title = "Type Inference, {Haskell} and Dependent Types", + school = "University of Strathclyde", + year = "2013", + URL = "https://personal.cis.strath.ac.uk/adam.gundry/thesis/thesis-2013-12-03.pdf", +} + +@Article{gupta-nandivada-15, + author = "Kartik Gupta and V. Krishna Nandivada", + title = "Lexical state analyzer for {JavaCC} grammars", + journal = spe, + URL = "http://dx.doi.org/10.1002/spe.2322", + year = "2015", +} + +@InProceedings{gustavsson-svenningsson-01, + author = "Jörgen Gustavsson and Josef Svenningsson", + title = "Constraint Abstractions", + booktitle = "Symposium on Programs as Data Objects", + year = "2001", + volume = "2053", + series = lncs, + publisher = springer, + URL = "http://www.cse.chalmers.se/~josefs/publications/ca.pdf", +} + +@InProceedings{guzman-suarez-94, + author = "Juan Carlos Guzm{\'a}n and Asc{\'a}nder Su{\'a}rez", + title = "An Extended Type System for Exceptions", + booktitle = mlapp, + series = "INRIA Research Reports", + publisher = "INRIA", + number = "2265", + year = "1994", + pages = "127--135", +} + +@InProceedings{haack-huisman-hurlin-08, + author = "Christian Haack and Marieke Huisman and Cl{\'{e}}ment + Hurlin", + title = "Reasoning about {Java's} Reentrant Locks", + booktitle = aplas, + pages = "171--187", + year = "2008", + series = lncs, + volume = "5356", + publisher = springer, + URL = "http://www.cs.ru.nl/~chaack/papers/papers/reentrant.pdf", +} + +@Article{haack-hurlin-09, + author = "Christian Haack and Cl{\'{e}}ment Hurlin", + title = "Resource Usage Protocols for Iterators", + journal = jot, + volume = "8", + number = "4", + pages = "55--83", + year = "2009", + URL = "http://www.jot.fm/issues/issue_2009_06/article3.pdf", +} + +@InProceedings{haack-wells-03, + author = "Christian Haack and J. B. Wells", + title = "Type error slicing in implicitly typed, higher-order + languages", + booktitle = esop, + year = "2003", + series = lncs, + publisher = springer, + volume = "2618", + URL = "http://www.macs.hw.ac.uk/~jbw/papers/Haack+Wells:Type-Error-Slicing-in-Implicitly-Typed-Higher-Order-Languages:ESOP-2003.pdf", +} + +@InProceedings{hall-94, + author = "Cordelia Hall and Kevin Hammond and Simon {Peyton + Jones} and Philip Wadler", + title = "Type classes in {Haskell}", + booktitle = esop, + pages = "241--256", + year = "1994", + volume = "788", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/Users/simonpj/Papers/classhask.ps.gz", +} + +@Article{hall-96, + author = "Cordelia Hall and Kevin Hammond and Simon {Peyton + Jones} and Philip Wadler", + title = "Type classes in {Haskell}", + journal = toplas, + year = "1996", + volume = "18", + number = "2", + pages = "109--138", + URL = "http://doi.acm.org/10.1145/227699.227700", +} + +@InProceedings{haller-odersky-10, + author = "Philipp Haller and Martin Odersky", + title = "Capabilities for Uniqueness and Borrowing", + booktitle = ecoop, + year = "2010", + pages = "354--378", + publisher = springer, + series = lncs, + volume = "6183", + URL = "http://lampwww.epfl.ch/~phaller/doc/haller-odersky10-Capabilities_for_uniqueness_and_borrowing.pdf", +} + +@TechReport{hallett-kfoury-04, + author = "Joseph J. Hallett and Assaf J. Kfoury", + title = "Programming Examples Needing Polymorphic Recursion", + institution = "Department of Computer Science, Boston University", + year = "2004", + number = "BUCS-TR-2004-004", + URL = "http://www.church-project.org/reports/electronic/Hal+Kfo:BUCS-TR-2004-004.pdf", +} + +@PhdThesis{hanus-88, + author = "Michael Hanus", + title = "Horn Clause Specifications with Polymorphic Types", + year = "1988", + school = "Fachbereich Informatik, Universität Dortmund", + URL = "http://www.informatik.uni-kiel.de/~mh/publications/various/Dissertation.dvi.Z", +} + +@InProceedings{hanus-89, + author = "Michael Hanus", + title = "Horn Clause Programs with Polymorphic Types: Semantics + and Resolution", + booktitle = tapsoft, + publisher = springer, + series = lncs, + volume = "352", + pages = "225--240", + year = "1989", + URL = "http://www.informatik.uni-kiel.de/~mh/publications/papers/TAPSOFT89.ps", +} + +@Manual{happy, + author = "Simon Marlow and Andy Gill", + title = "Happy: the parser generator for {Haskell}", + year = "2004", + URL = "http://www.haskell.org/happy/", +} + +@Article{hardy-88, + author = "Norm Hardy", + title = "The Confused Deputy (or why capabilities might have + been invented)", + journal = sigops, + year = "1988", + volume = "22", + number = "4", + pages = "36--38", + URL = "http://www.cis.upenn.edu/~KeyKOS/ConfusedDeputy.html", +} + +@Article{harfst-reingold-00, + author = "Gregory C. Harfst and Edward M. Reingold", + title = "A potential-based amortized analysis of the union-find + data structure", + journal = "{SIGACT} News", + volume = "31", + number = "3", + pages = "86--95", + year = "2000", + URL = "http://doi.acm.org/10.1145/356458.356463", +} + +@Article{harper-94, + author = "Robert Harper", + title = "A simplified account of polymorphic references", + journal = ipl, + volume = "51", + number = "4", + year = "1994", + pages = "201--206", + URL = "http://www.cs.cmu.edu/~rwh/papers/refs/ipl94.pdf", +} + +@Article{harper-99, + author = "Robert Harper", + title = "Proof-Directed Debugging", + journal = jfp, + volume = "9", + number = "4", + year = "1999", + pages = "463--469", + URL = "http://dx.doi.org/10.1017/S0956796808007119", +} + +@Article{harper-licata-07, + author = "Robert Harper and Daniel R. Licata", + title = "Mechanizing metatheory in a logical framework", + journal = jfp, + volume = "17", + number = "4--5", + year = "2007", + pages = "613--673", + URL = "http://www.cs.cmu.edu/~rwh/papers/mech/jfp07.pdf", +} + +@Misc{harper-lillibridge-91, + author = "Bob Harper and Mark Lillibridge", + title = "{ML} with callcc is unsound", + howpublished = "Message to the {TYPES} mailing list", + year = "1991", + URL = "http://www.cis.upenn.edu/~bcpierce/types/archives/1991/msg00034.html", +} + +@InProceedings{harper-pierce-91, + author = "Robert Harper and Benjamin Pierce", + title = "A Record Calculus Based on symmetric Concatenation", + pages = "131--142", + booktitle = popl, + year = "1991", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/merge.ps", +} + +@InCollection{harper-pierce-attapl, + author = "Robert Harper and Benjamin C. Pierce", + title = "Design Considerations for {ML}-Style Module Systems", + booktitle = "Advanced Topics in Types and Programming Languages", + pages = "293--345", + publisher = mitp, + year = "2005", + editor = "Benjamin C. Pierce", + chapter = "8", +} + +@Book{harrison-09, + author = "John Harrison", + title = "Handbook of Practical Logic and Automated Reasoning", + publisher = cup, + year = "2009", + URL = "http://www.cl.cam.ac.uk/~jrh13/atp/", +} + +@Book{haskell-98, + editor = "Simon {Peyton Jones}", + title = "{Haskell} 98 Language and Libraries: The Revised + Report", + publisher = cup, + year = "2003", + URL = "http://www.haskell.org/onlinereport/", +} + +@InProceedings{haskell-history-07, + author = "Paul Hudak and John Hughes and Simon {Peyton Jones} + and Philip Wadler", + title = "A History of {Haskell}: being lazy with class", + booktitle = hopl, + year = "2007", + URL = "https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/history.pdf", +} + +@TechReport{hawblitzel-05, + author = "Chris Hawblitzel", + title = "Linear Types for Aliased Resources", + institution = "Microsoft Research", + year = "2005", + number = "MSR-TR-2005-141", + URL = "http://research.microsoft.com/pubs/70228/tr-2005-141.pdf", +} + +@InProceedings{hecht-ullman-73, + author = "Matthew S. Hecht and Jeffrey D. Ullman", + title = "Analysis of a simple algorithm for global data flow + problems", + booktitle = popl, + pages = "207--217", + year = "1973", + URL = "http://doi.acm.org/10.1145/512927.512946", +} + +@TechReport{heeren-improving-02, + title = "Improving type-error messages in functional + languages", + author = "Bastiaan Heeren and Johan Jeuring and Doaitse + Swierstra and Pablo Azero Alcocer", + year = "2002", + institution = "University of Utrecht, Institute of Information and + Computing Science", + number = "UU-CS-2002-009", + URL = "http://archive.cs.uu.nl/pub/RUU/CS/techreps/CS-2002/2002-009.pdf", +} + +@TechReport{heeren2002generalizing, + title = "Generalizing {Hindley-Milner} Type Inference + Algorithms", + author = "Bastiaan Heeren and Jurriaan Hage and Doaitse + Swierstra", + year = "2002", + institution = "University of Utrecht, Institute of Information and + Computing Science", + number = "UU-CS-2002-031", + URL = "http://archive.cs.uu.nl/pub/RUU/CS/techreps/CS-2002/2002-031.pdf", +} + +@TechReport{heeren2002parametric, + title = "Parametric Type Inferencing for {Helium}", + author = "Bastiaan Heeren and Jurriaan Hage", + year = "2002", + institution = "University of Utrecht, Institute of Information and + Computing Science", + number = "UU-CS-2002-035", + URL = "http://archive.cs.uu.nl/pub/RUU/CS/techreps/CS-2002/2002-035.pdf", +} + +@InBook{hehner-96, + author = "Eric C. R. Hehner", + booktitle = "A classical mind", + title = "Abstractions of Time", + publisher = prentice, + year = "1994", + pages = "191--210", + URL = "http://www.cs.toronto.edu/~hehner/AoT.pdf", +} + +@Article{hehner-98, + author = "Eric C. R. Hehner", + title = "Formalization of Time and Space", + journal = fac, + year = "1998", + volume = "10", + pages = "290--206", + URL = "http://www.cs.toronto.edu/~hehner/FTS.pdf", +} + +@TechReport{heintze-93, + author = "Nevin Heintze", + institution = "Carnegie Mellon University, School of Computer + Science", + title = "Set Based Analysis of {ML} Programs", + year = "1993", + number = "CMU-CS-93-193", + URL = "http://reports-archive.adm.cs.cmu.edu/anon/1993/CMU-CS-93-193.ps", +} + +@InProceedings{heintze-mcallester-97, + author = "Nevin Heintze and David McAllester", + title = "Linear-Time Subtransitive Control Flow Analysis", + pages = "261--272", + booktitle = pldi, + year = "1997", + URL = "http://www.autoreason.com/PLDI97.ps", +} + +@InProceedings{heintze-riecke-slam-98, + author = "Nevin Heintze and Jon G. Riecke", + title = "The {SL}am Calculus: Programming with Secrecy and + Integrity", + booktitle = popl, + year = "1998", + pages = "365--377", + URL = "http://cm.bell-labs.com/cm/cs/who/nch/slam.ps", +} + +@InProceedings{heintze-tardieu-01, + author = "Nevin Heintze and Olivier Tardieu", + title = "Ultra-fast Aliasing Analysis using {CLA}: {A} Million + Lines of {C} Code in a Second", + pages = "254--263", + booktitle = pldi, + year = "2001", + URL = "http://cm.bell-labs.com/cm/cs/who/nch/pldi01-1m.ps", +} + +@InProceedings{helsen-thiemann-00, + author = "Simon Helsen and Peter Thiemann", + title = "Syntactic Type Soundness for the Region Calculus", + booktitle = hoots, + pages = "1--19", + year = "2000", + volume = "41", + number = "3", + series = entcs, + URL = "http://www.swen.uwaterloo.ca/~shelsen/papers/helsen-thiemann-hoots-00.pdf", +} + +@TechReport{henderson-modes-92, + author = "Fergus Henderson", + title = "Strong modes can change the world!", + institution = "Department of Computer Science, University of + Melbourne", + year = "1992", + number = "96/11", + URL = "http://www.cs.mu.oz.au/~fjh/papers/hons_thesis.ps.gz", +} + +@InProceedings{hendriks-oostrom-03, + author = "Dimitri Hendriks and Vincent van Oostrom", + title = "Adbmal", + booktitle = cade, + pages = "136--150", + year = "2003", + volume = "2741", + series = lncs, + publisher = springer, + URL = "http://www.cs.ru.nl/~hendriks/publication/ps/adbmal_cade.ps", +} + +@InProceedings{henglein-91, + author = "Fritz Henglein", + booktitle = fpca, + title = "Efficient Type Inference for Higher-Order Binding-Time + Analysis", + year = "1991", + pages = "448--472", + series = lncs, + volume = "523", + publisher = springer, + URL = "ftp://ftp.diku.dk/pub/diku/users/henglein/binding-time-analysis.dvi.gz", +} + +@Article{henglein-93, + author = "Fritz Henglein", + title = "Type Inference with Polymorphic Recursion", + journal = toplas, + year = "1993", + volume = "15", + number = "2", + pages = "253--289", + URL = "http://doi.acm.org/10.1145/169701.169692", +} + +@InProceedings{henglein-breaking-97, + author = "Fritz Henglein", + title = "Breaking through the $n^3$ barrier: Faster object type + inference", + booktitle = fool, + year = "1997", +} + +@Article{henglein-breaking-99, + author = "Fritz Henglein", + title = "Breaking through the $n^3$ barrier: Faster Object Type + Inference", + journal = "Theory and Practice of Object Systems", + year = "1999", + volume = "5", + number = "1", + pages = "57--72", + URL = "ftp://ftp.diku.dk/diku/semantics/papers/D-396.ps.gz", +} + +@Article{henglein-paige-87, + author = "Robert Paige and Fritz Henglein", + title = "Mechanical translation of set theoretic problem + specifications into efficient {RAM} code -- {A} case + study", + journal = jsc, + volume = "4", + number = "2", + year = "1987", + pages = "207--232", + URL = "http://dx.doi.org/10.1016/S0747-7171(87)80066-4", +} + +@PhdThesis{henglein-phd-89, + author = "Fritz Henglein", + school = "Rutgers University", + title = "Polymorphic Type Inference and Semi-Unification", + year = "1989", + URL = "ftp://ftp.diku.dk/diku/users/henglein/poly-typ-inf-and-semi-unif.ps.gz", +} + +@InProceedings{henglein-rehof-97, + author = "Fritz Henglein and Jakob Rehof", + title = "The Complexity of Subtype Entailment for Simple + Types", + pages = "352--361", + booktitle = lics, + year = "1997", + URL = "http://research.microsoft.com/~rehof/lics97.ps", +} + +@InProceedings{henglein-rehof-98, + author = "Fritz Henglein and Jakob Rehof", + title = "Constraint Automata and the Complexity of Recursive + Subtype Entailment", + booktitle = icalp, + year = "1998", + URL = "http://research.microsoft.com/~rehof/icalp98.ps", +} + +@TechReport{hennessy-2000, + author = "Matthew Hennessy", + title = "The security picalculus and non-interference", + year = "2000", + institution = "University of Sussex", + number = "2000:05", + URL = "ftp://ftp.cogs.susx.ac.uk/pub/reports/compsci/cs052000.ps.Z", +} + +@InProceedings{hennessy-riely-00, + author = "Matthew Hennessy and James Riely", + title = "Information Flow vs. Resource Access in the + Asynchronous Pi-Calculus", + booktitle = icalp, + series = lncs, + publisher = springer, + year = "2000", + URL = "http://www.depaul.edu/~jriely/papers/00icalp.ps.gz", +} + +@InProceedings{hepburn-wright-01, + author = "Mark Hepburn and David Wright", + title = "Trust in the Pi-Calculus", + booktitle = ppdp, + year = "2001", +} + +@Article{herlihy-schachte-sondergaard-07, + author = "Brian Herlihy and Peter Schachte and Harald + Søndergaard", + title = "Un-{Kleene} {Boolean} Equation Solving", + journal = ijfcs, + year = "2007", + volume = "18", + number = "2", + pages = "227--250", + URL = "http://dx.doi.org/10.1142/S0129054107004668", +} + +@InProceedings{heule-13, + author = "Stefan Heule and K. Rustan M. Leino and Peter + M{\"u}ller and Alexander J. Summers", + title = "Abstract Read Permissions: Fractional Permissions + without the Fractions", + booktitle = vmcai, + year = "2013", + pages = "315--334", + publisher = springer, + series = lncs, + volume = "7737", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml225.pdf", +} + +@InProceedings{higuchi-ohori-03, + author = "Tomoyuki Higuchi and Atsushi Ohori", + title = "A Static Type System for {JVM} Access Control", + booktitle = icfp, + pages = "227--237", + year = "2003", + URL = "http://doi.acm.org/10.1145/944726", +} + +@InProceedings{hillerstrom-lindley-16, + author = "Daniel Hillerstr{\"{o}}m and Sam Lindley", + title = "Liberating effects with rows and handlers", + booktitle = "International Workshop on Type-Driven Development + (TyDe@ICFP)", + pages = "15--27", + year = "2016", + URL = "http://homepages.inf.ed.ac.uk/slindley/papers/links-effect.pdf", +} + +@Article{hindley-69, + author = "J. Roger Hindley", + title = "The Principal Type-scheme of an Object in Combinatory + Logic", + journal = tams, + volume = "146", + pages = "29--60", + year = "1969", + URL = "http://dx.doi.org/10.2307/1995158", +} + +@InCollection{hinze-03, + author = "Ralf Hinze", + editor = "Jeremy Gibbons and Oege de Moor", + booktitle = "The Fun of Programming", + title = "Fun with Phantom Types", + publisher = palgrave, + year = "2003", + pages = "245--262", + URL = "http://www.informatik.uni-bonn.de/~ralf/publications/With.pdf", +} + +@TechReport{hinze-comparing-generic-06, + author = "Ralf Hinze and Johan Jeuring and Andres Löh", + year = "2006", + title = "Comparing approaches to generic programming in + {Haskell}", + number = "UU-CS-2006-022", + institution = "Department of Information and Computing Sciences, + Utrecht University", + URL = "http://www.cs.uu.nl/research/techreps/repo/CS-2006/2006-022.pdf", +} + +@InProceedings{hinze-derivable-00, + author = "Ralf Hinze and Simon Peyton Jones", + title = "Derivable type classes", + booktitle = hw, + year = "2000", + URL = "https://www.microsoft.com/en-us/research/wp-content/uploads/2000/09/derive.pdf", +} + +@Unpublished{hinze-paterson-05, + author = "Ralf Hinze and Ross Paterson", + title = "Derivation of a Typed Functional {LR} Parser", + note = "Unpublished", + year = "2005", + URL = "http://www.cs.ox.ac.uk/ralf.hinze/publications/TypedLR.pdf", +} + +@Article{hinze-paterson-06, + title = "Finger trees: a simple general-purpose data + structure", + author = "Ralf Hinze and Ross Paterson", + journal = jfp, + year = "2006", + number = "2", + volume = "16", + pages = "197--217", + URL = "http://www.cs.ox.ac.uk/ralf.hinze/publications/FingerTrees.pdf", +} + +@InProceedings{hirschowitz-cbv-04, + author = "Tom Hirschowitz and Xavier Leroy and J. B. Wells", + title = "Call-by-value mixin modules: Reduction semantics, side + effects, types", + booktitle = esop, + pages = "64--78", + year = "2004", + volume = "2986", + series = lncs, + publisher = springer, + URL = "http://gallium.inria.fr/~xleroy/publi/mixins-mm-esop2004.ps.gz", +} + +@Article{hirschowitz-leroy-04, + author = "Tom Hirschowitz and Xavier Leroy", + title = "Mixin Modules in a Call-by-Value Setting", + journal = toplas, + year = "2004", + note = "To appear", + URL = "http://gallium.inria.fr/~hirschow/papers/toplas-cmsv.ps.gz", +} + +@InProceedings{hoang-mitchell-lower-95, + author = "My Hoang and John C. Mitchell", + title = "Lower Bounds on Type Inference with Subtypes", + pages = "176--185", + booktitle = popl, + year = "1995", + URL = "http://doi.acm.org/10.1145/199448.199481", +} + +@Article{hoare-61, + author = "C. A. R. Hoare", + title = "Algorithm 65: find", + journal = cacm, + volume = "4", + number = "7", + year = "1961", + pages = "321--322", + URL = "http://doi.acm.org/10.1145/366622.366647", +} + +@Article{hoare-69, + author = "C. A. R. Hoare", + title = "An axiomatic basis for computer programming", + journal = cacm, + volume = "12", + number = "10", + year = "1969", + pages = "576--580", + URL = "http://doi.acm.org/10.1145/363235.363259", +} + +@Article{hoare-71, + author = "C. A. R. Hoare", + title = "Proof of a program: {FIND}", + journal = cacm, + year = "1971", + volume = "14", + number = "1", + pages = "39--45", + URL = "http://doi.acm.org/10.1145/362452.362489", +} + +@Article{hoare-data-72, + author = "C. A. R. Hoare", + title = "Proof of correctness of data representations", + journal = acta, + year = "1972", + volume = "4", + pages = "271--281", + URL = "http://dx.doi.org/10.1007/BF00289507", +} + +@InProceedings{hobor-gherghina-11, + author = "Aquinas Hobor and Cristian Gherghina", + title = "Barriers in Concurrent Separation Logic", + booktitle = esop, + year = "2011", + series = lncs, + publisher = springer, + URL = "http://www.comp.nus.edu.sg/~hobor/Publications/barrier.pdf", +} + +@InProceedings{hobor-indirection-10, + author = "Aquinas Hobor and Robert Dockins and Andrew W. Appel", + title = "A Theory of Indirection via Approximation", + booktitle = popl, + year = "2010", + URL = "http://www.comp.nus.edu.sg/~hobor/Publications/indirection.pdf", +} + +@InProceedings{hobor-oracle-08, + author = "Aquinas Hobor and Andrew W. Appel and Francesco {Zappa + Nardelli}", + title = "Oracle Semantics for Concurrent Separation Logic", + booktitle = esop, + pages = "353--367", + year = "2008", + volume = "4960", + series = lncs, + publisher = springer, + URL = "http://www.cs.princeton.edu/~appel/papers/concurrent.pdf", +} + +@Article{hoffmann-aehlig-hofmann-multivariate-12, + author = "Jan Hoffmann and Klaus Aehlig and Martin Hofmann", + title = "Multivariate amortized resource analysis", + journal = toplas, + volume = "34", + number = "3", + pages = "14:1--14:62", + year = "2012", + URL = "http://doi.acm.org/10.1145/2362389.2362393", +} + +@InProceedings{hoffmann-aehlig-hofmann-raml-12, + author = "Jan Hoffmann and Klaus Aehlig and Martin Hofmann", + title = "Resource Aware {ML}", + booktitle = cav, + pages = "781--786", + year = "2012", + URL = "http://dx.doi.org/10.1007/978-3-642-31424-7_64", + series = lncs, + volume = "7358", + publisher = springer, +} + +@InProceedings{hoffmann-hofmann-10, + author = "Jan Hoffmann and Martin Hofmann", + title = "Amortized Resource Analysis with Polynomial + Potential", + booktitle = esop, + pages = "287--306", + year = "2010", + volume = "6012", + series = lncs, + publisher = springer, + URL = "http://www.cs.yale.edu/homes/hoffmann/papers/aapoly_conference.pdf", +} + +@InProceedings{hoffmann-marmar-shao-13, + author = "Jan Hoffmann and Michael Marmar and Zhong Shao", + title = "Quantitative Reasoning for Proving Lock-Freedom", + booktitle = lics, + year = "2013", + pages = "124--133", + URL = "http://www.cs.cmu.edu/~janh/papers/lockfree2013.pdf", +} + +@Article{hofmann-00, + author = "Martin Hofmann", + title = "A type system for bounded space and functional + in-place update", + journal = njc, + year = "2000", + volume = "7", + number = "4", + pages = "258--289", + URL = "http://www.tcs.informatik.uni-muenchen.de/~mhofmann/nordic.ps.gz", +} + +@InProceedings{hofmann-jost-03, + author = "Martin Hofmann and Steffen Jost", + title = "Static prediction of heap space usage for first-order + functional programs", + booktitle = popl, + year = "2003", + pages = "185--197", + URL = "http://www2.tcs.ifi.lmu.de/~jost/research/POPL_2003_Jost_Hofmann.pdf", +} + +@InProceedings{hofmann-moser-14, + author = "Martin Hofmann and Georg Moser", + title = "Amortised Resource Analysis and Typed Polynomial + Interpretations", + booktitle = tlca, + pages = "272--286", + year = "2014", + volume = "8560", + series = lncs, + publisher = springer, + URL = "http://arxiv.org/pdf/1402.1922.pdf", +} + +@InProceedings{hofmann-pavlova-08, + author = "Martin Hofmann and Mariela Pavlova", + title = "Elimination of ghost variables in program logics", + booktitle = "Trustworthy Global Computing", + pages = "1--20", + year = "2008", + volume = "4912", + series = lncs, + publisher = springer, + URL = "http://www-sop.inria.fr/everest/personnel/Mariela.Pavlova/ghost.pdf", +} + +@Article{hofmann-pierce-94, + author = "Martin Hofmann and Benjamin Pierce", + title = "A Unifying Type-Theoretic Framework for Objects", + journal = jfp, + volume = "5", + number = "4", + pages = "593--635", + note = "Previous versions appeared in the Symposium on + Theoretical Aspects of Computer Science, 1994, (pages + 251--262) and, under the title ``An Abstract View of + Objects and Subtyping (Preliminary Report),'' as + University of Edinburgh, LFCS technical report + ECS-LFCS-92-226, 1992", + year = "1995", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/abstroop.ps", +} + +@InProceedings{hogg-91, + author = "John Hogg", + title = "Islands: Aliasing Protection in Object-Oriented + Languages", + booktitle = oopsla, + year = "1991", + pages = "271--285", + URL = "http://dx.doi.org/10.1145/118014.117975", +} + +@InProceedings{honda-al-00, + author = "Kohei Honda and Vasco Vasconcelos and Nobuko Yoshida", + title = "Secure information flow as typed process behaviour", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "1782", + pages = "180--199", + year = "2000", + URL = "ftp://ftp.dcs.qmw.ac.uk/lfp/kohei/siftp-esop00.ps.gz", +} + +@TechReport{honda-al-00-long, + author = "Kohei Honda and Vasco Vasconcelos and Nobuko Yoshida", + title = "Secure information flow as typed process behaviour", + institution = "Queen Mary and Westfield College, University of + London", + year = "1999", + number = "QMW-DCS-1999-767", + URL = "ftp://ftp.dcs.qmw.ac.uk/lfp/kohei/siftp-qmwrep.ps.gz", +} + +@InProceedings{honda-yoshida-02, + author = "Kohei Honda and Nobuko Yoshida", + title = "A Uniform Type Structure for Secure Information Flow", + booktitle = popl, + year = "2002", + pages = "81--92", + URL = "http://www.mcs.le.ac.uk/~nyoshida/paper/ifa_long.ps.gz", +} + +@InProceedings{honda-yoshida-04, + author = "Kohei Honda and Nobuko Yoshida", + title = "A compositional logic for polymorphic higher-order + functions", + booktitle = ppdp, + year = "2004", + pages = "191--202", + URL = "http://www.dcs.qmul.ac.uk/~kohei/logics/polyrec.pdf.gz", +} + +@InProceedings{honsell-01, + author = "Furio Honsell and Marino Miculan and Ivan Scagnetto", + title = "An axiomatic approach to metareasoning on nominal + algebras in {HOAS}", + booktitle = icalp, + pages = "963--978", + year = "2001", + volume = "2076", + series = lncs, + publisher = springer, + URL = "http://www.dimi.uniud.it/~miculan/Papers/ICALP01.pdf", +} + +@InCollection{hopcroft-minimizing-71, + author = "John~E. Hopcroft", + title = "An $n\log n$ algorithm for minimizing states in a + finite automaton", + booktitle = "Theory of Machines and Computations", + editor = "Z. Kohavi", + publisher = ap, + year = "1971", + pages = "189--196", +} + +@Book{hopcroft-motwani-ullman-00, + author = "John E. Hopcroft and Rajeev Motwani and Jeffrey D. + Ullman", + title = "Introduction to Automata Theory, Languages, and + Computation", + publisher = aw, + year = "2000", + URL = "http://www-db.stanford.edu/~ullman/ialc.html", +} + +@Article{hopcroft-ullman-73, + author = "John E. Hopcroft and Jeffrey D. Ullman", + title = "Set Merging Algorithms", + journal = siamjc, + volume = "2", + number = "4", + pages = "294--303", + year = "1973", + URL = "http://dx.doi.org/10.1137/0202024", +} + +@InProceedings{horning-74, + author = "James J. Horning", + title = "What the Compiler Should Tell the User", + booktitle = cc, + year = "1974", + pages = "525--548", + volume = "21", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3540069585_64", +} + +@Article{horspool-faster-90, + author = "R. Nigel Horspool and Michael Whitney", + title = "Even Faster {LR} Parsing", + journal = spe, + year = "1990", + volume = "20", + number = "6", + pages = "515--535", + URL = "http://www.cs.uvic.ca/~nigelh/Publications/fastparse.pdf", +} + +@InProceedings{horwitz-95, + author = "Susan Horwitz and Thomas Reps and Mooly Sagiv", + title = "Demand interprocedural dataflow analysis", + booktitle = "ACM Symposium on the Foundations of Software + Engineering (FSE)", + year = "1995", + URL = "http://www.cs.wisc.edu/wpis/papers/fse95a.ps", +} + +@Article{horwitz-demers-teitelbaum-87, + author = "Alan Demers and Susan Horwitz and Tim Teitelbaum", + title = "An efficient general algorithm for dataflow analysis", + journal = acta, + year = "1987", + volume = "24", + number = "6", + pages = "679--694", + URL = "http://dx.doi.org/10.1007/BF00282621", +} + +@Article{hosoya-pierce-02, + author = "Haruo Hosoya and Benjamin C. Pierce", + title = "Regular expression pattern matching for {XML}", + journal = jfp, + volume = "13", + number = "6", + year = "2003", + pages = "961--1004", + URL = "http://dx.doi.org/10.1017/S0956796802004410", +} + +@TechReport{howell-08, + author = "Rodney R. Howell", + title = "On Asymptotic Notation with Multiple Variables", + institution = "Kansas State University", + year = "2008", + number = "2007-4", + URL = "http://people.cs.ksu.edu/~rhowell/asymptotic.pdf", +} + +@Article{hru-76, + author = "Michael A. Harrison and Walter L. Ruzzo and Jeffrey D. + Ullman", + title = "Protection in Operating Systems", + journal = cacm, + year = "1976", + volume = "19", + number = "8", + pages = "461--471", + URL = "http://doi.acm.org/10.1145/360303.360333", +} + +@InProceedings{hubert-marche-07, + author = "Thierry Hubert and Claude Marché", + title = "Separation Analysis for Deductive Verification", + booktitle = hav, + year = "2007", + URL = "http://www.lri.fr/~marche/hubert07hav.pdf", +} + +@PhdThesis{huet-76, + author = "G{\'e}rard Huet", + title = "{R}{\'e}solution d'{\'e}quations dans des langages + d'ordre $1$, $2$, $\ldots$, $\omega$", + school = "Universit{\'e} Paris 7", + year = "1976", +} + +@Article{huet-98, + author = "Gérard Huet", + title = "Regular {Böhm} Trees", + journal = mscs, + year = "1998", + volume = "8", + pages = "671--680", + URL = "http://yquem.inria.fr/~huet/PUBLIC/RBT2.pdf", +} + +@Article{huet-zipper-97, + author = "G{\'e}rard Huet", + title = "The Zipper", + journal = jfp, + volume = "7", + number = "5", + year = "1997", + pages = "549--554", + URL = "http://yquem.inria.fr/~huet/PUBLIC/zip.pdf", +} + +@Article{hughes-arrows-00, + author = "John Hughes", + title = "Generalising monads to arrows", + journal = scp, + volume = "37", + number = "1--3", + year = "2000", + pages = "67--111", + URL = "http://www.cse.chalmers.se/~rjmh/Papers/arrows.pdf", +} + +@Article{hughes-matters-89, + author = "John Hughes", + title = "Why Functional Programming Matters", + journal = cj, + volume = "32", + number = "2", + pages = "98--107", + year = "1989", + URL = "http://www.cse.chalmers.se/~rjmh/Papers/whyfp.pdf", +} + +@InProceedings{hughes-pareto-sabry-96, + author = "John Hughes and Lars Pareto and Amr Sabry", + title = "Proving the correctness of reactive systems using + sized types", + booktitle = popl, + year = "1996", + pages = "410--423", + URL = "http://doi.acm.org/10.1145/237721.240882", +} + +@Article{hutton-fold-99, + author = "Graham Hutton", + title = "A Tutorial on the Universality and Expressiveness of + Fold", + journal = jfp, + volume = "9", + number = "4", + pages = "355--372", + year = "1999", + URL = "http://www.cs.nott.ac.uk/~pszgmh/fold.pdf", +} + +@Article{igarashi-kobayashi-00, + author = "Atsushi Igarashi and Naoki Kobayashi", + title = "Type Reconstruction for Linear $\pi$-Calculus with + {I}/{O} Subtyping", + journal = ic, + volume = "161", + pages = "1--44", + year = "2000", + URL = "http://www.sato.kuis.kyoto-u.ac.jp/~igarashi/papers/psgz/linear-pi.IC.ps.gz", +} + +@InProceedings{ishtiaq-ohearn-01, + author = "Samin S. Ishtiaq and Peter W. O'Hearn", + title = "{BI} as an assertion language for mutable data + structures", + booktitle = popl, + year = "2001", + pages = "14--26", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/bi-assertion-lan.pdf", +} + +@InCollection{iwaco-03, + author = "Dave Clarke and Sophia Drossopoulou and James Noble", + title = "Aliasing, Confinement, and Ownership in + Object-Oriented Programming", + booktitle = "Object-Oriented Technology. {ECOOP 2003} Workshop + Reader", + year = "2004", + publisher = springer, + series = lncs, + volume = "3013", + pages = "197--207", + URL = "http://dx.doi.org/10.1007/978-3-540-25934-3_19", +} + +@Manual{jacc, + title = "jacc: Just Another Compiler Compiler for {Java}", + author = "Mark P. Jones", + year = "2004", + URL = "http://web.cecs.pdx.edu/~mpj/jacc/jacc.pdf", +} + +@InProceedings{jackson-vaziri-00, + author = "Daniel Jackson and Mandana Vaziri", + title = "Finding Bugs with a Constraint Solver", + booktitle = issta, + year = "2000", + URL = "http://sdg.csail.mit.edu/pubs/2000/issta00.pdf", +} + +@InProceedings{jacobs-termination-15, + author = "Bart Jacobs and Dragan Bosnacki and Ruurd Kuipe", + title = "Modular Termination Verification", + booktitle = ecoop, + pages = "99--1023", + year = "2015", + series = lipics, + URL = "http://people.cs.kuleuven.be/~bart.jacobs/ecoop2015.pdf", +} + +@InProceedings{jagannathan-wright-95, + author = "Suresh Jagannathan and Andrew Wright", + title = "Effective Flow Analysis for Avoiding Run-Time Checks", + year = "1995", + booktitle = sas, + publisher = springer, + series = lncs, + volume = "983", + URL = "http://www.cs.purdue.edu/homes/suresh/papers/sas95.ps.gz", +} + +@PhdThesis{jansson-00, + author = "Patrik Jansson", + title = "Functional Polytypic Programming", + school = "Chalmers University of Technology", + year = "2000", + URL = "http://www.cse.chalmers.se/~patrikj/poly/polythesis/Jansson2000_PhD_thesis.pdf", +} + +@Book{java, + author = "James Gosling and Bill Joy and Guy Steele and Gilad + Bracha", + title = "The {Java} Language Specification, Second Edition", + publisher = aw, + year = "2000", + URL = "http://java.sun.com/docs/books/jls/", +} + +@Book{javasec, + author = "Li Gong and Gary Ellison and Mary Dageforde", + title = "Inside {Java 2} Platform Security, Second Edition", + publisher = aw, + year = "2003", + URL = "http://java.sun.com/docs/books/security/", +} + +@Article{jay-04, + author = "C. Barry Jay", + title = "The Pattern Calculus", + journal = toplas, + volume = "26", + number = "6", + pages = "911--937", + year = "2004", + URL = "http://www-staff.it.uts.edu.au/~cbj/Publications/pattern_calculus.pdf", + alturl = "http://doi.acm.org/10.1145/1034774.1034775", +} + +@Article{jeffery-03, + author = "Clinton L. Jeffery", + title = "Generating {LR} syntax error messages from examples", + journal = toplas, + volume = "25", + number = "5", + year = "2003", + pages = "631--640", + URL = "http://doi.acm.org/10.1145/937563.937566", +} + +@InProceedings{jensen-13, + author = "Jonas Braband Jensen and Nick Benton and Andrew + Kennedy", + title = "High-level separation logic for low-level code", + booktitle = popl, + pages = "301--314", + year = "2013", + URL = "http://research.microsoft.com/en-us/um/people/nick/hlsl.pdf", +} + +@InProceedings{jensen-98, + author = "Thomas Jensen", + title = "Inference of polymorphic and conditional strictness + properties", + booktitle = popl, + year = "1998", + pages = "209--221", + publisher = acmp, + URL = "http://www.irisa.fr/lande/jensen/papers/popl98.ps", +} + +@InProceedings{jensen-al-99, + author = "Thomas Jensen and Daniel {Le Métayer} and Tommy + Thorn", + title = "Verifying security properties of control-flow graphs", + booktitle = sp, + pages = "89--105", + year = "1999", + URL = "http://www.irisa.fr/lande/jensen/papers/SP99.ps", +} + +@InProceedings{jensen-birkedal-fictional-12, + author = "Jonas Braband Jensen and Lars Birkedal", + title = "Fictional Separation Logic", + booktitle = esop, + year = "2012", + pages = "377--396", + publisher = springer, + series = lncs, + volume = "7211", + URL = "http://cs.au.dk/~birke/papers/sharing-conf.pdf", +} + +@InProceedings{jensen-ployette-ridoux-02, + title = "Iteration schemes for fixed point computation", + author = "Thomas Jensen and Florimond Ployette and Olivier + Ridoux", + year = "2002", + booktitle = fics, + pages = "69--76", + URL = "http://www.irisa.fr/lande/REQS/fics02.ps", +} + +@InProceedings{jha-al-02, + author = "Somesh Jha and Jens Palsberg and Tian Zhao", + title = "Efficient Type Matching", + booktitle = fossacs, + pages = "187--204", + year = "2002", + publisher = springer, + series = lncs, + volume = "2303", + URL = "http://www.cs.ucla.edu/~palsberg/paper/fossacs02.pdf", +} + +@InProceedings{jia-05, + author = "Limin Jia and Frances Spalding and David Walker and + Neal Glew", + title = "Certifying Compilation for a Language with Stack + Allocation", + booktitle = lics, + year = "2005", + URL = "http://www.cs.princeton.edu/~dpw/papers/stackcert-lics05.pdf", + pages = "407--416", +} + +@InProceedings{jia-walker-06, + author = "Limin Jia and David Walker", + title = "{ILC}: {A} Foundation for Automated Reasoning About + Pointer Programs", + booktitle = esop, + year = "2006", + pages = "131--145", + publisher = springer, + series = lncs, + volume = "3924", + URL = "http://sip.cs.princeton.edu/pub/ilc-esop06.pdf", +} + +@InProceedings{jim-00, + author = "Trevor Jim", + title = "A Polar Type System", + booktitle = itrs, + year = "2000", + volume = "8", + series = pi, + publisher = carleton, + URL = "http://www.cee.hw.ac.uk/~jbw/itrs/itrs00/papers/Jim:ITRS-2000.ps.gz", +} + +@TechReport{jim-95, + author = "Trevor Jim", + title = "What are principal typings and what are they good + for?", + institution = "Massachusetts Institute of Technology", + year = "1995", + number = "MIT/LCS TM-532", + URL = "http://www.research.att.com/~trevor/papers/principal-typings.ps.gz", +} + +@Unpublished{jim-palsberg-99, + author = "Trevor Jim and Jens Palsberg", + title = "Type inference in systems of recursive types with + subtyping", + year = "1999", + note = "Manuscript", + URL = "http://www.cs.ucla.edu/~palsberg/draft/jim-palsberg99.pdf", +} + +@Manual{jml, + title = "{JML} Reference Manual", + author = "Gary T. Leavens and Erik Poll and Curtis Clifton and + Yoonsik Cheon and Clyde Ruby and David Cok and Peter + Müller and Joseph Kiniry and Patrice Chalin and Daniel + M. Zimmerman", + year = "2008", + URL = "http://www.jmlspecs.org/OldReleases/jmlrefman.pdf", +} + +@Article{jml-05, + author = "Lilian Burdy and Yoonsik Cheon and David Cok and + Michael Ernst and Joe Kiniry and Gary T. Leavens and K. + Rustan M. Leino and Erik Poll", + title = "An overview of {JML} tools and applications", + journal = sttt, + year = "2005", + volume = "7", + number = "3", + pages = "212--232", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/jml-sttt.pdf", +} + +@TechReport{johnson-75, + author = "Stephen C. Johnson", + title = "Yacc: Yet Another Compiler-Compiler", + institution = "Bell Laboratories", + year = "1975", + type = "Computing Science Technical Report", + number = "32", + URL = "http://dinosaur.compilertools.net/yacc/yacc.ps", +} + +@InProceedings{johnson-walz-86, + author = "Gregory F. Johnson and Janet A. Walz", + title = "A maximum-flow approach to anomaly isolation in + unification-based incremental type inference", + booktitle = popl, + pages = "44--57", + year = "1986", +} + +@InCollection{johnson-yacc-79, + author = "Steven C. Johnson", + title = "{Yacc}: Yet Another Compiler Compiler", + booktitle = "{UNIX} Programmer's Manual", + volume = "2", + publisher = "Holt, Rinehart, and Winston", + pages = "353--387", + year = "1979", + URL = "http://dinosaur.compilertools.net/", +} + +@InCollection{johnsson-85, + author = "Thomas Johnsson", + editor = "Jean-Pierre Jouannaud", + title = "Lambda Lifting: Transforming Programs to Recursive + Equations", + booktitle = fpca, + series = lncs, + volume = "201", + pages = "190--203", + publisher = springer, + year = "1985", + URL = "http://dx.doi.org/10.1007/3-540-15975-4_37", +} + +@InProceedings{jones-92, + author = "Mark P. Jones", + title = "A theory of qualified types", + booktitle = esop, + year = "1992", + volume = "582", + series = lncs, + publisher = springer, + URL = "http://web.cecs.pdx.edu/~mpj/pubs/esop92.html", +} + +@Book{jones-94, + author = "Mark P. Jones", + title = "Qualified Types: Theory and Practice", + publisher = cup, + year = "1994", +} + +@TechReport{jones-95, + author = "Mark P. Jones", + title = "From {Hindley-Milner} Types to First-Class + Structures", + institution = "Yale University", + year = "1995", + type = "Research Report", + number = "YALEU/DCS/RR-1075", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/haskwork95.html", +} + +@InProceedings{jones-96, + author = "Mark P. Jones", + title = "Using Parameterized Signatures to Express Modular + Structure", + booktitle = popl, + year = "1996", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/paramsig.html", +} + +@InProceedings{jones-dictionary-94, + author = "Mark P. Jones", + title = "Dictionary-free Overloading by Partial Evaluation", + booktitle = pepm, + year = "1994", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/pepm94.ps", +} + +@InProceedings{jones-peyton-jones-99, + author = "Mark P. Jones and Simon {Peyton Jones}", + title = "Lightweight Extensible Records for {Haskell}", + booktitle = hw, + year = "1999", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/recpro.ps.gz", +} + +@TechReport{jones-qualified-94, + author = "Mark P. Jones", + institution = "Yale University", + title = "Simplifying and Improving Qualified Types", + year = "1994", + number = "YALEU/DCS/RR-1040", + URL = "ftp://nebula.cs.yale.edu/pub/yale-fp/reports/RR-1040.ps.Z", +} + +@InProceedings{jones-thih-99, + author = "Mark P. Jones", + title = "Typing {Haskell} in {Haskell}", + booktitle = hw, + year = "1999", + URL = "http://web.cecs.pdx.edu/~mpj/thih/", +} + +@InProceedings{jorgensen-93, + author = "Niels Jørgensen", + title = "Chaotic Fixpoint Iteration Guided by Dynamic + Dependency", + booktitle = wsa, + year = "1993", + pages = "27--44", + series = lncs, + volume = "724", + publisher = springer, + URL = "http://webhotel2.ruc.dk/nielsj/research/publications/wsa93.ps", +} + +@InProceedings{jost-hammond-loidl-hofmann-10, + author = "Steffen Jost and Kevin Hammond and Hans{-}Wolfgang + Loidl and Martin Hofmann", + title = "Static determination of quantitative resource usage + for higher-order programs", + booktitle = popl, + pages = "223--236", + year = "2010", + URL = "http://www2.tcs.ifi.lmu.de/~jost/research/POPL_2010__Higher-Order_AA__Jost_etAl.pdf", +} + +@InProceedings{jost-loidl-hammond-scaife-hofmann-09, + author = "Steffen Jost and Hans{-}Wolfgang Loidl and Kevin + Hammond and Norman Scaife and Martin Hofmann", + title = "{"}Carbon Credits{"} for Resource-Bounded Computations + Using Amortised Analysis", + booktitle = fm, + pages = "354--369", + year = "2009", + series = lncs, + volume = "5850", + publisher = springer, + URL = "http://www2.tcs.ifi.lmu.de/~jost/research/FM09_AmortisedAnalysis__Jost_etAl.pdf", +} + +@TechReport{jouannaud-kirchner-90, + author = "Jean-Pierre Jouannaud and Claude Kirchner", + title = "Solving equations in abstract algebras: a rule-based + survey of unification", + institution = "Université Paris-Sud", + number = "561", + year = "1990", +} + +@InCollection{jouannaud-kirchner-91, + author = "Jean-Pierre Jouannaud and Claude Kirchner", + title = "Solving equations in abstract algebras: a rule-based + survey of unification", + booktitle = "Computational Logic. Essays in honor of Alan + Robinson", + publisher = mitp, + year = "1991", + editor = "Jean-Louis Lassez and Gordon Plotkin", + chapter = "8", + pages = "257--321", +} + +@InProceedings{jourdan-leroy-pottier-12, + author = "Jacques-Henri Jourdan and François Pottier and Xavier + Leroy", + title = "Validating ${LR}(1)$ Parsers", + year = "2012", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "7211", + pages = "397--416", + URL = "http://gallium.inria.fr/~fpottier/publis/jourdan-leroy-pottier-validating-parsers.pdf", +} + +@InProceedings{jourdan-verasco-15, + author = "Jacques{-}Henri Jourdan and Vincent Laporte and + Sandrine Blazy and Xavier Leroy and David Pichardie", + title = "A Formally-Verified {C} Static Analyzer", + booktitle = popl, + pages = "247--259", + year = "2015", + URL = "http://gallium.inria.fr/~xleroy/publi/verasco-popl2015.pdf", +} + +@InProceedings{jung-15, + author = "Ralf Jung and David Swasey and Filip Sieczkowski and + Kasper Svendsen and Aaron Turon and Lars Birkedal and + Derek Dreyer", + title = "Iris: Monoids and Invariants as an Orthogonal Basis + for Concurrent Reasoning", + booktitle = popl, + pages = "637--650", + year = "2015", + URL = "http://plv.mpi-sws.org/iris/paper.pdf", +} + +@Article{kam-ullman-76, + author = "John B. Kam and Jeffrey D. Ullman", + title = "Global Data Flow Analysis and Iterative Algorithms", + journal = jacm, + year = "1976", + volume = "23", + number = "1", + pages = "158--171", + URL = "http://doi.acm.org/10.1145/321921.321938", +} + +@Article{kam-ullman-77, + author = "John B. Kam and Jeffrey D. Ullman", + title = "Monotone Data Flow Analysis Frameworks", + journal = acta, + year = "1977", + volume = "7", + number = "3", + pages = "305--317", + URL = "http://dx.doi.org/10.1007/BF00290339", +} + +@InProceedings{kammar-lindley-oury-13, + author = "Ohad Kammar and Sam Lindley and Nicolas Oury", + title = "Handlers in action", + booktitle = icfp, + pages = "145--158", + year = "2013", + URL = "http://homepages.inf.ed.ac.uk/slindley/papers/handlers.pdf", +} + +@PhdThesis{kanig-10, + author = "Johannes Kanig", + title = "Specification and Proof of Higher-Order Programs", + school = "Université Paris-Sud", + year = "2010", + URL = "http://www.lri.fr/~kanig/files/thesis-kanig-15112010.pdf", +} + +@Article{kantorowitz-laor-86, + author = "E. Kantorowitz and H. Laor", + title = "Automatic generation of useful syntax error messages", + journal = spe, + volume = "16", + number = "7", + publisher = "John Wiley \& Sons", + URL = "http://dx.doi.org/10.1002/spe.4380160703", + pages = "627--640", + year = "1986", +} + +@InProceedings{kaplan-shafrir-tarjan-02, + author = "Haim Kaplan and Nira Shafrir and Robert E. Tarjan", + title = "Union-find with deletions", + booktitle = soda, + pages = "19--28", + year = "2002", + URL = "http://dl.acm.org/citation.cfm?id=545381.545384", +} + +@Article{kaplan-tarjan-99, + author = "Haim Kaplan and Robert E. Tarjan", + title = "Purely functional, real-time deques with catenation", + journal = jacm, + volume = "46", + number = "5", + year = "1999", + pages = "577--603", + URL = "http://www.math.tau.ac.il/~haimk/bob.ps", +} + +@Article{kapur-zhang-rrl, + author = "Deepak Kapur and Hantao Zhang", + title = "An overview of {Rewrite Rule Laboratory (RRL)}", + journal = "J. Comput. Appl. Math.", + year = "1995", + volume = "29", + number = "2", + pages = "91--114", + URL = "ftp://ftp.cs.albany.edu/pub/ipl/papers/overview.rrl.ps.gz", +} + +@TechReport{kashiwagi-wise-91, + author = "Yugo Kashiwagi and David S. Wise", + title = "Graph Algorithms in a Lazy Functional Programming + Language", + institution = "Indiana University", + year = "1991", + type = "Technical Report", + number = "330", + URL = "http://www.cs.indiana.edu/pub/techreports/TR330.pdf", +} + +@InProceedings{kassios-06, + author = "Ioannis T. Kassios", + title = "Dynamic Frames: Support for Framing, Dependencies and + Sharing Without Restrictions", + booktitle = fm, + year = "2006", + pages = "268--283", + publisher = springer, + series = lncs, + volume = "4085", + URL = "http://n.ethz.ch/~kassiosi/papers/fm06.pdf", +} + +@PhdThesis{keinanen-06, + author = "Misa Keinänen", + title = "Techniques For Solving {Boolean} Equation Systems", + school = "Helsinki University of Technology", + year = "2006", + note = "Research Report HUT-TCS-A105", + URL = "http://www.tcs.hut.fi/Publications/bibdb/HUT-TCS-A105.pdf", +} + +@Article{keisu-94, + author = "Torbjörn Keisu", + title = "Finite and Rational Tree Constraints", + journal = "Bulletin of the {IGPL}", + year = "1994", + volume = "2", + number = "2", + pages = "167--204", + URL = "http://www.dcs.kcl.ac.uk/journals/igpl/IGPL/V2-2/Keisu.ps.gz", +} + +@PhdThesis{keisu-phd-94, + author = "Torbjörn Keisu", + title = "Tree Constraints", + school = "The Royal Institute of Technology (KTH)", + year = "1994", + URL = "ftp://ftp.sics.se/pub/ps/papers/torbjorn-keisu-thesis.ps.gz", +} + +@InProceedings{kennedy-07, + author = "Andrew Kennedy", + title = "Compiling with continuations, continued", + booktitle = icfp, + year = "2007", + pages = "177--190", + URL = "http://research.microsoft.com/~akenn/sml/CompilingWithContinuationsContinued.pdf", +} + +@InProceedings{kennedy-75, + author = "Ken W. Kennedy", + title = "Node listings applied to data flow analysis", + booktitle = popl, + year = "1975", + pages = "10--21", + URL = "http://doi.acm.org/10.1145/512976.512978", +} + +@InProceedings{kennedy-94, + author = "Andrew Kennedy", + title = "Dimension Types", + booktitle = esop, + year = "1994", + volume = "788", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/~akenn/units/DimensionTypes.pdf", +} + +@TechReport{kennedy-96, + author = "Andrew Kennedy", + title = "Type Inference and Equational Theories", + institution = "École Polytechnique", + year = "1996", + number = "LIX/RR/96/09", +} + +@InProceedings{kerber-91, + author = "Manfred Kerber", + title = "How to Prove Higher Order Theorems in First Order + Logic", + booktitle = ijcai, + year = "1991", + pages = "137--142", + URL = "ftp://ftp.cs.bham.ac.uk/pub/authors/M.Kerber/91-IJCAI.pdf", +} + +@Book{kernighan-ritchie-88, + author = "Brian W. Kernighan and Dennis Ritchie", + title = "The {C} Programming Language, Second Edition", + publisher = prentice, + year = "1988", +} + +@InProceedings{kfoury-ml-90, + author = "Assaf J. Kfoury and Jerzy Tiuryn and Pawel Urzyczyn", + title = "{ML} Typability is {DEXPTIME}-Complete", + booktitle = "Colloquium on Trees in Algebra and Programming", + publisher = springer, + series = lncs, + volume = "431", + pages = "206--220", + year = "1990", + URL = "http://dx.doi.org/10.1007/3-540-52590-4_50", +} + +@Article{kfoury-recursion-93, + author = "A. J. Kfoury and J. Tiuryn and P. Urzyczyn", + title = "Type reconstruction in the presence of polymorphic + recursion", + journal = toplas, + volume = "15", + number = "2", + year = "1993", + pages = "290--311", + URL = "http://doi.acm.org/10.1145/169701.169687", +} + +@Article{kfoury-wells-2004, + author = "Assaf J. Kfoury and J. B. Wells", + title = "Principality and Type Inference for Intersection Types + Using Expansion Variables", + journal = tcs, + volume = "311", + number = "1--3", + pages = "1--70", + year = "2004", + URL = "http://www.church-project.org/reports/Kfo+Wel:TCSB-2004-v311n1-3.html", +} + +@Unpublished{kieburtz-02, + author = "Richard B. Kieburtz", + title = "${P}$-logic: Property verification for {Haskell} + programs", + note = "Draft", + year = "2002", + URL = "http://www.cse.ogi.edu/PacSoft/projects/programatica/plogic.pdf", +} + +@InProceedings{kieburtz-98, + author = "Richard B. Kieburtz", + title = "Taming effects with monadic typing", + booktitle = icfp, + year = "1998", + pages = "51--62", + URL = "http://doi.acm.org/10.1145/289423.289428", +} + +@InProceedings{kildall-73, + author = "Gary A. Kildall", + title = "A unified approach to global program optimization", + booktitle = popl, + year = "1973", + pages = "194--206", + URL = "http://doi.acm.org/10.1145/512927.512945", +} + +@InProceedings{kim-yi-calcagno-06, + author = "Ik-Soon Kim and Kwangkeun Yi and Cristiano Calcagno", + title = "A polymorphic modal type system for {Lisp}-like + multi-staged languages", + booktitle = popl, + year = "2006", + pages = "257--268", + URL = "http://www.doc.ic.ac.uk/~ccris/ftp/06-popl-kiyicr.pdf", +} + +@InProceedings{king-wadler-92, + author = "David King and Philip Wadler", + title = "Combining Monads", + booktitle = "Workshop on Functional Programming", + publisher = springer, + year = "1992", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/monadscomb/monadscomb.ps.gz", +} + +@InProceedings{kiselyov-shan-07, + author = "Oleg Kiselyov and Chung{-}chieh Shan", + title = "A Substructural Type System for Delimited + Continuations", + booktitle = tlca, + pages = "223--239", + year = "2007", + series = lncs, + volume = "4583", + publisher = springer, + URL = "http://homes.soic.indiana.edu/ccshan/binding/context.pdf", +} + +@Article{klein-seL4-2010, + author = "Gerwin Klein and June Andronick and Kevin Elphinstone + and Gernot Heiser and David Cock and Philip Derrin and + Dhammika Elkaduwe and Kai Engelhardt and Rafal Kolanski + and Michael Norrish and Thomas Sewell and Harvey Tuch + and Simon Winwood", + title = "{seL4}: formal verification of an operating-system + kernel", + journal = cacm, + volume = "53", + number = "6", + year = "2010", + pages = "107--115", + URL = "http://ertos.nicta.com.au/publications/papers/Klein_EHACDEEKNSTW_10.pdf", +} + +@InProceedings{kloos-majumdar-vafeiadis-15, + author = "Johannes Kloos and Rupak Majumdar and Viktor + Vafeiadis", + title = "Asynchronous Liquid Separation Types", + booktitle = ecoop, + pages = "396--420", + year = "2015", + URL = "https://www.mpi-sws.org/~viktor/papers/ecoop2015-alstypes.pdf", +} + +@Article{kmp-77, + author = "James H. Morris and Donald E. Knuth and Vaughan R. + Pratt", + title = "Fast Pattern Matching in Strings", + journal = siamjc, + year = "1977", + volume = "6", + number = "2", + pages = "323--350", + URL = "http://locus.siam.org/fulltext/SICOMP/volume-06/0206024.pdf", +} + +@Article{knight-89, + author = "Kevin Knight", + title = "Unification: a multidisciplinary survey", + journal = surveys, + year = "1989", + volume = "21", + number = "1", + pages = "93--124", + URL = "http://doi.acm.org/10.1145/62029.62030", +} + +@Article{knuth-77, + author = "Donald E. Knuth", + title = "A Generalization of {Dijkstra}'s Algorithm", + journal = ipl, + year = "1977", + volume = "6", + number = "1", + pages = "1--5", +} + +@Article{knuth-lr-65, + author = "Donald E. Knuth", + title = "On the translation of languages from left to right", + journal = "Information \& Control", + year = "1965", + volume = "8", + number = "6", + pages = "607--639", + URL = "http://www.sciencedirect.com/science/article/pii/S0019995865904262", +} + +@InProceedings{kobayashi-implicit-00, + author = "Naoki Kobayashi and Shin Saito and Eijiro Sumii", + title = "An Implicitly-Typed Deadlock-Free Process Calculus", + booktitle = concur, + publisher = springer, + series = lncs, + volume = "1877", + year = "2000", + pages = "489--503", + URL = "http://www.yl.is.s.u-tokyo.ac.jp/members/koba/papers/deadlock-inference-concur.ps.gz", +} + +@Article{kobayashi-linearity-99, + author = "Naoki Kobayashi and Benjamin C. Pierce and David N. + Turner", + title = "Linearity and the {Pi-Calculus}", + journal = toplas, + volume = "21", + number = "5", + pages = "914--947", + year = "1999", + URL = "http://doi.acm.org/10.1145/330249.330251", +} + +@Article{kobayashi-partial-98, + author = "Naoki Kobayashi", + title = "A Partially Deadlock-Free Typed Process Calculus", + journal = toplas, + volume = "20", + number = "2", + pages = "436--482", + year = "1998", + URL = "http://doi.acm.org/10.1145/276393.278524", +} + +@InProceedings{kobayashi-sumii-98, + author = "Eijiro Sumii and Naoki Kobayashi", + title = "A Generalized Deadlock-Free Process Calculus", + booktitle = hlcl, + year = "1998", + volume = "16", + series = entcs, + publisher = elsevier, + pages = "55--77", + URL = "http://www1.elsevier.com/gej-ng/31/29/23/40/26/39/tcs16.3.006.ps", +} + +@InProceedings{kobayashi-useless-00, + author = "Naoki Kobayashi", + title = "Type-based useless variable elimination", + pages = "84--93", + booktitle = pepm, + year = "2000", + URL = "http://www.yl.is.s.u-tokyo.ac.jp/members/koba/papers/PEPM00.ps.gz", +} + +@Article{koda-ruskey-93, + author = "Yasunori Koda and Frank Ruskey", + title = "A {Gray} Code for the Ideals of a Forest Poset", + journal = "Journal of Algorithms", + volume = "15", + number = "2", + year = "1993", + pages = "324--340", + URL = "http://www.cs.uvic.ca/~ruskey/Publications/ForestIdeals.ps", +} + +@InProceedings{kohlbecker-hygienic-86, + author = "Eugene Kohlbecker and Daniel P. Friedman and Matthias + Felleisen and Bruce Duba", + title = "Hygienic macro expansion", + booktitle = lfp, + year = "1986", + pages = "151--161", + URL = "http://doi.acm.org/10.1145/319838.319859", +} + +@InProceedings{kohlbecker-wand-87, + author = "Eugene E. Kohlbecker and Mitchell Wand", + title = "Macro-by-example: Deriving syntactic transformations + from their specifications", + booktitle = popl, + year = "1987", + pages = "77--84", + URL = "http://doi.acm.org/10.1145/41625.41632", +} + +@InProceedings{koprowski-binsztok-10, + author = "Adam Koprowski and Henri Binsztok", + title = "{TRX}: {A} Formally Verified Parser Interpreter", + booktitle = esop, + year = "2010", + pages = "345--365", + publisher = "Springer", + series = lncs, + volume = "6012", + URL = "http://adam-koprowski.net/papers/trx-ESOP-10.pdf", +} + +@Article{koprowski-binsztok-11, + author = "Adam Koprowski and Henri Binsztok", + title = "{TRX}: {A} Formally Verified Parser Interpreter", + journal = lmcs, + year = "2011", + volume = "7", + number = "2", + URL = "http://arxiv.org/pdf/1105.2576", +} + +@InProceedings{koved-al-02, + author = "Larry Koved and Marco Pistoia and Aaron Kershenbaum", + title = "Access rights analysis for {Java}", + pages = "359--372", + booktitle = oopsla, + year = "2002", + URL = "http://www.research.ibm.com/javasec/OOPSLA2002preprint.pdf", +} + +@Book{kozen-91, + author = "Dexter C. Kozen", + title = "The design and analysis of algorithms", + year = "1992", + series = "Texts and Monographs in Computer Science", + publisher = springer, + URL = "http://www.cs.cornell.edu/~kozen/papers/daa.pdf", +} + +@Article{kozen-palsberg-schwartzbach-95, + author = "Dexter Kozen and Jens Palsberg and Michael I. + Schwartzbach", + title = "Efficient Recursive Subtyping", + journal = mscs, + volume = "5", + number = "1", + pages = "113--125", + year = "1995", + URL = "http://www.cs.ucla.edu/~palsberg/paper/mscs95-kps.pdf", +} + +@InProceedings{krebbers-17, + author = "Robert Krebbers and Amin Timany and Lars Birkedal", + title = "Interactive proofs in higher-order concurrent + separation logic", + booktitle = popl, + year = "2017", + URL = "http://cs.au.dk/~birke/papers/ipm-conf.pdf", +} + +@InProceedings{krishnamurthi-99, + author = "Shriram Krishnamurthi and Matthias Felleisen and Bruce + F. Duba", + title = "From Macros to Reusable Generative Programming", + booktitle = gcse, + pages = "105--120", + year = "1999", + volume = "1799", + series = lncs, + publisher = springer, + URL = "http://www.cs.brown.edu/~sk/Publications/Papers/Published/kfd-macro-to-gen-prog/paper.ps", +} + +@PhdThesis{krishnaswami-12, + author = "Neelakantan R. Krishnaswami", + title = "Verifying Higher-Order Imperative Programs with + Higher-Order Separation Logic", + school = "School of Computer Science, Carnegie Mellon + University", + year = "2012", + URL = "http://www.cs.cmu.edu/~neelk/thesis.pdf", +} + +@InProceedings{krishnaswami-design-patterns-09, + author = "Neelakantan R. Krishnaswami and Jonathan Aldrich and + Lars {Bir\-ke\-dal} and Kasper Svendsen and Alexandre + Buisse", + title = "Design Patterns in Separation Logic", + booktitle = tldi, + pages = "105--116", + year = "2009", + URL = "http://www.cs.cmu.edu/~neelk/design-patterns-tldi09.pdf", +} + +@InProceedings{krishnaswami-sharing-12, + author = "Neelakantan R. Krishnaswami and Aaron Turon and Derek + Dreyer and Deepak Garg", + title = "Superficially substructural types", + booktitle = icfp, + year = "2012", + pages = "41--54", + URL = "http://www.mpi-sws.org/~neelk/icfp12-superficial-krishnaswami-turon-dreyer-garg.pdf", +} + +@Book{kroening-strichman-08, + author = "Daniel Kroening and Ofer Strichman", + title = "Decision procedures -- An algorithmic point of view", + publisher = springer, + year = "2008", + URL = "http://www.decision-procedures.org/", +} + +@InProceedings{kuan-07, + author = "George Kuan and David MacQueen", + title = "Efficient type inference using ranked type variables", + booktitle = ml, + year = "2007", + pages = "3--14", + URL = "http://people.cs.uchicago.edu/~gkuan/pubs/ml07-km.pdf", +} + +@InProceedings{kuncak-rinard-03, + author = "Viktor Kuncak and Martin Rinard", + title = "Structural Subtyping of Non-Recursive Types is + Decidable", + booktitle = lics, + year = "2003", + URL = "http://www.cag.lcs.mit.edu/~rinard/paper/lics03.pdf", +} + +@TechReport{kuncak-rinard-tr-03, + author = "Viktor Kuncak and Martin Rinard", + title = "On the Theory of Structural Subtyping", + institution = "MIT Laboratory for Computer Science", + year = "2003", + number = "879", + URL = "http://www.mit.edu/people/vkuncak/papers/TheoryStructuralSubtyping.ps", +} + +@InProceedings{laemmel-00, + author = "Ralf Lämmel and Joost Visser and Jan Kort", + title = "Dealing with Large Bananas", + pages = "46--59", + booktitle = wgp, + year = "2000", + URL = "http://homepages.cwi.nl/~ralf/wgp00.ps", +} + +@Unpublished{laemmel-scrap-05, + author = "Ralf Lämmel and Simon {Peyton Jones}", + title = "Scrap your boilerplate with class: extensible generic + functions", + note = "Submitted", + year = "2005", + URL = "http://research.microsoft.com/Users/simonpj/papers/hmap/gmap3.ps", +} + +@InProceedings{lai-user-99, + author = "Charlie Lai and Li Gong and Larry Koved and Anthony J. + Nadalin and Roland Schemers", + title = "User Authentication and Authorization in the {Java} + Platform", + booktitle = acsac, + pages = "285--290", + year = "1999", + URL = "http://www.acsac.org/1999/papers/thu-b-1500-lai.pdf", +} + +@InProceedings{lammich-13, + author = "Peter Lammich", + title = "Automatic Data Refinement", + booktitle = itp, + pages = "84--99", + year = "2013", + volume = "7998", + series = lncs, + publisher = springer, + URL = "http://www21.in.tum.de/~lammich/pub/autoref.pdf", +} + +@InProceedings{lammich-14, + author = "Peter Lammich", + title = "Verified Efficient Implementation of {Gabow}'s + Strongly Connected Component Algorithm", + booktitle = itp, + year = "2014", + pages = "325--340", + publisher = springer, + series = lncs, + volume = "8558", + URL = "http://www21.in.tum.de/~lammich/pub/gabow_scc.pdf", +} + +@InProceedings{lammich-15, + author = "Peter Lammich", + title = "Refinement to {Imperative/HOL}", + booktitle = itp, + pages = "253--269", + year = "2015", + series = lncs, + volume = "9236", + publisher = springer, + URL = "https://www21.in.tum.de/~lammich/pub/itp15_sepref.pdf", +} + +@InProceedings{lammich-16, + author = "Peter Lammich", + title = "Refinement Based Verification of Imperative Data + Structures", + booktitle = cpp, + year = "2016", + pages = "27--36", + URL = "https://www21.in.tum.de/~lammich/pub/cpp2016_impds.pdf", +} + +@InProceedings{lammich-lochbihler-10, + author = "Peter Lammich and Andreas Lochbihler", + title = "The {Isabelle} Collections Framework", + booktitle = itp, + pages = "339--354", + year = "2010", + series = lncs, + volume = "6172", + publisher = springer, + URL = "http://cs.uni-muenster.de/sev/publications/itp10.pdf", +} + +@Article{lammich-meis-12, + author = "Peter Lammich and Rene Meis", + title = "A Separation Logic Framework for {Imperative HOL}", + journal = "Archive of Formal Proofs", + year = "2012", + URL = "http://afp.sourceforge.net/entries/Separation_Logic_Imperative_HOL.shtml", +} + +@Article{lampson-73, + author = "Butler W. Lampson", + title = "A Note on the Confinement Problem", + journal = cacm, + volume = "16", + number = "10", + pages = "613--615", + year = "1973", + URL = "http://research.microsoft.com/lampson/11-Confinement/WebPage.html", +} + +@Article{landin-64, + author = "Peter J. Landin", + title = "The Mechanical Evaluation of Expressions", + journal = cj, + volume = "6", + number = "4", + year = "1964", + pages = "308--320", +} + +@Article{landin-65, + author = "Peter J. Landin", + title = "Correspondence between {ALGOL} 60 and {Church's} + Lambda-notation: part {I}", + journal = cacm, + volume = "8", + number = "2", + year = "1965", + pages = "89--101", + URL = "http://doi.acm.org/10.1145/363744.363749", +} + +@PhdThesis{larus-89, + author = "James Richard Larus", + title = "Restructuring Symbolic Programs for Concurrent + Execution on Multiprocessors", + school = "EECS Department, University of California, Berkeley", + year = "1989", + note = "Technical Report UCB/CSD-89-502", + URL = "http://www.eecs.berkeley.edu/Pubs/TechRpts/1989/CSD-89-502.pdf", +} + +@InProceedings{lassen-06, + author = "Soren B. Lassen", + title = "Head Normal Form Bisimulation for Pairs and the + $\lambda\mu$-Calculus", + booktitle = lics, + year = "2006", + pages = "297--306", + URL = "http://www.blassen.dk/soren/papers/2006lics.pdf", +} + +@InProceedings{lassen-99, + author = "Soren B. Lassen", + title = "Bisimulation in untyped lambda calculus: {Böhm} trees + and bisimulation up to context", + booktitle = mfps, + pages = "346--374", + year = "1999", + volume = "20", + series = entcs, + publisher = elsevier, + URL = "http://www.blassen.dk/soren/papers/1999mfps15.ps", +} + +@InCollection{lassez-al-88, + author = "Jean-Louis Lassez and Michael J. Maher and Kim G. + Marriott", + editor = "Jack Minker", + booktitle = "Foundations of Deductive Databases and Logic + Programming", + title = "Unification Revisited", + chapter = "15", + publisher = "Morgan Kaufmann", + year = "1988", + pages = "587--625", +} + +@Article{lassez-nguyen-sonenberg-82, + author = "Jean-Louis Lassez and V. L. Nguyen and Liz Sonenberg", + title = "Fixed point theorems and semantics: a folk tale", + journal = ipl, + year = "1982", + volume = "14", + number = "3", + pages = "112--116", + URL = "http://dx.doi.org/10.1016/0020-0190(82)90065-5", +} + +@InProceedings{laufer-odersky-92, + author = "Martin Odersky and Konstantin Läufer", + title = "An Extension of {ML} with First-Class Abstract Types", + year = "1992", + booktitle = mlapp, + pages = "78--91", + URL = "http://www.cs.luc.edu/laufer/papers/ml92.pdf", +} + +@Article{laufer-odersky-94, + author = "Konstantin L{\"a}ufer and Martin Odersky", + title = "Polymorphic Type Inference and Abstract Data Types", + journal = toplas, + year = "1994", + pages = "1411--1430", + volume = "16", + number = "5", + URL = "http://www.cs.luc.edu/laufer/papers/toplas94.pdf", +} + +@Article{launchbury-peyton-jones-95, + author = "John Launchbury and Simon Peyton Jones", + title = "State in {Haskell}", + journal = "{LISP} and Symbolic Computation", + publisher = springer, + pages = "293--341", + year = "1995", + volume = "8", + number = "4", + URL = "http://dx.doi.org/10.1007/BF01018827", +} + +@InProceedings{laviron-chang-rival-10, + author = "Vincent Laviron and Bor-Yuh Evan Chang and Xavier + Rival", + title = "Separating Shape Graphs", + booktitle = esop, + year = "2010", + pages = "387--406", + publisher = springer, + series = lncs, + volume = "6012", + URL = "http://xisa.cs.colorado.edu/papers/esop10-sepshapegraph.pdf", +} + +@TechReport{le-charlier-van-hentenryck-92, + author = "Baudouin {Le Charlier} and Pascal {Van Hentenryck}", + title = "A Universal Top-Down Fixpoint Algorithm", + institution = "Brown University", + year = "1992", + type = "Technical Report", + number = "CS-92-25", + URL = "ftp://ftp.cs.brown.edu/pub/techreports/92/cs92-25.ps.gz", +} + +@Article{le-metayer-88, + author = "Daniel {Le Métayer}", + title = "{ACE:} An Automatic Complexity Evaluator", + journal = toplas, + volume = "10", + number = "2", + pages = "248--266", + year = "1988", + URL = "http://doi.acm.org/10.1145/42190.42347", +} + +@Article{league-02, + author = "Christopher League and Zhong Shao and Valery + Trifonov", + title = "Type-Preserving Compilation of {Featherweight} + {Java}", + journal = toplas, + year = "2002", + volume = "24", + number = "2", + pages = "112--152", + URL = "http://flint.cs.yale.edu/flint/publications/fj-toplas.html", +} + +@InProceedings{league-03, + author = "Christopher League and Zhong Shao and Valery + Trifonov", + title = "Precision in Practice: a Type-Preserving {Java} + Compiler", + booktitle = cc, + pages = "106--120", + year = "2003", + volume = "2622", + series = lncs, + publisher = springer, + URL = "http://flint.cs.yale.edu/flint/publications/piptr.html", +} + +@InProceedings{league-99, + author = "Christopher League and Zhong Shao and Valery + Trifonov", + title = "Representing {Java} Classes in a Typed Intermediate + Language", + booktitle = icfp, + pages = "183--196", + year = "1999", + URL = "http://flint.cs.yale.edu/flint/publications/javaflint2.html", +} + +@InProceedings{leavens-baker-99, + author = "Gary T. Leavens and Albert L. Baker", + title = "Enhancing the Pre- and Postcondition Technique for + More Expressive Specifications", + booktitle = fm, + volume = "1709", + series = lncs, + year = "1999", + pages = "1087--1106", + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-48118-4_8", +} + +@InProceedings{lebotlan-remy-03, + author = "Didier {Le Botlan} and Didier R{\'e}my", + title = "{MLF}: Raising {ML} to the power of System ${F}$", + booktitle = icfp, + pages = "27--38", + year = "2003", + URL = "http://gallium.inria.fr/~remy/work/mlf/icfp.pdf", +} + +@InProceedings{lebresne-08, + author = "Sylvain Lebresne", + title = "A System ${F}$ with Call-by-Name Exceptions", + booktitle = icalp, + year = "2008", + pages = "323--335", + publisher = springer, + series = lncs, + volume = "5126", + URL = "http://www.pps.jussieu.fr/~lebresne/papers/SystemFWithExceptions.pdf", +} + +@Article{lee-yi-98, + author = "Oukseh Lee and Kwangkeun Yi", + title = "Proofs about a folklore let-polymorphic type inference + algorithm", + journal = toplas, + volume = "20", + number = "4", + year = "1998", + pages = "707--723", + URL = "http://doi.acm.org/10.1145/291891.291892", +} + +@InProceedings{lefessant-maranget-01, + author = "Fabrice {Le Fessant} and Luc Maranget", + title = "Optimizing Pattern Matching", + booktitle = icfp, + year = "2001", + URL = "http://gallium.inria.fr/~maranget/papers/opt-pat.ps.gz", +} + +@TechReport{leijen-algebraic-effects-16, + author = "Daan Leijen", + title = "Algebraic Effects for Functional Programming", + institution = "Microsoft Research", + number = "MSR-TR-2016-29", + year = "2016", + URL = "https://www.microsoft.com/en-us/research/publication/algebraic-effects-for-functional-programming/", +} + +@Article{leino-05, + author = "K. Rustan M. Leino", + title = "Efficient Weakest Preconditions", + journal = ipl, + year = "2005", + volume = "93", + number = "6", + pages = "281--288", + URL = "http://research.microsoft.com/pubs/70052/tr-2004-34.pdf", +} + +@InProceedings{leino-mueller-chalice-09, + author = "K. Rustan M. Leino and Peter M{\"u}ller", + title = "A Basis for Verifying Multi-threaded Programs", + booktitle = esop, + year = "2009", + pages = "378--393", + series = lncs, + volume = "5502", + publisher = springer, + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml191.pdf", +} + +@InProceedings{leino-mueller-smans-09, + author = "K. Rustan M. Leino and Peter Müller and Jan Smans", + title = "Verification of Concurrent Programs with {Chalice}", + booktitle = fosad, + year = "2009", + pages = "195--222", + publisher = springer, + series = lncs, + volume = "5705", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml197.pdf", +} + +@InProceedings{leino-mueller-smans-10, + author = "K. Rustan M. Leino and Peter Müller and Jan Smans", + title = "Deadlock-Free Channels and Locks", + booktitle = esop, + year = "2010", + pages = "407--426", + publisher = springer, + series = lncs, + volume = "6012", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml200ext.pdf", +} + +@Article{leino-nelson-02, + author = "K. Rustan M. Leino and Greg Nelson", + title = "Data abstraction and information hiding", + journal = toplas, + volume = "24", + number = "5", + year = "2002", + pages = "491--553", + URL = "http://research.microsoft.com/~leino/papers/krml71.pdf", +} + +@InProceedings{leino-schulte-07, + author = "K. Rustan M. Leino and Wolfram Schulte", + title = "Using History Invariants to Verify Observers", + booktitle = esop, + year = "2007", + pages = "80--94", + publisher = springer, + series = lncs, + volume = "4421", + URL = "http://research.microsoft.com/en-us/um/people/leino/papers/krml166.pdf", +} + +@PhdThesis{leroy-92, + author = "Xavier Leroy", + title = "Typage polymorphe d'un langage algorithmique", + school = "Université Paris 7", + year = "1992", + pages = "196", + URL = "http://gallium.inria.fr/~xleroy/publi/these-doctorat.ps.gz", +} + +@InProceedings{leroy-compcert-06, + author = "Xavier Leroy", + title = "Formal certification of a compiler back-end or: + programming a compiler with a proof assistant", + booktitle = popl, + year = "2006", + pages = "42--54", + URL = "http://gallium.inria.fr/~xleroy/publi/compiler-certif.pdf", +} + +@TechReport{leroy-phd-92, + author = "Xavier Leroy", + title = "Polymorphic typing of an algorithmic language", + institution = "INRIA", + year = "1992", + type = "Research Report", + number = "1778", + URL = "http://gallium.inria.fr/~xleroy/publi/phd-thesis.ps.gz", +} + +@MastersThesis{lescuyer-06, + author = "Stéphane Lescuyer", + title = "Codage de la logique du premier ordre polymorphe + multi-sortée dans la logique sans sortes", + school = "Master Parisien de Recherche en Informatique", + year = "2006", + URL = "http://www.seas.upenn.edu/~lescuyer/pdf/RapportDEA.pdf", +} + +@Article{lescuyer-11, + author = "St{\'{e}}phane Lescuyer", + title = "First-Class Containers in {Coq}", + journal = "Studia Informatica Universalis", + volume = "9", + number = "1", + pages = "87--127", + year = "2011", + URL = "http://studia.complexica.net/Art/RI090103.pdf", +} + +@PhdThesis{letouzey-04, + author = "Pierre Letouzey", + title = "Programmation fonctionnelle certifiée -- l'extraction + de programmes dans l'assistant {Coq}", + school = "Université Paris 11", + year = "2004", + URL = "http://www.lri.fr/~letouzey/download/these_letouzey.ps.gz", +} + +@InProceedings{levy-02, + author = "Paul Blain Levy", + title = "Possible World Semantics for General Storage in + Call-By-Value", + booktitle = csl, + series = lncs, + volume = "2471", + publisher = springer, + year = "2002", + URL = "http://www.cs.bham.ac.uk/~pbl/papers/storagecbv.ps", +} + +@InProceedings{lewis-al-00, + author = "Jeffrey Lewis and Mark Shields and Erik Meijer and + John Launchbury", + title = "Implicit Parameters: Dynamic Scoping with Static + Types", + booktitle = popl, + year = "2000", + pages = "108--118", + URL = "http://www.cse.ogi.edu/~mbs/pub/implicit_parameters/implicit.ps", +} + +@InProceedings{ley-wild-nanevski-subjective-13, + author = "Ruy Ley-Wild and Aleksandar Nanevski", + title = "Subjective auxiliary state for coarse-grained + concurrency", + booktitle = popl, + year = "2013", + pages = "561--574", + URL = "http://software.imdea.org/~aleks/papers/concur/scsl4.pdf", +} + +@InProceedings{licata-harper-09, + author = "Daniel R. Licata and Robert Harper", + title = "A universe of binding and computation", + booktitle = icfp, + year = "2009", + pages = "123--134", + URL = "http://www.cs.cmu.edu/~drl/pubs/lh09unibind/lh09unibind.pdf", +} + +@InProceedings{licata-zeilberger-harper-08, + author = "Daniel R. Licata and Noam Zeilberger and Robert + Harper", + title = "Focusing on Binding and Computation", + booktitle = lics, + year = "2008", + pages = "241--252", + URL = "http://www.cs.cmu.edu/~rwh/papers/focusing/paper.pdf", +} + +@TechReport{licata-zeilberger-harper-08-tr, + author = "Daniel R. Licata and Noam Zeilberger and Robert + Harper", + title = "Focusing on Binding and Computation", + institution = "Carnegie Mellon University", + year = "2008", + number = "CMU-CS-08-101", + URL = "http://www.cs.cmu.edu/~noam/research/lzh08focbind-tr.pdf", +} + +@InProceedings{lindley-mcbride-mclaughlin-17, + author = "Sam Lindley and Conor McBride and Craig McLaughlin", + title = "Do Be Do Be Do", + booktitle = popl, + year = "2017", + URL = "http://homepages.inf.ed.ac.uk/slindley/papers/frankly-draft-july2016.pdf", +} + +@Book{liskov-guttag-01, + author = "Barbara Liskov and John V. Guttag", + title = "Program Development in {Java} -- Abstraction, + Specification, and Object-Oriented Design", + year = "2001", + publisher = aw, + URL = "http://dl.acm.org/citation.cfm?id=556707", +} + +@Article{liskov-wing-94, + author = "Barbara Liskov and Jeannette M. Wing", + title = "A Behavioral Notion of Subtyping", + journal = toplas, + volume = "16", + number = "6", + year = "1994", + pages = "1811--1841", + URL = "http://www.cs.cmu.edu/~wing/publications/LiskovWing94.pdf", +} + +@InProceedings{liu-smolka-98, + author = "Xinxin Liu and Scott A. Smolka", + title = "Simple Linear-Time Algorithms for Minimal Fixed + Points", + booktitle = icalp, + year = "1998", + pages = "53--66", + series = lncs, + volume = "1443", + publisher = springer, + URL = "http://dx.doi.org/10.1007/BFb0055040", +} + +@TechReport{lngen-10, + author = "Brian Aydemir and Stephanie Weirich", + title = "{LNgen}: Tool Support for Locally Nameless + Representations", + institution = "University of Pennsylvania Department of Computer and + Information Science", + year = "2010", + type = "Technical Report", + number = "MS-CIS-10-24", + URL = "http://repository.upenn.edu/cis_reports/933/", +} + +@InProceedings{lochbihler-13, + author = "Andreas Lochbihler", + title = "Light-weight containers for {Isabelle}: efficient, + extensible, nestable", + booktitle = itp, + pages = "116--132", + year = "2013", + series = lncs, + volume = "7998", + publisher = springer, + URL = "https://pp.ipd.kit.edu/uploads/publikationen/lochbihler13itp.pdf", +} + +@InProceedings{longley-99, + author = "John Longley", + title = "When is a Functional Program Not a Functional + Program?", + booktitle = icfp, + year = "1999", + pages = "1--7", + URL = "http://doi.acm.org/10.1145/317636.317775", +} + +@InProceedings{longley-pollack-04, + author = "John Longley and Randy Pollack", + title = "Reasoning About {CBV} Functional Programs in + {Isabelle/HOL}", + booktitle = tphol, + year = "2004", + pages = "201--216", + URL = "http://homepages.inf.ed.ac.uk/rpollack/export/LongleyPollack04.pdf", + publisher = springer, + series = lncs, + volume = "3223", +} + +@InProceedings{lucassen-gifford-88, + author = "John M. Lucassen and David K. Gifford", + title = "Polymorphic effect systems", + booktitle = popl, + year = "1988", + pages = "47--57", + URL = "http://pag.lcs.mit.edu/reading-group/lucassen88effects.pdf", +} + +@Article{macqueen-plotkin-sethi-86, + author = "David B. MacQueen and Gordon D. Plotkin and Ravi + Sethi", + title = "An Ideal Model for Recursive Polymorphic Types", + journal = "Information and Control", + volume = "71", + number = "1--2", + year = "1986", + pages = "95--130", +} + +@PhdThesis{mader-97, + school = "Technische Universität München", + author = "Angelika Mader", + title = "Verification of Modal Properties Using {Boolean} + Equation Systems", + year = "1997", + URL = "http://eprints.eemcs.utwente.nl/1078/02/diss.pdf", +} + +@InProceedings{maeda-11, + author = "Toshiyuki Maeda and Haruki Sato and Akinori Yonezawa", + title = "Extended Alias Type System using Separating + Implication", + booktitle = tldi, + year = "2011", + pages = "29--42", + URL = "http://dx.doi.org/10.1145/1929553.1929559", +} + +@InProceedings{maher-88, + author = "Michael J. Maher", + title = "Complete Axiomatizations of the Algebras of Finite, + Rational and Infinite Trees", + booktitle = lics, + pages = "348--357", + year = "1988", +} + +@InProceedings{mairson-90, + author = "Harry G. Mairson", + title = "Deciding {ML} typability is complete for deterministic + exponential time", + booktitle = popl, + year = "1990", + pages = "382--401", + URL = "http://doi.acm.org/10.1145/96709.96748", +} + +@InCollection{mairson-kanellakis-mitchell-91, + author = "Harry G. Mairson and Paris C. Kanellakis and John C. + Mitchell", + title = "Unification and {ML} type reconstruction", + booktitle = "Computational Logic: Essays in Honor of Alan + Robinson", + publisher = mitp, + year = "1991", + editor = "J.-L. Lassez and G. Plotkin", + pages = "444--478", +} + +@Article{marche-krakatoa-04, + author = "Claude Marché and Christine Paulin-Mohring and Xavier + Urbain", + title = "The {Krakatoa} tool for certification of + {Java}/{JavaCard} programs annotated in {JML}", + journal = jlap, + year = "2004", + volume = "58", + number = "1--2", + pages = "89--106", + URL = "http://www3.ensiie.fr/~urbain/textes/jlap.ps.gz", +} + +@Article{maric-09, + author = "Filip Mari\'c", + title = "Formalization and Implementation of Modern {SAT} + Solvers", + journal = jar, + year = "2009", + volume = "43", + pages = "81--119", + URL = "http://poincare.matf.bg.ac.rs/~filip//phd/sat-tutorial.pdf", +} + +@Unpublished{maric-10, + author = "Filip Mari\'c", + title = "Formal Verification of a Modern {SAT} Solver", + note = "Unpublished", + year = "2010", + URL = "http://poincare.matf.bg.ac.rs/~filip//phd/sat-verification-shallow.pdf", +} + +@InProceedings{marlow-wadler-erlang-97, + title = "A Practical Subtyping System for {Erlang}", + author = "Simon Marlow and Philip Wadler", + pages = "136--149", + booktitle = icfp, + year = "1997", +} + +@TechReport{marriott-odersky-boolean-94, + author = "Kim Marriott and Martin Odersky", + title = "Negative {Boolean} Constraints", + institution = "Monash University", + year = "1994", + number = "94/203", + URL = "http://lampwww.epfl.ch/~odersky/papers/negative-tr.ps.gz", +} + +@Article{martelli-montanari-82, + author = "Alberto Martelli and Ugo Montanari", + title = "An Efficient Unification Algorithm", + journal = toplas, + volume = "4", + number = "2", + pages = "258--282", + year = "1982", + URL = "http://doi.acm.org/10.1145/357162.357169", +} + +@Article{mateescu-sighireanu-03, + author = "Radu Mateescu and Mihaela Sighireanu", + title = "Efficient on-the-fly model-checking for regular + alternation-free mu-calculus", + journal = scp, + volume = "46", + number = "3", + year = "2003", + pages = "255--281", + URL = "ftp://ftp.inrialpes.fr/pub/vasy/publications/cadp/Mateescu-Sighireanu-03.pdf", +} + +@TechReport{mauny-pottier-93, + author = "Michel Mauny and François Pottier", + title = "An implementation of {Caml Light} with existential + types", + number = "2183", + institution = "INRIA", + year = "1993", + URL = "http://gallium.inria.fr/~fpottier/publis/rapport-maitrise.ps.gz", +} + +@InProceedings{mazurak-10, + author = "Karl Mazurak and Jianzhou Zhao and Steve Zdancewic", + title = "Lightweight linear types in system ${F}^\circ$", + booktitle = tldi, + year = "2010", + pages = "77--88", + URL = "http://www.cis.upenn.edu/~stevez/papers/MZZ10.pdf", +} + +@InProceedings{mcadam-98, + title = "{On the Unification of Substitutions in Type + Inference}", + author = "Bruce J. McAdam", + publisher = springer, + booktitle = ifl, + series = lncs, + volume = "1595", + year = "1998", + pages = "139--154", + URL = "http://www.scms.rgu.ac.uk/staff/bjm/doc/IFL_98.ps", +} + +@Article{mcallester-02, + author = "David McAllester", + title = "On the Complexity Analysis of Static Analyses", + year = "2002", + pages = "512--537", + journal = jacm, + volume = "49", + number = "4", + URL = "http://doi.acm.org/10.1145/581771.581774", +} + +@InProceedings{mcallester-03, + author = "David McAllester", + title = "A Logical Algorithm for {ML} Type Inference", + booktitle = rta, + year = "2003", + pages = "436--451", + series = lncs, + publisher = springer, + volume = "2706", + URL = "http://ttic.uchicago.edu/~dmcallester/rta03.ps", +} + +@Unpublished{mcbride-derivative, + author = "Conor McBride", + title = "The Derivative of a Regular Type is its Type of + One-Hole Contexts", + note = "Unpublished", + URL = "http://strictlypositive.org/diff.pdf", +} + +@InProceedings{mcbride-mckinna-04, + author = "Conor McBride and James McKinna", + title = "{I} am not a number: {I} am a free variable", + booktitle = hw, + year = "2004", + URL = "http://www.cs.ru.nl/~james/RESEARCH/haskell2004.pdf", +} + +@Article{mcbride-paterson-08, + author = "Conor McBride and Ross Paterson", + title = "Applicative Programming with Effects", + journal = jfp, + year = "2008", + volume = "18", + number = "1", + pages = "1--13", + URL = "http://www.soi.city.ac.uk/~ross/papers/Applicative.pdf", +} + +@Article{mcbride-unif-03, + author = "Conor McBride", + title = "First-order unification by structural recursion", + journal = jfp, + volume = "13", + number = "6", + year = "2003", + pages = "1061--1075", + URL = "http://strictlypositive.org/unify.ps.gz", +} + +@InProceedings{mckinna-pollack-93, + author = "James McKinna and Randy Pollack", + title = "Pure Type Systems Formalized", + booktitle = tlca, + year = "1993", + pages = "289--305", + publisher = springer, + series = lncs, + number = "664", + URL = "http://www.dcs.ed.ac.uk/home/rap/export/formalPTS.ps.gz", +} + +@Article{mckinna-pollack-99, + author = "James McKinna and Randy Pollack", + title = "Some Lambda Calculus and Type Theory Formalized", + journal = jar, + year = "1999", + volume = "23", + number = "3--4", + pages = "373--409", +} + +@InCollection{mclean-94, + author = "John {McLean}", + title = "Security Models", + year = "1994", + booktitle = "Encyclopedia of Software Engineering", + editor = "John Marciniak", + publisher = "John Wiley \& Sons", + URL = "http://chacs.nrl.navy.mil/publications/CHACS/1994/1994mclean-ency.ps", +} + +@InProceedings{mclean-composition-94, + author = "John {McLean}", + title = "A General Theory of Composition for Trace Sets Closed + Under Selective Interleaving Functions", + year = "1994", + booktitle = sp, + URL = "http://chacs.nrl.navy.mil/publications/CHACS/1994/1994mclean-sp.ps", +} + +@InProceedings{meadows-94, + author = "Catherine Meadows", + title = "Formal Verification of Cryptographic Protocols: {A} + Survey", + booktitle = "Advances in Cryptology -- {ASIA\-CRYPT}'94", + year = "1995", + publisher = springer, + series = lncs, + volume = "917", + pages = "133--150", + URL = "http://chacs.nrl.navy.mil/publications/CHACS/1995/1995meadows-asiacrypt94.ps", +} + +@Article{mehta-nipkow-05, + author = "Farhad Mehta and Tobias Nipkow", + title = "Proving pointer programs in higher-order logic", + journal = ic, + volume = "199", + number = "1--2", + year = "2005", + pages = "200--227", + URL = "http://www4.informatik.tu-muenchen.de/~nipkow/pubs/ic05.ps.gz", +} + +@Article{melham-hol-93, + author = "Thomas F. Melham", + title = "The {HOL} Logic Extended with Quantification over Type + Variables", + journal = fmsd, + year = "1993", + volume = "3", + number = "1--2", + pages = "7--24", + URL = "http://web.comlab.ox.ac.uk/oucl/work/tom.melham/pub/Melham-1994-HLE.pdf", +} + +} + +@Article{melski-reps-00, + author = "David Melski and Thomas Reps", + title = "Interconvertibility of a class of set constraints and + context-free language reachability", + journal = tcs, + year = "2000", + volume = "248", + number = "1--2", + URL = "http://www.cs.wisc.edu/wpis/papers/tcs_submission98r2.ps", +} + +@Misc{menhir, + author = "François Pottier and Yann Régis-Gianas", + title = "The {Menhir} parser generator", + note = "\url{http://gallium.inria.fr/~fpottier/menhir/}", +} + +@Manual{merr, + title = "{Merr} User's Guide", + author = "Clinton L. Jeffery", + year = "2002", + URL = "http://unicon.sourceforge.net/merr/merrguid.pdf", +} + +@InProceedings{merz-00, + author = "Stephan Merz", + title = "Model Checking: {A} Tutorial Overview", + booktitle = "Fourth Summer School on Modeling and Verification of + Parallel Processes", + pages = "3--38", + publisher = springer, + series = lncs, + volume = "2067", + year = "2001", + URL = "http://www.loria.fr/~merz/papers/mc-tutorial.pdf", +} + +@InProceedings{merz-08, + author = "Stephan Merz", + editor = "N. Navet and S. Merz", + booktitle = "Modeling and Verification of Real-Time Systems: + Formalisms and Software Tools", + title = "An Introduction to Model Checking", + publisher = "ISTE Publishing", + year = "2008", + pages = "77--109", + URL = "http://www.loria.fr/~merz/papers/mc-iste2008.pdf", +} + +@InProceedings{miller-90, + author = "Dale Miller", + title = "An Extension to {ML} to Handle Bound Variables in Data + Structures", + booktitle = "Logical Frameworks BRA Workshop", + year = "1990", + URL = "http://www.lix.polytechnique.fr/Labo/Dale.Miller/papers/mll.pdf", +} + +@Article{miller-92, + author = "Dale Miller", + title = "Unification Under a Mixed Prefix", + journal = jsc, + volume = "14", + number = "4", + year = "1992", + pages = "321--358", + URL = "http://www.lix.polytechnique.fr/~dale/papers/jsc92.pdf", +} + +@Article{millstein-chambers-02, + author = "Todd Millstein and Craig Chambers", + title = "Modular statically typed multimethods", + journal = ic, + year = "2002", + volume = "175", + number = "1", + pages = "76--118", + URL = "http://www.cs.ucla.edu/~todd/research/iandc.ps", +} + +@InProceedings{millstein-chambers-99, + author = "Todd Millstein and Craig Chambers", + title = "Modular statically typed multimethods", + booktitle = ecoop, + pages = "279--303", + year = "1999", + volume = "1628", + series = lncs, + publisher = springer, + URL = "http://www.cs.ucla.edu/~todd/research/ecoop99.ps", +} + +@Article{milner-78, + title = "A Theory of Type Polymorphism in Programming", + author = "Robin Milner", + pages = "348--375", + journal = "Journal of Computer and System Sciences", + year = "1978", + volume = "17", + number = "3", + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.67.5276", +} + +@TechReport{milner-91, + author = "Robin Milner", + institution = "Laboratory for Foundations of Computer Science, + Department of Computer Science, University of + Edinburgh", + number = "{ECS--LFCS--91--180}", + title = "The Polyadic $\pi$-Calculus: a Tutorial", + year = "1991", + URL = "ftp://ftp.cl.cam.ac.uk/users/rm135/ppi.ps.Z", +} + +@InProceedings{milner-lcf-72, + author = "Robin Milner", + title = "Implementation and applications of {Scott's} logic for + computable functions", + booktitle = "Proceedings of the {ACM} conference on proving + assertions about programs", + year = "1972", + pages = "1--6", + URL = "http://doi.acm.org/10.1145/800235.807067", +} + +@TechReport{milner-lcf-tr-72, + author = "Robin Milner", + title = "Logic for Computable Functions -- Description of a + Machine Implementation", + institution = "Stanford University, Department of Computer Science", + year = "1972", + number = "CS-TR-72-288", + URL = "ftp://reports.stanford.edu/pub/cstr/reports/cs/tr/72/288/CS-TR-72-288.pdf", +} + +@TechReport{milner-lcf-tr-73, + author = "Robin Milner", + title = "Models of {LCF}", + institution = "Stanford University, Department of Computer Science", + year = "1973", + number = "CS-TR-73-332", + URL = "ftp://reports.stanford.edu/pub/cstr/reports/cs/tr/73/332/CS-TR-73-332.pdf", +} + +@TechReport{milner-parrow-walker-89b, + author = "Robin Milner and Joachim Parrow and David Walker", + title = "A Calculus of Mobile Processes, part 2", + institution = "Laboratory for Foundations of Computer Science, School + of Informatics at the University of Edinburgh", + year = "1989", + number = "ECS-LFCS-89-86", + URL = "http://www.lfcs.inf.ed.ac.uk/reports/89/ECS-LFCS-89-86/ECS-LFCS-89-86.ps", +} + +@InProceedings{milner-sangiorgi-92, + title = "Barbed Bisimulation", + author = "Robin Milner and Davide Sangiorgi", + booktitle = icalp, + year = "1992", + series = lncs, + volume = "623", + publisher = springer, + pages = "685--695", + URL = "ftp://ftp-sop.inria.fr/meije/theorie-par/davides/bn.ps.gz", +} + +@InProceedings{minamide-98, + author = "Yasuhiko Minamide", + title = "A functional representation of data structures with a + hole", + booktitle = popl, + year = "1998", + pages = "75--84", + URL = "http://www.score.cs.tsukuba.ac.jp/~minamide/papers/hole.popl98.pdf", +} + +@InProceedings{minamide-al-96, + author = "Yasuhiko Minamide and Greg Morrisett and Robert + Harper", + title = "Typed closure conversion", + booktitle = popl, + year = "1996", + pages = "271--283", + URL = "http://www.cs.cornell.edu/Info/People/jgm/papers/closure-summary.ps", +} + +@Article{mitchell-05, + author = "David G. Mitchell", + title = "A {SAT} Solver Primer", + journal = "Bulletin of the EATCS", + volume = "85", + year = "2005", + pages = "112--133", + URL = "http://www.cs.sfu.ca/~mitchell/papers/colLogCS85.pdf", +} + +@InProceedings{mitchell-84, + author = "John C. Mitchell", + title = "Coercion and type inference", + booktitle = popl, + pages = "175--185", + year = "1984", + URL = "http://portal.acm.org/citation.cfm?id=800529&dl=ACM&coll=portal", +} + +@InProceedings{mitchell-86, + author = "John C. Mitchell", + title = "Representation Independence and Data Abstraction", + booktitle = popl, + year = "1986", + pages = "263--276", + URL = "http://dx.doi.org/10.1145/512644.512669", +} + +@Article{mitchell-88, + author = "John C. Mitchell", + title = "Polymorphic type inference and containment", + journal = ic, + year = "1988", + volume = "76", + number = "2--3", + pages = "211--249", + URL = "http://dx.doi.org/10.1016/0890-5401(88)90009-0", +} + +@Article{mitchell-91, + author = "John C. Mitchell", + title = "Type Inference with Simple Subtypes", + journal = jfp, + year = "1991", + volume = "1", + number = "3", + pages = "245--286", +} + +@Book{mitchell-96, + author = "John C. Mitchell", + title = "Foundations for Programming Languages", + publisher = mitp, + year = "1996", +} + +@Article{mitchell-plotkin-88, + author = "John C. Mitchell and Gordon D. Plotkin", + title = "Abstract types have existential type", + journal = toplas, + volume = "10", + number = "3", + year = "1988", + pages = "470--502", + URL = "http://theory.stanford.edu/people/jcm/papers/mitch-plotkin-88.pdf", +} + +@InProceedings{mitls-13, + author = "Karthikeyan Bhargavan and C{\'{e}}dric Fournet and + Markulf Kohlweiss and Alfredo Pironti and Pierre{-}Yves + Strub", + title = "Implementing {TLS} with Verified Cryptographic + Security", + booktitle = sp, + pages = "445--459", + year = "2013", + URL = "http://prosecco.gforge.inria.fr/personal/karthik/pubs/implementing-tls-with-verified-cryptographic-security-sp13.pdf", +} + +@Article{mizuno-schmidt-92, + author = "Masaaki Mizuno and David A. Schmidt", + journal = fac, + title = "A Security Flow Control Algorithm and Its Denotational + Semantics Correctness Proof", + year = "1992", + volume = "4", + number = "6A", + pages = "727--754", + URL = "ftp://ftp.cis.ksu.edu/pub/CIS/Schmidt/papers/security.ps.Z", +} + +@Misc{mlton, + author = "Henry Cejtin and Matthew Fluet and Suresh Jagannathan + and Stephen Weeks", + title = "The {MLton} compiler", + year = "2007", + URL = "http://mlton.org/", +} + +@InProceedings{mogelberg-staton-10, + author = "Rasmus Ejlers Møgelberg and Sam Staton", + title = "Full abstraction in a metalanguage for state", + booktitle = lola, + year = "2010", +} + +@InProceedings{moggi-89, + author = "Eugenio Moggi", + title = "Computational $\lambda$-Calculus and Monads", + booktitle = lics, + year = "1989", + pages = "14--23", + URL = "http://www.disi.unige.it/person/MoggiE/ftp/lics89.ps.gz", +} + +@TechReport{moggi-89b, + author = "Eugenio Moggi", + title = "An abstract view of programming languages", + institution = "University of Edinburgh", + number = "ECS-LFCS-90-113", + year = "1989", + URL = "http://www.disi.unige.it/person/MoggiE/ftp/abs-view.ps.gz", +} + +@Article{moggi-91, + author = "Eugenio Moggi", + title = "Notions of computation and monads", + journal = ic, + year = "1991", + volume = "93", + number = "1", + URL = "http://www.disi.unige.it/person/MoggiE/ftp/ic91.pdf", +} + +@Article{moggi-sabry-04, + author = "Eugenio Moggi and Amr Sabry", + title = "An Abstract Monadic Semantics for Value Recursion", + journal = ita, + year = "2004", + volume = "38", + number = "4", + pages = "377--400", + URL = "http://www.disi.unige.it/person/MoggiE/ftp/ita04.pdf", +} + +@Article{monadic-regions-06, + author = "Matthew Fluet and Greg Morrisett", + title = "Monadic Regions", + journal = jfp, + year = "2006", + volume = "16", + number = "4--5", + pages = "485--545", + URL = "http://dx.doi.org/10.1017/S095679680600596X", +} + +@Unpublished{monnier-08, + author = "Stefan Monnier", + title = "Statically tracking state with Typed Regions", + note = "Unpublished", + year = "2008", + URL = "http://www.iro.umontreal.ca/~monnier/tr.pdf", +} + +@InProceedings{montagu-remy-09, + author = "Beno{\^\i}t Montagu and Didier R{\'e}my", + title = "Modeling Abstract Types in Modules with Open + Existential Types", + booktitle = popl, + year = "2009", + URL = "http://gallium.inria.fr/~remy/modules/Montagu-Remy@popl09:fzip.pdf", + pages = "63--74", +} + +@Article{morrisett-al-07, + title = "${L}^3$: {A} Linear Language with Locations", + author = "Amal Ahmed and Matthew Fluet and Greg Morrisett", + journal = fundamenta, + year = "2007", + number = "4", + volume = "77", + pages = "397--449", + URL = "http://ttic.uchicago.edu/~amal/papers/linloc-fi07.pdf", +} + +@Article{morrisett-ftal-99, + author = "Greg Morrisett and David Walker and Karl Crary and + Neal Glew", + title = "From System {F} to Typed Assembly Language", + journal = toplas, + year = "1999", + volume = "21", + number = "3", + pages = "528--569", + URL = "http://www.cs.cornell.edu/talc/papers/tal-toplas.pdf", +} + +@InProceedings{morrisett-rec-98, + author = "Greg Morrisett and Robert Harper", + title = "Typed Closure Conversion for Recursively-Defined + Functions (Extended Abstract)", + booktitle = hoots, + year = "1998", + series = entcs, + volume = "10", + publisher = elsevier, + URL = "http://www.cs.cornell.edu/home/jgm/papers/hootsclosure.ps", +} + +@InProceedings{moskewicz-chaff-01, + author = "Matthew W. Moskewicz and Conor F. Madigan and Ying + Zhao and Lintao Zhang and Sharad Malik", + title = "Chaff: Engineering an efficient {SAT} solver", + booktitle = dac, + year = "2001", + URL = "http://research.microsoft.com/users/lintaoz/papers/dac_2001.pdf", +} + +@Article{mosses-04, + author = "Peter D. Mosses", + title = "Modular structural operational semantics", + journal = jlap, + volume = "60--61", + year = "2004", + pages = "195--228", + URL = "http://www.brics.dk/RS/05/7/BRICS-RS-05-7.pdf", +} + +@InProceedings{mueller-94, + author = "Martin M{\"u}ller", + title = "A Constraint-Based Recast of {ML}-Polymorphism", + booktitle = "International Workshop on Unification", + year = "1994", + note = "Technical Report 94-R-243, CRIN, Nancy, France", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/UNIF94.ps", +} + +@Unpublished{mueller-98, + author = "Martin M{\"u}ller", + title = "Notes on {HM}$({X})$", + year = "1998", + URL = "http://www.ps.uni-sb.de/~mmueller/papers/HMX.ps.gz", + note = "Unpublished", +} + +@Article{mueller-feature-01, + title = "The First-Order Theory of Ordering Constraints over + Feature Trees", + year = "2001", + author = "Martin M{\"u}ller and Joachim Niehren and Ralf + Treinen", + journal = "Discrete Mathematics and Theoretical Computer + Science", + pages = "193--234", + number = "2", + volume = "4", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/FTSubTheory-Long:99.ps", +} + +@Article{mueller-holcf-99, + author = "Olaf Müller and Tobias Nipkow and David von Oheimb and + Oskar Slotosch", + title = "{HOLCF = HOL + LCF}", + journal = jfp, + volume = "9", + pages = "191--223", + year = "1999", + URL = "http://www4.informatik.tu-muenchen.de/~nipkow/pubs/jfp99.ps.gz", +} + +@Article{mueller-niehren-podelski-feature-99, + author = "Martin Müller and Joachim Niehren and Andreas + Podelski", + journal = "Constraints, an International Journal", + volume = "5", + number = "1--2", + title = "Ordering Constraints over Feature Trees", + mon = jan, + year = "2000", + pages = "7--42", + URL = "ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/ftsub-constraints-99.ps.gz", +} + +@InProceedings{mueller-niehren-podelski-ines-97, + author = "Joachim Niehren and Martin M{\"u}ller and Andreas + Podelski", + booktitle = tapsoft, + title = "Inclusion Constraints over Non-Empty Sets of Trees", + series = lncs, + publisher = springer, + volume = "1214", + year = "1997", + pages = "217--231", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/ines97.ps", +} + +@Article{mueller-nishimura-00, + author = "Martin M{\"u}ller and Susumu Nishimura", + title = "Type Inference for First-Class Messages with Feature + Constraints", + journal = ijfcs, + year = "2000", + volume = "11", + number = "1", + pages = "29--63", +} + +@InProceedings{mueller-nishimura-98, + author = "Martin M{\"u}ller and Susumu Nishimura", + title = "Type Inference for First-Class Messages with Feature + Constraints", + booktitle = asian, + pages = "169--187", + year = "1998", + volume = "1538", + series = lncs, + publisher = springer, + URL = "http://www.ps.uni-sb.de/Papers/abstracts/FirstClass98.ps", +} + +@TechReport{mueller-poetzsch-heffter-01, + author = "Peter M{\"u}ller and Arnd Poetzsch-Heffter", + title = "Universes: {A} Type System for Alias and Dependency + Control", + year = "2001", + institution = "Fernuniversit{\"a}t Hagen", + number = "279", + URL = "http://people.inf.ethz.ch/lehnerh/pm/publications/getpdf.php?bibname=Own&id=MuellerPoetzsch-Heffter01a.pdf", +} + +@InProceedings{mueller-rudich-07, + author = "Peter M{\"u}ller and Arsenii Rudich", + title = "Ownership transfer in universe types", + booktitle = oopsla, + year = "2007", + pages = "461--478", + URL = "http://dx.doi.org/10.1145/1297027.1297061", +} + +@InProceedings{mueller-schwerhoff-summers-16, + author = "Peter M{\"{u}}ller and Malte Schwerhoff and Alexander + J. Summers", + title = "Automatic Verification of Iterated Separating + Conjunctions Using Symbolic Execution", + booktitle = cav, + pages = "405--425", + year = "2016", + volume = "9779", + publisher = springer, + series = lncs, + URL = "https://arxiv.org/abs/1603.00649", +} + +@InProceedings{muller-rpc-98, + title = "Fast, optimized {Sun} {RPC} using automatic program + specialization", + author = "Gilles Muller and Renaud Marlet and Eugen-Nicolae + Volanschi and Charles Consel and Calton Pu and Ashvin + Goel", + booktitle = cdcs, + pages = "240--249", + year = "1998", + URL = "http://www.cc.gatech.edu/~calton/publications/dcs-98.pdf", +} + +@InProceedings{mycroft-84, + author = "Alan Mycroft", + title = "Polymorphic Type Schemes and Recursive Definitions", + booktitle = "International Symposium on Programming", + series = lncs, + volume = "167", + pages = "217--228", + year = "1984", + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-12925-1_41", +} + +@PhdThesis{myers-99, + author = "Andrew C. Myers", + title = "Mostly-Static Decentralized Information Flow Control", + school = "Massachusetts Institute of Technology", + year = "1999", + pages = "171", + note = "Technical Report MIT/LCS/TR-783", + URL = "http://www.cs.cornell.edu/andru/release/tr783.ps.gz", +} + +@Article{myers-liskov-00, + author = "Andrew C. Myers and Barbara Liskov", + title = "Protecting Privacy using the Decentralized Label + Model", + journal = "ACM Transactions on Software Engineering and + Methodology", + volume = "9", + number = "4", + year = "2000", + pages = "410--442", + URL = "http://www.cs.cornell.edu/andru/papers/iflow-tosem.ps.gz", +} + +@Article{myers-liskov-97, + author = "Andrew C. Myers and Barbara Liskov", + title = "A Decentralized Model for Information Flow Control", + year = "1997", + number = "5", + volume = "31", + pages = "129--142", + journal = "{ACM} Operating Systems Review", + URL = "http://www.cs.cornell.edu/andru/papers/iflow-sosp97/paper.html", +} + +@InProceedings{myers-liskov-98, + author = "Andrew C. Myers and Barbara Liskov", + title = "Complete, Safe Information Flow with Decentralized + Labels", + year = "1998", + pages = "186--197", + booktitle = sp, + URL = "http://www.cs.cornell.edu/andru/papers/sp98/top.html", +} + +@InProceedings{myers-popl-99, + author = "Andrew C. Myers", + title = "{JFlow}: practical mostly-static information flow + control", + booktitle = popl, + year = "1999", + pages = "228--241", + URL = "http://www.cs.cornell.edu/andru/papers/popl99/myers-popl99.ps.gz", +} + +@Article{myers-sabelfeld-03, + author = "Andrew C. Myers and Andrei Sabelfeld", + title = "Language-Based Information-Flow Security", + journal = "IEEE Journal on Selected Areas in Communications", + year = "2003", + volume = "21", + number = "1", + pages = "5--19", + URL = "http://www.cs.cornell.edu/andru/papers/jsac/sm-jsac03.pdf", +} + +@InProceedings{nadathur-qi-03, + author = "Gopalan Nadathur and Xiaochu Qi", + title = "Explicit Substitutions in the Reduction of Lambda + Terms", + booktitle = ppdp, + pages = "195--206", + year = "2003", + URL = "http://www-users.cs.umn.edu/~gopalan/papers/reduction.ps", + alturl = "http://doi.acm.org/10.1145/888270", +} + +@Book{naftalin-wadler-06, + author = "Maurice Naftalin and Philip Wadler", + title = "{Java} generics and collections", + publisher = "O'Reilly", + year = "2006", + URL = "http://shop.oreilly.com/product/9780596527754.do", +} + +@InProceedings{nakano-00, + author = "Hiroshi Nakano", + title = "A Modality for Recursion", + booktitle = lics, + pages = "255--266", + year = "2000", + URL = "http://www602.math.ryukoku.ac.jp/~nakano/papers/modality-lics00.ps.gz", +} + +@InProceedings{nakano-01, + author = "Hiroshi Nakano", + title = "Fixed-point Logic with the Approximation Modality and + Its {Kripke} Completeness", + booktitle = tacs, + pages = "165--182", + year = "2001", + volume = "2215", + series = lncs, + publisher = springer, + URL = "http://www602.math.ryukoku.ac.jp/~nakano/papers/modality-tacs01.pdf", +} + +@TechReport{nanevski-02, + author = "Aleksandar Nanevski", + title = "Meta-Programming with Names and Necessity", + institution = "School of Computer Science, Carnegie Mellon + University", + year = "2002", + number = "CMU-CS-02-123R", + URL = "http://www.eecs.harvard.edu/~aleks/papers/necessity/techrep2.ps", +} + +@InProceedings{nanevski-htt-06, + author = "Aleksandar Nanevski and Greg Morrisett and Lars + Birkedal", + title = "Polymorphism and Separation in {Hoare} Type Theory", + booktitle = icfp, + pages = "62--73", + year = "2006", + URL = "http://www.eecs.harvard.edu/~aleks/papers/hoarelogic/icfp06.pdf", +} + +@InProceedings{nanevski-htt-07, + author = "Aleksandar Nanevski and Amal Ahmed and Greg Morrisett + and Lars Birkedal", + title = "Abstract Predicates and Mutable {ADTs} in {Hoare} Type + Theory", + booktitle = esop, + year = "2007", + series = lncs, + volume = "4421", + pages = "189--204", + publisher = springer, + URL = "http://ynot.cs.harvard.edu/papers/esop07.pdf", +} + +@Article{nanevski-htt-08, + author = "Aleksandar Nanevski and Greg Morrisett and Lars + Birkedal", + title = "{Hoare} Type Theory, Polymorphism and Separation", + journal = jfp, + year = "2008", + volume = "18", + number = "5--6", + pages = "865--911", + URL = "http://ynot.cs.harvard.edu/papers/jfpsep07.pdf", +} + +@InProceedings{nanevski-structuring-10, + author = "Aleksandar Nanevski and Viktor Vafeiadis and Josh + Berdine", + title = "Structuring the verification of heap-manipulating + programs", + booktitle = popl, + year = "2010", + pages = "261--274", + URL = "http://software.imdea.org/~aleks/papers/reflect/reflect.pdf", +} + +@InProceedings{nanevski-ynot-08, + author = "Aleksandar Nanevski and Greg Morrisett and Avraham + Shinnar and Paul Govereau and Lars Birkedal", + title = "Ynot: dependent types for imperative programs", + booktitle = icfp, + year = "2008", + pages = "229--240", + URL = "http://software.imdea.org/~aleks/htt/ynot08.pdf", +} + +@Article{naraschewski-nipkow-99, + author = "Wolfgang Naraschewski and Tobias Nipkow", + title = "Type Inference Verified: Algorithm {W} in + {Isabelle/HOL}", + journal = jar, + year = "1999", + volume = "23", + pages = "299--318", + URL = "http://www4.informatik.tu-muenchen.de/~nipkow/pubs/W.ps.gz", +} + +@Article{naumann-survey-07, + author = "David A. Naumann", + title = "On assertion-based encapsulation for object invariants + and simulations", + journal = fac, + volume = "19", + number = "2", + year = "2007", + pages = "205--224", + publisher = springer, + URL = "https://guinness.cs.stevens-tech.edu/~naumann/publications/fmcoFinal.pdf", +} + +@InProceedings{navarro-perez-rybalchenko-11, + author = "Juan Antonio {Navarro P{\'e}rez} and Andrey + Rybalchenko", + title = "Separation logic + superposition calculus = heap + theorem prover", + booktitle = pldi, + year = "2011", + pages = "556--566", + URL = "http://www7.informatik.tu-muenchen.de/um/bibdb/navarro/pldi2011.pdf", +} + +@InProceedings{neumann-12, + author = "René Neumann", + booktitle = "ATx/WInG: Joint Proceedings of the Workshops on + Automated Theory eXploration and on Invariant + Generation", + pages = "36--45", + title = "A Framework for Verified Depth-First Algorithms", + publisher = "EasyChair", + series = "EPiC Series", + volume = "17", + year = "2012", + URL = "http://www.easychair.org/publications/?page=722211206", +} + +@InProceedings{nguyen-07, + author = "Huu Hai Nguyen and Cristina David and Shengchao Qin + and Wei-Ngan Chin", + title = "Automated Verification of Shape and Size Properties + Via Separation Logic", + booktitle = vmcai, + year = "2007", + pages = "251--266", + publisher = springer, + series = lncs, + volume = "4349", + URL = "http://www.scm.tees.ac.uk/s.qin/papers/vmcai07.pdf", +} + +@InProceedings{nicklisch-peyton-jones-96, + author = "Jan Nicklisch and Simon {Peyton Jones}", + title = "An exploration of modular programs", + booktitle = "Functional Programming Workshop", + year = "1996", + URL = "http://www.dcs.gla.ac.uk/fp/workshops/fpw96/Nicklisch.ps.gz", +} + +@InProceedings{niehren-priesnitz-01, + author = "Joachim Niehren and Tim Priesnitz", + title = "Non-Structural Subtype Entailment in Automata Theory", + booktitle = tacs, + publisher = springer, + year = "2001", + URL = "ftp://ftp.ps.uni-sb.de/pub/papers/ProgrammingSysLab/pauto.ps.gz", +} + +@Article{niehren-priesnitz-03, + author = "Joachim Niehren and Tim Priesnitz", + title = "Non-Structural Subtype Entailment in Automata Theory", + journal = ic, + year = "2003", + volume = "186", + number = "2", + pages = "319--354", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/subtype.pdf", +} + +@TechReport{nielsen-00, + author = "Lasse R. Nielsen", + title = "A denotational investigation of defunctionalization", + year = "2000", + institution = "BRICS", + number = "RS-00-47", + URL = "http://www.brics.dk/RS/00/47/", +} + +@Article{nielson-02, + author = "Flemming Nielson and Hanne Riis Nielson and Helmut + Seidl", + title = "A Succinct Solver for {ALFP}", + journal = njc, + year = "2002", + volume = "9", + number = "4", + pages = "335--372", + URL = "http://www.informatik.uni-trier.de/~seidl/papers/succinct.pdf", +} + +@Article{nielson-88, + author = "Flemming Nielson and Hanne Riis Nielson", + title = "Two-Level Semantics and Code Generation", + year = "1988", + pages = "59--133", + journal = tcs, + volume = "56", + number = "1", + URL = "http://dx.doi.org/10.1016/0304-3975(86)90006-X", +} + +@Article{nieuwenhuis-oliveras-tinelli-06, + author = "Robert Nieuwenhuis and Albert Oliveras and Cesare + Tinelli", + title = "Solving {SAT} and {SAT Modulo Theories}: From an + abstract {Davis--Putnam--Logemann--Loveland} procedure + to {DPLL(T)}", + journal = jacm, + volume = "53", + number = "6", + year = "2006", + pages = "937--977", + URL = "ftp://ftp.cs.uiowa.edu/pub/tinelli/papers/NieOT-JACM-06.pdf", +} + +@InProceedings{nipkow-15, + author = "Tobias Nipkow", + title = "Amortized Complexity Verified", + year = "2015", + booktitle = itp, + pages = "310--324", + volume = "9236", + series = lncs, + publisher = springer, + URL = "http://www21.in.tum.de/~nipkow/pubs/itp15.pdf", +} + +@InProceedings{nishimura-98, + title = "Static Typing for Dynamic Messages", + author = "Susumu Nishimura", + pages = "266--278", + booktitle = popl, + year = "1998", + URL = "ftp://ftp.kurims.kyoto-u.ac.jp/pub/paper/member/nisimura/dmesg-popl98.ps.gz", +} + +@InProceedings{ntzik-gardner-15, + author = "Gian Ntzik and Philippa Gardner", + title = "Reasoning about the {POSIX} file system: local update + and global pathnames", + booktitle = oopsla, + pages = "201--220", + year = "2015", + URL = "https://www.doc.ic.ac.uk/~pg/papers/oopsla2015.pdf", +} + +@Article{o'hearn-03, + author = "Peter O'Hearn", + title = "On Bunched Typing", + journal = jfp, + year = "2003", + volume = "13", + number = "4", + pages = "747--796", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/BunchedTyping.pdf", +} + +@Manual{objective-caml, + author = "Xavier Leroy and Damien Doligez and Jacques Garrigue + and Didier Rémy and Jérôme Vouillon", + title = "The {Objective Caml} system", + year = "2005", + URL = "http://caml.inria.fr/", +} + +@Article{oconnor-07, + author = "Russell O'Connor", + title = "Assembly: Circular Programming with Recursive do", + journal = "The Monad.Reader", + year = "2007", + volume = "6", + URL = "http://www.haskell.org/sitewiki/images/1/14/TMR-Issue6.pdf", +} + +@InProceedings{odersky-laufer-96, + author = "Martin Odersky and Konstantin Läufer", + title = "Putting Type Annotations To Work", + booktitle = popl, + year = "1996", + pages = "54--67", + URL = "http://lamp.epfl.ch/~odersky/papers/popl96.ps.gz", +} + +@InProceedings{odersky-local-94, + author = "Martin Odersky", + title = "A Functional Theory of Local Names", + pages = "48--59", + booktitle = popl, + year = "1994", + URL = "http://lampwww.epfl.ch/~odersky/papers/popl94.ps.gz", +} + +@InProceedings{odersky-observers-92, + author = "Martin Odersky", + title = "Observers for Linear Types", + booktitle = esop, + pages = "390--407", + year = "1992", + volume = "582", + series = lncs, + publisher = springer, + URL = "http://lamp.epfl.ch/~odersky/papers/esop92.ps.gz", +} + +@Article{odersky-sulzmann-wehr-99, + author = "Martin Odersky and Martin Sulzmann and Martin Wehr", + title = "Type Inference with Constrained Types", + journal = tapos, + year = "1999", + volume = "5", + number = "1", + pages = "35--55", + URL = "http://eprints.kfupm.edu.sa/73647/1/73647.pdf", +} + +@InProceedings{odersky-wadler-wehr-95, + author = "Martin Odersky and Philip Wadler and Martin Wehr", + title = "A Second Look at Overloading", + booktitle = fpca, + pages = "135--146", + year = "1995", + URL = "http://lampwww.epfl.ch/~odersky/papers/fpca95.ps.gz", +} + +@InProceedings{odersky-zenger-zenger-01, + author = "Martin Odersky and Matthias Zenger and Christoph + Zenger", + title = "Colored Local Type Inference", + booktitle = popl, + year = "2001", + pages = "41--53", + URL = "http://lampwww.epfl.ch/papers/clti-colored.ps.gz", +} + +@Article{ohearn-07, + author = "Peter W. O'Hearn", + title = "Resources, Concurrency and Local Reasoning", + journal = tcs, + year = "2007", + volume = "375", + number = "1--3", + pages = "271--307", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/concurrency.pdf", +} + +@InProceedings{ohearn-hiding-04, + author = "Peter W. O'Hearn and Hongseok Yang and John C. + Reynolds", + title = "Separation and information hiding", + booktitle = popl, + pages = "268--280", + year = "2004", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/separation-and-hiding.pdf", +} + +@Article{ohearn-hiding-09, + author = "Peter W. O'Hearn and Hongseok Yang and John C. + Reynolds", + title = "Separation and information hiding", + journal = toplas, + volume = "31", + number = "3", + year = "2009", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/toplas09.pdf", +} + +@Article{ohearn-reynolds-00, + author = "Peter W. O'Hearn and John C. Reynolds", + title = "From {Algol} to polymorphic linear lambda-calculus", + journal = jacm, + volume = "47", + number = "1", + year = "2000", + pages = "167--223", + URL = "http://www.cs.ucl.ac.uk/staff/p.ohearn/papers/AlgolToPolyLin.ps", +} + +@Article{ohearn-scir-99, + author = "Peter W. O'Hearn and John Power and Makoto Takeyama + and Robert D. Tennent", + title = "Syntactic Control of Interference Revisited", + journal = tcs, + volume = "228", + number = "1-2", + pages = "211--252", + year = "1999", + URL = "http://surface.syr.edu/cgi/viewcontent.cgi?article=1011&context=lcsmith_other", +} + +@Article{ohori-95, + author = "Atsushi Ohori", + title = "A Polymorphic Record Calculus and Its Compilation", + journal = toplas, + volume = "17", + number = "6", + pages = "844--895", + year = "1995", + URL = "http://doi.acm.org/10.1145/218570.218572", +} + +@InProceedings{ohori-buneman-88, + author = "Atsushi Ohori and Peter Buneman", + title = "Type Inference in a Database Programming Language", + booktitle = lfp, + pages = "174--183", + year = "1988", + URL = "http://www.jaist.ac.jp/~ohori/research/lfp88.pdf", +} + +@InProceedings{okasaki-96, + author = "Chris Okasaki", + title = "The role of lazy evaluation in amortized data + structures", + booktitle = icfp, + year = "1996", + pages = "62--72", + URL = "http://www.eecs.usma.edu/webs/people/okasaki/icfp96.ps", +} + +@InProceedings{okasaki-98, + author = "Chris Okasaki and Andy Gill", + title = "Fast Mergeable Integer Maps", + booktitle = ml, + pages = "77--86", + year = "1998", + URL = "http://www.cse.ogi.edu/~andy/papers/ml98maps.ps", +} + +@Book{okasaki-book-99, + author = "Chris Okasaki", + title = "Purely Functional Data Structures", + publisher = cup, + year = "1999", + URL = "http://www.cambridge.org/us/catalogue/catalogue.asp?isbn=0521663504", +} + +@TechReport{okasaki-phd-96, + author = "Chris Okasaki", + title = "Purely Functional Data Structures", + institution = "School of Computer Science, Carnegie Mellon + University", + year = "1996", + number = "CMU-CS-96-177", + URL = "http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf", +} + +@InProceedings{okasaki-views-98, + author = "Chris Okasaki", + title = "Views for {Standard ML}", + booktitle = ml, + pages = "14--23", + year = "1998", + URL = "http://www.eecs.usma.edu/Personnel/okasaki/ml98views.ps", +} + +@InProceedings{olderog-83, + author = "Ernst-Rüdiger Olderog", + title = "A characterization of {Hoare's} logic for programs + with {Pascal}-like procedures", + booktitle = stoc, + year = "1983", + pages = "320--329", + URL = "http://doi.acm.org/10.1145/800061.808761", +} + +@Manual{omega, + title = "{${\Omega}$}mega", + author = "Tim Sheard", + year = "2005", + URL = "http://www.cs.pdx.edu/~sheard/Omega/", +} + +@Article{oostrom-94, + author = "Vincent van Oostrom", + title = "Confluence by decreasing diagrams", + journal = tcs, + volume = "126", + number = "2", + pages = "259--280", + year = "1994", + URL = "ftp://ftp.cs.vu.nl/pub/papers/theory/IR-298.ps.Z", +} + +@Book{orourke-98, + author = "Joseph O'Rourke", + title = "Computational Geometry in {C}, Second Edition", + publisher = cup, + year = "1998", + URL = "http://maven.smith.edu/~orourke/books/compgeom.html", +} + +@InProceedings{otoole-gifford-89, + author = "James William {O'Toole, Jr.} and David K. Gifford", + title = "Type reconstruction with first-class polymorphic + values", + booktitle = pldi, + year = "1989", + pages = "207--217", + URL = "http://www.psrg.lcs.mit.edu/history/publications/Papers/pldi89-otoole.ps", +} + +@Article{ott-10, + author = "Peter Sewell and Francesco {Zappa Nardelli} and Scott + Owens and Gilles Peskine and Thomas Ridge and Susmit + Sarkar and Rok Strnisa", + title = "{Ott}: Effective tool support for the working + semanticist", + journal = jfp, + volume = "20", + number = "1", + pages = "71--122", + year = "2010", + URL = "http://www.cl.cam.ac.uk/~pes20/ott/ott-jfp.pdf", +} + +@Article{owens-reppy-turon-09, + author = "Scott Owens and John H. Reppy and Aaron Turon", + title = "Regular-expression derivatives re-examined", + journal = jfp, + volume = "19", + number = "2", + year = "2009", + pages = "173--190", + URL = "http://www.cl.cam.ac.uk/~so294/documents/jfp09.pdf", +} + +@Article{pager-77, + author = "David Pager", + title = "A Practical General Method for Constructing ${LR}(k)$ + Parsers", + journal = acta, + year = "1977", + volume = "7", + pages = "249--268", + URL = "http://dx.doi.org/10.1007/BF00290336", +} + +@Article{paige-tarjan-87, + author = "Robert Paige and Robert E. Tarjan", + title = "Three partition refinement algorithms", + journal = siamjc, + volume = "16", + number = "6", + pages = "973--989", + year = "1987", + URL = "http://locus.siam.org/fulltext/SICOMP/volume-16/0216062.pdf", +} + +@InProceedings{pale-01, + author = "Anders M{\o}ller and Michael I. Schwartzbach", + title = "The Pointer Assertion Logic Engine", + booktitle = pldi, + year = "2001", + pages = "221--231", + URL = "http://www.brics.dk/~amoeller/papers/pale/pale.pdf", +} + +@Article{palsberg-efficient-object-95, + author = "Jens Palsberg", + title = "Efficient inference of object types", + journal = ic, + volume = "123", + number = "2", + pages = "198--209", + year = "1995", + URL = "http://www.cs.ucla.edu/~palsberg/paper/ic95-p.pdf", +} + +@Article{palsberg-okeefe-flow-95, + author = "Jens Palsberg and Patrick M. O'Keefe", + title = "A Type System Equivalent to Flow Analysis", + journal = toplas, + year = "1995", + volume = "17", + number = "4", + pages = "576--599", + URL = "http://www.cs.ucla.edu/~palsberg/paper/toplas95-po.pdf", +} + +@InProceedings{palsberg-orbaek-95, + author = "Jens Palsberg and Peter {\O}rb{\ae}k", + booktitle = sas, + title = "Trust in the {$\lambda$}-calculus", + series = "Lecture Notes in Computer Science", + volume = "983", + pages = "314--330", + year = "1995", + URL = "ftp://ftp.daimi.au.dk/pub/empl/poe/lambda-trust.dvi.gz", +} + +@Article{palsberg-orbaek-97, + title = "Trust in the {$\lambda$}-calculus", + author = "Peter {\O}rb{\ae}k and Jens Palsberg", + pages = "557--591", + journal = jfp, + year = "1997", + volume = "7", + number = "6", + URL = "http://www.cs.ucla.edu/~palsberg/paper/jfp97.pdf", +} + +@Article{palsberg-smith-96, + author = "Jens Palsberg and Scott Smith", + title = "Constrained types and their expressiveness", + journal = toplas, + volume = "18", + number = "5", + pages = "519--527", + year = "1996", + URL = "http://www.cs.ucla.edu/~palsberg/paper/toplas96-ps.pdf", +} + +@Article{palsberg-wand-okeefe-97, + title = "Type inference with non-structural subtyping", + author = "Jens Palsberg and Mitchell Wand and Patrick M. + O'Keefe", + journal = fac, + year = "1997", + pages = "49--67", + volume = "9", + URL = "http://www.cs.ucla.edu/~palsberg/paper/fac97.pdf", +} + +@Article{palsberg-zhao-01, + author = "Jens Palsberg and Tian Zhao", + title = "Efficient and Flexible Matching of Recursive Types", + journal = ic, + volume = "171", + pages = "364--387", + year = "2001", + URL = "http://www.cs.ucla.edu/~palsberg/paper/ic01.pdf", +} + +@InProceedings{palsberg-zhao-02, + author = "Jens Palsberg and Tian Zhao", + title = "Efficient Type Inference for Record Concatenation and + Subtyping", + pages = "125--136", + booktitle = lics, + year = "2002", +} + +@Article{palsberg-zhao-04, + author = "Jens Palsberg and Tian Zhao", + title = "Type Inference for Record Concatenation and + Subtyping", + journal = ic, + year = "2004", + volume = "189", + pages = "54--86", + URL = "http://www.cs.ucla.edu/~palsberg/paper/ic04.pdf", +} + +@Misc{pangolin, + author = "Yann Régis-Gianas", + title = "The {Pangolin} programming language", + note = "\url{http://code.google.com/p/pangolin-programming-language/}", + year = "2008", + URL = "http://code.google.com/p/pangolin-programming-language/", +} + +@InProceedings{parkinson-bierman-05, + author = "Matthew Parkinson and Gavin Bierman", + title = "Separation logic and abstraction", + booktitle = popl, + year = "2005", + pages = "247--258", + URL = "http://dx.doi.org/10.1145/1040305.1040326", +} + +@InProceedings{parkinson-bierman-08, + author = "Matthew Parkinson and Gavin Bierman", + title = "Separation logic, abstraction and inheritance", + booktitle = popl, + year = "2008", + pages = "75--86", + URL = "http://dx.doi.org/10.1145/1328438.1328451", +} + +@InProceedings{parnas-71, + author = "David Lorge Parnas", + title = "Information distribution aspects of design + methodology", + booktitle = "Information Processing 71", + pages = "339--344", + volume = "1", + year = "1971", + URL = "http://cseweb.ucsd.edu/~wgg/CSE218/Parnas-IFIP71-information-distribution.PDF", +} + +@Article{parnas-72, + author = "David Lorge Parnas", + title = "On the criteria to be used in decomposing systems into + modules", + journal = cacm, + volume = "15", + number = "12", + year = "1972", + pages = "1053--1058", + URL = "http://doi.acm.org/10.1145/361598.361623", +} + +@TechReport{pasalic-dali-00, + author = "Emir Pa{\v s}ali{\'c} and Tim Sheard and Walid Taha", + title = "{DALI}: An Untyped, {CBV} Functional Language + Supporting First-Order Datatypes with Binders + (Technical Development)", + institution = "Oregon Graduate Institute", + year = "2000", + number = "00-007", + URL = "http://www.cse.ogi.edu/PacSoft/publications/phaseiiiq13papers/dali.pdf", +} + +@InProceedings{pasalic-linger-04, + author = "Pa{\v s}ali{\'c} and Nathan Linger", + title = "Meta-programming with Typed Object-Language + Representations", + booktitle = gpce, + pages = "136--167", + year = "2004", + URL = "http://web.cecs.pdx.edu/~sheard/papers/MetaProgTypObjLangReps.ps", +} + +@InProceedings{pasalic-tagless-02, + author = "Emir Pa{\v s}ali{\'c} and Walid Taha and Tim Sheard", + title = "Tagless staged interpreters for typed languages", + booktitle = icfp, + year = "2002", + pages = "218--229", + URL = "http://www.cs.rice.edu/~taha/teaching/02F/511/papers/pts02.pdf", +} + +@InProceedings{paterson-wegman-76, + author = "M. S. Paterson and M. N. Wegman", + title = "Linear Unification", + booktitle = "Annual {ACM} Symposium on Theory of Computing", + pages = "181--186", + year = "1976", +} + +@InProceedings{patwary-10, + author = "Md. Mostofa Ali Patwary and Jean Blair and Fredrik + Manne", + title = "Experiments on Union-Find Algorithms for the + Disjoint-Set Data Structure", + booktitle = "International Symposium on Experimental Algorithms + (SEA)", + pages = "411--423", + year = "2010", + series = lncs, + volume = "6049", + publisher = springer, + URL = "http://www.ii.uib.no/~fredrikm/fredrik/papers/SEA2010.pdf", +} + +@InProceedings{paulin-89, + author = "Christine Paulin-Mohring", + title = "Extracting ${F}_{\omega}$'s programs from proofs in + the Calculus of Constructions", + year = "1989", + booktitle = popl, + pages = "89--104", + URL = "http://doi.acm.org/10.1145/75277.75285", +} + +@TechReport{paulin-92, + author = "Christine Paulin-Mohring", + title = "Inductive Definitions in the system {Coq}: rules and + Properties", + institution = "ENS Lyon", + year = "1992", + type = "Research Report", + number = "RR1992-49", + URL = "ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR1992/RR1992-49.ps.Z", +} + +@InProceedings{pennello-86, + author = "Thomas J. Pennello", + title = "Very fast {LR} parsing", + booktitle = "Symposium on Compiler Construction", + pages = "145--151", + year = "1986", + URL = "http://doi.acm.org/10.1145/12276.13326", +} + +@Article{pessaux-leroy-00, + author = "Fran\c{c}ois Pessaux and Xavier Leroy", + title = "Type-based analysis of uncaught exceptions", + journal = toplas, + pages = "340--377", + volume = "22", + number = "2", + year = "2000", + URL = "http://gallium.inria.fr/~xleroy/publi/exceptions-toplas.ps.gz", +} + +@InProceedings{peterson-jones-93, + author = "John Peterson and Mark P. Jones", + title = "Implementing Type Classes", + booktitle = pldi, + pages = "227--236", + year = "1993", + URL = "http://web.cecs.pdx.edu/~mpj/pubs/pldi93.ps", +} + +@Book{peyton-jones-ifl-87, + author = "Simon {Peyton Jones}", + title = "The Implementation of Functional Programming + Languages", + publisher = prentice, + year = "1987", + URL = "http://research.microsoft.com/Users/simonpj/papers/slpj-book-1987/", +} + +@Article{peyton-jones-rank-07, + author = "Simon {Peyton Jones} and Dimitrios Vytiniotis and + Stephanie Weirich and Mark Shields", + title = "Practical type inference for arbitrary-rank types", + journal = jfp, + volume = "17", + number = "1", + pages = "1--82", + year = "2007", + URL = "http://research.microsoft.com/en-us/um/people/simonpj/papers/higher-rank/putting.pdf", +} + +@Unpublished{peyton-jones-shields-04, + author = "Simon {Peyton Jones} and Mark Shields", + title = "Lexically-Scoped Type Variables", + year = "2004", + note = "Manuscript", + URL = "http://www.cse.ogi.edu/~mbs/pub/scoped/", +} + +@InProceedings{peyton-jones-simple-gadts-06, + author = "Simon {Peyton Jones} and Dimitrios Vytiniotis and + Stephanie Weirich and Geoffrey Washburn", + title = "Simple unification-based type inference for {GADTs}", + booktitle = icfp, + year = "2006", + pages = "50--61", + URL = "https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/gadt-pldi.pdf", +} + +@Misc{peyton-jones-tackling-09, + author = "Simon {Peyton Jones}", + title = "Tackling the Awkward Squad: monadic input/output, + concurrency, exceptions, and foreign-language calls in + {Haskell}", + howpublished = "Online lecture notes", + year = "2009", + URL = "http://research.microsoft.com/en-us/um/people/simonpj/papers/marktoberdorf/mark.pdf", +} + +@InProceedings{peyton-jones-wadler-93, + author = "Simon {Peyton Jones} and Philip Wadler", + title = "Imperative functional programming", + booktitle = popl, + year = "1993", + pages = "71--84", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/imperative/imperative.ps.gz", +} + +@TechReport{peyton-jones-wobbly-04, + author = "Simon {Peyton~Jones} and Geoffrey Washburn and + Stephanie Weirich", + title = "Wobbly types: type inference for generalised algebraic + data types", + institution = "University of Pennsylvania", + year = "2004", + number = "MS-CIS-05-26", + URL = "http://www.cis.upenn.edu/~geoffw/research/papers/MS-CIS-05-26.pdf", +} + +@InProceedings{pfenning-elliott-88, + author = "Frank Pfenning and Conal Elliott", + title = "Higher-Order Abstract Syntax", + pages = "199--208", + booktitle = pldi, + year = "1988", + URL = "http://doi.acm.org/10.1145/53990.54010", +} + +@InProceedings{pfenning-lee-89, + author = "Frank Pfenning and Peter Lee", + title = "{LEAP}: {A} Language with Eval And Polymorphism", + booktitle = tapsoft, + year = "1989", + publisher = springer, + series = lncs, + volume = "352", + pages = "345--359", + URL = "http://dx.doi.org/10.1007/3-540-50940-2_46", +} + +@InProceedings{pientka-08, + author = "Brigitte Pientka", + title = "A type-theoretic foundation for programming with + higher-order abstract syntax and first-class + substitutions", + booktitle = popl, + year = "2008", + pages = "371--382", + URL = "http://www.cs.mcgill.ca/~bpientka/papers/hoasfun-short.pdf", +} + +@InProceedings{pientka-dunfield-08, + author = "Brigitte Pientka and Joshua Dunfield", + title = "Programming with Proofs and Explicit Contexts", + booktitle = ppdp, + pages = "163--173", + year = "2008", + URL = "http://www.cs.mcgill.ca/~bpientka/papers/ppdp-pientka.pdf", +} + +@InProceedings{pientka-pearl-07, + author = "Brigitte Pientka", + title = "Proof Pearl: The power of higher-order encodings in + the logical framework {LF}", + booktitle = tphol, + pages = "246--261", + year = "2007", + volume = "4732", + series = lncs, + publisher = springer, + URL = "http://www.cs.mcgill.ca/~bpientka/papers/pearl.pdf", +} + +@InProceedings{pierce-sangiorgi-93, + author = "Benjamin Pierce and Davide Sangiorgi", + title = "Typing and Subtyping for Mobile Processes", + pages = "376--385", + booktitle = lics, + year = "1993", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/pi-lics.ps", +} + +@Book{pierce-tapl, + author = "Benjamin C. Pierce", + title = "Types and Programming Languages", + publisher = mitp, + year = "2002", + URL = "http://www.cis.upenn.edu/~bcpierce/tapl/", +} + +@Article{pierce-turner-00, + author = "Benjamin C. Pierce and David N. Turner", + title = "Local Type Inference", + journal = toplas, + year = "2000", + volume = "22", + number = "1", + pages = "1--44", + URL = "http://doi.acm.org/10.1145/345099.345100", +} + +@TechReport{pierce-turner-92, + author = "Benjamin C. Pierce and David N. Turner", + title = "Statically Typed Friendly Functions via Partially + Abstract Types", + institution = "University of Edinburgh, LFCS", + type = "Technical Report", + number = "ECS-LFCS-93-256", + year = "1993", + note = "Also available as INRIA Research Report 1899", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/friendly.ps", +} + +@Article{pierce-turner-94, + author = "Benjamin C. Pierce and David N. Turner", + title = "Simple Type-Theoretic Foundations for Object-Oriented + Programming", + journal = jfp, + volume = "4", + number = "2", + pages = "207--247", + year = "1994", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/oop.ps", +} + +@Article{pierce-undecidable-92, + author = "Benjamin C. Pierce", + title = "Bounded Quantification is Undecidable", + journal = ic, + year = "1994", + volume = "112", + number = "1", + pages = "131--165", + URL = "http://www.cis.upenn.edu/~bcpierce/papers/fsubpopl.ps", +} + +@InProceedings{pilkiewicz-pottier-monotonicity-11, + author = "Alexandre Pilkiewicz and François Pottier", + title = "The essence of monotonic state", + booktitle = tldi, + year = "2011", + URL = "http://gallium.inria.fr/~fpottier/publis/pilkiewicz-pottier-monotonicity.pdf", +} + +@InProceedings{piskac-13, + author = "Ruzica Piskac and Thomas Wies and Damien Zufferey", + title = "Automating Separation Logic Using {SMT}", + booktitle = cav, + pages = "773--789", + year = "2013", + series = lncs, + volume = "8044", + publisher = springer, + URL = "https://www.mpi-sws.org/~piskac/publications/PiskacWiesZuffrey13SepLog.pdf", +} + +@InProceedings{piskac-14, + author = "Ruzica Piskac and Thomas Wies and Damien Zufferey", + title = "Automating Separation Logic with Trees and Data", + booktitle = cav, + pages = "711--728", + year = "2014", + series = lncs, + volume = "8559", + publisher = springer, + URL = "http://cs.nyu.edu/wies/publ/automating_separation_logic_with_trees_and_data.pdf", +} + +@Article{pitts-03, + author = "Andrew M. Pitts", + title = "Nominal Logic, {A} First Order Theory of Names and + Binding", + journal = ic, + year = "2003", + volume = "186", + pages = "165--193", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/nomlfo/nomlfo-jv.pdf", +} + +@InProceedings{pitts-05, + author = "Andrew M. Pitts", + title = "Alpha-Structural Recursion and Induction", + booktitle = tphol, + year = "2005", + series = lncs, + publisher = springer, + URL = "http://www.cl.cam.ac.uk/~amp12/papers/alpsri/alpsri-ea.pdf", +} + +@Article{pitts-06, + author = "Andrew M. Pitts", + title = "Alpha-Structural Recursion and Induction", + journal = jacm, + year = "2006", + volume = "53", + pages = "459--506", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/alpsri/alpsri.pdf", +} + +@InProceedings{pitts-10, + author = "Andrew M. Pitts", + title = "Nominal {System} ${T}$", + booktitle = popl, + pages = "159--170", + year = "2010", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/nomst/nomst-popl.pdf", +} + +@InProceedings{pitts-gabbay-00, + author = "Andrew M. Pitts and Murdoch J. Gabbay", + title = "A Metalanguage for Programming with Bound Names Modulo + Renaming", + booktitle = mpc, + pages = "230--255", + year = "2000", + volume = "1837", + series = lncs, + publisher = springer, + URL = "http://www.cl.cam.ac.uk/~amp12/papers/metpbn/metpbn.pdf", +} + +@Article{pitts-parametric-00, + author = "Andrew M. Pitts", + title = "Parametric Polymorphism and Operational Equivalence", + journal = mscs, + year = "2000", + volume = "10", + pages = "321--359", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/parpoe/parpoe.pdf", +} + +@InProceedings{plaid-permissions-11, + author = "Jonathan Aldrich and Ronald Garcia and Mark Hahnenberg + and Manuel Mohr and Karl Naden and Darpan Saini and + Sven Stork and Joshua Sunshine and {\'E}ric Tanter and + Roger Wolff", + title = "Permission-based programming languages", + booktitle = icse, + year = "2011", + pages = "828--831", + URL = "http://www.cs.cmu.edu/~aldrich/papers/plaid-NIER2010.pdf", +} + +@InCollection{plotkin-90, + author = "Gordon Plotkin", + title = "An illative theory of relations", + booktitle = "Situation Theory and its Applications", + pages = "133--146", + publisher = "Stanford University", + year = "1990", + number = "22", + series = "CSLI Lecture Notes", + URL = "http://homepages.inf.ed.ac.uk/gdp/publications/illative.pdf", +} + +@Article{plotkin-lcf-77, + author = "Gordon D. Plotkin", + title = "{LCF} Considered as a Programming Language", + journal = tcs, + volume = "5", + number = "3", + year = "1977", + pages = "225--255", + URL = "http://homepages.inf.ed.ac.uk/gdp/publications/LCF.pdf", +} + +@InCollection{plural-11, + author = "Kevin Bierhoff and Nels E. Beckman and Jonathan + Aldrich", + title = "Checking Concurrent Typestate with Access Permissions + in {Plural}: {A} Retrospective", + booktitle = "Engineering of Software", + pages = "35--48", + publisher = springer, + year = "2011", + editor = "Peri L. Tarr and Alexander L. Wolf", + URL = "http://www.cs.cmu.edu/~aldrich/papers/bierhoff-plural-festschrift11.pdf", +} + +@InProceedings{polikarpova-15, + author = "Nadia Polikarpova and Julian Tschannen and Carlo A. + Furia", + title = "A Fully Verified Container Library", + booktitle = fm, + pages = "414--434", + year = "2015", + series = lncs, + volume = "9109", + publisher = springer, + URL = "http://se.inf.ethz.ch/people/tschannen/publications/ptf-fm15.pdf", +} + +@Article{pollack-sato-ricciotti-11, + author = "Randy Pollack and Masahiko Sato and Wilmer Ricciotti", + title = "A Canonical Locally Named Representation of Binding", + year = "2012", + journal = jar, + volume = "49", + number = "2", + pages = "185--207", + URL = "http://homepages.inf.ed.ac.uk/rpollack/export/PollackSatoRicciottiJAR.pdf", +} + +@InProceedings{poplmark, + author = "Brian E. Aydemir and Aaron Bohannon and Matthew + Fairbairn and J. Nathan Foster and Benjamin C. Pierce + and Peter Sewell and Dimitrios Vytiniotis and Geoffrey + Washburn and Stephanie Weirich and Steve Zdancewic", + title = "Mechanized Metatheory for the Masses: The + \textsc{PoplMark} Challenge", + booktitle = tphol, + year = "2005", + series = lncs, + volume = "3603", + pages = "50--65", + publisher = springer, + URL = "http://research.microsoft.com/en-us/people/dimitris/poplmark.pdf", +} + +@Misc{popuri-bison-06, + author = "Satya Kiran Popuri", + title = "Understanding {C} parsers generated by {GNU Bison}", + year = "2006", + URL = "http://www.cs.uic.edu/~spopuri/cparser.html", +} + +@InCollection{potanin-13, + author = "Alex Potanin and Johan {\"{O}}stlund and Yoav Zibin + and Michael D. Ernst", + title = "Immutability", + booktitle = "Aliasing in Object-Oriented Programming. Types, + Analysis and Verification", + pages = "233--269", + year = "2013", + series = lncs, + volume = "7850", + publisher = springer, + URL = "https://homes.cs.washington.edu/~mernst/pubs/immutability-aliasing-2013-lncs7850.pdf", +} + +@InProceedings{pottier-alphacaml, + author = "François Pottier", + title = "An overview of {C$\alpha$ml}", + year = "2006", + booktitle = "ACM Workshop on ML", + pages = "27--52", + volume = "148", + number = "2", + series = entcs, + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-alphacaml.pdf", +} + +@Misc{pottier-alphacaml-software, + author = "François Pottier", + title = "{C$\alpha$ml}", + year = "2005", + URL = "http://gallium.inria.fr/~fpottier/alphaCaml/", +} + +@InProceedings{pottier-antiframe-08, + author = "François Pottier", + title = "Hiding local state in direct style: a higher-order + anti-frame rule", + year = "2008", + booktitle = lics, + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-antiframe-2008.pdf", + pages = "331--340", +} + +@Unpublished{pottier-caf, + author = "François Pottier", + title = "Three comments on the anti-frame rule", + note = "Unpublished", + year = "2009", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-caf-2009.pdf", +} + +@InProceedings{pottier-conchon-icfp-00, + author = "François Pottier and Sylvain Conchon", + title = "Information Flow Inference for Free", + booktitle = icfp, + year = "2000", + pages = "46--57", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-conchon-icfp00.ps.gz", +} + +@InProceedings{pottier-csfw-02, + author = "François Pottier", + title = "A Simple View of Type-Secure Information Flow in the + $\pi$-Calculus", + year = "2002", + booktitle = csfw, + pages = "320--330", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-csfw15.ps.gz", +} + +@TechReport{pottier-dea-95, + author = "François Pottier", + title = "Implémentation d'un système de modules évolué en + {Caml-Light}", + institution = "INRIA", + number = "2449", + type = "Research Report", + year = "1995", + URL = "http://gallium.inria.fr/~fpottier/publis/memoire-dea.ps.gz", +} + +@Unpublished{pottier-dfs-scc-15, + author = "François Pottier", + title = "Depth-First Search and Strong Connectivity in {Coq}", + year = "2014", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-dfs-scc.pdf", + note = "Submitted for publication", +} + +@InProceedings{pottier-esop-00, + author = "François Pottier", + title = "A 3-part type inference engine", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "1782", + pages = "320--335", + year = "2000", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-esop-2000.ps.gz", +} + +@Unpublished{pottier-gaf, + author = "François Pottier", + title = "Generalizing the higher-order frame and anti-frame + rules", + note = "Unpublished", + year = "2009", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-gaf-2009.pdf", +} + +@InProceedings{pottier-gauthier-04, + author = "François Pottier and Nadji Gauthier", + title = "Polymorphic Typed Defunctionalization", + booktitle = popl, + year = "2004", + pages = "89--98", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-gauthier-popl04.pdf", +} + +@Article{pottier-gauthier-hosc, + author = "François Pottier and Nadji Gauthier", + title = "Polymorphic Typed Defunctionalization and + Concretization", + journal = hosc, + year = "2006", + volume = "19", + pages = "125--162", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-gauthier-hosc.pdf", +} + +@InProceedings{pottier-gdr-95, + author = "François Pottier", + title = "Type inference and simplification for recursively + constrained types", + booktitle = "Actes du {GDR} Programmation 1995 (journée du pôle + Programmation Fonctionnelle)", + year = "1995", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-gdr-95.ps.gz", +} + +@TechReport{pottier-hmx-01, + author = "François Pottier", + title = "A semi-syntactic soundness proof for {HM$(X)$}", + institution = "INRIA", + number = "4150", + type = "Research Report", + year = "2001", + URL = "http://hal.inria.fr/docs/00/07/24/75/PDF/RR-4150.pdf", +} + +@Article{pottier-ic-01, + author = "François Pottier", + title = "Simplifying subtyping constraints: a theory", + journal = ic, + year = "2001", + volume = "170", + number = "2", + pages = "153--183", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-ic01.ps.gz", +} + +@InProceedings{pottier-icfp-96, + author = "François Pottier", + title = "Simplifying subtyping constraints", + booktitle = icfp, + year = "1996", + pages = "122--133", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-icfp96.ps.gz", +} + +@InProceedings{pottier-icfp-98, + author = "François Pottier", + title = "A Framework for Type Inference with Subtyping", + booktitle = icfp, + year = "1998", + pages = "228--238", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-icfp98.ps.gz", +} + +@InProceedings{pottier-lics-03, + author = "François Pottier", + title = "A Constraint-Based Presentation and Generalization of + Rows", + year = "2003", + booktitle = lics, + pages = "331--340", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-lics03.ps.gz", +} + +@InProceedings{pottier-lics-07, + author = "François Pottier", + title = "Static name control for {FreshML}", + booktitle = lics, + year = "2007", + pages = "356--365", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-pure-freshml.pdf", +} + +@Article{pottier-njc-00, + author = "François Pottier", + title = "A Versatile Constraint-Based Type Inference System", + journal = njc, + year = "2000", + volume = "7", + number = "4", + pages = "312--347", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-njc-2000.ps.gz", +} + +@Misc{pottier-notes-dea, + author = "Xavier Leroy and François Pottier", + title = "Notes du cours de {DEA} «~Typage et programmation~»", + year = "2002", + URL = "http://gallium.inria.fr/~fpottier/dea/dea-typage.ps.gz", +} + +@TechReport{pottier-phd-english-98, + author = "François Pottier", + title = "Type inference in the presence of subtyping: from + theory to practice", + institution = "INRIA", + number = "3483", + type = "Research Report", + year = "1998", + URL = "http://hal.inria.fr/docs/00/07/32/05/PDF/RR-3483.pdf", +} + +@PhdThesis{pottier-phd-french-98, + author = "François Pottier", + title = "Synthèse de types en présence de sous-typage: de la + théorie à la pratique", + school = "Université Paris 7", + year = "1998", + URL = "http://gallium.inria.fr/~fpottier/publis/these-fpottier.ps.gz", +} + +@InProceedings{pottier-protzenko-13, + author = "François Pottier and Jonathan Protzenko", + title = "Programming with permissions in {Mezzo}", + booktitle = icfp, + year = "2013", + pages = "173--184", + URL = "http://gallium.inria.fr/~fpottier/publis/pottier-protzenko-mezzo.pdf", +} + +@InProceedings{pottier-protzenko-lessons-mezzo-15, + author = "François Pottier and Jonathan Protzenko", + title = "A few lessons from the {Mezzo} project", + booktitle = snapl, + year = "2015", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-protzenko-lessons-mezzo.pdf", +} + +@InProceedings{pottier-reachability-cc-2016, + author = "François Pottier", + title = "Reachability and error diagnosis in {LR}(1) parsers", + booktitle = cc, + year = "2016", + pages = "88--98", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-reachability-cc2016.pdf", +} + +@InProceedings{pottier-reachability-jfla-2016, + author = "François Pottier", + title = "Reachability and error diagnosis in {LR}(1) automata", + booktitle = jfla, + year = "2016", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-reachability-jfla2016.pdf", +} + +@InProceedings{pottier-regis-gianas-06, + author = "François Pottier and Yann Régis-Gianas", + title = "Stratified type inference for generalized algebraic + data types", + booktitle = popl, + year = "2006", + pages = "232--244", + URL = "http://gallium.inria.fr/~fpottier/publis/pottier-regis-gianas-popl06.pdf", +} + +@Article{pottier-regis-gianas-typed-lr, + author = "François Pottier and Yann {Régis-Gianas}", + title = "Towards efficient, typed {LR} parsers", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-regis-gianas-typed-lr.pdf", + year = "2006", + pages = "155--180", + journal = entcs, + volume = "148", + number = "2", +} + +@InCollection{pottier-remy-emlti, + author = "François Pottier and Didier Rémy", + title = "The Essence of {ML} Type Inference", + booktitle = "Advanced Topics in Types and Programming Languages", + pages = "389--489", + publisher = mitp, + year = "2005", + editor = "Benjamin C. Pierce", + chapter = "10", + URL = "http://gallium.inria.fr/~fpottier/publis/emlti-final.pdf", +} + +@Unpublished{pottier-remy-emlti-long, + author = "François Pottier and Didier Rémy", + title = "The Essence of {ML} Type Inference", + note = "Draft of an extended version. Unpublished", + year = "2003", + URL = "http://cristal.inria.fr/attapl/emlti-long.pdf", +} + +@InProceedings{pottier-simonet-02, + author = "François Pottier and Vincent Simonet", + title = "Information Flow Inference for {ML}", + booktitle = popl, + year = "2002", + pages = "319--330", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-simonet-popl02.ps.gz", +} + +@Article{pottier-simonet-toplas-03, + author = "François Pottier and Vincent Simonet", + title = "Information Flow Inference for {ML}", + year = "2003", + volume = "25", + number = "1", + pages = "117--158", + journal = toplas, + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-simonet-toplas.ps.gz", +} + +@InProceedings{pottier-skalka-smith-01, + author = "François Pottier and Christian Skalka and Scott + Smith", + title = "A Systematic Approach to Static Access Control", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "2028", + pages = "30--45", + year = "2001", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-skalka-smith-esop01.ps.gz", +} + +@Article{pottier-skalka-smith-05, + author = "François Pottier and Christian Skalka and Scott + Smith", + title = "A Systematic Approach to Static Access Control", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-skalka-smith-toplas.ps.gz", + volume = "27", + number = "2", + pages = "344--382", + journal = toplas, + year = "2005", +} + +@Article{pottier-ssphs-13, + author = "François Pottier", + title = "Syntactic soundness proof of a type-and-capability + system with hidden state", + journal = jfp, + volume = "23", + number = "1", + pages = "38--144", + year = "2013", + URL = "http://gallium.inria.fr/~fpottier/publis/fpottier-ssphs.pdf", +} + +@Misc{pottier-wallace, + author = "François Pottier", + title = "Wallace: an efficient implementation of type inference + with subtyping", + year = "2000", + URL = "http://gallium.inria.fr/~fpottier/wallace/", +} + +@InCollection{pottinger-80, + author = "Garrel Pottinger", + title = "A type assignment for the strongly normalizable + $\lambda$-terms", + booktitle = "To H. B. Curry: Essays on Combinatory Logic, Lambda + Calculus, and Formalism", + pages = "561--577", + publisher = ap, + year = "1980", + editor = "J. Roger Hindley and Jonathan P. Seldin", +} + +@InProceedings{pouillard-11, + author = "Nicolas Pouillard", + title = "Nameless, painless", + booktitle = icfp, + year = "2011", + pages = "320--332", + URL = "http://nicolaspouillard.fr/publis/nameless-painless.pdf", +} + +@InProceedings{pouillard-pottier-10, + author = "Nicolas Pouillard and François Pottier", + title = "A fresh look at programming with names and binders", + booktitle = icfp, + year = "2010", + pages = "217--228", + URL = "http://gallium.inria.fr/~fpottier/publis/pouillard-pottier-fresh-look.pdf", +} + +@Article{pouillard-pottier-12, + author = "Nicolas Pouillard and François Pottier", + title = "A unified treatment of syntax with binders", + journal = jfp, + volume = "22", + number = "4--5", + pages = "614--704", + year = "2012", + URL = "http://gallium.inria.fr/~fpottier/publis/pouillard-pottier-unified.pdf", +} + +@Article{pratt-tiuryn-96, + author = "Vaughan Pratt and Jerzy Tiuryn", + title = "Satisfiability of Inequalities in a Poset", + journal = fundamenta, + year = "1996", + volume = "28", + number = "1--2", + pages = "165--182", + URL = "ftp://ftp.mimuw.edu.pl/pub/users/tiuryn/sat-ineq.ps.gz", +} + +@Article{pretnar-15, + author = "Matija Pretnar", + title = "An Introduction to Algebraic Effects and Handlers", + journal = entcs, + volume = "319", + pages = "19--35", + year = "2015", + URL = "http://www.eff-lang.org/handlers-tutorial.pdf", +} + +@Misc{programatica-04, + author = "Thomas Hallgren and James Hook and Mark P. Jones and + Richard Kieburtz", + title = "An overview of the {Programatica} ToolSet", + howpublished = "High Confidence Software and Systems Conference + (HCSS)", + year = "2004", + URL = "http://ogi.altocumulus.org/~hallgren/Programatica/HCSS04/hcss04-tools.pdf", +} + +@Book{proofs-and-types, + author = "Jean-Yves Girard and Yves Lafont and Paul Taylor", + title = "Proofs and Types", + publisher = cup, + year = "1990", + URL = "http://www.paultaylor.eu/stable/prot.pdf", +} + +@PhdThesis{protzenko-phd-14, + author = "Jonathan Protzenko", + title = "{Mezzo}: a typed language for safe effectful + concurrent programs", + year = "2014", + school = "Université Paris Diderot", + URL = "https://hal.inria.fr/tel-01086106/document", +} + +@InProceedings{pugh-weddell-90, + author = "William Pugh and Grant Weddell", + title = "Two-directional record layout for multiple + inheritance", + booktitle = pldi, + pages = "85--91", + year = "1990", + URL = "http://doi.acm.org/10.1145/93542.93556", +} + +@Article{purdom-74, + author = "Paul Purdom", + title = "The size of {LALR(1)} parsers", + year = "1974", + journal = "BIT Numerical Mathematics", + volume = "14", + number = "3", + URL = "http://dx.doi.org/10.1007/BF01933232", + publisher = kluwer, + pages = "326--337", +} + +@Article{qian-96, + author = "Zhenyu Qian", + title = "Unification of higher-order patterns in linear time + and space", + journal = jlc, + year = "1996", + volume = "6", + number = "3", + pages = "315--341", +} + +@TechReport{raffalli-98, + author = "Christophe Raffalli", + title = "Type checking in system ${F}^\eta$", + institution = "LAMA, Université de Savoie", + year = "1998", + type = "Prépublication", + number = "98-05a", + URL = "ftp://www.lama.univ-savoie.fr/pub/users/RAFFALLI/Papers/Feta-partial.ps", +} + +@Unpublished{raffalli-99, + author = "Christophe Raffalli", + title = "An optimized complete semi-algorithm for system + ${F}^\eta$", + note = "Unpublished", + year = "1999", + URL = "ftp://www.lama.univ-savoie.fr/pub/users/RAFFALLI/Papers/Feta-total.ps", +} + +@InProceedings{ramachandran-93, + author = "Viswanath Ramachandran and Pascal Van Hentenryck", + title = "Incremental Algorithms for Constraint Solving and + Entailment over Rational Trees", + booktitle = fsttcs, + pages = "205--217", + year = "1993", +} + +@InProceedings{ramalingam-02, + author = "G. Ramalingam and Alex Varshavsky and John Field and + Deepak Goyal and Shmuel Sagiv", + title = "Deriving Specialized Program Analyses for Certifying + Component-Client Conformance", + booktitle = pldi, + pages = "83--94", + year = "2002", + URL = "http://pages.cs.wisc.edu/~ramali/Papers/pldi02.pdf", +} + +@Book{real-world-ocaml, + author = "Yaron Minsky and Anil Madhavapeddy and Jason Hickey", + title = "Real World {OCaml}: Functional programming for the + masses", + publisher = "O'Reilly", + year = "2013", + URL = "https://realworldocaml.org/", +} + +@InProceedings{recursive-alias-types-00, + author = "David Walker and Greg Morrisett", + title = "Alias Types for Recursive Data Structures", + booktitle = tic, + year = "2000", + series = lncs, + volume = "2071", + pages = "177--206", + publisher = springer, + URL = "http://www.cs.cornell.edu/talc/papers/alias-recursion.pdf", +} + +@TechReport{reed-15, + author = "Eric Reed", + title = "Patina: {A} Formalization of the {Rust} Programming + Language", + institution = "University of Washington", + year = "2015", + number = "UW-CSE-15-03-02", + URL = "ftp://ftp.cs.washington.edu/tr/2015/03/UW-CSE-15-03-02.pdf", +} + +@InProceedings{regensburger-holcf-95, + author = "Franz Regensburger", + title = "{HOLCF}: Higher Order Logic of Computable Functions", + booktitle = tphol, + year = "1995", + pages = "293--307", + publisher = springer, + series = lncs, + volume = "971", + URL = "http://www4.informatik.tu-muenchen.de/publ/papers/Regensburger_HOLT1995.pdf", +} + +@PhdThesis{regis-gianas-07, + author = "Yann Régis-Gianas", + title = "Des types aux assertions logiques : preuve automatique + ou assistée de propriétés sur les programmes + fonctionnels", + school = "Université Paris 7", + year = "2007", + URL = "http://gallium.inria.fr/~regisgia/these-yann.regis-gianas.pdf", +} + +@InProceedings{regis-gianas-pottier-08, + author = "Yann Régis-Gianas and François Pottier", + title = "A {Hoare} Logic for Call-by-Value Functional + Programs", + booktitle = mpc, + year = "2008", + series = lncs, + volume = "5133", + publisher = springer, + URL = "http://gallium.inria.fr/~fpottier/publis/regis-gianas-pottier-hoarefp.pdf", + pages = "305--335", +} + +@InProceedings{rehof-faehndrich-01, + author = "Jakob Rehof and Manuel Fähndrich", + title = "Type-Based Flow Analysis: From Polymorphic Subtyping + to {CFL}-Reachability", + booktitle = popl, + pages = "54--66", + year = "2001", + URL = "http://research.microsoft.com/~rehof/popl01.ps", +} + +@TechReport{rehof-minimality-96, + author = "Jakob Rehof", + year = "1996", + title = "Minimal Typings in Atomic Subtyping", + institution = "Department of Computer Science, University of + Copenhagen", + number = "D-278", + URL = "ftp://ftp.diku.dk/diku/semantics/papers/D-278.ps.gz", +} + +@InProceedings{rehof-minimality-97, + author = "Jakob Rehof", + title = "Minimal Typings in Atomic Subtyping", + booktitle = popl, + year = "1997", + pages = "278--291", + URL = "http://research.microsoft.com/~rehof/popl97.ps", +} + +@InProceedings{reistad-gifford-94, + author = "Brian Reistad and David K. Gifford", + title = "Static dependent costs for estimating execution time", + booktitle = lfp, + year = "1994", + pages = "65--78", + URL = "https://groups.csail.mit.edu/cgs/pubs/lfp94.pdf", +} + +@InProceedings{remy-89, + author = "Didier Rémy", + title = "Type checking records and variants in a natural + extension of {ML}", + booktitle = popl, + pages = "77--88", + year = "1989", + URL = "http://doi.acm.org/10.1145/75277.75284", +} + +@InProceedings{remy-efficient-records-92, + author = "Didier Rémy", + title = "Efficient Representation of Extensible Records", + booktitle = mlapp, + year = "1992", + URL = "http://gallium.inria.fr/~remy/ftp/eff-repr-of-ext-records.pdf", +} + +@TechReport{remy-equational-92, + author = "Didier R{\'e}my", + title = "Extending {ML} Type System with a Sorted Equational + Theory", + institution = "INRIA", + number = "1766", + year = "1992", + URL = "http://gallium.inria.fr/~remy/ftp/eq-theory-on-types.pdf", +} + +@InProceedings{remy-esop-98, + author = "Didier R{\'e}my", + title = "From Classes to Objects via Subtyping", + booktitle = esop, + year = "1998", + series = lncs, + publisher = springer, + volume = "1381", + pages = "200--220", + URL = "http://gallium.inria.fr/~remy/ftp/classes-to-objects.pdf", +} + +@InCollection{remy-for-free-94, + author = "Didier R{\'e}my", + title = "Typing Record Concatenation for Free", + booktitle = "Theoretical Aspects Of Object-Oriented Programming. + Types, Semantics and Language Design", + publisher = mitp, + year = "1994", + editor = "Carl A. Gunter and John C. Mitchell", + URL = "http://gallium.inria.fr/~remy/ftp/taoop2.pdf", +} + +@InProceedings{remy-icfp-05, + author = "Didier Rémy", + title = "Simple, partial type inference for System ${F}$ based + on type containment", + booktitle = icfp, + year = "2005", + URL = "http://gallium.inria.fr/~remy/work/fml/fml-icfp.pdf", +} + +@InProceedings{remy-icfp05, + author = "Didier Rémy", + title = "Simple, partial type inference for System ${F}$ based + on type containment", + booktitle = icfp, + year = "2005", + URL = "http://gallium.inria.fr/~remy/work/fml/fml-icfp.pdf", +} + +@InProceedings{remy-lfp-92, + author = "Didier R{\'e}my", + title = "Projective {ML}", + booktitle = lfp, + pages = "66--75", + year = "1992", + URL = "http://gallium.inria.fr/~remy/ftp/lfp92.pdf", +} + +@InProceedings{remy-mlart-94, + author = "Didier R{\'e}my", + title = "Programming Objects with {ML-ART}: An extension to + {ML} with Abstract and Record Types", + booktitle = tacs, + year = "1994", + pages = "321--346", + publisher = springer, + URL = "http://gallium.inria.fr/~remy/ftp/tacs94.pdf", +} + +@Misc{remy-newton-95, + author = "Didier R{\'e}my", + title = "A case study of typechecking with constrained types: + Typing record concatenation", + howpublished = "Workshop on Advances in Types for Computer Science", + year = "1995", + URL = "http://gallium.inria.fr/~remy/work/sub-concat.dvi.gz", +} + +@InCollection{remy-records-94, + author = "Didier R{\'e}my", + title = "Type Inference for Records in a Natural Extension of + {ML}", + booktitle = "Theoretical Aspects Of Object-Oriented Programming: + Types, Semantics and Language Design", + publisher = mitp, + year = "1994", + editor = "Carl A. Gunter and John C. Mitchell", + URL = "http://gallium.inria.fr/~remy/ftp/taoop1.pdf", +} + +@TechReport{remy-start-93, + author = "Didier R{\'e}my", + title = "Syntactic Theories and the Algebra of Record Terms", + institution = "INRIA", + number = "1869", + year = "1993", + type = "Research Report", + URL = "http://gallium.inria.fr/~remy/ftp/record-algebras.pdf", +} + +@InProceedings{remy-vouillon-objective-ml-97, + author = "Didier R{\'e}my and J{\'e}r{\^o}me Vouillon", + title = "{Objective} {ML}: {A} simple object-oriented extension + of {ML}", + booktitle = popl, + year = "1997", + pages = "40--53", + URL = "http://gallium.inria.fr/~remy/ftp/objective-ml!popl97.pdf", +} + +@Article{remy-vouillon-objective-ml-98, + author = "Didier R{\'e}my and J{\'e}r{\^o}me Vouillon", + title = "{Objective} {ML}: {An} effective object-oriented + extension to {ML}", + journal = tapos, + year = "1998", + pages = "27--50", + volume = "4", + number = "1", + URL = "http://gallium.inria.fr/~remy/ftp/objective-ml!tapos98.pdf", +} + +@Article{remy-yakobowski-11, + author = "Didier R{\'e}my and Boris Yakobowski", + title = "A {Church}-Style Intermediate Language for {MLF}", + journal = tcs, + year = "2012", + volume = "435", + number = "1", + pages = "77--105", + URL = "http://gallium.inria.fr/~remy/mlf/Remy-Yakobowski:xmlf@tcs2011.pdf", +} + +@Article{reps-98, + author = "Thomas Reps", + title = "Program analysis via graph reachability", + journal = ist, + year = "1998", + volume = "40", + number = "11--12", + pages = "701--726", + URL = "http://www.cs.wisc.edu/wpis/papers/tr1386.pdf", +} + +@PhdThesis{retert-09, + author = "William S. Retert", + title = "Implementing Permission Analysis", + school = "University of Wisconsin-Milwaukee", + year = "2009", +} + +@InProceedings{reus-schwinghammer-06, + title = "Separation Logic for Higher-order Store", + year = "2006", + author = "Bernhard Reus and Jan Schwinghammer", + booktitle = csl, + series = lncs, + volume = "4207", + publisher = springer, + pages = "575--590", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/seplogic-hos.pdf", +} + +@Article{revuz-92, + author = "Dominique Revuz", + title = "Minimization of acyclic deterministic automata in + linear time", + journal = tcs, + volume = "92", + number = "1", + year = "1992", + pages = "181--189", +} + +@InProceedings{reynolds-02, + author = "John C. Reynolds", + title = "Separation Logic: {A} Logic for Shared Mutable Data + Structures", + booktitle = lics, + pages = "55--74", + year = "2002", + URL = "http://www.cs.cmu.edu/~jcr/seplogic.pdf", +} + +@InProceedings{reynolds-69, + author = "John C. Reynolds", + title = "Automatic Computation of Data Set Definitions", + booktitle = "Information Processing 68", + volume = "1", + publisher = "North Holland", + year = "1969", + pages = "456--461", +} + +@InProceedings{reynolds-74, + author = "John C. Reynolds", + title = "Towards a theory of type structure", + booktitle = "Colloque sur la Programmation", + pages = "408--425", + year = "1974", + volume = "19", + series = lncs, + publisher = springer, + URL = "http://www.springerlink.com/content/p5801737k78207p7/", +} + +@TechReport{reynolds-75, + author = "John C. Reynolds", + title = "User-defined Types and Procedural Data Structures as + Complementary Approaches to Data Abstraction", + institution = "Carnegie Mellon University", + year = "1975", + number = "1278", + URL = "http://repository.cmu.edu/compsci/1278/", +} + +@InProceedings{reynolds-78, + author = "John C. Reynolds", + title = "Syntactic control of interference", + booktitle = popl, + year = "1978", + pages = "39--46", + URL = "http://doi.acm.org/10.1145/512760.512766", +} + +@InProceedings{reynolds-83, + author = "John C. Reynolds", + title = "Types, Abstraction and Parametric Polymorphism", + booktitle = "Information Processing 83", + publisher = elsevier, + year = "1983", + pages = "513--523", + URL = "http://www.cse.chalmers.se/edu/year/2010/course/DAT140_Types/Reynolds_typesabpara.pdf", +} + +@InProceedings{reynolds-85, + author = "John C. Reynolds", + title = "Three Approaches to Type Structure", + booktitle = tapsoft, + series = lncs, + volume = "185", + publisher = springer, + year = "1985", + pages = "97--138", + URL = "http://dx.doi.org/10.1007/3-540-15198-2_7", +} + +@Article{reynolds-98a, + author = "John C. Reynolds", + title = "Definitional Interpreters for Higher-Order Programming + Languages", + journal = "Higher-Order and Symbolic Computation", + volume = "11", + number = "4", + pages = "363--397", + year = "1998", + URL = "https://cs.au.dk/~hosc/local/HOSC-11-4-pp363-397.pdf", +} + +@Article{reynolds-98b, + author = "John C. Reynolds", + title = "Definitional Interpreters Revisited", + journal = "Higher-Order and Symbolic Computation", + volume = "11", + number = "4", + pages = "355--361", + year = "1998", + URL = "https://cs.au.dk/~hosc/local/HOSC-11-4-pp355-361.pdf", +} + +@InCollection{reynolds-abstraction-94, + author = "John C. Reynolds", + title = "User Defined Types and Procedural Data Structures as + Complementary Approaches to Data Abstraction", + booktitle = taoop, + publisher = mitp, + year = "1994", + pages = "13--23", + editor = "Carl A. Gunter and John C. Mitchell", +} + +@InCollection{reynolds-intro-90, + author = "John C. Reynolds", + title = "An Introduction to the Polymorphic Lambda Calculus", + booktitle = "Logical Foundations of Functional Programming", + editor = "G{\'e}rard Huet", + publisher = aw, + year = "1990", + pages = "77--86", + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.7.9916", +} + +@Article{rhiger-03, + author = "Morten Rhiger", + title = "A Foundation for Embedded Languages", + journal = toplas, + year = "2003", + volume = "25", + number = "3", + pages = "291--315", + URL = "http://doi.acm.org/10.1145/641909.641910", +} + +@InProceedings{riba-09, + author = "Colin Riba", + title = "On the Values of Reducibility Candidates", + booktitle = tlca, + year = "2009", + pages = "264--278", + publisher = springer, + series = lncs, + volume = "5608", + URL = "http://perso.ens-lyon.fr/colin.riba/papers/values.pdf", +} + +@InProceedings{ringenburg-grossman-05, + author = "Michael F. Ringenburg and Dan Grossman", + title = "Types for Describing Coordinated Data Structures", + booktitle = tldi, + pages = "25--36", + year = "2005", + URL = "http://www.cs.washington.edu/homes/miker/coord/coordinated_tldi05.pdf", +} + +@Article{rittri-89, + author = "Mikael Rittri", + title = "Using types as Search Keys in Function Libraries", + journal = jfp, + volume = "1", + number = "1", + pages = "71--89", + year = "1991", +} + +@Article{rittri-93, + author = "Mikael Rittri", + title = "Retrieving library functions by unifying types modulo + linear isomorphism", + journal = rairo, + year = "1993", + volume = "27", + number = "6", + pages = "523--540", +} + +@PhdThesis{rival-hdr, + author = "Xavier Rival", + title = "Abstract Domains for the Static Analysis of Programs + Manipulating Complex Data Structures", + school = "École Normale Supérieure", + year = "2011", + type = "Habilitation à diriger des recherches", + URL = "http://www.di.ens.fr/~rival/hdr.pdf", +} + +@Article{robinson-65, + author = "J. Alan Robinson", + title = "A Machine-Oriented Logic Based on the Resolution + Principle", + journal = jacm, + year = "1965", + volume = "12", + number = "1", + pages = "23--41", + URL = "http://doi.acm.org/10.1145/321250.321253", +} + +@InProceedings{rompf-amin-16, + author = "Tiark Rompf and Nada Amin", + title = "Type soundness for dependent object types {(DOT)}", + booktitle = oopsla, + pages = "624--641", + year = "2016", + URL = "http://lampwww.epfl.ch/~amin/dot/soundness_oopsla16.pdf", +} + +@Article{ross-sagiv-98, + author = "John L. Ross and Mooly Sagiv", + title = "Building a Bridge between Pointer Aliases and Program + Dependences", + journal = njc, + volume = "5", + number = "4", + year = "1998", + mon = "Winter", + pages = "361--386", + URL = "http://www.math.tau.ac.il/~msagiv/njc98.ps", +} + +@InProceedings{rossberg-15, + author = "Andreas Rossberg", + title = "{1ML} -- core and modules united ({F}-ing first-class + modules)", + booktitle = icfp, + pages = "35--47", + year = "2015", + URL = "https://people.mpi-sws.org/~rossberg/papers/Rossberg%20-%201ML%20--%20Core%20and%20modules%20united.pdf", +} + +@Article{runciman-toyn-91, + author = "Colin Runciman and Ian Toyn", + title = "Retrieving re-usable software components by + polymorphic type", + journal = jfp, + year = "1991", + pages = "191--211", + volume = "1", + number = "2", +} + +@Book{russell-norvig-09, + author = "Stuart Russell and Peter Norvig", + title = "Artificial Intelligence: {A} Modern Approach", + publisher = prentice, + year = "2009", + URL = "http://aima.cs.berkeley.edu/", +} + +@PhdThesis{russo-98, + school = "University of Edinburgh", + title = "Types For Modules", + year = "1998", + pages = "360", + author = "Claudio V. Russo", + URL = "http://www.dcs.ed.ac.uk/home/cvr/ECS-LFCS-98-389.html", +} + +@Misc{rust, + title = "The {Rust} programming language", + author = "{The Mozilla foundation}", + year = "2014", + URL = "https://doc.rust-lang.org/book/", +} + +@InProceedings{rust-14, + author = "Nicholas D. Matsakis and Felix S. {Klock,II}", + title = "The {Rust} Language", + booktitle = hilt, + year = "2014", + pages = "103--104", + URL = "http://doi.acm.org/10.1145/2663171.2663188", +} + +@Unpublished{rust-servo-15, + author = "Brian Anderson and Lars Bergstrom and David Herman and + Josh Matthews and Keegan McAllister and Manish + Goregaokar and Jack Moffitt and Simon Sapin", + title = "Experience Report: Developing the {Servo} Web Browser + Engine using {Rust}", + year = "2015", + URL = "http://arxiv.org/abs/1505.07383", +} + +@InProceedings{sabelfeld-sands-99, + author = "Andrei Sabelfeld and David Sands", + title = "A {PER} Model of Secure Information Flow in Sequential + Programs", + booktitle = esop, + volume = "1575", + series = lncs, + year = "1999", + publisher = springer, + pages = "40--58", + URL = "http://www.cse.chalmers.se/~andrei/esop99.ps", +} + +@InProceedings{sabin-freuder-94, + author = "Daniel Sabin and Eugene C. Freuder", + title = "Contradicting Conventional Wisdom in Constraint + Satisfaction", + booktitle = ppcp, + publisher = springer, + series = lncs, + volume = "874", + year = "1994", + pages = "10--20", + URL = "http://4c.ucc.ie/web/upload/publications/inProc/sabin94contradicting.pdf", +} + +@Article{sabry-98, + author = "Amr Sabry", + title = "What is a Purely Functional Language?", + journal = jfp, + year = "1998", + volume = "8", + number = "1", + pages = "1--22", + URL = "http://dx.doi.org/10.1017/S0956796897002943", +} + +@InProceedings{sage-06, + author = "Jessica Gronski and Kenneth Knowles and Aaron Tomb and + Stephen N. Freund and Cormac Flanagan", + title = "{Sage}: Hybrid Checking for Flexible Specifications", + booktitle = "Scheme and Functional Programming", + year = "2006", + pages = "93--104", + URL = "http://www.cs.williams.edu/~freund/papers/06-sfp.pdf", +} + +@TechReport{saha-al-98, + author = "Bratin Saha and Nevin Heintze and Dino Oliva", + title = "Subtransitive {CFA} using Types", + institution = "Yale University", + year = "1998", + number = "YALEU/DCS/TR-1166", + URL = "http://flint.cs.yale.edu/flint/publications/cfa.ps.gz", +} + +@InProceedings{sands-90, + author = "David Sands", + title = "Complexity Analysis for a Lazy Higher-Order Language", + booktitle = esop, + pages = "361--376", + year = "1990", + series = lncs, + volume = "432", + publisher = springer, + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.9125", +} + +@InProceedings{sands-gustavsson-moran-02, + author = "David Sands and J{\"{o}}rgen Gustavsson and Andrew + Moran", + title = "Lambda Calculi and Linear Speedups", + booktitle = "The Essence of Computation, Complexity, Analysis, + Transformation. Essays Dedicated to Neil D. Jones", + pages = "60--84", + year = "2002", + volume = "2566", + publisher = springer, + series = lncs, + URL = "http://www.cse.chalmers.se/~dave/papers/Sands-Gustavsson-Moran.pdf", +} + +@Article{sangiorgi-98, + author = "Davide Sangiorgi", + title = "On the bisimulation proof method", + journal = mscs, + volume = "8", + number = "5", + pages = "447--479", + year = "1998", + URL = "http://www.cs.unibo.it/~sangio/DOC_public/bis-proof.ps.gz", +} + +@InProceedings{sansom-93, + author = "Patrick M. Sansom", + title = "Time profiling a lazy functional compiler", + booktitle = "Functional Programming, Workshops in Computing", + year = "1993", + publisher = springer, + URL = "ftp://ftp.dcs.glasgow.ac.uk/pub/glasgow-fp/authors/Patrick_Sansom/1993_profiling-compiler_GLASGOWFP.ps.gz", +} + +@InProceedings{scala, + author = "Martin Odersky and Matthias Zenger", + title = "Scalable Component Abstractions", + booktitle = oopsla, + pages = "41--57", + year = "2005", + URL = "http://lamp.epfl.ch/~odersky/papers/ScalableComponent.pdf", +} + +@PhdThesis{schimpf-81, + author = "Karl Max Schimpf", + title = "Construction Methods of {LR} Parsers", + school = "University of Pennsylvania", + year = "1981", + URL = "http://repository.upenn.edu/cis_reports/725/", +} + +@Article{schneider-00, + author = "Fred B. Schneider", + title = "Enforceable security policies", + year = "2000", + journal = tissec, + volume = "3", + number = "1", + pages = "1--50", + URL = "http://www.cs.cornell.edu/fbs/publications/EnfSecPols.pdf", +} + +@Book{schneider-97, + author = "Fred B. Schneider", + title = "On Concurrent Programming", + publisher = springer, + year = "1997", +} + +@InProceedings{schroeder-mossakowski-02, + author = "Lutz Schr{\"o}der and Till Mossakowski", + title = "{HasCASL}: Towards Integrated Specification and + Development of Functional Programs", + booktitle = amast, + year = "2002", + pages = "99--116", + publisher = springer, + series = lncs, + volume = "2422", + URL = "http://www.informatik.uni-bremen.de/~lschrode/hascasl/recursion.ps", +} + +@Article{schubert-83, + author = "Lenhart K. Schubert and Mary Angela Papalaskaris and + Jay Taugher", + title = "Determining Type, Part, Color, and Time + Relationships", + journal = computer, + volume = "16", + number = "10", + pages = "53--60", + year = "1983", +} + +@TechReport{schwartzbach-95, + author = "Michael I. Schwartzbach", + title = "Polymorphic Type Inference", + institution = "BRICS", + year = "1995", + number = "BRICS-LS-95-3", + URL = "http://www.brics.dk/LS/95/3/BRICS-LS-95-3.ps.gz", +} + +@InProceedings{schwinghammer-birkedal-stovring-11, + author = "Jan Schwinghammer and Lars Birkedal and Kristian + Støvring", + title = "A step-indexed {Kripke} model of hidden state via + recursive properties on recursively defined metric + spaces", + booktitle = fossacs, + year = "2011", + number = "6604", + pages = "305--319", + series = lncs, + publisher = springer, + URL = "http://www.itu.dk/~birkedal/papers/relpoms-antiframe-conf.pdf", +} + +@InProceedings{schwinghammer-csl-09, + author = "Jan Schwinghammer and Lars Birkedal and Bernhard Reus + and Hongseok Yang", + title = "Nested {Hoare} triples and frame rules for + higher-order store", + booktitle = csl, + pages = "440--454", + year = "2009", + volume = "5771", + series = lncs, + publisher = springer, + URL = "http://www.itu.dk/~birkedal/papers/nested-triples-conf.pdf", +} + +@InProceedings{schwinghammer-sfhs-10, + author = "Jan Schwinghammer and Hongseok Yang and Lars Birkedal + and François Pottier and Bernhard Reus", + title = "A Semantic Foundation for Hidden State", + booktitle = fossacs, + year = "2010", + pages = "2--17", + publisher = springer, + series = lncs, + volume = "6014", + URL = "http://gallium.inria.fr/~fpottier/publis/sfhs.pdf", +} + +@PhdThesis{schwoon-02, + author = "Stefan Schwoon", + title = "Model-Checking Pushdown Systems", + school = "Technische Universit{\"a}t M{\"u}nchen", + year = "2002", + URL = "http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/schwoon-phd02.pdf", +} + +@Article{scott-lcf-93, + author = "Dana S. Scott", + title = "A Type-Theoretical Alternative to {ISWIM}, {CUCH}, + {OWHY}", + journal = tcs, + volume = "121", + number = "1--2", + year = "1993", + pages = "411--440", + URL = "http://dx.doi.org/10.1016/0304-3975(93)90095-B", +} + +@Book{sedgewick-graphs-java, + author = "Robert Sedgewick and Michael Schidlowsky", + title = "Algorithms in {Java}: Graph Algorithms", + publisher = aw, + year = "2003", +} + +@Article{seidel-sharir-05, + author = "Raimund Seidel and Micha Sharir", + title = "Top-Down Analysis of Path Compression", + journal = siamjc, + volume = "34", + number = "3", + pages = "515--525", + year = "2005", + URL = "http://dx.doi.org/10.1137/S0097539703439088", +} + +@Article{sekar-al-95, + title = "Adaptive Pattern Matching", + author = "R. C. Sekar and R. Ramesh and I. V. Ramakrishnan", + pages = "1207--1234", + journal = siamjc, + year = "1995", + volume = "24", + number = "6", + URL = "http://seclab.cs.sunysb.edu/sekar/papers/adaptive.ps", + alturl = "http://locus.siam.org/fulltext/SICOMP/volume-24/0224073.pdf", +} + +@Article{sethi-ullman-70, + author = "Ravi Sethi and J. D. Ullman", + title = "The Generation of Optimal Code for Arithmetic + Expressions", + journal = jacm, + volume = "17", + number = "4", + year = "1970", + pages = "715--728", + URL = "http://doi.acm.org/10.1145/321607.321620", +} + +@InProceedings{sewell-vitek-00, + author = "Peter Sewell and Jan Vitek", + title = "Secure Composition of Untrusted Code: Wrappers and + Causality Types", + year = "2000", + booktitle = csfw, + URL = "http://www.cl.cam.ac.uk/users/pes20/wraptypes.ps", +} + +@TechReport{sewell-vitek-99, + author = "Peter Sewell and Jan Vitek", + title = "Secure Composition of Untrusted Code: Wrappers and + Causality Types", + number = "478", + institution = "Computer Laboratory, University of Cambridge", + year = "1999", + URL = "http://www.cl.cam.ac.uk/users/pes20/wraptypes-tr.ps", +} + +@Article{sha-steiglitz-93, + author = "Edwin Hsing-Mean Sha and Kenneth Steiglitz", + title = "Maintaining Bipartite Matchings in the Presence of + Failures", + journal = "Networks", + year = "1993", + volume = "23", + number = "5", + pages = "459--471", + URL = "http://www.nd.edu/~esha/papers/oldsha/alg.ps", +} + +@Article{shao-certified-05, + author = "Zhong Shao and Valery Trifonov and Bratin Saha and + Nikolaos Papaspyrou", + title = "A type system for certified binaries", + journal = toplas, + volume = "27", + number = "1", + year = "2005", + pages = "1--45", + URL = "http://flint.cs.yale.edu/flint/publications/tscb-toplas.pdf", +} + +@InProceedings{sheard-04, + author = "Tim Sheard", + title = "Languages of the Future", + booktitle = oopsla, + year = "2004", + pages = "116--119", + URL = "http://doi.acm.org/10.1145/1028664.1028711", +} + +@InProceedings{sheard-05, + author = "Tim Sheard", + title = "Putting {Curry-Howard} To Work", + booktitle = hw, + year = "2005", + pages = "74--85", + URL = "http://web.cecs.pdx.edu/~sheard/papers/PutCurryHoward2WorkFinalVersion.ps", +} + +@InProceedings{sheard-challenges-01, + author = "Tim Sheard", + title = "Accomplishments and Research Challenges in + Meta-Programming", + booktitle = saig, + pages = "2--44", + year = "2001", + volume = "2196", + series = lncs, + publisher = springer, + URL = "http://www.cse.ogi.edu/PacSoft/publications/2001/challeges_sheard.pdf", +} + +@InProceedings{sheard-metaml-98, + author = "Tim Sheard", + title = "Using {MetaML}: {A} staged Programming Language", + booktitle = afp, + pages = "207--239", + year = "1998", + volume = "1608", + series = lncs, + publisher = springer, + URL = "http://web.cecs.pdx.edu/~sheard/papers/summerschool.ps", +} + +@InProceedings{sheard-pasalic-04, + author = "Tim Sheard and Emir Pa{\v s}ali{\'c}", + title = "Meta-Programming with Built-in Type Equality", + booktitle = lfm, + year = "2004", + URL = "http://cs-www.cs.yale.edu/homes/carsten/lfm04/proceedings/pasalic.pdf", +} + +@InProceedings{shields-peyton-jones-02, + author = "Mark B. Shields and Simon {Peyton Jones}", + title = "First class modules for {Haskell}", + booktitle = fool, + year = "2002", + pages = "28--40", + URL = "http://www.cse.ogi.edu/~mbs/pub/first_class_modules/first_class_modules.pdf", +} + +@InProceedings{shinwell-03, + author = "Mark R. Shinwell and Andrew M. Pitts and Murdoch J. + Gabbay", + title = "{FreshML}: Programming with Binders Made Simple", + booktitle = icfp, + pages = "263--274", + year = "2003", + URL = "http://www.cl.cam.ac.uk/~amp12/papers/frepbm/frepbm.pdf", +} + +@InProceedings{shinwell-05, + author = "Mark R. Shinwell", + title = "{Fresh O'Caml}: nominal abstract syntax for the + masses", + booktitle = ml, + year = "2005", + URL = "http://www.cl.cam.ac.uk/users/mrs30/papers/masses.pdf", +} + +@PhdThesis{shinwell-phd, + author = "Mark R. Shinwell", + title = "The Fresh Approach: functional programming with names + and binders", + school = "University of Cambridge", + year = "2005", + URL = "http://www.cl.cam.ac.uk/users/mrs30/papers/thesis.pdf", +} + +@Article{shinwell-pitts-05, + author = "Mark R. Shinwell and Andrew M. Pitts", + title = "On a Monadic Semantics for Freshness", + journal = tcs, + year = "2005", + volume = "342", + pages = "28--55", + URL = "http://www.cl.cam.ac.uk/users/amp12/papers/monsf/monsf-jv.pdf", +} + +@InProceedings{shivers-96, + author = "Olin Shivers", + title = "A universal scripting framework or, {Lambda}: the + ultimate ``little language''", + booktitle = "Concurrency and Parallelism: Programming, Networking + and Security", + pages = "254--265", + year = "1996", + volume = "1179", + series = lncs, + publisher = springer, + URL = "http://www.ai.mit.edu/people/shivers/ll.ps", +} + +@Article{sikmhs-12, + author = "Jan Schwinghammer and Lars Birkedal and François + Pottier and Bernhard Reus and Kristian St{\o}vring and + Hongseok Yang", + title = "A step-indexed {Kripke} Model of Hidden State", + journal = mscs, + note = "To appear", + year = "2012", + URL = "http://gallium.inria.fr/~fpottier/publis/sikmhs.pdf", +} + +@InProceedings{simonet-02, + author = "Vincent Simonet", + title = "Fine-grained Information Flow Analysis for a + $\lambda$-calculus with Sum Types", + booktitle = csfw, + pages = "223--237", + year = "2002", + URL = "http://gallium.inria.fr/~simonet/publis/simonet-csfw-02.ps.gz", +} + +@InProceedings{simonet-03, + author = "Vincent Simonet", + title = "An Extension of {HM(X)} with Bounded Existential and + Universal Data-Types", + year = "2003", + booktitle = icfp, + URL = "http://gallium.inria.fr/~simonet/publis/simonet-icfp03.ps.gz", +} + +@TechReport{simonet-flowcaml-manual, + author = "Vincent Simonet", + title = "The {Flow Caml} system: documentation and user's + manual", + institution = "INRIA", + number = "0282", + year = "2003", + URL = "http://gallium.inria.fr/~simonet/soft/flowcaml/manual/", +} + +@TechReport{simonet-pottier-hmg, + author = "Vincent Simonet and François Pottier", + title = "Constraint-Based Type Inference for Guarded Algebraic + Data Types", + year = "2005", + institution = "INRIA", + type = "Research Report", + number = "5462", + URL = "http://www.inria.fr/rrrt/rr-5462.html", +} + +@InProceedings{simonet-solver-03, + author = "Vincent Simonet", + title = "Type inference with structural subtyping: a faithful + formalization of an efficient constraint solver", + booktitle = aplas, + publisher = springer, + series = lncs, + volume = "2895", + year = "2003", + URL = "http://gallium.inria.fr/~simonet/publis/simonet-aplas03.pdf", +} + +@PhdThesis{simonet-these, + author = "Vincent Simonet", + title = "Inférence de flots d'information pour {ML}: + formalisation et implantation", + school = "Université Paris 7", + year = "2004", + URL = "http://gallium.inria.fr/~simonet/publis/simonet-these.pdf", +} + +@Article{simplify, + author = "David Detlefs and Greg Nelson and James B. Saxe", + title = "{Simplify}: a theorem prover for program checking", + journal = jacm, + volume = "52", + number = "3", + year = "2005", + pages = "365--473", + URL = "http://doi.acm.org/10.1145/1066100.1066102", +} + +@PhdThesis{skalka-phd-02, + author = "Christian Skalka", + title = "Types for Programming Language-Based Security", + school = "The Johns Hopkins University", + year = "2002", + URL = "http://www.cs.uvm.edu/~skalka/skalka-pubs/skalka-phd-thesis.ps", +} + +@InProceedings{skalka-pottier-tip-02, + author = "Christian Skalka and François Pottier", + title = "Syntactic Type Soundness for {HM}{$(X)$}", + year = "2002", + booktitle = "Workshop on Types in Programming (TIP)", + series = entcs, + volume = "75", + URL = "http://gallium.inria.fr/~fpottier/publis/skalka-fpottier-tip-02.ps.gz", +} + +@InProceedings{skalka-smith-00, + author = "Christian Skalka and Scott Smith", + title = "Static Enforcement of Security with Types", + booktitle = icfp, + year = "2000", + pages = "34--45", + URL = "http://www.cs.uvm.edu/~skalka/skalka-pubs/skalka-smith-icfp00.ps", +} + +@InProceedings{smallfoot-05, + author = "Josh Berdine and Cristiano Calcagno and Peter W. + O'Hearn", + title = "Smallfoot: Modular Automatic Assertion Checking with + Separation Logic", + booktitle = fmco, + pages = "115--137", + year = "2005", + volume = "4111", + series = lncs, + publisher = springer, + URL = "http://research.microsoft.com/pubs/67598/smallfoot.pdf", +} + +@InProceedings{smans-implicit-09, + title = "Implicit Dynamic Frames: Combining Dynamic Frames and + Separation Logic", + year = "2009", + author = "Jan Smans and Bart Jacobs and Frank Piessens", + booktitle = ecoop, + pages = "148--172", + volume = "5653", + series = lncs, + publisher = springer, + URL = "http://people.cs.kuleuven.be/~jan.smans/ecoop09.pdf", +} + +@InProceedings{smetsers-94, + author = "Sjaak Smetsers and Erik Barendsen and Marko C. J. D. + van Eekelen and Marinus J. Plasmeijer", + title = "Guaranteeing Safe Destructive Updates Through a Type + System with Uniqueness Information for Graphs", + booktitle = "Dagstuhl Seminar on Graph Transformations in Computer + Science", + year = "1994", + pages = "358--379", + publisher = springer, + series = lncs, + volume = "776", + URL = "http://www.mbsd.cs.ru.nl/publications/papers/1994/smes94-guaranteeing.pdf", +} + +@InProceedings{smith-01, + author = "Geoffrey S. Smith", + title = "A New Type System for Secure Information Flow", + booktitle = csfw, + pages = "115--125", + year = "2001", + URL = "http://www.cs.fiu.edu/~smithg/papers/csfw01.pdf", +} + +@InProceedings{smith-93, + author = "Geoffrey S. Smith", + title = "Polymorphic type Inference with Overloading and + Subtyping", + booktitle = tapsoft, + series = lncs, + volume = "668", + publisher = springer, + year = "1993", + pages = "671--685", + URL = "http://dx.doi.org/10.1007/3-540-56610-4_97", +} + +@Article{smith-94, + author = "Geoffrey S. Smith", + title = "Principal Type Schemes for Functional Programs with + Overloading and Subtyping", + journal = scp, + year = "1994", + volume = "23", + number = "2--3", + pages = "197--226", + URL = "http://www.cs.fiu.edu/~smithg/papers/scp94.pdf", +} + +@PhdThesis{smith-phd-89, + author = "Scott Fraser Smith", + title = "Partial Objects in Type Theory", + school = "Cornell University", + year = "1989", + URL = "http://www.cs.jhu.edu/~scott/pll/older-papers/thesis.pdf", +} + +@InProceedings{smith-volpano-98, + title = "Secure Information Flow in a Multi-Threaded Imperative + Language", + booktitle = popl, + author = "Geoffrey Smith and Dennis Volpano", + year = "1998", + pages = "355--364", + URL = "http://www.cs.nps.navy.mil/people/faculty/volpano/papers/popl98.ps.Z", +} + +@InProceedings{smith-wang-00, + author = "Scott Smith and Tiejun Wang", + title = "Polyvariant Flow Analysis with Constrained Types", + booktitle = esop, + publisher = springer, + series = lncs, + volume = "1782", + pages = "382--396", + year = "2000", + URL = "http://link.springer.de/link/service/series/0558/papers/1782/17820382.pdf", +} + +@Book{sml-97, + author = "Robin Milner and Mads Tofte and Robert Harper and + David MacQueen", + title = "The Definition of {Standard ML} -- Revised", + publisher = mitp, + year = "1997", +} + +@Article{smolka-treinen-94, + title = "Records for Logic Programming", + year = "1994", + author = "Gert Smolka and Ralf Treinen", + volume = "18", + journal = jlp, + number = "3", + pages = "229--258", + URL = "http://www.ps.uni-sb.de/Papers/abstracts/RecordsLogProg.ps", +} + +@Article{smyth-plotkin-82, + author = "Michael B. Smyth and Gordon D. Plotkin", + title = "The Category-Theoretic Solution of Recursive Domain + Equations", + journal = siamjc, + volume = "11", + number = "4", + year = "1982", + pages = "761--783", + URL = "http://homepages.inf.ed.ac.uk/gdp/publications/Category_Theoretic_Solution.pdf", +} + +@InProceedings{snyder-86, + author = "Alan Snyder", + title = "Encapsulation and inheritance in object-oriented + programming languages", + booktitle = oopsla, + year = "1986", + pages = "38--45", + URL = "http://doi.acm.org/10.1145/28697.28702", +} + +@InProceedings{sobel-friedman-98, + author = "Jonathan Sobel and Daniel P. Friedman", + title = "Recycling continuations", + booktitle = icfp, + year = "1998", + pages = "251--260", + URL = "http://www.cs.indiana.edu/hyplan/dfried/rc.ps", +} + +@Article{soisalon-soininen-82, + author = "Eljas Soisalon-Soininen", + title = "Inessential Error Entries and Their Use in {LR} Parser + Optimization", + journal = toplas, + volume = "4", + number = "2", + year = "1982", + pages = "179--195", + URL = "http://doi.acm.org/10.1145/357162.357165", +} + +@InProceedings{solomon-78, + author = "Marvin H. Solomon", + title = "Type Definitions with Parameters", + booktitle = popl, + year = "1978", + pages = "31--38", + URL = "http://doi.acm.org/10.1145/512760.512765", +} + +@Article{soloviev-83, + author = "Sergei V. Soloviev", + title = "The category of finite sets and Cartesian Closed + Categories", + journal = "Journal of Soviet Mathematics", + year = "1983", + volume = "22", + number = "3", + pages = "1387--1400", +} + +@InProceedings{sozeau-06, + author = "Matthieu Sozeau", + title = "Subset Coercions in {Coq}", + booktitle = types, + year = "2006", + volume = "4502", + pages = "237--252", + URL = "http://www.lri.fr/~sozeau/research/russell/article.pdf", +} + +@InProceedings{sozeau-finger-07, + author = "Matthieu Sozeau", + booktitle = icfp, + pages = "13--24", + URL = "http://mattam.org/research/publications/Program-ing_Finger_Trees_in_Coq.pdf", + title = "Program-ing Finger Trees in {Coq}", + year = "2007", +} + +@Article{spec-sharp-04, + author = "Mike Barnett and Rob DeLine and Manuel Fähndrich and + K. Rustan M. Leino and Wolfram Schulte", + title = "Verification of object-oriented programs with + invariants", + journal = jot, + year = "2004", + volume = "3", + number = "6", + URL = "http://research.microsoft.com/research/pubs/view.aspx?type=article&id=1161", +} + +@Article{spivey-90, + year = "1990", + volume = "14", + title = "A Functional Theory of Exceptions", + pages = "25--42", + journal = scp, + author = "Mike Spivey", +} + +@InProceedings{stata-abadi-98, + author = "R. Stata and M. Abadi", + title = "A Type System for {Java} Bytecode Subroutines", + year = "1998", + pages = "149--160", + booktitle = popl, + URL = "http://gatekeeper.dec.com/pub/DEC/SRC/research-reports/abstracts/src-rr-158.html", +} + +@Article{steckler-wand-97, + author = "Paul A. Steckler and Mitchell Wand", + title = "Lightweight closure conversion", + journal = toplas, + volume = "19", + number = "1", + year = "1997", + pages = "48--86", + URL = "ftp://ftp.ccs.neu.edu/pub/people/wand/papers/steckler-wand-97.ps", +} + +@InProceedings{steensgaard-96, + author = "Bjarne Steensgaard", + booktitle = popl, + title = "Points-to Analysis in Almost Linear Time", + year = "1996", + pages = "32--41", + URL = "ftp://ftp.research.microsoft.com/users/rusa/popl96.ps", +} + +@InProceedings{steffen-fix-machine-95, + author = "Bernhard Steffen and Andreas Cla{\ss}en and Marion + Klein and Jens Knoop and Tiziana Margaria", + title = "The Fixpoint-Analysis Machine", + booktitle = concur, + year = "1995", + pages = "72--87", + publisher = springer, + series = lncs, + volume = "962", + URL = "http://dx.doi.org/10.1007/3-540-60218-6_6", +} + +@InProceedings{stehr-00, + author = "Mark-Oliver Stehr", + title = "{CINNI} -- {A} Generic Calculus of Explicit + Substitutions and its Application to $\lambda$-, + $\sigma$- and $\pi$-calculi", + booktitle = wrla, + year = "2000", + volume = "36", + series = entcs, + publisher = elsevier, + URL = "http://formal.cs.uiuc.edu/stehr/extcinni.ps", +} + +@InProceedings{stewart-veristar-12, + author = "Gordon Stewart and Lennart Beringer and Andrew W. + Appel", + title = "Verified heap theorem prover by paramodulation", + booktitle = icfp, + year = "2012", + pages = "3--14", + URL = "http://www.cs.princeton.edu/~appel/papers/veristar.pdf", +} + +@InProceedings{stoughton-81, + author = "Allen Stoughton", + title = "Access Flow: {A} Protection Model Which Integrates + Access Control and Information Flow", + pages = "9--18", + booktitle = sp, + year = "1981", +} + +@Article{strachey-fundamental, + author = "Christopher Strachey", + title = "Fundamental Concepts in Programming Languages", + journal = hosc, + year = "2000", + volume = "13", + number = "1--2", + pages = "11--49", + URL = "http://dx.doi.org/10.1023/A:1010000313106", +} + +@Article{strom-yemini-86, + author = "Robert E. Strom and Shaula Yemini", + title = "Typestate: {A} programming language concept for + enhancing software reliability", + journal = tose, + volume = "12", + number = "1", + year = "1986", + pages = "157--171", + URL = "http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf", +} + +@InProceedings{stuckey-sulzmann-02, + author = "Peter J. Stuckey and Martin Sulzmann", + title = "A Theory of Overloading", + booktitle = icfp, + pages = "167--178", + year = "2002", + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.62.8605", +} + +@InProceedings{stuckey-sulzmann-wazny-03, + author = "Peter J. Stuckey and Martin Sulzmann and Jeremy + Wazny", + title = "Interactive type debugging in {Haskell}", + booktitle = hw, + pages = "72--83", + year = "2003", + URL = "http://www.cs.mu.oz.au/~pjs/papers/p316-stuckey.pdf", +} + +@InProceedings{su-aiken-01, + author = "Zhendong Su and Alexander Aiken", + title = "Entailment with Conditional Equality Constraints", + booktitle = esop, + year = "2001", + pages = "170--189", + series = lncs, + volume = "2028", + URL = "http://www.cs.ucdavis.edu/~su/publications/esop01.pdf", +} + +@InProceedings{su-al-02, + author = "Zhendong Su and Alexander Aiken and Joachim Niehren + and Tim Priesnitz and Ralf Treinen", + title = "The First-Order Theory of Subtyping Constraints", + booktitle = popl, + pages = "203--216", + year = "2002", + URL = "http://theory.stanford.edu/~aiken/publications/papers/popl02.pdf", +} + +@PhdThesis{sulzmann-00, + author = "Martin Sulzmann", + title = "A general framework for {Hindley/Milner} type systems + with constraints", + school = "Yale University, Department of Computer Science", + year = "2000", + URL = "http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.7.7745", +} + +@InProceedings{sulzmann-01, + author = "Martin Sulzmann", + title = "A General Type Inference Framework for + {Hindley/Milner} Style Systems", + booktitle = "International Symposium on Functional and Logic + Programming", + series = lncs, + volume = "2024", + pages = "246--263", + publisher = springer, + year = "2001", + URL = "http://link.springer.de/link/service/series/0558/papers/2024/20240248.pdf", +} + +@TechReport{sulzmann-mueller-zenger-99, + author = "Martin Sulzmann and Martin Müller and Christoph + Zenger", + title = "{Hindley/Milner} style type systems in constraint + form", + institution = "University of South Australia, School of Computer and + Information Science", + type = "Research Report", + year = "1999", + number = "ACRC--99--009", + URL = "http://www.ps.uni-sb.de/~mmueller/papers/hm-constraints.ps.gz", +} + +@InProceedings{sulzmann-odersky-wehr-97, + author = "Martin Sulzmann and Martin Odersky and Martin Wehr", + title = "Type Inference with Constrained Types", + booktitle = fool, + year = "1997", + URL = "ftp://ftp.ira.uka.de/pub/uni-karlsruhe/papers/techreports/1996/1996-28.ps.gz", +} + +@TechReport{sulzmann-records-97, + author = "Martin Sulzmann", + title = "Designing Record Systems", + institution = "Yale University", + year = "1997", + type = "Research Report", + number = "YALEU/DCS/RR-1128", + URL = "http://www.cs.mu.oz.au/~sulzmann/publications/tr-1128.ps.gz", +} + +@TechReport{sulzmann-wang-04, + author = "Martin Sulzmann and Meng Wang", + title = "A Systematic Translation of Guarded Recursive Data + Types to Existential Types", + institution = "National University of Singapore", + number = "TR22/04", + year = "2004", + ps = "http://www.cs.mu.oz.au/~sulzmann/publications/translate-grdts.ps.gz", +} + +@InProceedings{sumii-09, + author = "Eijiro Sumii", + title = "A Complete Characterization of Observational + Equivalence in Polymorphic lambda-Calculus with General + References", + booktitle = csl, + series = lncs, + publisher = springer, + volume = "5771", + pages = "455--469", + year = "2009", + URL = "http://www.kb.ecei.tohoku.ac.jp/~sumii/pub/poly-ref.pdf", +} + +@InProceedings{svendsen-birkedal-icap-14, + author = "Kasper Svendsen and Lars Birkedal", + title = "Impredicative Concurrent Abstract Predicates", + booktitle = esop, + year = "2014", + pages = "149--168", + volume = "8410", + publisher = springer, + series = lncs, + URL = "http://cs.au.dk/~birke/papers/icap-conf.pdf", +} + +@InProceedings{svendsen-birkedal-parkinson-hocap-13, + author = "Kasper Svendsen and Lars Birkedal and Matthew J. + Parkinson", + booktitle = esop, + pages = "169--188", + publisher = springer, + series = lncs, + title = "Modular Reasoning about Separation of Concurrent Data + Structures", + volume = "7792", + year = "2013", + URL = "http://cs.au.dk/~birke/papers/hocap-conf.pdf", +} + +@InProceedings{svendsen-birkedal-parkinson-joins-13, + author = "Kasper Svendsen and Lars Birkedal and Matthew J. + Parkinson", + title = "Joins: {A} Case Study in Modular Specification of a + Concurrent Reentrant Higher-Order Library", + booktitle = ecoop, + year = "2013", + pages = "327--351", + publisher = springer, + series = lncs, + volume = "7920", + URL = "http://cs.au.dk/~birke/papers/joins-conf.pdf", +} + +@Article{swamy-06, + author = "Nikhil Swamy and Michael Hicks and Greg Morrisett and + Dan Grossman and Trevor Jim", + title = "Safe Manual Memory Management in {Cyclone}", + journal = scp, + year = "2006", + volume = "62", + number = "2", + pages = "122--144", + URL = "http://www.cs.umd.edu/~mwh/papers/cyc-mm-scp.pdf", +} + +@InProceedings{swierstra-duponcheel-96, + author = "S. Doaitse Swierstra and Luc Duponcheel", + title = "Deterministic, Error-Correcting Combinator Parsers", + booktitle = "Advanced Functional Programming", + year = "1996", + publisher = "Springer", + series = "Lecture Notes in Computer Science", + volume = "1129", + pages = "184--207", + URL = "http://www.staff.science.uu.nl/~swier101/Papers/1996/DetErrCorrComPars.pdf", +} + +@PhdThesis{taha-99, + author = "Walid Taha", + title = "Multi-stage Programming: Its Theory and Applications", + school = "Oregon Graduate Institute", + year = "1999", + URL = "http://www.cs.rice.edu/~taha/publications/thesis/thesis.pdf", +} + +@InProceedings{taha-gentle-04, + author = "Walid Taha", + title = "A Gentle Introduction to Multi-stage Programming", + booktitle = dspg, + pages = "30--50", + year = "2004", + volume = "3016", + series = lncs, + publisher = springer, + URL = "http://www.cs.rice.edu/~taha/publications/journal/dspg04a.pdf", +} + +@InProceedings{taha-nielsen-03, + author = "Walid Taha and Michael Florentin Nielsen", + title = "Environment classifiers", + booktitle = popl, + year = "2003", + pages = "26--37", + URL = "http://www.cs.rice.edu/~taha/publications/conference/popl03.pdf", +} + +@Article{takahashi-95, + author = "Masako Takahashi", + title = "Parallel Reductions in $\lambda$-Calculus", + journal = ic, + year = "1995", + volume = "118", + number = "1", + pages = "120--127", + URL = "http://dx.doi.org/10.1006/inco.1995.1057", +} + +@Article{talcott-93, + author = "Carolyn Talcott", + title = "A Theory of Binding Structures and Applications to + Rewriting", + journal = tcs, + year = "1993", + volume = "112", + number = "1", + pages = "99--143", + URL = "http://steam.stanford.edu/MT/91amast-tcs.ps.Z", +} + +@Article{talpin-jouvelot-94, + author = "Jean-Pierre Talpin and Pierre Jouvelot", + title = "The type and effect discipline", + journal = ic, + year = "1994", + volume = "11", + number = "2", + pages = "245--296", + URL = "http://www.irisa.fr/prive/talpin/papers/ic94.pdf", +} + +@InProceedings{tan-wusl-09, + author = "Gang Tan and Zhong Shao and Xinyu Feng and Hongxu + Cai", + title = "Weak Updates and Separation Logic", + booktitle = aplas, + pages = "178--193", + year = "2009", + volume = "5904", + series = lncs, + publisher = springer, + URL = "http://flint.cs.yale.edu/flint/publications/wusl.pdf", +} + +@Book{tapl, + author = "Benjamin C. Pierce", + title = "Types and Programming Languages", + publisher = mitp, + year = "2002", +} + +@Manual{tarditi-appel-00, + title = "{ML-Yacc} User's Manual", + author = "David R. Tarditi and Andrew W. Appel", + year = "2000", + URL = "http://www.smlnj.org/doc/ML-Yacc/", +} + +@Article{tarjan-72, + author = "Robert Tarjan", + title = "Depth-First Search and Linear Graph Algorithms", + journal = siamjc, + year = "1972", + volume = "1", + number = "2", + pages = "146--160", + URL = "http://epubs.siam.org/doi/abs/10.1137/0201010", +} + +@Article{tarjan-75, + author = "Robert Endre Tarjan", + title = "Efficiency of a Good But Not Linear Set Union + Algorithm", + journal = jacm, + year = "1975", + volume = "22", + number = "2", + pages = "215--225", + URL = "http://www.csd.uwo.ca/~eschost/Teaching/07-08/CS445a/p215-tarjan.pdf", +} + +@Article{tarjan-79, + author = "Robert Endre Tarjan", + title = "Applications of Path Compression on Balanced Trees", + journal = jacm, + year = "1979", + volume = "26", + number = "4", + pages = "690--715", + URL = "http://doi.acm.org/10.1145/322154.322161", +} + +@Unpublished{tarjan-99-notes, + title = "Class notes: Disjoint Set Union", + author = "Robert E. Tarjan", + year = "1999", + URL = "http://www.cs.princeton.edu/courses/archive/spr00/cs423/handout3.pdf", +} + +@Article{tarjan-amortized-85, + author = "Robert Endre Tarjan", + title = "Amortized Computational Complexity", + year = "1985", + journal = "SIAM Journal on Algebraic and Discrete Methods", + volume = "6", + number = "2", + pages = "306--318", + URL = "http://dx.doi.org/10.1137/0606031", +} + +@Article{tarjan-leeuwen-84, + author = "Robert E. Tarjan and Jan {van Leeuwen}", + title = "Worst-Case Analysis of Set Union Algorithms", + journal = jacm, + volume = "31", + number = "2", + pages = "245--281", + year = "1984", + URL = "http://dx.doi.org/10.1145/62.2160", +} + +@Article{tarjan-yannakakis-84, + author = "Robert E. Tarjan and Mihalis Yannakakis", + title = "Simple Linear-Time Algorithms to Test Chordality of + Graphs, Test Acyclicity of Hypergraphs, and Selectively + Reduce Acyclic Hypergraphs", + journal = siamjc, + year = "1984", + volume = "13", + number = "3", + pages = "566--579", + URL = "http://dx.doi.org/10.1137/0213035", +} + +@Article{tarjan-yao-79, + author = "Robert Endre Tarjan and Andrew Chi-Chih Yao", + title = "Storing a sparse table", + journal = cacm, + volume = "22", + number = "11", + year = "1979", + pages = "606--611", + URL = "http://doi.acm.org/10.1145/359168.359175", +} + +@InProceedings{template-haskell-02, + author = "Tim Sheard and Simon {Peyton Jones}", + title = "Template metaprogramming for {Haskell}", + booktitle = hw, + year = "2002", + pages = "1--16", + URL = "https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/meta-haskell.pdf", +} + +@Article{tennent-ghica-00, + author = "Robert D. Tennent and Dan Ghica", + title = "Abstract models of storage", + journal = hosc, + year = "2000", + volume = "13", + pages = "119--129", + URL = "http://dx.doi.org/10.1023/A:1010022312623", +} + +@InProceedings{thatte-94, + author = "Satish R. Thatt{\'e}", + title = "Automated synthesis of interface adapters for reusable + classes", + booktitle = popl, + year = "1994", + pages = "174--187", + URL = "http://doi.acm.org/10.1145/174675.177850", +} + +@InProceedings{thielecke-03, + author = "Hayo Thielecke", + title = "From control effects to typed continuation passing", + booktitle = popl, + year = "2003", + pages = "139--149", + URL = "http://www.cs.bham.ac.uk/~hxt/research/effects.pdf", +} + +@InProceedings{thielecke-06, + author = "Hayo Thielecke", + title = "Frame rules from answer types for code pointers", + booktitle = popl, + year = "2006", + pages = "309--319", + URL = "http://www.cs.bham.ac.uk/~hxt/research/popl06thielecke.pdf", +} + +@Article{thielecke-barrel-02, + author = "Hayo Thielecke", + title = "Comparing Control Constructs by Double-barrelled + {CPS}", + journal = hosc, + year = "2002", + volume = "15", + number = "2--3", + pages = "141--160", + URL = "http://www.cs.bham.ac.uk/~hxt/research/HOSC-double-barrel.pdf", +} + +@InProceedings{thiemann-01, + author = "Peter Thiemann", + title = "Enforcing Security Properties Using Type + Specialization", + booktitle = esop, + publisher = springer, + series = lncs, + year = "2001", + URL = "http://www.informatik.uni-freiburg.de/~thiemann/papers/espps-het.ps.gz", +} + +@InProceedings{thiemann-99, + author = "Peter Thiemann", + title = "{ML}-Style Typing, Lambda Lifting, and Partial + Evaluation", + booktitle = "Latin American Conference on Functional Programming", + year = "1999", + URL = "http://www.informatik.uni-freiburg.de/~thiemann/papers/clapf99.ps.gz", +} + +@InProceedings{tiuryn-92, + author = "Jerzy Tiuryn", + title = "Subtype inequalities", + pages = "308--317", + booktitle = lics, + year = "1992", +} + +@Article{tiuryn-urzyczyn-02, + author = "Jerzy Tiuryn and Pawel Urzyczyn", + title = "The subtyping problem for second-order types is + undecidable", + journal = ic, + volume = "179", + number = "1", + year = "2002", + pages = "1--18", + URL = "http://dx.doi.org/10.1006/inco.2001.2950", +} + +@InProceedings{tiuryn-wand-93, + author = "Jerzy Tiuryn and Mitchell Wand", + title = "Type Reconstruction with Recursive Types and Atomic + Subtyping", + pages = "686--701", + year = "1993", + booktitle = tapsoft, + series = lncs, + volume = "668", + publisher = springer, + URL = "ftp://ftp.ccs.neu.edu/pub/people/wand/papers/caap-93.dvi", +} + +@PhdThesis{tofte-88, + author = "Mads Tofte", + title = "Operational Semantics and Polymorphic Type Inference", + school = "University of Edinburgh", + year = "1988", + URL = "http://www.itu.dk/people/tofte/publ/phdthesis/thesis-part1and2.ps", +} + +@Article{tofte-retro-04, + author = "Mads Tofte and Lars Birkedal and Martin Elsman and + Niels Hallenberg", + title = "A Retrospective on Region-Based Memory Management", + journal = hosc, + year = "2004", + volume = "17", + number = "3", + pages = "245--265", + URL = "http://www.itu.dk/people/birkedal/papers/regmmp.ps.gz", +} + +@InProceedings{tofte-talpin-94, + author = "Mads Tofte and Jean-Pierre Talpin", + title = "Implementation of the Typed Call-by-Value + $\lambda$-Calculus using a Stack of Regions", + booktitle = popl, + year = "1994", + pages = "188--201", + URL = "http://www.irisa.fr/prive/talpin/papers/popl94.pdf", +} + +@Article{tofte-talpin-97, + author = "Mads Tofte and Jean-Pierre Talpin", + title = "Region-based memory management", + journal = ic, + volume = "132", + number = "2", + year = "1997", + pages = "109--176", + URL = "http://www.irisa.fr/prive/talpin/papers/ic97.pdf", +} + +@InProceedings{tolmach-97, + author = "Andrew Tolmach", + title = "Combining Closure Conversion with Closure Analysis + using Algebraic Types", + booktitle = tic, + year = "1997", + URL = "http://www.cs.pdx.edu/~apt/tic97.ps", +} + +@Article{tolmach-oliva-98, + author = "Andrew Tolmach and Dino P. Oliva", + title = "From {ML} to {Ada}: Strongly-typed Language + Interoperability via Source Translation", + journal = jfp, + year = "1998", + volume = "8", + number = "4", + pages = "367--412", + URL = "http://dx.doi.org/10.1017/S0956796898003086", +} + +@Article{topor-82, + author = "Rodney W. Topor", + title = "A Note on Error Recovery in Recursive Descent + Parsers", + journal = notices, + volume = "17", + number = "2", + year = "1982", + pages = "37--40", + URL = "http://doi.acm.org/10.1145/947902.947905", +} + +@InProceedings{tov-pucella-10, + author = "Jesse A. Tov and Riccardo Pucella", + title = "Stateful Contracts for Affine Types", + booktitle = esop, + year = "2010", + pages = "550--569", + publisher = springer, + series = lncs, + volume = "6012", + URL = "http://www.eecs.harvard.edu/~tov/pubs/affine-contracts/affinecontracts10-bw.pdf", +} + +@InProceedings{tov-pucella-11, + author = "Jesse A. Tov and Riccardo Pucella", + title = "Practical Affine Types", + booktitle = popl, + year = "2011", + pages = "447--458", + URL = "http://www.eecs.harvard.edu/~tov/pubs/alms/", +} + +@InProceedings{trifonov-smith-96, + author = "Valery Trifonov and Scott Smith", + title = "Subtyping Constrained Types", + booktitle = sas, + series = lncs, + volume = "1145", + pages = "349--365", + year = "1996", + publisher = springer, + URL = "http://flint.cs.yale.edu/trifonov/papers/subcon.pdf", +} + +@InProceedings{tschantz-ernst-05, + author = "Matthew S. Tschantz and Michael D. Ernst", + title = "Javari: adding reference immutability to {Java}", + booktitle = oopsla, + year = "2005", + pages = "211--230", + URL = "https://homes.cs.washington.edu/~mernst/pubs/ref-immutability-oopsla2005.pdf", +} + +@InProceedings{tse-zdancewic-04, + author = "Stephen Tse and Steve Zdancewic", + title = "Run-time Principals in Information-flow Type Systems", + booktitle = sp, + year = "2004", + URL = "http://www.cis.upenn.edu/~stevez/papers/TZ04a.pdf", +} + +@InProceedings{tsuiki-94, + author = "Hideki Tsuiki", + title = "On Typed Calculi with a Merge Operator", + booktitle = fsttcs, + pages = "101--112", + year = "1994", + volume = "880", + series = lncs, + publisher = springer, + URL = "http://www.i.h.kyoto-u.ac.jp/~tsuiki/papers/fsttcs.ps.gz", +} + +@Unpublished{tuerk-10, + author = "Thomas Tuerk", + title = "Local reasoning about while-loops", + year = "2010", + note = "Unpublished", + URL = "http://www.cl.cam.ac.uk/~tt291/talks/vstte10.pdf", +} + +@PhdThesis{turner-95, + author = "David N. Turner", + title = "The Polymorphic Pi-Calculus: Theory and + Implementation", + school = "University of Edinburgh", + year = "1995", + URL = "http://www.lfcs.inf.ed.ac.uk/reports/96/ECS-LFCS-96-345/", +} + +@InProceedings{turner-wadler-mossin-95, + author = "David N. Turner and Philip Wadler and Christian + Mossin", + year = "1995", + title = "Once upon a type", + booktitle = fpca, + publisher = acmp, + pages = "1--11", + URL = "ftp://ftp.dcs.gla.ac.uk/pub/glasgow-fp/authors/Philip_Wadler/once.dvi", +} + +@InProceedings{turon-caresl-13, + author = "Aaron Turon and Derek Dreyer and Lars Birkedal", + title = "Unifying refinement and {Hoare}-style reasoning in a + logic for higher-order concurrency", + booktitle = icfp, + year = "2013", + pages = "377--390", + URL = "http://www.mpi-sws.org/~turon/caresl/caresl.pdf", +} + +@InProceedings{unbound-11, + author = "Stephanie Weirich and Brent A. Yorgey and Tim Sheard", + title = "Binders unbound", + booktitle = icfp, + pages = "333--345", + year = "2011", + URL = "http://www.seas.upenn.edu/~sweirich/papers/icfp11.pdf", +} + +@Misc{unicon, + title = "Unicon", + note = "\url{http://unicon.sourceforge.net/}", + URL = "http://unicon.sourceforge.net/", +} + +@Article{urban-04, + author = "Christian Urban and Andrew Pitts and Murdoch Gabbay", + title = "Nominal Unification", + journal = tcs, + year = "2004", + URL = "http://www.cl.cam.ac.uk/~cu200/Unification/nomu-tcs.ps", + volume = "323", + pages = "473--497", +} + +@Article{urban-08, + author = "Christian Urban", + title = "Nominal Techniques in {Isabelle/HOL}", + journal = jar, + volume = "40", + number = "4", + year = "2008", + pages = "327--356", + URL = "http://www4.in.tum.de/~urbanc/Publications/nom-tech.ps", +} + +@Unpublished{urban-nipkow-08, + author = "Christian Urban and Tobias Nipkow", + title = "Nominal Verification of Algorithm {W}", + year = "2008", + note = "Unpublished", + URL = "http://www4.in.tum.de/~urbanc/Publications/w-07.pdf", +} + +@InProceedings{urban-tasson-05, + author = "Christian Urban and Christine Tasson", + title = "Nominal Techniques in {Isabelle/HOL}", + booktitle = cade, + year = "2005", + series = lncs, + publisher = springer, + volume = "3632", + pages = "38--53", + URL = "http://www4.in.tum.de/~urbanc/Publications/nom-cade-05.ps", +} + +@Unpublished{vacid, + author = "K. Rustan M. Leino and Michal Moskal", + title = "{VACID}-0: Verification of Ample Correctness of + Invariants of Data-structures, Edition 0", + note = "Manuscript KRML 209", + year = "2010", + URL = "http://research.microsoft.com/en-us/um/people/moskal/pdf/vacid0.pdf", +} + +@Article{vafeiadis-11, + author = "Viktor Vafeiadis", + title = "Concurrent Separation Logic and Operational + Semantics", + journal = entcs, + volume = "276", + year = "2011", + pages = "335--351", + URL = "http://www.mpi-sws.org/~viktor/papers/mfps2011-cslsound.pdf", +} + +@InProceedings{vaziri-jackson-03, + author = "Mandana Vaziri and Daniel Jackson", + title = "Checking Heap-Manipulating Procedures with a + Constraint Solver", + booktitle = tacas, + year = "2003", + publisher = springer, + series = lncs, + volume = "2619", + URL = "http://sdg.lcs.mit.edu/pubs/2003/checkingHMPs.pdf", +} + +@InProceedings{vdw-mckinna-08, + author = "Eelis {van der Weegen} and James McKinna", + title = "A Machine-Checked Proof of the Average-Case Complexity + of {Quicksort} in {Coq}", + booktitle = types, + year = "2008", + pages = "256--271", + publisher = springer, + series = lncs, + volume = "5497", + URL = "http://www.xs4all.nl/~weegen/eelis/research/quicksort/", +} + +@InProceedings{vergauwen-lewi-94, + author = "Bart Vergauwen and Johan Lewi", + title = "Efficient Local Correctness Checking for Single and + Alternating {Boolean} Equation Systems", + booktitle = icalp, + year = "1994", + pages = "304--315", + publisher = springer, + series = lncs, + volume = "820", + URL = "http://dx.doi.org/10.1007/3-540-58201-0_77", +} + +@InProceedings{vergauwen-nested-94, + author = "Bart Vergauwen and Johan Lewi and I. Avau and A. + Poté", + title = "Efficient computation of nested fix-points, with + applications to model checking", + booktitle = ictl, + pages = "165--179", + year = "1994", + volume = "827", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/BFb0013987", +} + +@InProceedings{vergauwen-wauman-lewi-94, + author = "Bart Vergauwen and J. Wauman and Johan Lewi", + title = "Efficient fixpoint computation", + booktitle = sas, + pages = "314--328", + year = "1994", + volume = "864", + series = lncs, + publisher = springer, + URL = "http://dx.doi.org/10.1007/3-540-58485-4_49", +} + +@TechReport{verifast, + author = "Bart Jacobs and Frank Piessens", + title = "The {VeriFast} Program Verifier", + institution = "Department of Computer Science, Katholieke + Universiteit Leuven", + year = "2008", + number = "CW-520", + URL = "http://people.cs.kuleuven.be/~bart.jacobs/verifast/verifast.pdf", +} + +@InProceedings{villard-lozes-calcagno-09, + author = "Jules Villard and Étienne Lozes and Cristiano + Calcagno", + booktitle = aplas, + pages = "194--209", + publisher = springer, + series = lncs, + title = "Proving Copyless Message Passing", + URL = "http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/VLC-aplas09.pdf", + volume = "5904", + year = "2009", +} + +@InProceedings{villard-lozes-calcagno-10, + author = "Jules Villard and Étienne Lozes and Cristiano + Calcagno", + booktitle = tacas, + pages = "275--279", + publisher = springer, + series = lncs, + title = "Tracking Heaps that Hop with {Heap-Hop}", + URL = "http://www.lsv.ens-cachan.fr/Publis/PAPERS/PDF/VLC-tacas10.pdf", + volume = "6015", + year = "2010", +} + +@Article{vitek-bokowski-01, + author = "Jan Vitek and Boris Bokowski", + title = "Confined types in {Java}", + journal = spe, + volume = "31", + number = "6", + pages = "507--532", + year = "2001", + URL = "https://www.cerias.purdue.edu/assets/pdf/bibtex_archive/2001-63.pdf", +} + +@Article{volpano-97, + author = "Dennis Volpano", + title = "Provably-Secure Programming Languages for Remote + Evaluation", + journal = notices, + volume = "32", + number = "1", + pages = "117--119", + year = "1997", +} + +@Article{volpano-smith-97, + author = "Dennis Volpano and Geoffrey Smith", + title = "A Type-Based Approach to Program Security", + journal = lncs, + volume = "1214", + pages = "607--621", + year = "1997", + URL = "http://www.cs.nps.navy.mil/people/faculty/volpano/papers/tapsoft97.ps.Z", +} + +@InProceedings{volpano-smith-csfw-97, + author = "Dennis Volpano and Geoffrey Smith", + year = "1997", + title = "Eliminating Covert Flows with Minimum Typings", + booktitle = csfw, + pages = "156--168", + URL = "http://www.cs.nps.navy.mil/people/faculty/volpano/papers/csfw97.ps.Z", +} + +@Article{volpano-smith-irvine-96, + author = "Dennis Volpano and Geoffrey Smith and Cynthia Irvine", + title = "A Sound Type System for Secure Flow Analysis", + journal = "Journal of Computer Security", + volume = "4", + number = "3", + pages = "167--187", + year = "1996", + URL = "http://www.cs.nps.navy.mil/people/faculty/volpano/papers/jcs96.ps.Z", +} + +@InProceedings{vorobyov-96, + author = "Sergei G. Vorobyov", + title = "An Improved Lower Bound for the Elementary Theories of + Trees", + booktitle = cade, + pages = "275--287", + year = "1996", + volume = "1104", + series = lncs, + publisher = springer, + URL = "http://www.mpi-sb.mpg.de/~sv/publications/complexity/2ILB.ps.Z", +} + +@InProceedings{vouillon-mellies-04, + author = "Jérôme Vouillon and Paul-André Melliès", + title = "Semantic types: a fresh look at the ideal model for + types", + booktitle = popl, + year = "2004", + pages = "52--63", + URL = "http://www.pps.jussieu.fr/~vouillon/publi/cbv.ps.gz", +} + +@InProceedings{vries-06, + author = "Edsko de Vries and Rinus Plasmeijer and David + Abrahamson", + title = "Uniqueness Typing Redefined", + booktitle = ifl, + pages = "181--198", + year = "2006", + volume = "4449", + series = lncs, + publisher = springer, + URL = "https://www.cs.tcd.ie/~devriese/pub/ifl06-paper.pdf", +} + +@InProceedings{vries-07, + author = "Edsko de Vries and Rinus Plasmeijer and David + Abrahamson", + title = "Equality Based Uniqueness Typing", + booktitle = tfp, + year = "2007", + URL = "https://www.cs.tcd.ie/~devriese/pub/tfp07-paper.pdf", +} + +@Unpublished{vytiniotis-boxy-05, + author = "Dimitrios Vytiniotis and Stephanie Weirich and Simon + {Peyton Jones}", + title = "Boxy types: type inference for higher-rank types and + impredicativity", + note = "Manuscript", + year = "2005", + URL = "http://research.microsoft.com/Users/simonpj/papers/boxy/", +} + +@Article{vytiniotis-outsidein-11, + author = "Dimitrios Vytiniotis and Simon L. {Peyton Jones} and + Tom Schrijvers and Martin Sulzmann", + title = "{OutsideIn(X)}: Modular type inference with local + assumptions", + journal = jfp, + volume = "21", + number = "4--5", + year = "2011", + pages = "333--412", + URL = "http://research.microsoft.com/en-us/um/people/simonpj/papers/constraints/jfp-outsidein.pdf", +} + +@InProceedings{vytiniotis-pie-07, + author = "Dimitrios Vytiniotis and Stephanie Weirich", + title = "Dependent Types: Easy as {PIE}", + booktitle = tfp, + year = "2007", + URL = "http://www.seas.upenn.edu/~sweirich/papers/tfp07.pdf", +} + +@InProceedings{wadler-85, + author = "Philip L. Wadler", + title = "How to replace failure by a list of successes", + booktitle = fpca, + publisher = springer, + series = lncs, + volume = "201", + year = "1985", + pages = "113--128", + URL = "http://dx.doi.org/10.1007/3-540-15975-4_33", +} + +@InProceedings{wadler-blott-89, + author = "Philip Wadler and Stephen Blott", + title = "How to make ad-hoc polymorphism less ad-hoc", + pages = "60--76", + booktitle = popl, + year = "1989", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/class/class.ps.gz", +} + +@Article{wadler-comprehending-92, + author = "Philip Wadler", + title = "Comprehending monads", + journal = mscs, + year = "1992", + volume = "2", + pages = "461--493", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/monads/monads.ps.gz", +} + +@InProceedings{wadler-essence-92, + author = "Philip Wadler", + title = "The essence of functional programming", + booktitle = popl, + year = "1992", + pages = "1--14", + note = "Invited talk", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/essence/essence.ps", +} + +@InProceedings{wadler-free-89, + author = "Philip Wadler", + title = "Theorems for free!", + booktitle = fpca, + year = "1989", + pages = "347--359", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/free/free.ps.gz", +} + +@Article{wadler-isomorphism-07, + author = "Philip Wadler", + title = "The {Girard}-{Reynolds} isomorphism (second edition)", + journal = tcs, + year = "2007", + volume = "375", + number = "1--3", + pages = "201--226", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/gr2/gr2.pdf", +} + +@InCollection{wadler-linear-90, + author = "Philip Wadler", + title = "Linear types can change the world!", + booktitle = "Programming Concepts and Methods", + publisher = "North Holland", + year = "1990", + editor = "M. Broy and C. Jones", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/linear/linear.ps", +} + +@Article{wadler-thiemann-03, + author = "Philip Wadler and Peter Thiemann", + title = "The marriage of effects and monads", + journal = tocl, + volume = "4", + number = "1", + pages = "1--32", + year = "2003", + URL = "http://homepages.inf.ed.ac.uk/wadler/papers/effectstocl/effectstocl.ps.gz", +} + +@InProceedings{walker-00, + author = "David Walker", + title = "A Type System for Expressive Security Policies", + booktitle = popl, + year = "2000", + pages = "254--267", + URL = "http://www.cs.cornell.edu/home/walker/papers/sa-popl00_ps.gz", +} + +@InCollection{walker-attapl-05, + author = "David Walker", + title = "Substructural Type Systems", + booktitle = "Advanced Topics in Types and Programming Languages", + pages = "3--43", + publisher = mitp, + year = "2005", + editor = "Benjamin C. Pierce", + chapter = "1", +} + +@Article{walker-capabilities-00, + author = "David Walker and Karl Crary and Greg Morrisett", + title = "Typed memory management via static capabilities", + journal = toplas, + volume = "22", + number = "4", + year = "2000", + pages = "701--771", + URL = "http://www.cs.princeton.edu/~dpw/papers/capabilities-toplas.pdf", +} + +@PhdThesis{wallach-99, + author = "Dan S. Wallach", + title = "A New Approach to Mobile Code Security", + school = "Princeton University", + year = "1999", + URL = "http://www.cs.princeton.edu/sip/pub/dwallach-dissertation.html", +} + +@Article{wallach-appel-felten-00, + author = "Dan S. Wallach and Andrew W. Appel and Edward W. + Felten", + title = "Safkasi: {A} Security Mechanism for Language-based + Systems", + journal = "ACM Transactions on Software Engineering and + Methodology", + year = "2000", + volume = "9", + number = "4", + pages = "341--378", + URL = "http://www.cs.rice.edu/~dwallach/pub/tosem2000.ps", +} + +@InProceedings{wallach-felten-stack-98, + author = "Dan S. Wallach and Edward Felten", + title = "Understanding {Java} Stack Inspection", + booktitle = sp, + year = "1998", + URL = "http://www.cs.princeton.edu/sip/pub/oakland98.php3", +} + +@Article{wand-80, + author = "Mitchell Wand", + title = "Continuation-Based Program Transformation Strategies", + journal = jacm, + volume = "27", + number = "1", + year = "1980", + pages = "164--180", + URL = "http://dx.doi.org/10.1145/322169.322183", +} + +@InProceedings{wand-85, + author = "Mitchell Wand", + title = "Embedding type structure in semantics", + booktitle = popl, + year = "1985", + pages = "1--6", + URL = "http://doi.acm.org/10.1145/318593.318602", +} + +@InProceedings{wand-86, + author = "Mitchell Wand", + title = "Finding the Source of Type Errors", + booktitle = popl, + pages = "38--43", + year = "1986", + URL = "http://doi.acm.org/10.1145/512644.512648", +} + +@Article{wand-87, + author = "Mitchell Wand", + title = "A Simple Algorithm and Proof for Type Inference", + journal = fundamenta, + volume = "10", + pages = "115--122", + year = "1987", + URL = "http://www.cs.ucla.edu/~palsberg/course/cs239/reading/wand87.pdf", +} + +@Article{wand-concat, + author = "Mitchell Wand", + title = "Type Inference for Record Concatenation and Multiple + Inheritance", + year = "1991", + volume = "93", + number = "1", + pages = "1--15", + journal = ic, + URL = "ftp://ftp.ccs.neu.edu/pub/people/wand/papers/ic-91.dvi", +} + +@InCollection{wand-objects, + author = "Mitchell Wand", + title = "Type Inference for Objects with Instance Variables and + Inheritance", + booktitle = taoop, + editor = "Carl A. Gunter and John C. Mitchell", + publisher = mitp, + pages = "97--120", + year = "1994", + URL = "ftp://ftp.ccs.neu.edu/pub/people/wand/papers/gunter-mitchell-94.dvi", +} + +@InProceedings{wand-steckler-94, + author = "Mitchell Wand and Paul A. Steckler", + title = "Selective and lightweight closure conversion", + booktitle = popl, + year = "1994", + pages = "435--445", + URL = "http://doi.acm.org/10.1145/174675.178044", +} + +@Article{ward-96, + author = "Martin Ward", + title = "Derivation of Data Intensive Algorithms by Formal + Transformation -- The {Schorr-Waite} Graph Marking + Algorithm", + journal = tose, + year = "1996", + volume = "22", + number = "9", + pages = "665--686", + URL = "http://www.cse.dmu.ac.uk/~mward/martin/papers/sw-alg-t.pdf", +} + +@InCollection{warren-82, + author = "D. H. D. Warren", + title = "Higher-order extensions to {PROLOG}: are they + needed?", + booktitle = "Machine Intelligence 10", + pages = "441--454", + publisher = ellis, + year = "1982", + editor = "J. E. Hayes and D. Michie and Y-H. Pao", +} + +@InProceedings{warth-douglass-millstein-08, + author = "Alessandro Warth and James R. Douglass and Todd D. + Millstein", + title = "Packrat parsers can support left recursion", + booktitle = pepm, + year = "2008", + pages = "103--110", + URL = "http://www.cs.ucla.edu/~todd/research/pepm08.pdf", +} + +@Article{wegbreit-75, + author = "Ben Wegbreit", + title = "Mechanical Program Analysis", + journal = cacm, + volume = "18", + number = "9", + year = "1975", + pages = "528--539", + URL = "http://doi.acm.org/10.1145/361002.361016", +} + +@Article{wegener-02, + author = "Ingo Wegener", + title = "A simplified correctness proof for a well-known + algorithm computing strongly connected components", + journal = "Information Processing Letters", + year = "2002", + volume = "83", + number = "1", + pages = "17--19", + URL = "http://ls2-www.cs.uni-dortmund.de/~wegener/papers/connected.pdf", +} + +@InProceedings{weirich-00, + author = "Stephanie Weirich", + title = "Type-Safe Cast: Functional Pearl", + booktitle = icfp, + year = "2000", + pages = "58--67", + URL = "http://www.cis.upenn.edu/~sweirich/papers/cast/cast.pdf", +} + +@Article{weirich-polytypic-06, + author = "Stephanie Weirich", + title = "Type-Safe Run-time Polytypic Programming", + journal = jfp, + year = "2006", + volume = "16", + number = "10", + pages = "681--710", + URL = "http://www.seas.upenn.edu/~sweirich/papers/erasure/erasure-jfp.pdf", +} + +@Misc{weirich-tc-04, + author = "Stephanie Weirich", + title = "A typechecker that produces a typed term from an + untyped source", + howpublished = "Part of the Glasgow Haskell compiler's test suite", + year = "2004", + URL = "http://cvs.haskell.org/cgi-bin/cvsweb.cgi/fptools/testsuite/tests/ghc-regress/gadt/tc.hs?rev=1.1", +} + +@InProceedings{wells-02, + author = "J. B. Wells", + title = "The Essence of Principal Typings", + booktitle = icalp, + pages = "913--925", + publisher = springer, + volume = "2380", + series = lncs, + year = "2002", + URL = "http://www.macs.hw.ac.uk/~jbw/papers/Wells:The-Essence-of-Principal-Typings:ICALP-2002.pdf", +} + +@TechReport{wells-95, + author = "J. B. Wells", + title = "The Undecidability of {Mitchell's} Subtyping + Relation", + institution = "Computer Science Department, Boston University", + year = "1995", + URL = "http://www.cs.bu.edu/ftp/pub/jbw/types/subtyping-undecidable.ps.gz", + type = "Technical Report", + number = "95-019", +} + +@Article{wells-99, + author = "J. B. Wells", + title = "Typability and type checking in System {F} are + equivalent and undecidable", + journal = apal, + year = "1999", + volume = "98", + number = "1--3", + pages = "111--156", + URL = "http://www.macs.hw.ac.uk/~jbw/papers/f-undecidable-APAL.ps.gz", +} + +@PhdThesis{werner-94, + author = "Benjamin Werner", + title = "Une Théorie des Constructions Inductives", + school = "Université Paris 7", + year = "1994", +} + +@InProceedings{westbrook-05, + author = "Edwin Westbrook and Aaron Stump and Ian Wehrman", + title = "A language-based approach to functionally correct + imperative programming", + booktitle = icfp, + year = "2005", + pages = "268--279", + URL = "http://cl.cse.wustl.edu/papers/rsp1-icfp05.pdf", +} + +@PhdThesis{westbrook-08, + author = "Edwin M. Westbrook", + title = "Higher-Order Encodings with Constructors", + school = "Washington University", + year = "2008", + URL = "http://www.cs.rice.edu/~emw4/thesis-westbrook.pdf", +} + +@TechReport{why, + author = "Jean-Christophe Filliâtre", + title = "{Why}: a multi-language multi-prover verification + tool", + institution = "LRI, Université Paris Sud", + type = "Research Report", + number = "1366", + year = "2003", + URL = "http://www.lri.fr/~filliatr/ftp/publis/why-tool.ps.gz", +} + +@InProceedings{why-07, + author = "Jean-Christophe Filliâtre and Claude Marché", + title = "The {Why}/{Kra\-ka\-toa}/{Ca\-du\-ceus} Platform for + Deductive Program Verification", + booktitle = cav, + year = "2007", + pages = "173--177", + volume = "4590", + series = lncs, + publisher = springer, + URL = "http://www.lri.fr/~filliatr/ftp/publis/cav07.pdf", +} + +@Article{williams-64, + author = "J. W. J. Williams", + title = "Algorithm 232: Heapsort", + journal = cacm, + year = "1964", + volume = "7", + number = "6", + pages = "347--348", + URL = "http://doi.acm.org/10.1145/512274.512284", +} + +@InProceedings{wing-rollins-zaremsky-92, + author = "Jeannette M. Wing and Eugene Rollins and Amy Moormann + Zaremski", + title = "Thoughts on a {Larch/ML} and a New Application for + {LP}", + booktitle = "First International Workshop on Larch", + year = "1992", + URL = "http://reports-archive.adm.cs.cmu.edu/anon/usr0/ftp/home/ftp/1992/CMU-CS-92-135.ps", + pages = "297--312", +} + +@Book{wirth-78, + author = "Niklaus Wirth", + title = "Algorithms + Data Structures = Programs", + year = "1978", + publisher = prentice, +} + +@InProceedings{wisnesky-malecha-morrisett-09, + author = "Ryan Wisnesky and Gregory Malecha and Greg Morrisett", + title = "Certified Web Services in {Ynot}", + booktitle = wwv, + year = "2009", + URL = "http://wisnesky.net/wwv09.pdf", +} + +@InProceedings{wolff-11, + author = "Roger Wolff and Ronald Garcia and \'{E}ric Tanter and + Jonathan Aldrich", + title = "Gradual typestate", + booktitle = ecoop, + year = "2011", + pages = "459--483", + publisher = springer, + series = lncs, + volume = "6813", + URL = "http://www.cs.cmu.edu/~aldrich/papers/aldrich-gradual-ecoop11.pdf", +} + +@InProceedings{woodward-79, + author = "J. P. L. Woodward", + title = "Applications for Multilevel Secure Operating Systems", + booktitle = "Proceedings NCC", + year = "1979", + pages = "319--328", + volume = "48", + publisher = "{AFIPS} Press", +} + +@Article{wright-cartwright-97, + author = "Andrew K. Wright and Robert Cartwright", + title = "A Practical Soft Type System for {Scheme}", + journal = toplas, + volume = "19", + number = "1", + pages = "87--152", + year = "1997", + URL = "http://doi.acm.org/10.1145/239912.239917", +} + +@Article{wright-felleisen-94, + title = "A Syntactic Approach to Type Soundness", + author = "Andrew K. Wright and Matthias Felleisen", + pages = "38--94", + journal = ic, + year = "1994", + volume = "115", + number = "1", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/ic94-wf.ps.gz", +} + +@TechReport{wright-restriction-93, + author = "Andrew K. Wright", + institution = "Rice University", + title = "Polymorphism for Imperative Languages without + Imperative Types", + year = "1993", + number = "93-200", +} + +@Article{wright-restriction-95, + author = "Andrew K. Wright", + title = "Simple Imperative Polymorphism", + journal = lsc, + volume = "8", + number = "4", + year = "1995", + pages = "343--356", + URL = "http://www.cs.rice.edu/CS/PLT/Publications/Scheme/lasc95-w.ps.gz", +} + +@InProceedings{wyk-99, + author = "Eric van Wyk and Oege de Moor and Simon {Peyton + Jones}", + title = "Aspect-oriented compilers", + booktitle = gcse, + pages = "121--133", + year = "1999", + volume = "1799", + series = lncs, + publisher = springer, + URL = "https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/aspects.pdf", +} + +@PhdThesis{xi-98, + author = "Hongwei Xi", + title = "Dependent Types in Practical Programming", + school = "Carnegie Mellon University", + year = "1998", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/thesis.ps", +} + +@InProceedings{xi-ats, + author = "Hongwei Xi", + title = "Applied Type System", + year = "2004", + booktitle = "{TYPES} 2003", + publisher = springer, + series = lncs, + volume = "3085", + pages = "394--408", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/types03.pdf", +} + +@InProceedings{xi-chen-chen-03, + author = "Hongwei Xi and Chiyan Chen and Gang Chen", + title = "Guarded Recursive Datatype Constructors", + booktitle = popl, + year = "2003", + pages = "224--235", + URL = "http://www.cs.bu.edu/fac/hwxi/academic/papers/popl03.ps", +} + +@InProceedings{xi-cps-01, + author = "Hongwei Xi and Carsten Schürmann", + title = "{CPS} Transform for {Dependent ML}", + booktitle = wollic, + year = "2001", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/DMLcps.pdf", +} + +@InProceedings{xi-dead-99, + author = "Hongwei Xi", + title = "Dead Code Elimination through Dependent Types", + booktitle = padl, + pages = "228--242", + year = "1999", + volume = "1551", + series = lncs, + publisher = springer, + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/padl99.ps", +} + +@Misc{xi-dml, + author = "Hongwei Xi", + title = "Dependent {ML}", + year = "2001", + URL = "http://www.cs.bu.edu/~hwxi/DML/DML.html", +} + +@Article{xi-dml-07, + author = "Hongwei Xi", + title = "Dependent {ML}: an approach to practical programming + with dependent types", + journal = jfp, + year = "2007", + volume = "17", + number = "2", + pages = "215--286", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/JFPdml.pdf", +} + +@Article{xi-patterns-03, + author = "Hongwei Xi", + title = "{Dependently Typed Pattern Matching}", + journal = jucs, + volume = "9", + number = "8", + year = "2003", + pages = "851--872", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/jucs03.pdf", +} + +@InProceedings{xi-pfenning-99, + author = "Hongwei Xi and Frank Pfenning", + title = "Dependent Types in Practical Programming", + booktitle = popl, + year = "1999", + pages = "214--227", + URL = "http://www.ececs.uc.edu/~hwxi/academic/papers/popl99.ps", +} + +@InProceedings{xi-views-05, + author = "Dengping Zhu and Hongwei Xi", + title = "Safe Programming with Pointers through Stateful + Views", + booktitle = padl, + publisher = springer, + series = lncs, + volume = "3350", + year = "2005", + pages = "83--97", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/padl05.pdf", +} + +@InProceedings{xie-aiken-05, + author = "Yichen Xie and Alex Aiken", + title = "Scalable error detection using {Boolean} + satisfiability", + booktitle = popl, + year = "2005", + pages = "351--363", + URL = "http://glide.stanford.edu/saturn/papers/popl05.pdf", +} + +@InProceedings{xu-06, + author = "Dana N. Xu", + title = "Extended static checking for {Haskell}", + booktitle = hw, + year = "2006", + pages = "48--59", + publisher = acmp, + URL = "http://www.cl.cam.ac.uk/~nx200/research/escH-hw.ps", +} + +@InProceedings{xu-09, + author = "Dana N. Xu and Simon {Peyton Jones} and Koen + Claessen", + title = "Static contract checking for {Haskell}", + booktitle = popl, + year = "2009", + pages = "41--52", + URL = "http://research.microsoft.com/en-us/um/people/simonpj/papers/verify/HaskellContract.ps", +} + +@InProceedings{yang-join-08, + author = "Hongseok Yang and Oukseh Lee and Josh Berdine and + Cristiano Calcagno and Byron Cook and Dino Distefano + and Peter W. O'Hearn", + title = "Scalable Shape Analysis for Systems Code", + year = "2008", + pages = "385--398", + booktitle = cav, + publisher = springer, + series = lncs, + volume = "5123", + URL = "http://research.microsoft.com/en-us/um/cambridge/projects/terminator/cav08b.pdf", +} + +@Article{yi-06, + author = "Kwangkeun Yi", + title = "Educational Pearl: 'Proof-directed debugging' + revisited for a first-order version", + journal = jfp, + volume = "16", + number = "6", + year = "2006", + pages = "663--670", + URL = "http://ropas.snu.ac.kr/~kwang/paper/06-jfp-yi.pdf", +} + +@InProceedings{yoshida-96, + author = "Nobuko Yoshida", + title = "Graph Types for Monadic Mobile Processes", + booktitle = fsttcs, + mon = dec, + year = "1996", + publisher = springer, + series = lncs, + volume = "1180", + pages = "371--386", + URL = "http://www.mcs.le.ac.uk/~nyoshida/paper/graph1_short.ps.gz", +} + +@TechReport{yoshida-96-full, + author = "Nobuko Yoshida", + title = "Graph Types for Monadic Mobile Processes", + number = "ECS-LFCS-96-350", + institution = "University of Edinburgh", + year = "1996", + URL = "http://www.lfcs.inf.ed.ac.uk/reports/96/ECS-LFCS-96-350/", +} + +@InProceedings{yoshida-al-02, + author = "Nobuko Yoshida and Kohei Honda and Martin Berger", + title = "Linearity and Bisimulation", + booktitle = fossacs, + publisher = springer, + series = lncs, + year = "2002", + URL = "http://www.mcs.le.ac.uk/~nyoshida/paper/fossacs_ca_final.ps.gz", +} + +@TechReport{yoshida-al-02-long, + author = "Nobuko Yoshida and Kohei Honda and Martin Berger", + title = "Linearity and Bisimulation", + institution = "University of Leicester", + year = "2001", + number = "MSC-2001/48", + URL = "http://www.mcs.le.ac.uk/~nyoshida/paper/lb.ps.gz", +} + +@InProceedings{yoshida-honda-berger-07, + author = "Nobuko Yoshida and Kohei Honda and Martin Berger", + title = "Logical Reasoning for Higher-Order Functions with + Local State", + booktitle = fossacs, + pages = "361--377", + year = "2007", + volume = "4423", + series = lncs, + publisher = springer, + URL = "http://www.doc.ic.ac.uk/~mberger/publications/fossacs07/fossacs07.pdf", +} + +@InProceedings{zdancewic-myers-01, + author = "Steve Zdancewic and Andrew C. Myers", + title = "Secure Information Flow and {CPS}", + booktitle = esop, + publisher = springer, + series = lncs, + year = "2001", + URL = "http://www.cs.cornell.edu/zdance/lincont.ps", +} + +@Article{zdancewic-myers-02, + author = "Steve Zdancewic and Andrew C. Myers", + title = "Secure Information Flow via Linear Continuations", + journal = "Higher Order and Symbolic Computation", + year = "2002", + volume = "15", + number = "2--3", + pages = "209--234", + URL = "http://www.cis.upenn.edu/~stevez/papers/ZM02.pdf", +} + +@InProceedings{zendra-97, + author = "Olivier Zendra and Dominique Colnet and Suzanne + Collin", + title = "Efficient Dynamic Dispatch without Virtual Function + Tables. The {SmallEiffel} Compiler", + booktitle = oopsla, + pages = "125--141", + year = "1997", + URL = "http://www.loria.fr/~colnet/publis/oopsla97.ps.gz", +} + +@Article{zenger-97, + author = "Christoph Zenger", + title = "Indexed Types", + journal = tcs, + year = "1997", + volume = "187", + number = "1--2", + pages = "147--165", + URL = "http://dx.doi.org/10.1016/S0304-3975(97)00062-5", +} + +@PhdThesis{zenger-98, + author = "Christoph Zenger", + title = "Indizierte Typen", + school = "Universität Karlsruhe", + year = "1998", + URL = "http://www.christoph-zenger.de/papers/thesis.ps.gz", +} + +@PhdThesis{zhao-07, + author = "Yang Zhao", + title = "Concurrency Analysis Based on Fractional Permission + System", + school = "University of Wisconsin", + year = "2007", + URL = "http://www.cs.uwm.edu/~boyland/papers/yangzhao-thesis.pdf", +} + +@TechReport{zheng-myers-04, + author = "Lantian Zheng and Andrew C. Myers", + title = "Dynamic Security Labels and Noninterference", + institution = "Cornell University", + year = "2004", + number = "2004-1924", + URL = "http://www.cs.cornell.edu/andru/papers/dynl-tr.pdf", +} + +@InProceedings{zhu-xi-03, + author = "Dengping Zhu and Hongwei Xi", + title = "A Typeful and Tagless Representation for {XML} + Documents", + booktitle = aplas, + publisher = springer, + series = lncs, + volume = "2895", + year = "2003", + pages = "89--104", + URL = "http://www.cs.bu.edu/~hwxi/academic/papers/aplas03.pdf", +} + +@Misc{zibin-gil-01, + author = "Yoav Zibin and Yossi Gil", + title = "Theory and Practice of Incremental Subtyping Tests and + Message Dispatching", + year = "2001", + URL = "http://www.cs.technion.ac.il/~yogi/incremental-dispatching.ps.gz", +} + +@InProceedings{zibin-gil-02, + author = "Yoav Zibin and Yossi Gil", + title = "Fast Algorithm for Creating Space Efficient + Dispatching Tables with Application to + Multi-Dispatching", + booktitle = oopsla, + pages = "142--160", + year = "2002", + URL = "http://www.cs.technion.ac.il/~zyoav/publications/OOPSLA02-dispatching-TS.pdf", +} + +@InProceedings{zibin-gil-03, + author = "Yoav Zibin and Yossi Gil", + title = "Incremental Algorithms for Dispatching in Dynamically + Typed Languages", + booktitle = popl, + year = "2003", + URL = "http://www.cs.technion.ac.il/~zyoav/publications/POPL03-dispatching-CT.pdf", +} + +@TechReport{zwanenburg-97, + author = "Jan Zwanenburg", + title = "A Type System for Record Concatenation and Subtyping", + year = "1997", + institution = "Eindhoven University of Technology", + URL = "http://www.cs.ru.nl/~janz/publications/type_check.ps", +} diff --git a/doc/macros.tex b/doc/macros.tex index e680422363622492b1c07b6ac44f98e356d59143..062d083d6dbc37e86dafc16748ddc136e5b51de0 100644 --- a/doc/macros.tex +++ b/doc/macros.tex @@ -73,6 +73,8 @@ \newcommand{\ocamlbuild}{\href{https://github.com/ocaml/ocamlbuild/blob/master/manual/manual.adoc}{\texttt{ocamlbuild}}\xspace} \newcommand{\opam}{\href{https://opam.ocaml.org/}{\texttt{opam}}\xspace} \newcommand{\ppxderiving}{\href{https://github.com/whitequark/ppx_deriving}{\texttt{ppx\_deriving}}\xspace} +\newcommand{\hashcons}{\href{https://github.com/backtracking/ocaml-hashcons}{\texttt{hashcons}}\xspace} + \newcommand{\repoURL}{https://gitlab.inria.fr/fpottier/visitors} \newcommand{\srcFile}[1]{\href{\repoURL/blob/master/src/#1}{\texttt{#1}}} diff --git a/doc/main.tex b/doc/main.tex index f3dff4d35e459f838c5c636b7ed721d5e1c9cfd6..2a42d3dfa3211e5b593d47c5becf24685cbbe36e 100644 --- a/doc/main.tex +++ b/doc/main.tex @@ -395,21 +395,8 @@ is found. \label{fig:expr08} \end{figure} -\begin{figure}[p] -\codefollowupgeneral{Figures~\ref{fig:expr12} and \ref{fig:expr13}} -\origfirstline{expr13double}{4} -\caption{A transformation of arithmetic expressions} -\label{fig:expr13double} -\end{figure} - -\begin{figure}[p] -\codefollowupgeneral{Figures~\ref{fig:expr12}, \ref{fig:expr13}, and~\ref{fig:expr08}} -\origfirstline{expr14}{6} -\caption{Conversions between two types of arithmetic expressions} -\label{fig:expr14} -\end{figure} - \subsection{Visitors for open and closed data types} +\label{sec:advanced:openclosed} The algebraic data types of arithmetic expressions shown in the previous section (\sref{sec:intro}) are \emph{closed}. That is, the type \oc|expr| @@ -478,22 +465,45 @@ integer constant in an arithmetic expression. This is done in object that inherits \oc|map| and overrides the method \dataconvisitor{EConst}. +% ------------------------------------------------------------------------------ -% TEMPORARY ICI -% expr13 (expr from oexpr) -% expr08 (hexpr) -% expr14 (moving from expr to hexpr and back) -% TEMPORARY import/export devraient plutôt s'écrire à l'aide de la fonction -% omap sur oexpr? +\begin{figure}[p] +\codefollowupgeneral{Figures~\ref{fig:expr12} and \ref{fig:expr13}} +\origfirstline{expr13double}{4} +\caption{A transformation of arithmetic expressions} +\label{fig:expr13double} +\end{figure} + +\begin{figure}[p] +\codefollowupgeneral{Figures~\ref{fig:expr12}, \ref{fig:expr13}, and~\ref{fig:expr08}} +\origfirstline{expr14}{6} +\caption{Conversions between two types of arithmetic expressions} +\label{fig:expr14} +\end{figure} -% TEMPORARY illustration: types ouverts, et comment les fermer +\subsection{Visitors for hash-consed abstract syntax trees} +\label{sec:advanced:hashconsed} -% ------------------------------------------------------------------------------ +On top of the open data type \oc|oexpr| of the previous section +(\sref{sec:advanced:openclosed}), one can define not just the closed data type +\oc|expr| of ordinary arithmetic expressions, but also other closed data types +of expressions where every node is annotated with information. + +As an example, let us define a type \oc|hexpr| of hash-consed (that is, +maximally-shared) arithmetic expressions. We follow Filliâtre and Conchon's +approach~\cite{filliatre-conchon-06} and use their package \hashcons (which +can be installed via \opam). % TEMPORARY illustration: types ouverts, fermés avec hash-consing +% expr08 (hexpr) +% expr14 (moving from expr to hexpr and back) + % ------------------------------------------------------------------------------ +\bibliographystyle{plain} +\bibliography{english} + \end{document} % TEMPORARY diff --git a/doc/plain.bst b/doc/plain.bst new file mode 100644 index 0000000000000000000000000000000000000000..20711523c42ccabd77a4d4569cc8e89a2d078549 --- /dev/null +++ b/doc/plain.bst @@ -0,0 +1,1106 @@ +% BibTeX standard bibliography style `plain' + % version 0.99a for BibTeX versions 0.99a or later, LaTeX version 2.09. + % Copyright (C) 1985, all rights reserved. + % Copying of this file is authorized only if either + % (1) you make absolutely no changes to your copy, including name, or + % (2) if you do make changes, you name it something other than + % btxbst.doc, plain.bst, unsrt.bst, alpha.bst, and abbrv.bst. + % This restriction helps ensure that all standard styles are identical. + % The file btxbst.doc has the documentation for this style. + +% Modified by Francois.Pottier@inria.fr with support for url field. + +ENTRY + { address + author + booktitle + chapter + edition + editor + howpublished + institution + journal + key + month + note + number + organization + pages + publisher + school + series + title + type + url + volume + year + } + {} + { label } + +INTEGERS { output.state before.all mid.sentence after.sentence after.block } + +FUNCTION {init.state.consts} +{ #0 'before.all := + #1 'mid.sentence := + #2 'after.sentence := + #3 'after.block := +} + +STRINGS { s t } + +FUNCTION {output.nonnull} +{ 's := + output.state mid.sentence = + { ", " * write$ } + { output.state after.block = + { add.period$ write$ + newline$ + "\newblock " write$ + } + { output.state before.all = + 'write$ + { add.period$ " " * write$ } + if$ + } + if$ + mid.sentence 'output.state := + } + if$ + s +} + +FUNCTION {output} +{ duplicate$ empty$ + 'pop$ + 'output.nonnull + if$ +} + +FUNCTION {output.check} +{ 't := + duplicate$ empty$ + { pop$ "empty " t * " in " * cite$ * warning$ } + 'output.nonnull + if$ +} + +FUNCTION {output.bibitem} +{ newline$ + "\bibitem{" write$ + cite$ write$ + "}" write$ + newline$ + "" + before.all 'output.state := +} + +FUNCTION {fin.entry} +{ add.period$ + write$ + newline$ +} + +FUNCTION {new.block} +{ output.state before.all = + 'skip$ + { after.block 'output.state := } + if$ +} + +FUNCTION {new.sentence} +{ output.state after.block = + 'skip$ + { output.state before.all = + 'skip$ + { after.sentence 'output.state := } + if$ + } + if$ +} + +FUNCTION {not} +{ { #0 } + { #1 } + if$ +} + +FUNCTION {and} +{ 'skip$ + { pop$ #0 } + if$ +} + +FUNCTION {or} +{ { pop$ #1 } + 'skip$ + if$ +} + +FUNCTION {new.block.checka} +{ empty$ + 'skip$ + 'new.block + if$ +} + +FUNCTION {new.block.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.block + if$ +} + +FUNCTION {new.sentence.checka} +{ empty$ + 'skip$ + 'new.sentence + if$ +} + +FUNCTION {new.sentence.checkb} +{ empty$ + swap$ empty$ + and + 'skip$ + 'new.sentence + if$ +} + +FUNCTION {field.or.null} +{ duplicate$ empty$ + { pop$ "" } + 'skip$ + if$ +} + +FUNCTION {emphasize} +{ duplicate$ empty$ + { pop$ "" } + { "{\em " swap$ * "}" * } + if$ +} + +INTEGERS { nameptr namesleft numnames } + +FUNCTION {format.names} +{ 's := + #1 'nameptr := + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$ 't := + nameptr #1 > + { namesleft #1 > + { ", " * t * } + { numnames #2 > + { "," * } + 'skip$ + if$ + t "others" = + { " et~al." * } + { " and " * t * } + if$ + } + if$ + } + 't + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {format.authors} +{ author empty$ + { "" } + { author format.names } + if$ +} + +FUNCTION {format.editors} +{ editor empty$ + { "" } + { editor format.names + editor num.names$ #1 > + { ", editors" * } + { ", editor" * } + if$ + } + if$ +} + +FUNCTION {format.title} +{ title empty$ + { "" } + { url empty$ + { title "t" change.case$ } + { "\href{" url "}{" title "t" change.case$ "}" * * * * } + if$ } + if$ +} + +FUNCTION {n.dashify} +{ 't := + "" + { t empty$ not } + { t #1 #1 substring$ "-" = + { t #1 #2 substring$ "--" = not + { "--" * + t #2 global.max$ substring$ 't := + } + { { t #1 #1 substring$ "-" = } + { "-" * + t #2 global.max$ substring$ 't := + } + while$ + } + if$ + } + { t #1 #1 substring$ * + t #2 global.max$ substring$ 't := + } + if$ + } + while$ +} + +FUNCTION {format.date} +{ year empty$ + { month empty$ + { "" } + { "there's a month but no year in " cite$ * warning$ + month + } + if$ + } + { month empty$ + 'year + { month " " * year * } + if$ + } + if$ +} + +FUNCTION {format.btitle} +{ url empty$ + { title emphasize } + { "\href{" url "}{" title emphasize "}" * * * * } + if$ +} + +FUNCTION {tie.or.space.connect} +{ duplicate$ text.length$ #3 < + { "~" } + { " " } + if$ + swap$ * * +} + +FUNCTION {either.or.check} +{ empty$ + 'pop$ + { "can't use both " swap$ * " fields in " * cite$ * warning$ } + if$ +} + +FUNCTION {format.bvolume} +{ volume empty$ + { "" } + { "volume" volume tie.or.space.connect + series empty$ + 'skip$ + { " of " * series emphasize * } + if$ + "volume and number" number either.or.check + } + if$ +} + +FUNCTION {format.number.series} +{ volume empty$ + { number empty$ + { series field.or.null } + { output.state mid.sentence = + { "number" } + { "Number" } + if$ + number tie.or.space.connect + series empty$ + { "there's a number but no series in " cite$ * warning$ } + { " in " * series * } + if$ + } + if$ + } + { "" } + if$ +} + +FUNCTION {format.edition} +{ edition empty$ + { "" } + { output.state mid.sentence = + { edition "l" change.case$ " edition" * } + { edition "t" change.case$ " edition" * } + if$ + } + if$ +} + +INTEGERS { multiresult } + +FUNCTION {multi.page.check} +{ 't := + #0 'multiresult := + { multiresult not + t empty$ not + and + } + { t #1 #1 substring$ + duplicate$ "-" = + swap$ duplicate$ "," = + swap$ "+" = + or or + { #1 'multiresult := } + { t #2 global.max$ substring$ 't := } + if$ + } + while$ + multiresult +} + +FUNCTION {format.pages} +{ pages empty$ + { "" } + { pages multi.page.check + { "pages" pages n.dashify tie.or.space.connect } + { "page" pages tie.or.space.connect } + if$ + } + if$ +} + +FUNCTION {format.vol.num.pages} +{ volume field.or.null + number empty$ + 'skip$ + { "(" number * ")" * * + volume empty$ + { "there's a number but no volume in " cite$ * warning$ } + 'skip$ + if$ + } + if$ + pages empty$ + 'skip$ + { duplicate$ empty$ + { pop$ format.pages } + { ":" * pages n.dashify * } + if$ + } + if$ +} + +FUNCTION {format.chapter.pages} +{ chapter empty$ + 'format.pages + { type empty$ + { "chapter" } + { type "l" change.case$ } + if$ + chapter tie.or.space.connect + pages empty$ + 'skip$ + { ", " * format.pages * } + if$ + } + if$ +} + +FUNCTION {format.in.ed.booktitle} +{ booktitle empty$ + { "" } + { editor empty$ + { "In " booktitle emphasize * } + { "In " format.editors * ", " * booktitle emphasize * } + if$ + } + if$ +} + +FUNCTION {empty.misc.check} +{ author empty$ title empty$ howpublished empty$ + month empty$ year empty$ note empty$ + and and and and and + key empty$ not and + { "all relevant fields are empty in " cite$ * warning$ } + 'skip$ + if$ +} + +FUNCTION {format.thesis.type} +{ type empty$ + 'skip$ + { pop$ + type "t" change.case$ + } + if$ +} + +FUNCTION {format.tr.number} +{ type empty$ + { "Technical Report" } + 'type + if$ + number empty$ + { "t" change.case$ } + { number tie.or.space.connect } + if$ +} + +FUNCTION {format.article.crossref} +{ key empty$ + { journal empty$ + { "need key or journal for " cite$ * " to crossref " * crossref * + warning$ + "" + } + { "In {\em " journal * "\/}" * } + if$ + } + { "In " key * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {format.crossref.editor} +{ editor #1 "{vv~}{ll}" format.name$ + editor num.names$ duplicate$ + #2 > + { pop$ " et~al." * } + { #2 < + 'skip$ + { editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" = + { " et~al." * } + { " and " * editor #2 "{vv~}{ll}" format.name$ * } + if$ + } + if$ + } + if$ +} + +FUNCTION {format.book.crossref} +{ volume empty$ + { "empty volume in " cite$ * "'s crossref of " * crossref * warning$ + "In " + } + { "Volume" volume tie.or.space.connect + " of " * + } + if$ + editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { series empty$ + { "need editor, key, or series for " cite$ * " to crossref " * + crossref * warning$ + "" * + } + { "{\em " * series * "\/}" * } + if$ + } + { key * } + if$ + } + { format.crossref.editor * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {format.incoll.inproc.crossref} +{ editor empty$ + editor field.or.null author field.or.null = + or + { key empty$ + { booktitle empty$ + { "need editor, key, or booktitle for " cite$ * " to crossref " * + crossref * warning$ + "" + } + { "In {\em " booktitle * "\/}" * } + if$ + } + { "In " key * } + if$ + } + { "In " format.crossref.editor * } + if$ + " \cite{" * crossref * "}" * +} + +FUNCTION {article} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { journal emphasize "journal" output.check + format.vol.num.pages output + format.date "year" output.check + } + { format.article.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {book} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {booklet} +{ output.bibitem + format.authors output + new.block + format.title "title" output.check + howpublished address new.block.checkb + howpublished output + address output + format.date output + new.block + note output + fin.entry +} + +FUNCTION {inbook} +{ output.bibitem + author empty$ + { format.editors "author and editor" output.check } + { format.authors output.nonnull + crossref missing$ + { "author and editor" editor either.or.check } + 'skip$ + if$ + } + if$ + new.block + format.btitle "title" output.check + crossref missing$ + { format.bvolume output + format.chapter.pages "chapter and pages" output.check + new.block + format.number.series output + new.sentence + publisher "publisher" output.check + address output + } + { format.chapter.pages "chapter and pages" output.check + new.block + format.book.crossref output.nonnull + } + if$ + format.edition output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {incollection} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.chapter.pages output + new.sentence + publisher "publisher" output.check + address output + format.edition output + format.date "year" output.check + } + { format.incoll.inproc.crossref output.nonnull + format.chapter.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {inproceedings} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + crossref missing$ + { format.in.ed.booktitle "booktitle" output.check + format.bvolume output + format.number.series output + format.pages output + address empty$ + { organization publisher new.sentence.checkb + organization output + publisher output + format.date "year" output.check + } + { address output.nonnull + format.date "year" output.check + new.sentence + organization output + publisher output + } + if$ + } + { format.incoll.inproc.crossref output.nonnull + format.pages output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {conference} { inproceedings } + +FUNCTION {manual} +{ output.bibitem + author empty$ + { organization empty$ + 'skip$ + { organization output.nonnull + address output + } + if$ + } + { format.authors output.nonnull } + if$ + new.block + format.btitle "title" output.check + author empty$ + { organization empty$ + { address new.block.checka + address output + } + 'skip$ + if$ + } + { organization address new.block.checkb + organization output + address output + } + if$ + format.edition output + format.date output + new.block + note output + fin.entry +} + +FUNCTION {mastersthesis} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + "Master's thesis" format.thesis.type output.nonnull + school "school" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {misc} +{ output.bibitem + format.authors output + title howpublished new.block.checkb + format.title output + howpublished new.block.checka + howpublished output + format.date output + new.block + note output + fin.entry + empty.misc.check +} + +FUNCTION {phdthesis} +{ output.bibitem + format.authors "author" output.check + new.block + format.btitle "title" output.check + new.block + "PhD thesis" format.thesis.type output.nonnull + school "school" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {proceedings} +{ output.bibitem + editor empty$ + { organization output } + { format.editors output.nonnull } + if$ + new.block + format.btitle "title" output.check + format.bvolume output + format.number.series output + address empty$ + { editor empty$ + { publisher new.sentence.checka } + { organization publisher new.sentence.checkb + organization output + } + if$ + publisher output + format.date "year" output.check + } + { address output.nonnull + format.date "year" output.check + new.sentence + editor empty$ + 'skip$ + { organization output } + if$ + publisher output + } + if$ + new.block + note output + fin.entry +} + +FUNCTION {techreport} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + format.tr.number output.nonnull + institution "institution" output.check + address output + format.date "year" output.check + new.block + note output + fin.entry +} + +FUNCTION {unpublished} +{ output.bibitem + format.authors "author" output.check + new.block + format.title "title" output.check + new.block + note "note" output.check + format.date output + fin.entry +} + +FUNCTION {default.type} { misc } + +MACRO {jan} {"January"} + +MACRO {feb} {"February"} + +MACRO {mar} {"March"} + +MACRO {apr} {"April"} + +MACRO {may} {"May"} + +MACRO {jun} {"June"} + +MACRO {jul} {"July"} + +MACRO {aug} {"August"} + +MACRO {sep} {"September"} + +MACRO {oct} {"October"} + +MACRO {nov} {"November"} + +MACRO {dec} {"December"} + +MACRO {acmcs} {"ACM Computing Surveys"} + +MACRO {acta} {"Acta Informatica"} + +MACRO {cacm} {"Communications of the ACM"} + +MACRO {ibmjrd} {"IBM Journal of Research and Development"} + +MACRO {ibmsj} {"IBM Systems Journal"} + +MACRO {ieeese} {"IEEE Transactions on Software Engineering"} + +MACRO {ieeetc} {"IEEE Transactions on Computers"} + +MACRO {ieeetcad} + {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"} + +MACRO {ipl} {"Information Processing Letters"} + +MACRO {jacm} {"Journal of the ACM"} + +MACRO {jcss} {"Journal of Computer and System Sciences"} + +MACRO {scp} {"Science of Computer Programming"} + +MACRO {sicomp} {"SIAM Journal on Computing"} + +MACRO {tocs} {"ACM Transactions on Computer Systems"} + +MACRO {tods} {"ACM Transactions on Database Systems"} + +MACRO {tog} {"ACM Transactions on Graphics"} + +MACRO {toms} {"ACM Transactions on Mathematical Software"} + +MACRO {toois} {"ACM Transactions on Office Information Systems"} + +MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"} + +MACRO {tcs} {"Theoretical Computer Science"} + +READ + +FUNCTION {sortify} +{ purify$ + "l" change.case$ +} + +INTEGERS { len } + +FUNCTION {chop.word} +{ 's := + 'len := + s #1 len substring$ = + { s len #1 + global.max$ substring$ } + 's + if$ +} + +FUNCTION {sort.format.names} +{ 's := + #1 'nameptr := + "" + s num.names$ 'numnames := + numnames 'namesleft := + { namesleft #0 > } + { nameptr #1 > + { " " * } + 'skip$ + if$ + s nameptr "{vv{ } }{ll{ }}{ ff{ }}{ jj{ }}" format.name$ 't := + nameptr numnames = t "others" = and + { "et al" * } + { t sortify * } + if$ + nameptr #1 + 'nameptr := + namesleft #1 - 'namesleft := + } + while$ +} + +FUNCTION {sort.format.title} +{ 't := + "A " #2 + "An " #3 + "The " #4 t chop.word + chop.word + chop.word + sortify + #1 global.max$ substring$ +} + +FUNCTION {author.sort} +{ author empty$ + { key empty$ + { "to sort, need author or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {author.editor.sort} +{ author empty$ + { editor empty$ + { key empty$ + { "to sort, need author, editor, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { editor sort.format.names } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {author.organization.sort} +{ author empty$ + { organization empty$ + { key empty$ + { "to sort, need author, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { author sort.format.names } + if$ +} + +FUNCTION {editor.organization.sort} +{ editor empty$ + { organization empty$ + { key empty$ + { "to sort, need editor, organization, or key in " cite$ * warning$ + "" + } + { key sortify } + if$ + } + { "The " #4 organization chop.word sortify } + if$ + } + { editor sort.format.names } + if$ +} + +FUNCTION {presort} +{ type$ "book" = + type$ "inbook" = + or + 'author.editor.sort + { type$ "proceedings" = + 'editor.organization.sort + { type$ "manual" = + 'author.organization.sort + 'author.sort + if$ + } + if$ + } + if$ + " " + * + year field.or.null sortify + * + " " + * + title field.or.null + sort.format.title + * + #1 entry.max$ substring$ + 'sort.key$ := +} + +ITERATE {presort} + +SORT + +STRINGS { longest.label } + +INTEGERS { number.label longest.label.width } + +FUNCTION {initialize.longest.label} +{ "" 'longest.label := + #1 'number.label := + #0 'longest.label.width := +} + +FUNCTION {longest.label.pass} +{ number.label int.to.str$ 'label := + number.label #1 + 'number.label := + label width$ longest.label.width > + { label 'longest.label := + label width$ 'longest.label.width := + } + 'skip$ + if$ +} + +EXECUTE {initialize.longest.label} + +ITERATE {longest.label.pass} + +FUNCTION {begin.bib} +{ preamble$ empty$ + 'skip$ + { preamble$ write$ newline$ } + if$ + "\begin{thebibliography}{" longest.label * "}" * write$ newline$ +} + +EXECUTE {begin.bib} + +EXECUTE {init.state.consts} + +ITERATE {call.type$} + +FUNCTION {end.bib} +{ newline$ + "\end{thebibliography}" write$ newline$ +} + +EXECUTE {end.bib}