[1] | Unicon. http://unicon.sourceforge.net/. [ bib | http ] |
[2] | Martín Abadi and Luca Cardelli. A theory of primitive objects: Second-order systems. Science of Computer Programming, 25(2--3):81--116, December 1995. [ bib | .pdf ] |
[3] | Martín Abadi and Luca Cardelli. A theory of primitive objects: Untyped and first-order systems. Information and Computation, 125(2):78--102, March 1996. [ bib | .pdf ] |
[4] | Martín Abadi and Marcelo P. Fiore. Syntactic considerations on recursive types. In Logic in Computer Science (LICS), pages 242--252, July 1996. [ bib | .ps ] |
[5] | Martín Abadi, Anindya Banerjee, Nevin Heintze, and Jon G. Riecke. A core calculus of dependency. In Principles of Programming Languages (POPL), pages 147--160, January 1999. [ bib | .ps ] |
[6] | Martín Abadi and Bruno Blanchet. Secrecy types for asymmetric communication. In Foundations of Software Science and Computation Structures (FOSSACS), volume 2030 of Lecture Notes in Computer Science, pages 25--41. Springer, April 2001. [ bib | .html ] |
[7] | Martín Abadi, Butler Lampson, and Jean-Jacques Lévy. Analysis and caching of dependencies. In International Conference on Functional Programming (ICFP), pages 83--91, May 1996. [ bib | .ps ] |
[8] | Martín Abadi, Benjamin Pierce, and Gordon Plotkin. Faithful ideal models for recursive polymorphic types. International Journal of Foundations of Computer Science, 2(1):1--21, March 1991. [ bib | .ps ] |
[9] | Andreas Abel. Termination checking with types. RAIRO Theoretical Informatics and Applications, 38(4):277--319, 2004. [ bib | .pdf ] |
[10] | Andreas Abel. MiniAgda: Integrating sized and dependent types. In Workshop on Partiality And Recursion in Interactive Theorem Provers (PAR), July 2010. [ bib | .pdf ] |
[11] | Andreas Abel, Marcin Benke, Ana Bove, John Hughes, and Ulf Norell. Verifying Haskell programs using constructive type theory. In Haskell workshop, pages 62--73, September 2005. [ bib | .pdf ] |
[12] | Samson Abramsky. Domain theory in logical form. Annals of Pure and Applied Logic, 51:1--77, 1991. [ bib | .ps.gz ] |
[13] | Samson Abramsky, Kohei Honda, and Guy McCusker. A fully abstract game semantics for general references. In Logic in Computer Science (LICS), pages 334--344, 1998. [ bib | .ps.gz ] |
[14] | Peter Achten and Marinus J. Plasmeijer. The ins and outs of Clean I/O. Journal of Functional Programming, 5(1):81--110, 1995. [ bib | http ] |
[15] | Sten Agerholm. A HOL basis for reasoning about functional programs. Technical Report RS-94-44, BRICS, December 1994. [ bib | .ps.gz ] |
[16] | Sten Agerholm. LCF examples in HOL. Technical Report RS-94-18, BRICS, June 1994. [ bib | .ps.gz ] |
[17] | Amal Ahmed, Andrew W. Appel, Christopher D. Richards, Kedar N. Swadi, Gang Tan, and Daniel C. Wang. Semantic foundations for typed assembly languages. ACM Transactions on Programming Languages and Systems, 32(3), 2010. [ bib | .pdf ] |
[18] | Amal Ahmed and Matthias Blume. Typed closure conversion preserves observational equivalence. In International Conference on Functional Programming (ICFP), pages 157--168, September 2008. [ bib | .pdf ] |
[19] | Amal Ahmed, Derek Dreyer, and Andreas Rossberg. State-dependent representation independence. In Principles of Programming Languages (POPL), pages 340--353, January 2009. [ bib | .pdf ] |
[20] | Amal Ahmed, Matthew Fluet, and Greg Morrisett. L^{3}: A linear language with locations. Fundamenta Informaticæ, 77(4):397--449, 2007. [ bib | .pdf ] |
[21] | Amal J. Ahmed, Andrew W. Appel, and Roberto Virga. A stratified semantics of general references embeddable in higher-order logic. In Logic in Computer Science (LICS), pages 75--86, July 2002. [ bib | .pdf ] |
[22] | Amal J. Ahmed, Matthew Fluet, and Greg Morrisett. A step-indexed model of substructural state. In International Conference on Functional Programming (ICFP), pages 78--91, September 2005. [ bib | .pdf ] |
[23] | Amal Jamil Ahmed. Semantics of types for mutable state. PhD thesis, Princeton University, 2004. [ bib | .pdf ] |
[24] | Alfred Aho, Ravi Sethi, and Jeffrey Ullman. Compilateurs: principes, techniques et outils. InterEditions, 1989. [ bib ] |
[25] | Alfred V. Aho, John E. Hopcroft, and Jeffrey D. Ullman. The design and analysis of computer algorithms. Addison-Wesley, 1974. [ bib ] |
[26] | Alfred V. Aho, John E. Hopcroft, and Jeffrey D. Ullman. Data structures and algorithms. Addison-Wesley, 1983. [ bib ] |
[27] | Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. Compilers: Principles, techniques, and tools. Addison-Wesley, 1986. [ bib ] |
[28] | Alfred V. Aho and Jeffrey D. Ullman. Optimization of LR(k) parsers. Journal of Computer and System Sciences, 6(6):573--602, 1972. [ bib | http ] |
[29] | Alfred V. Aho and Jeffrey D. Ullman. The theory of parsing, translation, and compiling. Prentice Hall, 1972. [ bib | http ] |
[30] | Alfred V. Aho and Jeffrey D. Ullman. A technique for speeding up LR(k) parsers. SIAM Journal on Computing, 2(2):106--127, 1973. [ bib | http ] |
[31] | Alexander Aiken. Introduction to set constraint-based program analysis. Science of Computer Programming, 35:79--111, 1999. [ bib | .pdf ] |
[32] | Alexander Aiken, Manuel Fähndrich, and Raph Levien. Better static memory management: improving region-based analysis of higher-order languages. ACM SIGPLAN Notices, 30(6):174--185, June 1995. [ bib | .pdf ] |
[33] | Alexander Aiken, Manuel Fähndrich, Jeffrey S. Foster, and Zhendong Su. A toolkit for constructing type- and constraint-based program analyses. Lecture Notes in Computer Science, 1473:76--96, 1998. [ bib | .pdf ] |
[34] | Alexander S. Aiken. The Illyria system, 1994. [ bib | .html ] |
[35] | Alexander S. Aiken and Manuel Fähndrich. Making set-constraint based program analyses scale. Technical Report CSD-96-917, University of California, Berkeley, September 1996. [ bib | .pdf ] |
[36] | Alexander S. Aiken and Manuel Fähndrich. Subtyping polymorphic constrained types. Technical Report CSD-96-898, University of California, Berkeley, March 1996. [ bib ] |
[37] | Alexander S. Aiken and Manuel Fähndrich. Program analysis using mixed term and set constraints. In Static Analysis Symposium (SAS), pages 114--126, September 1997. [ bib | .pdf ] |
[38] | Alexander S. Aiken and Edward L. Wimmers. Solving systems of set constraints. In Logic in Computer Science (LICS), pages 329--340, June 1992. [ bib | .pdf ] |
[39] | Alexander S. Aiken and Edward L. Wimmers. Type inclusion constraints and type inference. In Functional Programming Languages and Computer Architecture (FPCA), pages 31--41. ACM Press, 1993. [ bib | .pdf ] |
[40] | Alexander S. Aiken, Edward L. Wimmers, and T. K. Lakshman. Soft typing with conditional types. In Principles of Programming Languages (POPL), pages 163--173, January 1994. [ bib | .pdf ] |
[41] | Alexander S. Aiken, Edward L. Wimmers, and Jens Palsberg. Optimal representations of polymorphic types with subtyping. Technical Report CSD-96-909, University of California, Berkeley, July 1996. [ bib | .pdf ] |
[42] | Elvira Albert, Puri Arenas, Samir Genaim, German Puebla, and Damiano Zanardini. Cost analysis of object-oriented bytecode programs. Theoretical Computer Science, 413(1):142--159, 2012. [ bib | .pdf ] |
[43] | Jonathan Aldrich. Resource-based programming in Plaid. Fun Ideas and Thoughts, June 2010. [ bib | .pdf ] |
[44] | Jonathan Aldrich. The power of interoperability: why objects are inevitable. In ACM Symposium on New Ideas in Programming and Reflections on Software (Onward!), pages 101--116, October 2013. [ bib | .pdf ] |
[45] | Jonathan Aldrich, Ronald Garcia, Mark Hahnenberg, Manuel Mohr, Karl Naden, Darpan Saini, Sven Stork, Joshua Sunshine, Éric Tanter, and Roger Wolff. Permission-based programming languages. In International Conference on Software Engineering (ICSE), pages 828--831, May 2011. [ bib | .pdf ] |
[46] | Jonathan Aldrich, Joshua Sunshine, Darpan Saini, and Zachary Sparks. Typestate-oriented programming. In Companion to Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 1015--1022, October 2009. [ bib | .pdf ] |
[47] | Guillaume Allais, James Chapman, Conor McBride, and James McKinna. Type-and-scope safe programs and their proofs. In Certified Programs and Proofs (CPP), pages 195--207, January 2017. [ bib | .pdf ] |
[48] | Paulo Sérgio Almeida. Balloon types: Controlling sharing of state in data types. In European Conference on Object-Oriented Programming (ECOOP), volume 1241 of Lecture Notes in Computer Science, pages 32--59. Springer, June 1997. [ bib | http ] |
[49] | Stephen Alstrup, Mikkel Thorup, Inge Li Gørtz, Theis Rauhe, and Uri Zwick. Union-find with constant time deletions. ACM Transactions on Algorithms, 11(1):6:1--6:28, 2014. [ bib | http ] |
[50] | Thorsten Altenkirch, Nils Anders Danielsson, Andres Löh, and Nicolas Oury. ΠΣ: Dependent types without the sugar. In Functional and Logic Programming, volume 6009 of Lecture Notes in Computer Science, pages 40--55. Springer, April 2010. [ bib | .pdf ] |
[51] | Thorsten Altenkirch, Conor McBride, and James McKinna. Why dependent types matter. Unpublished, April 2005. [ bib | .pdf ] |
[52] | Thorsten Altenkirch and Bernhard Reus. Monadic presentations of lambda terms using generalized inductive types. In Computer Science Logic, volume 1683 of Lecture Notes in Computer Science, pages 453--468. Springer, 1999. [ bib | .pdf ] |
[53] | Roberto Amadio and Yann Régis-Gianas. Certifying and reasoning on cost annotations of functional programs. In Foundational and Practical Aspects of Resource Analysis, volume 7177 of Lecture Notes in Computer Science, pages 72--89. Springer, May 2011. [ bib | http ] |
[54] | Roberto Amadio and Yann Régis-Gianas. Certifying and reasoning about cost annotations of functional programs. Higher-Order and Symbolic Computation, January 2013. [ bib | http ] |
[55] | Roberto M. Amadio, Nicholas Ayache, François Bobot, Jaap Boender, Brian Campbell, Ilias Garnier, Antoine Madet, James McKinna, Dominic P. Mulligan, Mauro Piccolo, Randy Pollack, Yann Régis-Gianas, Claudio Sacerdoti Coen, Ian Stark, and Paolo Tranquilli. Certified complexity (CerCo). In Foundational and Practical Aspects of Resource Analysis, volume 8552 of Lecture Notes in Computer Science, pages 1--18. Springer, August 2014. [ bib | http ] |
[56] | Roberto M. Amadio and Luca Cardelli. Subtyping recursive types. ACM Transactions on Programming Languages and Systems, 15(4):575--631, September 1993. [ bib | .pdf ] |
[57] | Pierre America and Jan Rutten. Solving reflexive domain equations in a category of complete metric spaces. In Mathematical Foundations of Programming Semantics, volume 298 of Lecture Notes in Computer Science, pages 254--288. Springer, 1988. [ bib | http ] |
[58] | Afshin Amighi, Christian Haack, Marieke Huisman, and Clément Hurlin. Permission-based separation logic for multithreaded Java programs. Logical Methods in Computer Science, 11(1):1--66, 2015. [ bib | http ] |
[59] | Nada Amin, Samuel Grütter, Martin Odersky, Tiark Rompf, and Sandro Stucki. The essence of dependent object types. In A List of Successes That Can Change the World -- Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday, volume 9600 of Lecture Notes in Computer Science, pages 249--272. Springer, 2016. [ bib | .pdf ] |
[60] | Nada Amin and Tiark Rompf. Type soundness proofs with definitional interpreters. In Principles of Programming Languages (POPL), pages 666--679, January 2017. [ bib | .pdf ] |
[61] | Henrik Reif Andersen. Model checking and Boolean graphs. Theoretical Computer Science, 126(1):3--30, 1994. [ bib | http ] |
[62] | Brian Anderson, Lars Bergstrom, David Herman, Josh Matthews, Keegan McAllister, Manish Goregaokar, Jack Moffitt, and Simon Sapin. Experience report: Developing the Servo web browser engine using Rust. 2015. [ bib | http ] |
[63] | T. Anderson, J. Eve, and J. J. Horning. Efficient LR(1) parsers. Acta Informatica, 2:12--39, 1973. [ bib | http ] |
[64] | Gregory R. Andrews. Foundations of multithreaded, parallel, and distributed programming. Addison-Wesley, 2000. [ bib ] |
[65] | Gregory R. Andrews and Richard P. Reitman. An axiomatic approach to information flow in programs. ACM Transactions on Programming Languages and Systems, 2(1):56--76, January 1980. [ bib ] |
[66] | Peter B. Andrews. An introduction to mathematical logic and type theory: to truth through proof. Academic Press, 1986. [ bib ] |
[67] | Timos Antonopoulos, Nikos Gorogiannis, Christoph Haase, Max I. Kanovich, and Joël Ouaknine. Foundations for decision problems in separation logic with general inductive predicates. In Foundations of Software Science and Computation Structures (FOSSACS), volume 8412 of Lecture Notes in Computer Science, pages 411--425. Springer, April 2014. [ bib | .pdf ] |
[68] | Maria-Virginia Aponte and Roberto Di Cosmo. Type isomorphisms for module signatures. In Programming Languages: Implementations, Logics, and Programs (PLILP), volume 1140 of Lecture Notes in Computer Science, pages 334--346. Springer, September 1996. [ bib | http ] |
[69] | Andrew Appel. Modern compiler implementation in ML. Cambridge University Press, 1998. [ bib | http ] |
[70] | Andrew W. Appel. Compiling with continuations. Cambridge University Press, 1992. [ bib | http ] |
[71] | Andrew W. Appel. Verified software toolchain. In European Symposium on Programming (ESOP), volume 6602 of Lecture Notes in Computer Science, pages 1--17. Springer, March 2011. [ bib | .pdf ] |
[72] | Andrew W. Appel. VeriSmall: Verified Smallfoot shape analysis. In Certified Programs and Proofs (CPP), volume 7086 of Lecture Notes in Computer Science, pages 231--246. Springer, December 2011. [ bib | .pdf ] |
[73] | Andrew W. Appel and Trevor Jim. Shrinking lambda expressions in linear time. Journal of Functional Programming, 7(5):515--540, 1997. [ bib | .ps.gz ] |
[74] | Andrew W. Appel, Paul-André Melliès, Christopher D. Richards, and Jérôme Vouillon. A very modal model of a modern, major, general type system. In Principles of Programming Languages (POPL), pages 109--122, January 2007. [ bib | .pdf ] |
[75] | Krzysztof R. Apt. Ten years of Hoare's logic: A survey---part I. ACM Transactions on Programming Languages and Systems, 3(4):431--483, 1981. [ bib | http ] |
[76] | Zena M. Ariola and Jan Willem Klop. Equational term graph rewriting. Fundamenta Informaticæ, 26(3--4):207--240, 1996. [ bib | .ps.Z ] |
[77] | André Arnold and Paul Crubillé. A linear algorithm to solve fixed-point equations on transition systems. Information Processing Letters, 29(2):57--66, 1988. [ bib | http ] |
[78] | André Arnold and Maurice Nivat. The metric space of infinite trees. Algebraic and topological properties. Fundamenta Informaticæ, 3(4):181--205, 1980. [ bib ] |
[79] | Kenichi Asai and Yukiyoshi Kameyama. Polymorphic delimited continuations. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 239--254. Springer, November 2007. [ bib | .pdf ] |
[80] | David Aspinall, Lennart Beringer, Martin Hofmann, Hans-Wolfgang Loidl, and Alberto Momigliano. A program logic for resources. Theoretical Computer Science, 389(3):411--445, 2007. [ bib | .pdf ] |
[81] | David Aspinall and Martin Hofmann. Another type system for in-place update. In European Symposium on Programming (ESOP), volume 2305 of Lecture Notes in Computer Science, pages 36--52. Springer, April 2002. [ bib | .pdf ] |
[82] | David Aspinall, Martin Hofmann, and Michal Konečný. A type system with usage aspects. Journal of Functional Programming, 18(2):141--178, 2008. [ bib | http ] |
[83] | Robert Atkey. Parameterised notions of computation. Journal of Functional Programming, 19(3--4):355--376, 2009. [ bib | .pdf ] |
[84] | Robert Atkey. Syntax for free: representing syntax with binding using parametricity. In Typed Lambda Calculi and Applications (TLCA), volume 5608 of Lecture Notes in Computer Science, pages 35--49. Springer, July 2009. [ bib | .pdf ] |
[85] | Robert Atkey. Amortised resource analysis with separation logic. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 85--103. Springer, 2010. [ bib | .pdf ] |
[86] | Robert Atkey. Amortised resource analysis with separation logic. Logical Methods in Computer Science, 7(2:17), 2011. [ bib | .pdf ] |
[87] | Robert Atkey, Sam Lindley, and Jeremy Yallop. Unembedding domain-specific languages. In Haskell symposium, pages 37--48, September 2009. [ bib | .pdf ] |
[88] | Lennart Augustsson. Implementing Haskell overloading. In Functional Programming Languages and Computer Architecture (FPCA), pages 65--73, 1993. [ bib | http ] |
[89] | Jean-Michel Autebert. Théorie des langages et des automates. Masson, 1994. [ bib ] |
[90] | Jean-Michel Autebert, Jean Berstel, and Luc Boasson. Context-free languages and push-down automata. In Handbook of Formal Languages, volume 1, pages 111--174. Springer, 1997. [ bib | .ps.gz ] |
[91] | Jeremy Avigad and Kevin Donnelly. Formalizing O notation in Isabelle/HOL. In International Joint Conference on Automated Reasoning, volume 3097 of Lecture Notes in Computer Science, pages 357--371. Springer, July 2004. [ bib | .pdf ] |
[92] | Nicholas Ayache, Roberto M. Amadio, and Yann Régis-Gianas. Certifying and reasoning on cost annotations in C programs. In Formal Methods for Industrial Critical Systems, volume 7437 of Lecture Notes in Computer Science, pages 32--46. Springer, August 2012. [ bib | http ] |
[93] | John Aycock and Nigel Horspool. Simple generation of static single-assignment form. In Compiler Construction (CC), volume 1781 of Lecture Notes in Computer Science. Springer, March 2000. [ bib | .ps ] |
[94] | Brian Aydemir, Arthur Charguéraud, Benjamin C. Pierce, Randy Pollack, and Stephanie Weirich. Engineering formal metatheory. In Principles of Programming Languages (POPL), pages 3--15, January 2008. [ bib | .pdf ] |
[95] | Brian Aydemir and Stephanie Weirich. LNgen: Tool support for locally nameless representations. Technical Report MS-CIS-10-24, University of Pennsylvania Department of Computer and Information Science, June 2010. [ bib | http ] |
[96] | Brian E. Aydemir, Aaron Bohannon, Matthew Fairbairn, J. Nathan Foster, Benjamin C. Pierce, Peter Sewell, Dimitrios Vytiniotis, Geoffrey Washburn, Stephanie Weirich, and Steve Zdancewic. Mechanized metatheory for the masses: The PoplMark challenge. In Theorem Proving in Higher Order Logics (TPHOLs), volume 3603 of Lecture Notes in Computer Science, pages 50--65. Springer, August 2005. [ bib | .pdf ] |
[97] | Henry G. Baker. List processing in real time on a serial computer. Communications of the ACM, 21(4):280--294, April 1978. [ bib | http ] |
[98] | Henry G. Baker. Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In ACM Symposium on Lisp and Functional Programming (LFP), pages 218--226, June 1990. [ bib | .ps.gz ] |
[99] | Thibaut Balabonski, François Pottier, and Jonathan Protzenko. Type soundness and race freedom for Mezzo. In Proceedings of the 12th International Symposium on Functional and Logic Programming (FLOPS 2014), volume 8475 of Lecture Notes in Computer Science, pages 253--269. Springer, June 2014. [ bib | .pdf ] |
[100] | Thibaut Balabonski, François Pottier, and Jonathan Protzenko. The design and formalization of Mezzo, a permission-based programming language. ACM Transactions on Programming Languages and Systems, 38(4):14:1--14:94, August 2016. [ bib | .pdf ] |
[101] | Vincent Balat, Roberto Di Cosmo, and Marcelo Fiore. Remarks on isomorphisms in typed lambda calculi with empty and sum type. In Logic in Computer Science (LICS), July 2002. [ bib | .ps.gz ] |
[102] | Anindya Banerjee, Nevin Heintze, and Jon G. Riecke. Region analysis and the polymorphic lambda calculus. In Logic in Computer Science (LICS), pages 88--97, July 1999. [ bib | .pdf ] |
[103] | Anindya Banerjee, Nevin Heintze, and Jon G. Riecke. Design and correctness of program transformations based on control-flow analysis. In International Symposium on Theoretical Aspects of Computer Software (TACS), volume 2215 of Lecture Notes in Computer Science, pages 420--447. Springer, October 2001. [ bib | .ps.gz ] |
[104] | Anindya Banerjee and David Naumann. Secure information flow and pointer confinement in a Java-like language. In IEEE Computer Security Foundations Workshop, pages 253--267, June 2002. [ bib | .ps ] |
[105] | Anindya Banerjee and David A. Naumann. A simple semantics and static analysis for Java security. Technical Report 2001-1, Stevens Institute of Technology, June 2001. [ bib | .ps ] |
[106] | Anindya Banerjee and David A. Naumann. Representation independence, confinement, and access control. In Principles of Programming Languages (POPL), pages 166--177, January 2002. [ bib | .ps ] |
[107] | Anindya Banerjee and David A. Naumann. State based ownership, reentrance, and encapsulation. In European Conference on Object-Oriented Programming (ECOOP), volume 3586 of Lecture Notes in Computer Science, pages 387--411. Springer, July 2005. [ bib | .pdf ] |
[108] | Jean-Pierre Banâtre, Ciarán Bryce, and Daniel Le Métayer. Compile-time detection of information flow in sequential programs. In European Symposium on Research in Computer Security, volume 875 of Lecture Notes in Computer Science, pages 55--74. Springer, 1994. [ bib | .ps.Z ] |
[109] | Andrew Barber. Dual intuitionistic linear logic. Technical Report ECS-LFCS-96-347, Laboratory for Foundations of Computer Science, School of Informatics at the University of Edinburgh, September 1996. [ bib | http ] |
[110] | Henk P. Barendregt. The lambda calculus, its syntax and semantics. Elsevier Science, 1984. [ bib | http ] |
[111] | Henk P. Barendregt. Functional programming and lambda calculus. In J. Van Leeuwen, editor, Handbook of Theoretical Computer Science, pages 321--363. Elsevier Science, 1990. [ bib ] |
[112] | Erik Barendsen and Sjaak Smetsers. Uniqueness type inference. In Programming Languages: Implementations, Logics, and Programs (PLILP), volume 982 of Lecture Notes in Computer Science, pages 189--206. Springer, 1995. [ bib | http ] |
[113] | Mike Barnett, Rob DeLine, Manuel Fähndrich, K. Rustan M. Leino, and Wolfram Schulte. Verification of object-oriented programs with invariants. Journal of Object Technology, 3(6), 2004. [ bib | http ] |
[114] | Mike Barnett, K. Rustan M. Leino, and Wolfram Schulte. The Spec# programming system: An overview. In Construction and Analysis of Safe, Secure and Interoperable Smart devices (CASSIS), volume 3362 of Lecture Notes in Computer Science, pages 49--69. Springer, 2004. [ bib | .pdf ] |
[115] | Mike Barnett, David A. Naumann, Wolfram Schulte, and Qi Sun. 99.44% pure: Useful abstractions in specifications. In Formal Techniques for Java-like Programs, 2004. [ bib | .pdf ] |
[116] | Chris Barrett, Riko Jacob, and Madhav Marathe. Formal language constrained path problems. SIAM Journal on Computing, 30(3):809--837, 2000. [ bib | .ps.gz ] |
[117] | Frank Bartels, Friedrich von Henke, Holger Pfeifer, and Harald Rueß. Mechanizing domain theory. Ulmer Informatik-Berichte 96-10, Universität Ulm, Fakultät für Informatik, 1996. [ bib | .ps.gz ] |
[118] | Gilles Barthe, Julien Forest, David Pichardie, and Vlad Rusu. Defining and reasoning about recursive functions: A practical tool for the Coq proof assistant. In Functional and Logic Programming, volume 3945 of Lecture Notes in Computer Science, pages 114--129. Springer, April 2006. [ bib | .pdf ] |
[119] | Gilles Barthe, John Hatcliff, and Morten Heine Sørensen. CPS translations and applications: The cube and beyond. Higher-Order and Symbolic Computation, 12(2):125--170, 1999. [ bib | http ] |
[120] | Aditi Barthwal and Michael Norrish. Verified, executable parsing. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 160--174. Springer, 2009. [ bib | .pdf ] |
[121] | Massimo Bartoletti, Pierpaolo Degano, and GianLuigi Ferrari. Static analysis for stack inspection. In International Workshop on Concurrency and Coordination, volume 54 of Electronic Notes in Theoretical Computer Science. Elsevier Science, 2001. [ bib ] |
[122] | Andrej Bauer, Martin Hofmann, and Aleksandr Karbyshev. On monadic parametricity of second-order functionals. In Foundations of Software Science and Computation Structures (FOSSACS), volume 7794 of Lecture Notes in Computer Science, pages 225--240. Springer, March 2013. [ bib | .pdf ] |
[123] | Andrej Bauer and Matija Pretnar. An effect system for algebraic effects and handlers. Logical Methods in Computer Science, 10(4), 2014. [ bib | .pdf ] |
[124] | Mike Beaven and Ryan Stansifer. Explaining type errors in polymorphic languages. ACM Letters on Programming Languages and Systems, 2(4):17--30, March 1993. [ bib | .ps.gz ] |
[125] | C. J. Bell, Robert Dockins, Aquinas Hobor, Andrew W. Appel, and David Walker. Comparing semantic and syntactic methods in mechanized proof frameworks. In International Workshop on Proof-Carrying Code (PCC), June 2008. [ bib | .pdf ] |
[126] | D. E. Bell and Leonard J. LaPadula. Secure computer systems: Unified exposition and Multics interpretation. Technical Report MTR-2997, The MITRE Corp., July 1975. [ bib | .pdf ] |
[127] | Jeffrey M. Bell, Françoise Bellegarde, and James Hook. Type-driven defunctionalization. In International Conference on Functional Programming (ICFP), August 1997. [ bib | http ] |
[128] | Michael A. Bender, Jeremy T. Fineman, Seth Gilbert, and Robert E. Tarjan. A new approach to incremental cycle detection and related problems. ACM Transactions on Algorithms, 12(2):14:1--14:22, 2016. [ bib | http ] |
[129] | Jesper Bengtson, Jonas Braband Jensen, and Lars Birkedal. Charge! A framework for higher-order separation logic in Coq. In Interactive Theorem Proving (ITP), pages 315--331, August 2012. [ bib | .pdf ] |
[130] | Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn. A decidable fragment of separation logic. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 3328 of Lecture Notes in Computer Science, pages 97--109. Springer, December 2004. [ bib | .pdf ] |
[131] | Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn. Smallfoot: Modular automatic assertion checking with separation logic. In Formal Methods for Components and Objects, volume 4111 of Lecture Notes in Computer Science, pages 115--137. Springer, November 2005. [ bib | .pdf ] |
[132] | Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn. Symbolic execution with separation logic. In Asian Symposium on Programming Languages and Systems (APLAS), volume 3780 of Lecture Notes in Computer Science, pages 52--68. Springer, 2005. [ bib | .pdf ] |
[133] | Josh Berdine and Peter W. O'Hearn. Strong update, disposal, and encapsulation in bunched typing. In Mathematical Foundations of Programming Semantics, volume 158 of Electronic Notes in Theoretical Computer Science, pages 81--98. Elsevier Science, May 2006. [ bib | .pdf ] |
[134] | Josh Berdine, Peter W. O'Hearn, Uday S. Reddy, and Hayo Thielecke. Linear continuation-passing. Higher-Order and Symbolic Computation, 15(2--3):181--208, 2002. [ bib | .pdf ] |
[135] | Martin Berger, Kohei Honda, and Nobuko Yoshida. A logical analysis of aliasing in imperative higher-order functions. In International Conference on Functional Programming (ICFP), pages 280--293, September 2005. [ bib | http ] |
[136] | K. Bernstein and E. W. Stark. Debugging type errors. Unpublished, November 1995. [ bib | .ps.gz ] |
[137] | Bernard Berthomieu and Camille le Moniès de Sagazan. A calculus of tagged types, with applications to process languages. In Workshop on Types for Program Analysis, pages 1--15, May 1995. [ bib | .ps.gz ] |
[138] | Yves Bertot and Pierre Castéran. Interactive theorem proving and program development -- Coq'Art: The calculus of inductive constructions. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2004. [ bib | .pdf ] |
[139] | Frédéric Besson, Thomas de Grenier de Latour, and Thomas Jensen. Secure calling contexts for stack inspection. In Principles and Practice of Declarative Programming (PPDP), pages 76--87, October 2002. [ bib | .pdf ] |
[140] | Frédéric Besson, Thomas P. Jensen, Daniel Le Métayer, and Tommy Thorn. Model checking security properties of control flow graphs. Journal of Computer Security, 9(3):217--250, 2001. [ bib | .pdf ] |
[141] | Achyutram Bhamidipaty and Todd A. Proebsting. Very fast YACC-compatible parsers (for very little effort). Software: Practice and Experience, 28(2):181--190, February 1998. [ bib | .ps ] |
[142] | Karthik Bhargavan, Cédric Fournet, and Andy Gordon. Modular verification of security protocol code by typing. In Principles of Programming Languages (POPL), pages 445--456, January 2010. [ bib | .pdf ] |
[143] | Karthik Bhargavan, Cédric Fournet, Andy Gordon, Sergio Maffeis, and Jesper Bengtson. The F7 typechecker, 2011. http://research.microsoft.com/en-us/projects/f7/. [ bib | http ] |
[144] | Karthikeyan Bhargavan, Cédric Fournet, Markulf Kohlweiss, Alfredo Pironti, and Pierre-Yves Strub. Implementing TLS with verified cryptographic security. In IEEE Symposium on Security and Privacy (S&P), pages 445--459, May 2013. [ bib | .pdf ] |
[145] | Girish Bhat and Rance Cleaveland. Efficient local model-checking for fragments of the modal μ-calculus. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 1055 of Lecture Notes in Computer Science, pages 107--126. Springer, March 1996. [ bib | .ps.gz ] |
[146] | Armin Biere, Alessandro Cimatti, Edmund Clarke, and Yunshan Zhu. Symbolic model checking without BDDs. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 1579 of Lecture Notes in Computer Science, pages 193--207. Springer, March 1999. [ bib | .pdf ] |
[147] | Kevin Bierhoff and Jonathan Aldrich. Modular typestate checking of aliased objects. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 301--320, October 2007. [ bib | .pdf ] |
[148] | Kevin Bierhoff, Nels E. Beckman, and Jonathan Aldrich. Practical API protocol checking with access permissions. In European Conference on Object-Oriented Programming (ECOOP), volume 5653 of Lecture Notes in Computer Science, pages 195--219. Springer, July 2009. [ bib | .pdf ] |
[149] | Kevin Bierhoff, Nels E. Beckman, and Jonathan Aldrich. Checking concurrent typestate with access permissions in Plural: A retrospective. In Peri L. Tarr and Alexander L. Wolf, editors, Engineering of Software, pages 35--48. Springer, 2011. [ bib | .pdf ] |
[150] | Bodil Biering, Lars Birkedal, and Noah Torp-Smith. BI hyperdoctrines and higher-order separation logic. In European Symposium on Programming (ESOP), volume 3444 of Lecture Notes in Computer Science, pages 233--247. Springer, April 2005. [ bib | .pdf ] |
[151] | Richard Bird and Lambert Meertens. Nested datatypes. In Mathematics of Program Construction (MPC), volume 1422 of Lecture Notes in Computer Science, pages 52--67. Springer, 1998. [ bib | .pdf ] |
[152] | Richard Bird and Ross Paterson. de Bruijn notation as a nested datatype. Journal of Functional Programming, 9(1):77--91, January 1999. [ bib | http ] |
[153] | Richard S. Bird and John Hughes. The alpha-beta algorithm: An exercise in program transformation. Information Processing Letters, 24(1):53--57, 1987. [ bib | http ] |
[154] | Lars Birkedal, Bernhard Reus, Jan Schwinghammer, Kristian Støvring, Jacob Thamsborg, and Hongseok Yang. Step-indexed Kripke models over recursive worlds. In Principles of Programming Languages (POPL), pages 119--132, January 2011. [ bib | .pdf ] |
[155] | Lars Birkedal, Nick Rothwell, Mads Tofte, and David N. Turner. The ML kit (version 1). Technical Report DIKU 93/14, Department of Computer Science, University of Copenhagen, 1993. [ bib | http ] |
[156] | Lars Birkedal, Jan Schwinghammer, and Kristian Støvring. A metric model of lambda calculus with guarded recursion. Presented at FICS 2010, July 2010. [ bib | .pdf ] |
[157] | Lars Birkedal, Kristian Støvring, and Jacob Thamsborg. The category-theoretic solution of recursive metric-space quations. Technical Report ITU-2009-119, IT University of Copenhagen, 2009. [ bib | .pdf ] |
[158] | Lars Birkedal, Kristian Støvring, and Jacob Thamsborg. Realizability semantics of parametric polymorphism, general references, and recursive types. In Foundations of Software Science and Computation Structures (FOSSACS), volume 5504 of Lecture Notes in Computer Science, pages 456--470. Springer, March 2009. [ bib | .pdf ] |
[159] | Lars Birkedal, Kristian Støvring, and Jacob Thamsborg. Realisability semantics of parametric polymorphism, general references, and recursive types. Mathematical Structures in Computer Science, 20(4):655--703, 2010. [ bib | .pdf ] |
[160] | Lars Birkedal and Mads Tofte. A constraint-based region inference algorithm. Theoretical Computer Science, 258:299--392, 2001. [ bib | .ps.gz ] |
[161] | Lars Birkedal, Noah Torp-Smith, and Hongseok Yang. Semantics of separation-logic typing and higher-order frame rules for Algol-like languages. Logical Methods in Computer Science, 2(5), November 2006. [ bib | http ] |
[162] | Andrew D. Birrell. An introduction to programming with C# threads. Manuscript, 2003. [ bib | .pdf ] |
[163] | Sandip K. Biswas. Dynamic slicing in higher-order programming languages. PhD thesis, University of Pennsylvania, August 1997. [ bib ] |
[164] | Frédéric Blanqui and Adam Koprowski. CoLoR: a coq library on well-founded rewrite relations and its application to the automated verification of termination certificates. Mathematical Structures in Computer Science, 21(4):827--859, August 2011. [ bib | .pdf ] |
[165] | Guy E. Blelloch and John Greiner. Parallelism in sequential functional languages. In Functional Programming Languages and Computer Architecture (FPCA), pages 226--237, 1995. [ bib | .ps.gz ] |
[166] | François Bobot, Jean-Christophe Filliâtre, Claude Marché, and Andrei Paskevich. Let's verify this with Why3. Software Tools for Technology Transfer, 17(6):709--727, 2015. [ bib | http ] |
[167] | Robert L. Bocchino Jr. Alias control for deterministic parallelism. In Dave Clarke, James Noble, and Tobias Wrigstad, editors, Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 156--195. Springer, 2013. [ bib | http ] |
[168] | Robert L. Bocchino Jr. and Vikram S. Adve. Types, regions, and effects for safe programming with object-oriented parallel frameworks. In European Conference on Object-Oriented Programming (ECOOP), volume 6813 of Lecture Notes in Computer Science, pages 306--332. Springer, July 2011. [ bib | .pdf ] |
[169] | Robert L. Bocchino Jr., Vikram S. Adve, Sarita V. Adve, and Marc Snir. Parallel programming must be deterministic by default. In USENIX Conference on Hot Topics in Parallelism (HotPar), pages 1--6, 2009. [ bib | .pdf ] |
[170] | Robert L. Bocchino Jr., Vikram S. Adve, Danny Dig, Sarita V. Adve, Stephen Heumann, Rakesh Komuravelli, Jeffrey Overbey, Patrick Simmons, Hyojin Sung, and Mohsen Vakilian. A type and effect system for deterministic parallel Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 97--116, October 2009. [ bib | .pdf ] |
[171] | Robert L. Bocchino Jr., Stephen Heumann, Nima Honarmand, Sarita V. Adve, Vikram S. Adve, Adam Welc, and Tatiana Shpeisman. Safe nondeterminism in a deterministic-by-default parallel language. In Principles of Programming Languages (POPL), pages 535--548, January 2011. [ bib | .pdf ] |
[172] | Chiara Bodei, Pierpaolo Degano, Flemming Nielson, and Hanne Riis Nielson. Static analysis of processes for no read-up and no write-down. In Foundations of Software Science and Computation Structures (FOSSACS), volume 1578 of Lecture Notes in Computer Science, pages 120--134. Springer, March 1999. [ bib | .ps ] |
[173] | Hans-J. Boehm and Sarita V. Adve. You don't know jack about shared variables or memory models. Communications of the ACM, 55(2):48--54, February 2012. [ bib | http ] |
[174] | Sylvie Boldo, François Clément, Jean-Christophe Filliâtre, Micaela Mayero, Guillaume Melquiond, and Pierre Weis. Wave equation numerical resolution: a comprehensive mechanized proof of a C program. Journal of Automated Reasoning, 50(4):423--456, April 2013. [ bib | http ] |
[175] | Sylvie Boldo, Catherine Lelay, and Guillaume Melquiond. Coquelicot: A user-friendly library of real analysis for Coq. Mathematics in Computer Science, 9(1):41--62, March 2015. [ bib | http ] |
[176] | Daniel Bonniot. Type-checking multi-methods in ML (a modular approach). In Foundations of Object-Oriented Languages (FOOL), January 2002. [ bib | .ps ] |
[177] | Urban Boquist. Code optimisation techniques for lazy functional languages. PhD thesis, Chalmers University of Technology, April 1999. [ bib | .pdf ] |
[178] | Michele Boreale and Davide Sangiorgi. A fully abstract semantics for causality in the π-calculus. Acta Informatica, 35(5):353--400, May 1998. [ bib | .pdf ] |
[179] | Johannes Borgström, Juan Chen, , and Nikhil Swamy. Verified stateful programs with substructural state and Hoare types. In Programming Languages Meets Program Verification (PLPV), January 2011. [ bib | .pdf ] |
[180] | Richard Bornat. Proving pointer programs in Hoare logic. In Mathematics of Program Construction (MPC), volume 1837 of Lecture Notes in Computer Science, pages 102--126. Springer, 2000. [ bib | .pdf ] |
[181] | Richard Bornat, Cristiano Calcagno, Peter O'Hearn, and Matthew Parkinson. Permission accounting in separation logic. In Principles of Programming Languages (POPL), pages 259--270, January 2005. [ bib | .pdf ] |
[182] | Ahmed Bouajjani, Javier Esparza, and Oded Maler. Reachability analysis of pushdown automata: Application to model-checking. In International Conference on Concurrency Theory (CONCUR), volume 1243 of Lecture Notes in Computer Science, pages 135--150. Springer, July 1997. [ bib | .pdf ] |
[183] | Gérard Boudol. Typing termination in a higher-order concurrent imperative language. Information and Computation, 2009. To appear. [ bib | .pdf ] |
[184] | Gérard Boudol and Ilaria Castellani. Non-interference for concurrent programs and thread systems. To appear, September 2001. [ bib | .ps.gz ] |
[185] | Sylvain Boulmé. Intuitionistic refinement calculus. In Typed Lambda Calculi and Applications (TLCA), volume 4583 of Lecture Notes in Computer Science, pages 54--69. Springer, June 2007. [ bib | .pdf ] |
[186] | François Bourdoncle and Stephan Merz. On the integration of functional programming, class-based object-oriented programming, and multi-methods. Research Report 26, Centre de Mathématiques Appliquées, Ecole des Mines de Paris, March 1996. [ bib | .html ] |
[187] | François Bourdoncle and Stephan Merz. Type checking higher-order polymorphic multi-methods. In Principles of Programming Languages (POPL), pages 302--315, January 1997. [ bib | .html ] |
[188] | Chandrasekhar Boyapati, Robert Lee, and Martin Rinard. Ownership types for safe programming: preventing data races and deadlocks. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 211--230, November 2002. [ bib | http ] |
[189] | Chandrasekhar Boyapati, Barbara Liskov, and Liuba Shrira. Ownership types for object encapsulation. In Principles of Programming Languages (POPL), pages 213--223, January 2003. [ bib | .pdf ] |
[190] | John Boyland. Alias burying: Unique variables without destructive reads. Science of Computer Programming, 31(6):533--553, May 2001. [ bib | .ps ] |
[191] | John Boyland. Checking interference with fractional permissions. In Static Analysis Symposium (SAS), volume 2694 of Lecture Notes in Computer Science, pages 55--72. Springer, June 2003. [ bib | .pdf ] |
[192] | John Boyland, James Noble, and William Retert. Capabilities for sharing: A generalisation of uniqueness and read-only. In European Conference on Object-Oriented Programming (ECOOP), volume 2072 of Lecture Notes in Computer Science, pages 2--27. Springer, June 2001. [ bib | .ps ] |
[193] | John Tang Boyland. Semantics of fractional permissions with nesting. ACM Transactions on Programming Languages and Systems, 32(6):22:1--22:33, 2010. [ bib | http ] |
[194] | John Tang Boyland and William Retert. Connecting effects and uniqueness with adoption. In Principles of Programming Languages (POPL), pages 283--295, January 2005. [ bib | .pdf ] |
[195] | Gilad Bracha and William Cook. Mixin-based inheritance. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 303--311, 1990. [ bib | .ps ] |
[196] | Gilad Bracha and Gary Lindstrom. Modularity meets inheritance. Technical Report UUCS-91-017, University of Utah, October 1991. [ bib | .ps ] |
[197] | Aaron R. Bradley and Zohar Manna. The calculus of computation. Springer, 2007. [ bib | http ] |
[198] | Thomas Braibant and Damien Pous. Tactics for reasoning modulo AC in Coq. In Certified Programs and Proofs (CPP), volume 7086 of Lecture Notes in Computer Science, pages 167--182. Springer, 2011. [ bib | http ] |
[199] | Marc M. Brandis and Hanspeter Mössenböck. Single-pass generation of static single-assignment form for structured languages. ACM Transactions on Programming Languages and Systems, 16(6):1684--1698, 1994. [ bib | .ps.gz ] |
[200] | Michael Brandt and Fritz Henglein. Coinductive axiomatization of recursive type equality and subtyping. Fundamenta Informaticæ, 33:309--338, 1998. [ bib | .ps.gz ] |
[201] | Gilles Brassard and Paul Bratley. Fundamentals of algorithmics. Prentice Hall, 1996. [ bib ] |
[202] | Val Breazu-Tannen, Thierry Coquand, Carl A. Gunter, and Andre Scedrov. Inheritance as implicit coercion. Information and Computation, 93(1):172--221, July 1991. [ bib | .pdf ] |
[203] | Stephen Brookes and Peter W. O'Hearn. Concurrent separation logic. SIGLOG News, 3(3):47--65, 2016. [ bib | http ] |
[204] | Stephen D. Brookes. A semantics for concurrent separation logic. In International Conference on Concurrency Theory (CONCUR), volume 3170 of Lecture Notes in Computer Science, pages 16--34. Springer, August 2004. [ bib | http ] |
[205] | James Brotherston, Dino Distefano, and Rasmus Lerchedahl Petersen. Automated cyclic entailment proofs in separation logic. In International Conference on Automated Deduction (CADE), volume 6803 of Lecture Notes in Computer Science, pages 131--146. Springer, July 2011. [ bib | .pdf ] |
[206] | Kim Bruce, Luca Cardelli, Giuseppe Castagna, The Hopkins Object Group, Gary T. Leavens, and Benjamin Pierce. On binary methods. Technical Report 95-08a, Department of Computer Science, Iowa State University, December 1995. [ bib | .ps.Z ] |
[207] | Kim Bruce, Roberto Di Cosmo, and Giuseppe Longo. Provable isomorphisms of types. Mathematical Structures in Computer Science, 2(2):231--247, 1992. [ bib | .dvi ] |
[208] | Kim B. Bruce, Luca Cardelli, and Benjamin C. Pierce. Comparing object encodings. Information and Computation, 155(1/2):108--133, November 1999. [ bib | .ps ] |
[209] | Julian Brunner and Peter Lammich. Formal verification of an executable LTL model checker with partial order reduction. Journal of Automated Reasoning, 60(1):3--21, 2018. [ bib | .pdf ] |
[210] | Peter Buchlovsky and Hayo Thielecke. A type-theoretic reconstruction of the visitor pattern. Electronic Notes in Theoretical Computer Science, 155:309--329, 2006. [ bib | .pdf ] |
[211] | Michele Bugliesi, Stefano Calzavara, Fabienne Eigner, and Matteo Maffei. Affine refinement types for secure distributed programming. To appear, 2015. [ bib | .pdf ] |
[212] | Michele Bugliesi and Silvia Crafa. Object calculi for dynamic messages. In Foundations of Object-Oriented Languages (FOOL), 1999. [ bib ] |
[213] | Michele Bugliesi and Santiago M. Pericás-Geertsen. Type inference for variant object types. Information and Computation, 177(1):2--27, August 2002. [ bib | .ps.gz ] |
[214] | Alexandre Buisse, Lars Birkedal, and Kristian Støvring. A step-indexed Kripke model of separation logic for storable locks. Electronic Notes in Theoretical Computer Science, 276:121--143, September 2011. [ bib | .pdf ] |
[215] | Lukas Bulwahn, Alexander Krauss, Florian Haftmann, Levent Erkök, and John Matthews. Imperative functional programming with Isabelle/HOL. In Theorem Proving in Higher Order Logics (TPHOLs), volume 5170 of Lecture Notes in Computer Science, pages 134--149. Springer, August 2008. [ bib | .pdf ] |
[216] | Peter Buneman and Atsushi Ohori. Polymorphism and type inference in database programming. ACM Transactions on Database Systems, 21(1):30--76, 1996. [ bib | .pdf ] |
[217] | Lilian Burdy, Yoonsik Cheon, David Cok, Michael Ernst, Joe Kiniry, Gary T. Leavens, K. Rustan M. Leino, and Erik Poll. An overview of JML tools and applications. Software Tools for Technology Transfer, 7(3):212--232, June 2005. [ bib | .pdf ] |
[218] | R. M. Burstall, D. B. MacQueen, and D. T. Sannella. HOPE: An experimental applicative language. In ACM Symposium on Lisp and Functional Programming (LFP), pages 136--143, 1980. [ bib | http ] |
[219] | Jiazhen Cai and Robert Paige. Program derivation by fixed point computation. Science of Computer Programming, 11(3):197--261, 1989. [ bib | .ps ] |
[220] | Luís Caires and João Costa Seco. The type discipline of behavioral separation. In Principles of Programming Languages (POPL), pages 275--286, January 2013. [ bib | http ] |
[221] | Cristiano Calcagno and Dino Distefano. Infer: An automatic program verifier for memory safety of C programs. In NASA Formal Methods (NFM), volume 6617 of Lecture Notes in Computer Science, pages 459--465. Springer, April 2011. [ bib | .pdf ] |
[222] | Cristiano Calcagno, Dino Distefano, Jérémy Dubreil, Dominik Gabi, Pieter Hooimeijer, Martino Luca, Peter W. O'Hearn, Irene Papakonstantinou, Jim Purbrick, and Dulma Rodriguez. Moving fast with software verification. In NASA Formal Methods (NFM), volume 9058 of Lecture Notes in Computer Science, pages 3--11. Springer, April 2015. [ bib | http ] |
[223] | Cristiano Calcagno, Dino Distefano, and Peter O'Hearn. Open-sourcing Facebook Infer: Identify bugs before you ship. https://code.facebook.com/posts/1648953042007882/open-sourcing-facebook-infer-identify-bugs-before-you-ship/, June 2015. [ bib ] |
[224] | Cristiano Calcagno, Dino Distefano, Peter W. O'Hearn, and Hongseok Yang. Compositional shape analysis by means of bi-abduction. In Principles of Programming Languages (POPL), pages 289--300, January 2009. [ bib | .pdf ] |
[225] | Cristiano Calcagno, Dino Distefano, Peter W. O'Hearn, and Hongseok Yang. Compositional shape analysis by means of bi-abduction. Journal of the ACM, 58(6), 2011. [ bib | .pdf ] |
[226] | Cristiano Calcagno, Dino Distefano, and Viktor Vafeiadis. Bi-abductive resource invariant synthesis. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 259--274. Springer, December 2009. [ bib | .pdf ] |
[227] | Cristiano Calcagno, Simon Helsen, and Peter Thiemann. Syntactic type soundness results for the region calculus. Information and Computation, 173(2):199--221, 2002. [ bib | .pdf ] |
[228] | Cristiano Calcagno, Eugenio Moggi, and Tim Sheard. Closed types for a safe imperative MetaML. Journal of Functional Programming, 13(3):545--571, May 2003. [ bib | http ] |
[229] | Cristiano Calcagno, Eugenio Moggi, and Walid Taha. ML-like inference for classifiers. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 79--93. Springer, 2004. [ bib | .pdf ] |
[230] | Cristiano Calcagno, Peter W. O'Hearn, and Hongseok Yang. Local action and abstract separation logic. In Logic in Computer Science (LICS), pages 366--378, July 2007. [ bib | .pdf ] |
[231] | Cristiano Calcagno, Hongseok Yang, and Peter W. O'Hearn. Computability and complexity results for a spatial assertion language for data structures. In Asian Symposium on Programming Languages and Systems (APLAS), pages 289--300, December 2001. [ bib | .ps ] |
[232] | Quentin Carbonneaux, Jan Hoffmann, Tahina Ramananandro, and Zhong Shao. End-to-end verification of stack-space bounds for C programs. In Programming Language Design and Implementation (PLDI), pages 270--281, June 2014. [ bib | .pdf ] |
[233] | Quentin Carbonneaux, Jan Hoffmann, Thomas Reps, and Zhong Shao. Automated resource analysis with Coq proof objects. In Computer Aided Verification (CAV), volume 10427 of Lecture Notes in Computer Science, pages 64--85. Springer, July 2017. [ bib | .pdf ] |
[234] | Luca Cardelli. Basic polymorphic typechecking. Science of Computer Programming, 8(2):147--172, 1987. [ bib | .pdf ] |
[235] | Luca Cardelli. A semantics of multiple inheritance. Information and Computation, 76(2/3):138--164, February 1988. [ bib | .pdf ] |
[236] | Luca Cardelli. Typeful programming. In Formal Description of Programming Concepts, IFIP State of the Art Reports Series. Springer, February 1989. [ bib | .pdf ] |
[237] | Luca Cardelli. The Quest language and system, 1991. [ bib | .pdf ] |
[238] | Luca Cardelli. Type systems. In Allen B. Tucker, editor, The Computer Science and Engineering Handbook, pages 2208--2236. CRC Press, 1997. [ bib | .pdf ] |
[239] | Luca Cardelli and Giuseppe Longo. A semantic basis for Quest. Journal of Functional Programming, 1(4):417--458, October 1991. [ bib | .pdf ] |
[240] | Luca Cardelli, Florian Matthes, and Martín Abadi. Extensible syntax with lexical scoping. Research Report 121, Digital Equipment Corporation, Systems Research Center, February 1994. [ bib | .ps.gz ] |
[241] | Luca Cardelli and John Mitchell. Operations on records. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
[242] | Luca Cardelli and Peter Wegner. On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471--522, December 1985. [ bib | .pdf ] |
[243] | Felice Cardone. A coinductive completeness proof for the equivalence of recursive types. Theoretical Computer Science, 275(1--2):575--587, 2002. [ bib | http ] |
[244] | Felice Cardone and Mario Coppo. Type inference with recursive types: syntax and semantics. Information and Computation, 92(1):48--80, 1991. [ bib | http ] |
[245] | Jacques Carette. Gaussian elimination: a case study in efficient genericity with MetaOCaml. Science of Computer Programming, 62(1):3--24, September 2005. [ bib | .pdf ] |
[246] | Jacques Carette, Oleg Kiselyov, and Chung chieh Shan. Finally tagless, partially evaluated. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 222--238. Springer, November 2007. [ bib | .pdf ] |
[247] | Sébastien Carlier, Jeff Polakow, J. B. Wells, and A. J. Kfoury. System E: Expansion variables for flexible typing with linear and non-linear types and intersection types. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, 2004. [ bib | .pdf ] |
[248] | Sébastien Carlier and J. B. Wells. Type inference with expansion variables and intersection types in System E and an exact correspondence with β-reduction. Technical Report HW-MACS-TR-0012, Heriot-Watt University, January 2004. [ bib | .pdf ] |
[249] | Robert Cartwright. Notes on object-oriented program design, January 2000. [ bib | http ] |
[250] | Giuseppe Castagna. F_{<=}^{&} : integrating parametric and “ad hoc” second order polymorphism. In International Workshop on Database Programming Languages, Workshops in Computing. Springer, September 1993. [ bib ] |
[251] | Giuseppe Castagna. Covariance and contravariance: Conflict without a cause. ACM Transactions on Programming Languages and Systems, 17(3):431--447, May 1995. [ bib | .ps.Z ] |
[252] | Giuseppe Castagna and Alain Frisch. A gentle introduction to semantic subtyping. In Principles and Practice of Declarative Programming (PPDP), pages 198--199, July 2005. [ bib | .pdf ] |
[253] | Henry Cejtin, Matthew Fluet, Suresh Jagannathan, and Stephen Weeks. The MLton compiler, 2007. [ bib | http ] |
[254] | Henry Cejtin, Suresh Jagannathan, and Stephen Weeks. Flow-directed closure conversion for typed languages. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 56--71. Springer, March 2000. [ bib | http ] |
[255] | Manuel M. T. Chakravarty, Gabriele Keller, Simon L. Peyton Jones, and Simon Marlow. Associated types with class. In Principles of Programming Languages (POPL), pages 1--13, January 2005. [ bib | .pdf ] |
[256] | Craig Chambers and Gary T. Leavens. BeCecil, a core object-oriented language with block structure and multimethods: Semantics and typing. Technical Report UW-CSE-96-12-02, University of Washington, December 1996. [ bib | .ps.gz ] |
[257] | Bor-Yuh Evan Chang and Xavier Rival. Relational inductive shape analysis. In Principles of Programming Languages (POPL), pages 247--260, January 2008. [ bib | .pdf ] |
[258] | Arthur Charguéraud. Program verification through characteristic formulae. In International Conference on Functional Programming (ICFP), pages 321--332, September 2010. [ bib | .pdf ] |
[259] | Arthur Charguéraud. Characteristic formulae for the verification of imperative programs. In International Conference on Functional Programming (ICFP), pages 418--430, September 2011. [ bib | .pdf ] |
[260] | Arthur Charguéraud. The locally nameless representation. Journal of Automated Reasoning, 49(3):363--408, 2012. [ bib | .pdf ] |
[261] | Arthur Charguéraud. Characteristic formulae for mechanized program verification. PhD thesis, Université Paris 7, December 2010. [ bib | .pdf ] |
[262] | Arthur Charguéraud. The optimal fixed point combinator. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 195--210. Springer, July 2010. [ bib | .pdf ] |
[263] | Arthur Charguéraud. Characteristic formulae for the verification of imperative programs, 2013. Unpublished. http://www.chargueraud.org/research/2013/cf/cf.pdf. [ bib ] |
[264] | Arthur Charguéraud. The CFML tool and library. http://www.chargueraud.org/softs/cfml/, 2019. [ bib ] |
[265] | Arthur Charguéraud and François Pottier. Functional translation of a calculus of capabilities. In International Conference on Functional Programming (ICFP), pages 213--224, September 2008. [ bib | .pdf ] |
[266] | Arthur Charguéraud and François Pottier. Machine-checked verification of the correctness and amortized complexity of an efficient union-find implementation. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 137--153. Springer, August 2015. [ bib | .pdf ] |
[267] | Arthur Charguéraud and François Pottier. Verifying the correctness and amortized complexity of a union-find implementation in separation logic with time credits. Journal of Automated Reasoning, September 2017. [ bib | .pdf ] |
[268] | Chih-Ping Chen and Paul Hudak. Rolling your own mutable ADT---a connection between linear types and monads. In Principles of Programming Languages (POPL), pages 54--66, January 1997. [ bib | .ps ] |
[269] | Chiyan Chen, Rui Shi, and Hongwei Xi. A typeful approach to object-oriented programming with multiple inheritance. In Practical Aspects of Declarative Languages (PADL), volume 3057 of Lecture Notes in Computer Science. Springer, June 2004. [ bib | .pdf ] |
[270] | Chiyan Chen and Hongwei Xi. Implementing typeful program transformations. In ACM Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 20--28, June 2003. [ bib | .pdf ] |
[271] | Chiyan Chen and Hongwei Xi. Meta-programming through typeful code representation. In International Conference on Functional Programming (ICFP), pages 275--286, August 2003. [ bib | .pdf ] |
[272] | Chiyan Chen and Hongwei Xi. Combining programming with theorem proving. In International Conference on Functional Programming (ICFP), pages 66--77, September 2005. [ bib | .pdf ] |
[273] | Haogang Chen, Daniel Ziegler, Tej Chajed, Adam Chlipala, M. Frans Kaashoek, and Nickolai Zeldovich. Using Crash Hoare logic for certifying the FSCQ file system. pages 18--37, October 2015. [ bib | .pdf ] |
[274] | Juan Chen and David Tarditi. A simple typed intermediate language for object-oriented languages. In Principles of Programming Languages (POPL), pages 38--49, January 2005. [ bib | .pdf ] |
[275] | Ran Chen, Cyril Cohen, Jean-Jacques Lévy, Stephan Merz, and Laurent Théry. Formal proofs of Tarjan's algorithm in Why3, Coq, and Isabelle. Manuscript, October 2018. [ bib | .pdf ] |
[276] | Ran Chen and Jean-Jacques Lévy. A semi-automatic proof of strong connectivity. In Verified Software: Theories, Tools and Experiments, volume 10712 of Lecture Notes in Computer Science, pages 49--65. Springer, July 2017. [ bib | .pdf ] |
[277] | James Cheney. Scrap your nameplate. In International Conference on Functional Programming (ICFP), pages 180--191, September 2005. [ bib | .pdf ] |
[278] | James Cheney and Ralf Hinze. A lightweight implementation of generics and dynamics. In Haskell workshop, 2002. [ bib | .pdf ] |
[279] | James Cheney and Ralf Hinze. First-class phantom types. Technical Report 1901, Cornell University, 2003. [ bib | http ] |
[280] | James Cheney and Christian Urban. αProlog: A logic programming language with names, binding and α-equivalence. In International Conference on Logic Programming (ICLP), volume 3132 of Lecture Notes in Computer Science, pages 269--283. Springer, September 2004. [ bib | .pdf ] |
[281] | Perry Cheng and Guy E. Blelloch. A parallel, real-time garbage collector. In Programming Language Design and Implementation (PLDI), pages 125--136, June 2001. [ bib | .pdf ] |
[282] | Wei-Ngan Chin and Siau-Cheng Khoo. Calculating sized types. Higher-Order and Symbolic Computation, 14(2--3):261--300, September 2001. [ bib | http ] |
[283] | Olaf Chitil. Compositional explanation of types and algorithmic debugging of type errors. In International Conference on Functional Programming (ICFP), pages 193--204, September 2001. [ bib | .ps.gz ] |
[284] | Adam Chlipala. A certified type-preserving compiler from lambda calculus to assembly language. In Programming Language Design and Implementation (PLDI), pages 54--65, June 2007. [ bib | .pdf ] |
[285] | Adam Chlipala. Parametric higher-order abstract syntax for mechanized semantics. In International Conference on Functional Programming (ICFP), pages 143--156, September 2008. [ bib | .pdf ] |
[286] | Adam Chlipala. The Bedrock structured programming system: combining generative metaprogramming and Hoare logic in an extensible program verifier. In International Conference on Functional Programming (ICFP), pages 391--402, September 2013. [ bib | .pdf ] |
[287] | Adam Chlipala. Certified programming and dependent types. MIT Press, November 2013. [ bib | http ] |
[288] | Adam Chlipala. From network interface to multithreaded web applications: A case study in modular program verification. In Principles of Programming Languages (POPL), pages 609--622, January 2015. [ bib | .pdf ] |
[289] | Adam Chlipala, Gregory Malecha, Greg Morrisett, Avraham Shinnar, and Ryan Wisnesky. Effective interactive proofs for higher-order imperative programs. In International Conference on Functional Programming (ICFP), pages 79--90, September 2009. [ bib | .pdf ] |
[290] | Venkatesh Choppella. Unification source-tracking with application to diagnosis of type inference. PhD thesis, Indiana University, August 2002. [ bib | http ] |
[291] | Jacek Chrzaszcz. Polymorphic subtyping without distributivity. In International Symposium on Mathematical Foundations of Computer Science, volume 1450 of Lecture Notes in Computer Science, pages 346--355. Springer, August 1998. [ bib | .ps.gz ] |
[292] | Dave Clarke and Sophia Drossopoulou. Ownership, encapsulation and the disjointness of type and effect. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 292--310, November 2002. [ bib | .ps ] |
[293] | Dave Clarke, Sophia Drossopoulou, and James Noble. Aliasing, confinement, and ownership in object-oriented programming. In Object-Oriented Technology. ECOOP 2003 Workshop Reader, volume 3013 of Lecture Notes in Computer Science, pages 197--207. Springer, 2004. [ bib | http ] |
[294] | Dave Clarke, Johan Östlund, Ilya Sergey, and Tobias Wrigstad. Ownership types: A survey. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 15--58. Springer, 2013. [ bib | http ] |
[295] | Dave Clarke and Tobias Wrigstad. External uniqueness is unique enough. In European Conference on Object-Oriented Programming (ECOOP), volume 2743 of Lecture Notes in Computer Science, pages 176--200. Springer, July 2003. [ bib | .pdf ] |
[296] | David G. Clarke, James Noble, and John Potter. Simple ownership types for object containment. In European Conference on Object-Oriented Programming (ECOOP), volume 2072 of Lecture Notes in Computer Science, pages 53--76. Springer, June 2001. [ bib | .pdf ] |
[297] | David G. Clarke, John M. Potter, and James Noble. Ownership types for flexible alias protection. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 48--64, October 1998. [ bib | http ] |
[298] | Edmund Clarke. Programming language constructs for which it is impossible to obtain good Hoare axiom systems. Journal of the ACM, 26(1):129--147, January 1979. [ bib | http ] |
[299] | Rance Cleaveland and Bernhard Steffen. A linear-time model-checking algorithm for the alternation-free modal mu-calculus. In Computer Aided Verification (CAV), volume 575 of Lecture Notes in Computer Science, pages 48--58. Springer, 1991. [ bib | http ] |
[300] | Dominique Clément, Joëlle Despeyroux, Thierry Despeyroux, and Gilles Kahn. A simple applicative language: Mini-ML. In ACM Symposium on Lisp and Functional Programming (LFP), pages 13--27, 1986. [ bib ] |
[301] | John Clements and Matthias Felleisen. A tail-recursive semantics for stack inspections. In European Symposium on Programming (ESOP), volume 2618 of Lecture Notes in Computer Science, pages 22--37. Springer, April 2003. [ bib | .ps.gz ] |
[302] | Martin Clochard, Jean-Christophe Filliâtre, and Andrei Paskevich. How to avoid proving the absence of integer overflows. In Verified Software: Theories, Tools and Experiments, volume 9593 of Lecture Notes in Computer Science, pages 94--109. Springer, July 2015. [ bib | http ] |
[303] | Martin Clochard, Claude Marché, and Andrei Paskevich. Verified programs with binders. In Programming Languages Meets Program Verification (PLPV), pages 29--40, January 2014. [ bib | http ] |
[304] | Michael J. Coblenz, Joshua Sunshine, Jonathan Aldrich, Brad A. Myers, Sam Weber, and Forrest Shull. Exploring language support for immutability. In International Conference on Software Engineering (ICSE), pages 736--747, May 2016. [ bib | .pdf ] |
[305] | Albert Cohen, Sébastien Donadio, Maria-Jesus Garzaran, Christoph Herrmann, Oleg Kiselyov, and David Padua. In search of a program generator to implement generic transformations for high-performance computing. Science of Computer Programming, 62(1):25--46, September 2006. [ bib | .ps.gz ] |
[306] | Ernie Cohen, Markus Dahlweid, Mark A. Hillebrand, Dirk Leinenbach, Michal Moskal, Thomas Santen, Wolfram Schulte, and Stephan Tobies. VCC: A practical system for verifying concurrent C. In Theorem Proving in Higher Order Logics (TPHOLs), volume 5674 of Lecture Notes in Computer Science, pages 23--42. Springer, 2009. [ bib | http ] |
[307] | Dario Colazzo and Giorgio Ghelli. Subtyping recursive types in Kernel Fun. In Logic in Computer Science (LICS), pages 137--146, July 1999. [ bib ] |
[308] | Gregory D. Collins and Zhong Shao. Intensional analysis of higher-kinded recursive types. Technical Report YALEU/DCS/TR-1240, Yale University, 2002. [ bib | .pdf ] |
[309] | Alain Colmerauer. Equations and inequations on finite and infinite trees. In International Conference on Fifth Generation Computer Systems (FGCS), pages 85--99, November 1984. [ bib ] |
[310] | Hubert Comon. Constraints in term algebras (short survey). In International Conference on Algebraic Methodology and Software Technology (AMAST), Workshops in Computing. Springer, 1993. [ bib | .ps ] |
[311] | Hubert Comon and Pierre Lescanne. Equational problems and disunification. Journal of Symbolic Computation, 7:371--425, 1989. [ bib | .pdf ] |
[312] | Sylvain Conchon and Evelyne Contejean. The Alt-Ergo automatic theorem prover, 2011. http://alt-ergo.lri.fr/. [ bib | http ] |
[313] | Sylvain Conchon and Fabrice Le Fessant. Jocaml: Mobile agents for Objective-Caml. In International Symposium on Agent Systems and Applications and International Symposium on Mobile Agents (ASA/MA), pages 22--29, October 1999. [ bib | .ps.gz ] |
[314] | Sylvain Conchon and Jean-Christophe Filliâtre. A persistent union-find data structure. In ACM Workshop on ML, pages 37--46, October 2007. [ bib | http ] |
[315] | Sylvain Conchon, Johannes Kanig, and Stéphane Lescuyer. Sat-Micro: petit mais costaud! In Journées Françaises des Langages Applicatifs (JFLA), January 2008. [ bib | .ps ] |
[316] | Sylvain Conchon and François Pottier. JOIN(X): Constraint-based type inference for the join-calculus. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 221--236. Springer, April 2001. [ bib | .ps.gz ] |
[317] | Jeffrey Considine. Efficient hash-consing of recursive types. Technical Report 2000-006, Boston University, January 2000. [ bib | .pdf ] |
[318] | Byron Cook, Christoph Haase, Joël Ouaknine, Matthew J. Parkinson, and James Worrell. Tractable reasoning in a fragment of separation logic. In International Conference on Concurrency Theory (CONCUR), volume 6901 of Lecture Notes in Computer Science, pages 235--249. Springer, September 2011. [ bib | .pdf ] |
[319] | Stephen A. Cook. The complexity of theorem-proving procedures. In ACM Symposium on Theory of Computing, pages 151--158, May 1971. [ bib | http ] |
[320] | William R. Cook. On understanding data abstraction, revisited. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 557--572, October 2009. [ bib | .pdf ] |
[321] | Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy. Iterative data-flow analysis, revisited. Technical Report TR04-432, Rice University, March 2004. [ bib | .pdf ] |
[322] | Mario Coppo and Mariangiola Dezani-Ciancaglini. An extension of the basic functionality theory for the λ-calculus. Notre Dame J. Formal Logic, 21(4):685--693, 1980. [ bib ] |
[323] | Thierry Coquand. An analysis of Girard's paradox. In Logic in Computer Science (LICS), pages 227--236, June 1986. [ bib | .pdf ] |
[324] | Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to algorithms (third edition). MIT Press, 2009. [ bib | http ] |
[325] | Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Algorithmique (troisième Édition). Sciences Sup. Dunod, 2010. Traduction française. [ bib | http ] |
[326] | Bruno Courcelle. Fundamental properties of infinite trees. Theoretical Computer Science, 25(2):95--169, March 1983. [ bib ] |
[327] | Patrick Cousot. Methods and logics for proving programs. In Formal Models and Semantics, volume B of Handbook of Theoretical Computer Science, chapter 15, pages 841--993. Elsevier Science, 1990. [ bib | .pdf.gz ] |
[328] | Patrick Cousot and Radhia Cousot. Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Principles of Programming Languages (POPL), pages 238--252, January 1977. [ bib | .pdf ] |
[329] | Patrick Cousot and Radhia Cousot. Constructive versions of Tarski's fixed point theorems. Pacific Journal of Mathematics, 81(1):43--57, 1979. [ bib | .pdf ] |
[330] | Patrick Cousot and Radhia Cousot. Formal language, grammar and set-constraint-based program analysis by abstract interpretation. In Functional Programming Languages and Computer Architecture (FPCA), pages 170--181. ACM Press, 1995. [ bib ] |
[331] | Patrick Cousot and Radhia Cousot. A gentle introduction to formal verification of computer systems by abstract interpretation. In J. Esparza, O. Grumberg, and M. Broy, editors, Logics and Languages for Reliability and Security, NATO Science Series III: Computer and Systems Sciences, pages 1--29. IOS Press, 2010. [ bib | http ] |
[332] | Patrick Cousot, Radhia Cousot, Jérôme Feret, Antoine Miné, and Xavier Rival. The Astrée static analyzer, 2011. http://www.astree.ens.fr/. [ bib | http ] |
[333] | Duncan Coutts, Roman Leshchinskiy, and Don Stewart. Stream fusion: from lists to streams to nothing at all. In International Conference on Functional Programming (ICFP), pages 315--326, October 2007. [ bib | http ] |
[334] | Erik Crank and Matthias Felleisen. Parameter-passing and the lambda calculus. In Principles of Programming Languages (POPL), pages 233--244, January 1991. [ bib | .ps.gz ] |
[335] | Karl Crary. Type-theoretic methodology for practical programming languages. PhD thesis, Cornell University, August 1998. [ bib | .ps.gz ] |
[336] | Karl Crary. Simple, efficient object encoding using intersection types. Technical Report CMU-CS-99-100, Carnegie Mellon University, 1999. [ bib | .ps.gz ] |
[337] | Karl Crary. A simple proof of call-by-value standardization. Technical Report CMU-CS-09-137, Carnegie Mellon University, 2009. [ bib | .pdf ] |
[338] | Karl Crary, David Walker, and Greg Morrisett. Typed memory management in a calculus of capabilities. In Principles of Programming Languages (POPL), pages 262--275, January 1999. [ bib | .pdf ] |
[339] | Karl Crary and Stephanie Weirich. Flexible type analysis. In International Conference on Functional Programming (ICFP), pages 233--248, 1999. [ bib | .ps.gz ] |
[340] | Karl Crary and Stephanie Weirich. Resource bound certification. In Principles of Programming Languages (POPL), pages 184--198, January 2000. [ bib | .pdf ] |
[341] | Karl Crary, Stephanie Weirich, and Greg Morrisett. Intensional polymorphism in type-erasure semantics. In International Conference on Functional Programming (ICFP), pages 301--313, September 1998. [ bib | .ps ] |
[342] | Karl Crary, Stephanie Weirich, and Greg Morrisett. Intensional polymorphism in type erasure semantics. Journal of Functional Programming, 12(6):567--600, November 2002. [ bib | .ps ] |
[343] | Julien Cretin. Erasable coercions: a unified approach to type systems. PhD thesis, Université Paris Diderot, January 2014. [ bib | http ] |
[344] | Julien Cretin and Didier Rémy. On the power of coercion abstraction. In Principles of Programming Languages (POPL), pages 361--372, January 2012. [ bib | .pdf ] |
[345] | Pavel Curtis. Constrained quantification in polymorphic type analysis. PhD thesis, Cornell University, February 1990. [ bib | .ps.gz ] |
[346] | Luis Damas. Type assignment in programming languages. PhD thesis, University of Edinburgh, 1985. [ bib ] |
[347] | Luis Damas and Robin Milner. Principal type-schemes for functional programs. In Principles of Programming Languages (POPL), pages 207--212, 1982. [ bib | http ] |
[348] | Werner Damm and Bernhard Josko. A sound and relatively^{*} complete axiomatization of Clarke's language L4. In Logic of Programs, volume 164 of Lecture Notes in Computer Science, pages 161--175. Springer, 1983. [ bib | http ] |
[349] | Nils Anders Danielsson. Lightweight semiformal time complexity analysis for purely functional data structures. In Principles of Programming Languages (POPL), January 2008. [ bib | .pdf ] |
[350] | Nils Anders Danielsson and Thorsten Altenkirch. Subtyping, declaratively. In Mathematics of Program Construction (MPC), volume 6120 of Lecture Notes in Computer Science, pages 100--118. Springer, June 2010. [ bib | .pdf ] |
[351] | Nils Anders Danielsson, John Hughes, Patrik Jansson, and Jeremy Gibbons. Fast and loose reasoning is morally correct. In Principles of Programming Languages (POPL), pages 206--217, January 2006. [ bib | .pdf ] |
[352] | Norman Danner, Jennifer Paykin, and James S. Royer. A static cost analysis for a higher-order language. In Programming Languages Meets Program Verification (PLPV), pages 25--34, January 2013. [ bib | .pdf ] |
[353] | Olivier Danvy. Functional unparsing. Technical Report RS-98-12, BRICS, May 1998. [ bib | http ] |
[354] | Olivier Danvy. Functional unparsing. Journal of Functional Programming, 8(6):621--625, November 1998. [ bib | http ] |
[355] | Olivier Danvy and Andrzej Filinski. Representing control: A study of the CPS transformation. Mathematical Structures in Computer Science, 2(4):361--391, 1992. [ bib | http ] |
[356] | Olivier Danvy and Lasse R. Nielsen. Defunctionalization at work. Technical Report RS-01-23, BRICS, June 2001. [ bib | http ] |
[357] | Olivier Danvy and Lasse R. Nielsen. Defunctionalization at work. In Principles and Practice of Declarative Programming (PPDP), pages 162--174, September 2001. [ bib | http ] |
[358] | Olivier Danvy and Lasse R. Nielsen. A first-order one-pass CPS transformation. Theoretical Computer Science, 308(1--3):239--257, 2003. [ bib | http ] |
[359] | Olivier Danvy and Lasse R. Nielsen. CPS transformation of beta-redexes. Technical Report RS-04-39, BRICS, December 2004. [ bib | .pdf ] |
[360] | Thi Bich Hanh Dao. Résolution de contraintes du premier ordre dans la théorie des arbres finis ou infinis. PhD thesis, Université de la Méditerranée, December 2000. [ bib | .ps.gz ] |
[361] | Zaynah Dargaye and Xavier Leroy. Mechanized verification of CPS transformations. In Logic for Programming Artificial Intelligence and Reasoning (LPAR), volume 4790 of Lecture Notes in Artificial Intelligence, pages 211--225. Springer, 2007. [ bib | .pdf ] |
[362] | Rowan Davies. Practical refinement-type checking. Technical Report CMU-CS-05-110, School of Computer Science, Carnegie Mellon University, May 2005. [ bib | .pdf ] |
[363] | Rowan Davies and Frank Pfenning. Intersection types and computational effects. In International Conference on Functional Programming (ICFP), pages 198--208, September 2000. [ bib | .pdf ] |
[364] | Martin Davis, George Logemann, and Donald Loveland. A machine program for theorem-proving. Communications of the ACM, 5(7):394--397, 1962. [ bib | http ] |
[365] | Martin Davis and Hilary Putnam. A computing procedure for quantification theory. Journal of the ACM, 7(3):201--215, 1960. [ bib | http ] |
[366] | Nicolaas G. de Bruijn. Lambda-calculus notation with nameless dummies: a tool for automatic formula manipulation with application to the Church-Rosser theorem. Indag. Math., 34(5):381--392, 1972. [ bib ] |
[367] | Edsko de Vries, Rinus Plasmeijer, and David Abrahamson. Uniqueness typing redefined. In Implementation of Functional Languages (IFL), volume 4449 of Lecture Notes in Computer Science, pages 181--198. Springer, 2006. [ bib | .pdf ] |
[368] | Edsko de Vries, Rinus Plasmeijer, and David Abrahamson. Equality based uniqueness typing. In Trends in Functional Programming (TFP), 2007. [ bib | .pdf ] |
[369] | M. Debbabi, E. Giasson, B. Ktari, F. Michaud, and N. Tawbi. Secure self-certified COTS. In IEEE International Workshop on Enterprise Security (WETICE'00), June 2000. [ bib | .pdf ] |
[370] | Benjamin Delaware, Bruno C. d. S. Oliveira, and Tom Schrijvers. Meta-theory à la carte. In Principles of Programming Languages (POPL), pages 207--218, January 2013. [ bib | .pdf ] |
[371] | Benjamin Delaware, Steven Keuchel, Tom Schrijvers, and Bruno C. d. S. Oliveira. Modular monadic meta-theory. In International Conference on Functional Programming (ICFP), pages 319--330, September 2013. [ bib | .pdf ] |
[372] | Germán Andrés Delbianco and Aleksandar Nanevski. Hoare-style reasoning with (algebraic) continuations. In International Conference on Functional Programming (ICFP), pages 363--376, September 2013. [ bib | .pdf ] |
[373] | Robert DeLine and Manuel Fähndrich. Enforcing high-level protocols in low-level software. In Programming Language Design and Implementation (PLDI), pages 59--69, June 2001. [ bib | http ] |
[374] | Robert DeLine and Manuel Fähndrich. The Fugue protocol checker: Is your software baroque? Technical Report MSR-TR-2004-07, Microsoft Research, January 2004. [ bib | http ] |
[375] | Robert DeLine and Manuel Fähndrich. Typestates for objects. In European Conference on Object-Oriented Programming (ECOOP), volume 3086 of Lecture Notes in Computer Science, pages 465--490. Springer, June 2004. [ bib | http ] |
[376] | Alan Demers, Susan Horwitz, and Tim Teitelbaum. An efficient general algorithm for dataflow analysis. Acta Informatica, 24(6):679--694, November 1987. [ bib | http ] |
[377] | Peter Dencker, Karl Dürre, and Johannes Heuft. Optimization of parser tables for portable compilers. ACM Transactions on Programming Languages and Systems, 6(4):546--572, 1984. [ bib | http ] |
[378] | Dorothy E. Denning. Cryptography and data security. Addison-Wesley, 1982. [ bib ] |
[379] | Dorothy E. Denning and Peter J. Denning. Certification of programs for secure information flow. Communications of the ACM, 20(7):504--513, July 1977. [ bib ] |
[380] | Greg Dennis, Felix Change, and Daniel Jackson. Modular verification of code with SAT. In International Symposium on Software Testing and Analysis (ISSTA), July 2006. [ bib | .pdf ] |
[381] | Joel E. Denny and Brian A. Malloy. The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution. Science of Computer Programming, 75(11):943--979, 2010. [ bib | http ] |
[382] | Frank DeRemer and Thomas Pennello. Efficient computation of LALR(1) look-ahead sets. ACM Transactions on Programming Languages and Systems, 4(4):615--649, 1982. [ bib | http ] |
[383] | Franklin L. DeRemer. Simple LR(k) grammars. Communications of the ACM, 14(7):453--460, 1971. [ bib | http ] |
[384] | Franklin Lewis DeRemer. Practical translators for LR(k) languages. Technical Report MIT-LCS-TR-065, Massachusetts Institute of Technology, 1969. [ bib | .pdf ] |
[385] | David Detlefs, Greg Nelson, and James B. Saxe. Simplify: a theorem prover for program checking. Journal of the ACM, 52(3):365--473, 2005. [ bib | http ] |
[386] | David L. Detlefs, K. Rustan M. Leino, and Greg Nelson. Wrestling with rep exposure. Research Report 156, SRC, July 1998. [ bib | .pdf ] |
[387] | David L. Detlefs, K. Rustan M. Leino, Greg Nelson, and James B. Saxe. Extended static checking. Research Report 159, Compaq SRC, December 1998. [ bib | .pdf ] |
[388] | Roberto Di Cosmo. Deciding type isomorphisms in a type assignment framework. Journal of Functional Programming, 3(3):485--525, 1993. [ bib | .dvi ] |
[389] | Roberto Di Cosmo. Isomorphisms of types: from λ-calculus to information retrieval and language design. Progress in Theoretical Computer Science. Birkhauser, 1995. [ bib | .html ] |
[390] | Werner Dietl, Sophia Drossopoulou, and Peter Müller. Separating ownership topology and encapsulation with generic universe types. ACM Transactions on Programming Languages and Systems, 33(6):20, 2011. [ bib | .pdf ] |
[391] | Werner Dietl and Peter Müller. Universes: Lightweight ownership for JML. Journal of Object Technology, 4(8):5--32, 2005. [ bib | .pdf ] |
[392] | E. W. Dijkstra. A note on two problems in connection with graphs. Numerische Mathematik, 1:269--271, 1959. [ bib ] |
[393] | Edsger W. Dijkstra. Guarded commands, nondeterminacy and formal derivation of programs. Communications of the ACM, 18(8):453--457, 1975. [ bib | http ] |
[394] | Allyn Dimock. Type- and flow-directed compilation for specialized data representations. PhD thesis, Harvard University, January 2002. [ bib | .ps.gz ] |
[395] | Allyn Dimock, Ian Westmacott, Robert Muller, Franklyn Turbak, and J. B. Wells. Functioning without closure: type-safe customized function representations for Standard ML. In International Conference on Functional Programming (ICFP), September 2001. [ bib | .ps ] |
[396] | Thomas Dinsdale-Young, Lars Birkedal, Philippa Gardner, Matthew J. Parkinson, and Hongseok Yang. Views: compositional reasoning for concurrent programs. In Principles of Programming Languages (POPL), pages 287--300, January 2013. [ bib | .pdf ] |
[397] | Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew Parkinson, and Viktor Vafeiadis. Concurrent abstract predicates. Technical report, University of Cambridge, Computer Laboratory, April 2010. [ bib | .pdf ] |
[398] | Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew J. Parkinson, and Viktor Vafeiadis. Concurrent abstract predicates. In European Conference on Object-Oriented Programming (ECOOP), volume 6183 of Lecture Notes in Computer Science, pages 504--528. Springer, 2010. [ bib | .pdf ] |
[399] | Dino Distefano and Matthew J. Parkinson. jStar: towards practical verification for Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 213--226, October 2008. [ bib | .pdf ] |
[400] | Robert Dockins, Aquinas Hobor, and Andrew W. Appel. A fresh look at separation algebras and share accounting. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 161--177. Springer, December 2009. [ bib | .pdf ] |
[401] | Mike Dodds, Xinyu Feng, Matthew J. Parkinson, and Viktor Vafeiadis. Deny-guarantee reasoning. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 363--377. Springer, March 2009. [ bib | .pdf ] |
[402] | Mike Dodds, Suresh Jagannathan, and Matthew J. Parkinson. Modular reasoning for deterministic parallelism. In Principles of Programming Languages (POPL), pages 259--270, January 2011. [ bib | .pdf ] |
[403] | Mike Dodds, Suresh Jagannathan, Matthew J. Parkinson, Kasper Svendsen, and Lars Birkedal. Verifying custom synchronization constructs using higher-order separation logic. ACM Transactions on Programming Languages and Systems, 28(2), January 2016. [ bib | http ] |
[404] | Stephen Dolan, K. C. Sivaramakrishnan, and Anil Madhavapeddy. Bounding data races in space and time. In Programming Language Design and Implementation (PLDI), pages 242--255, June 2018. [ bib | .pdf ] |
[405] | Charles Donnelly and Richard Stallman. Bison, January 2015. [ bib | http ] |
[406] | Kevin Donnelly and Hongwei Xi. Combining higher-order abstract syntax with first-order abstract syntax in ATS. In ACM Workshop on Mechanized Reasoning about Languages with Variable Binding, pages 58--63, 2005. [ bib | .pdf ] |
[407] | Vincent Dornic, Pierre Jouvelot, and David K. Gifford. Polymorphic time systems for estimating program complexity. ACM Letters on Programming Languages and Systems, 1(1):33--45, 1992. [ bib | .pdf ] |
[408] | Gilles Dowek. Higher-order unification and matching. In J. Alan Robinson and Andrei Voronkov, editors, Handbook of Automated Reasoning, pages 1009--1062. Elsevier Science, 2001. [ bib | .ps ] |
[409] | Gilles Dowek, Thérèse Hardin, and Claude Kirchner. Higher order unification via explicit substitutions. Research Report 2709, INRIA, November 1995. [ bib | .html ] |
[410] | Gilles Dowek, Thérèse Hardin, Claude Kirchner, and Frank Pfenning. Unification via explicit substitutions: the case of higher-order patterns. Research Report 3591, INRIA, December 1998. [ bib | .html ] |
[411] | William F. Dowling and Jean H. Gallier. Linear-time algorithms for testing the satisfiability of propositional Horn formulae. Journal of Logic Programming, 1(3):267--284, 1984. [ bib ] |
[412] | Peter J. Downey, Ravi Sethi, and Robert Endre Tarjan. Variations on the common subexpression problem. Journal of the ACM, 27(4):758--771, October 1980. [ bib | http ] |
[413] | Derek Dreyer, Georg Neis, and Lars Birkedal. The impact of higher-order state and control effects on local relational reasoning. In International Conference on Functional Programming (ICFP), pages 143--156, September 2010. [ bib | .pdf ] |
[414] | Catherine Dubois and Valérie Ménissier-Morain. Typage de ML: Spécification et preuve en Coq. In Actes du GDR Programmation, November 1997. [ bib | .ps.gz ] |
[415] | Catherine Dubois and Valérie Ménissier-Morain. Certification of a type inference tool for ML: Damas-Milner within Coq. Journal of Automated Reasoning, 23(3--4):319--346, November 1999. [ bib | .pdf ] |
[416] | Dominic Duggan and Frederick Bent. Explaining type inference. Science of Computer Programming, 27(1), June 1996. [ bib ] |
[417] | Dirk Dussart, Fritz Henglein, and Christian Mossin. Polymorphic recursion and subtype qualifications: Polymorphic binding-time analysis in polynomial time. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science, pages 118--135. Springer, September 1995. [ bib | .dvi.gz ] |
[418] | Kent Dybvig, Robert Hieb, and Carl Bruggeman. Syntactic abstraction in Scheme. Lisp and Symbolic Computation, 5(4):295--326, 1993. [ bib | .pdf ] |
[419] | Manuel Eberl. Proving divide and conquer complexities in Isabelle/HOL. Journal of Automated Reasoning, 58(4):483--508, 2017. [ bib | .pdf ] |
[420] | Jonathan Eifrig, Scott Smith, and Valery Trifonov. Sound polymorphic type inference for objects. ACM SIGPLAN Notices, 30(10):169--184, 1995. [ bib | .ps.gz ] |
[421] | Jonathan Eifrig, Scott Smith, and Valery Trifonov. Type inference for recursively constrained types and its application to OOP. In Mathematical Foundations of Programming Semantics, volume 1 of Electronic Notes in Theoretical Computer Science. Elsevier Science, 1995. [ bib | .ps.gz ] |
[422] | E. Allen Emerson and Chin-Laung Lei. Efficient model checking in fragments of the propositional mu-calculus. In Logic in Computer Science (LICS), pages 267--278, June 1986. [ bib ] |
[423] | Martin Emms and Hans Leiß. Extending the type checker for SML by polymorphic recursion --- A correctness proof. Technical Report 96-101, Centrum für Informations- und Sprachverarbeitung, Universität München, 1996. [ bib | .ps.gz ] |
[424] | Úlfar Erlingsson and Fred B. Schneider. SASI enforcement of security policies: a retrospective. In New Security Paradigms Workshop, pages 87--95, September 1999. [ bib | .ps ] |
[425] | Úlfar Erlingsson and Fred B. Schneider. IRM enforcement of Java stack inspection. In IEEE Symposium on Security and Privacy (S&P), pages 246--255, May 2000. [ bib | http ] |
[426] | Javier Esparza, David Hansel, Peter Rossmanith, and Stefan Schwoon. Efficient algorithms for model checking pushdown systems. In Computer Aided Verification (CAV), volume 1855 of Lecture Notes in Computer Science, pages 232--247. Springer, July 2000. [ bib | .pdf ] |
[427] | Javier Esparza, Peter Lammich, René Neumann, Tobias Nipkow, Alexander Schimpf, and Jan-Georg Smaus. A fully verified executable LTL model checker. In Computer Aided Verification (CAV), volume 8044 of Lecture Notes in Computer Science, pages 463--478. Springer, July 2013. [ bib | .pdf ] |
[428] | Sylvain Conchon et Jean-Christophe Filliâtre. Apprendre à programmer avec OCaml: Algorithmes et structures de données. Eyrolles, 2014. [ bib | http ] |
[429] | Karl-Filip Faxén. A static semantics for Haskell. Journal of Functional Programming, 12(4--5):295--357, July 2002. [ bib | .ps.gz ] |
[430] | Christian Fecht and Helmut Seidl. A faster solver for general systems of equations. Science of Computer Programming, 35(2--3):137--162, 1999. [ bib | .ps.gz ] |
[431] | J. S. Fenton. Information protection systems. PhD thesis, University of Cambridge, 1973. [ bib ] |
[432] | J. S. Fenton. Memoryless subsystems. Computer Journal, 17(2):143--147, May 1974. [ bib ] |
[433] | Francisco Ferreira and Brigitte Pientka. Programs using syntax with first-class binders. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 504--529. Springer, April 2017. [ bib | .pdf ] |
[434] | John Field and Tim Teitelbaum. Incremental reduction in the lambda calculus. In ACM Symposium on Lisp and Functional Programming (LFP), pages 307--322, 1990. [ bib ] |
[435] | Andrzej Filinski. Representing layered monads. In Principles of Programming Languages (POPL), pages 175--188, January 1999. [ bib | .ps.gz ] |
[436] | Jean-Christophe Filliâtre. Backtracking iterators. In ACM Workshop on ML, pages 55--62, September 2006. [ bib | .ps.gz ] |
[437] | Jean-Christophe Filliâtre and Sylvain Conchon. Type-safe modular hash-consing. In ACM Workshop on ML, pages 12--19, September 2006. [ bib | .pdf ] |
[438] | Jean-Christophe Filliâtre, Léon Gondelman, and Andrei Paskevich. The spirit of ghost code. In Computer Aided Verification (CAV), volume 8559 of Lecture Notes in Computer Science, pages 1--16. Springer, July 2014. [ bib | .pdf ] |
[439] | Jean-Christophe Filliâtre and Andrei Paskevich. Why3---where programs meet provers. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 125--128. Springer, March 2013. [ bib | http ] |
[440] | Jean-Christophe Filliâtre and Mário Pereira. A modular way to reason about iteration. In NASA Formal Methods (NFM), volume 9690 of Lecture Notes in Computer Science, pages 322--336. Springer, June 2016. [ bib | http ] |
[441] | Jean-Christophe Filliâtre. Verification of non-functional programs using interpretations in type theory. Journal of Functional Programming, 13(4):709--745, July 2003. [ bib | .ps.gz ] |
[442] | Jean-Christophe Filliâtre. Why: a multi-language multi-prover verification tool. Research Report 1366, LRI, Université Paris Sud, March 2003. [ bib | .ps.gz ] |
[443] | Jean-Christophe Filliâtre. Formal proof of a program: Find. Science of Computer Programming, 64:332--240, 2006. [ bib | .ps.gz ] |
[444] | Jean-Christophe Filliâtre and Pierre Letouzey. Functors for proofs and programs. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 370--384. Springer, March 2004. [ bib | http ] |
[445] | Jean-Christophe Filliâtre and Claude Marché. Multi-prover verification of C programs. In International Conference on Formal Engineering Methods (ICFEM), volume 3308 of Lecture Notes in Computer Science, pages 15--29. Springer, November 2004. [ bib | .ps.gz ] |
[446] | Jean-Christophe Filliâtre and Claude Marché. The Why/Krakatoa/Caduceus platform for deductive program verification. In Computer Aided Verification (CAV), volume 4590 of Lecture Notes in Computer Science, pages 173--177. Springer, July 2007. [ bib | .pdf ] |
[447] | Robert Bruce Findler and Matthias Felleisen. Contracts for higher-order functions. In International Conference on Functional Programming (ICFP), pages 48--59, October 2002. [ bib | .pdf ] |
[448] | Adam Fischbach and John Hannan. Specification and correctness of lambda lifting. Journal of Functional Programming, 13(3):509--543, May 2003. [ bib | http ] |
[449] | Michael J. Fischer. Lambda calculus schemata. In Proceedings of the ACM Conference on Proving Assertions About Programs, pages 104--109, 1972. [ bib | http ] |
[450] | Michael J. Fischer. Lambda-calculus schemata. Lisp and Symbolic Computation, 6(3--4):259--288, 1993. [ bib | http ] |
[451] | Kathleen Fisher and John C. Mitchell. On the relationship between classes, objects and data abstraction. Theory and Practice of Object Systems, 4(1):3--25, 1998. [ bib | .ps ] |
[452] | Cormac Flanagan. Effective static debugging via componential set-based analysis. PhD thesis, Rice University, May 1997. [ bib | .ps.gz ] |
[453] | Cormac Flanagan and Martín Abadi. Types for safe locking. In European Symposium on Programming (ESOP), volume 1576 of Lecture Notes in Computer Science, pages 91--108. Springer, March 1999. [ bib | .pdf ] |
[454] | Cormac Flanagan and Matthias Felleisen. Modular and polymorphic set-based analysis: Theory and practice. Technical Report TR96-266, Rice University, November 1996. [ bib | .ps.gz ] |
[455] | Cormac Flanagan and Matthias Felleisen. Componential set-based analysis. In Programming Language Design and Implementation (PLDI), pages 235--248, 1997. [ bib | .ps.gz ] |
[456] | Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Stephanie Weirich, and Matthias Felleisen. Catching bugs in the web of program invariants. In Programming Language Design and Implementation (PLDI), 1996. [ bib | .ps.gz ] |
[457] | Cormac Flanagan, K. Rustan M. Leino, Mark Lillibridge, Greg Nelson, James B. Saxe, and Raymie Stata. Extended static checking for Java. In Programming Language Design and Implementation (PLDI), pages 234--245, 2002. [ bib | .ps ] |
[458] | Cormac Flanagan, Amr Sabry, Bruce F. Duba, and Matthias Felleisen. The essence of compiling with continuations. In Programming Language Design and Implementation (PLDI), pages 237--247, 1993. [ bib | .pdf ] |
[459] | Cormac Flanagan and James B. Saxe. Avoiding exponential explosion: generating compact verification conditions. In Principles of Programming Languages (POPL), pages 193--205, 2001. [ bib | .ps ] |
[460] | R. W. Floyd. Assigning meanings to programs. In Mathematical Aspects of Computer Science, volume 19 of Proceedings of Symposia in Applied Mathematics, pages 19--32. American Mathematical Society, 1967. [ bib | .pdf ] |
[461] | Matthew Fluet. Monadic and substructural type systems for region-based memory management. PhD thesis, Cornell University, January 2007. [ bib | .pdf ] |
[462] | Matthew Fluet and Greg Morrisett. Monadic regions. Journal of Functional Programming, 16(4--5):485--545, 2006. [ bib | http ] |
[463] | Matthew Fluet, Greg Morrisett, and Amal Ahmed. Linear regions are all you need. In European Symposium on Programming (ESOP), volume 3924 of Lecture Notes in Computer Science, pages 7--21. Springer, March 2006. [ bib | .pdf ] |
[464] | Matthew Fluet and Riccardo Pucella. Phantom types and subtyping. In IFIP International Conference on Theoretical Computer Science (TCS), pages 448--460, August 2002. [ bib | http ] |
[465] | Matthew Fluet and Riccardo Pucella. Phantom types and subtyping. In IFIP International Conference on Theoretical Computer Science (TCS), volume 223 of IFIP Conference Proceedings, pages 448--460. Kluwer, August 2002. [ bib | .ps ] |
[466] | Matthew Fluet and Riccardo Pucella. Practical datatype specializations with phantom types and recursion schemes. In ACM Workshop on ML, Electronic Notes in Theoretical Computer Science, September 2005. [ bib | .pdf ] |
[467] | Riccardo Focardi and Roberto Gorrieri. A classification of security properties for process algebras. Journal of Computer Security, 3(1):5--33, 1995. [ bib | .ps.gz ] |
[468] | Bryan Ford. Packrat parsing: simple, powerful, lazy, linear time. In International Conference on Functional Programming (ICFP), pages 36--47, October 2002. [ bib | .pdf ] |
[469] | Bryan Ford. Parsing expression grammars: a recognition-based syntactic foundation. In Principles of Programming Languages (POPL), pages 111--122, January 2004. [ bib | .pdf ] |
[470] | Jeffrey S. Foster and Alex Aiken. Checking programmer-specified non-aliasing. Technical Report UCB//CSD-01-1160, University of California, Berkeley, October 2001. [ bib | .pdf ] |
[471] | Jeffrey S. Foster, Tachio Terauchi, and Alex Aiken. Flow-sensitive type qualifiers. In Programming Language Design and Implementation (PLDI), pages 1--12, June 2002. [ bib | .pdf ] |
[472] | Cédric Fournet and Georges Gonthier. The reflexive chemical abstract machine and the join-calculus. In Principles of Programming Languages (POPL), pages 372--385, January 1996. [ bib | http ] |
[473] | Cédric Fournet and Andrew D. Gordon. Stack inspection: Theory and variants. In Principles of Programming Languages (POPL), pages 307--318, January 2002. [ bib | .ps ] |
[474] | Cédric Fournet and Andrew D. Gordon. Stack inspection: Theory and variants. ACM Transactions on Programming Languages and Systems, 25(3):360--399, May 2003. [ bib | http ] |
[475] | Cédric Fournet, Cosimo Laneve, Luc Maranget, and Didier Rémy. Inheritance in the join calculus. Journal of Logic and Algebraic Programming, 57(2):23--69, 2003. [ bib | .pdf ] |
[476] | Cédric Fournet, Luc Maranget, Cosimo Laneve, and Didier Rémy. Implicit typing à la ML for the join-calculus. In International Conference on Concurrency Theory (CONCUR), volume 1243 of Lecture Notes in Computer Science, pages 196--212. Springer, 1997. [ bib | .pdf ] |
[477] | Adrian Francalanza, Julian Rathke, and Vladimiro Sassone. Permission-based separation logic for message-passing concurrency. Logical Methods in Computer Science, 7(3), 2011. [ bib | http ] |
[478] | Michael Fredman and Michael Saks. The cell probe complexity of dynamic data structures. In Annual Symposium on Theory of Computing (STOC), pages 345--354. ACM, May 1989. [ bib | http ] |
[479] | Michael L. Fredman and Robert Endre Tarjan. Fibonacci heaps and their uses in improved network optimization algorithms. Journal of the ACM, 34(3):596--615, 1987. [ bib | http ] |
[480] | Tim Freeman and Frank Pfenning. Refinement types for ML. In Programming Language Design and Implementation (PLDI), pages 268--277, 1991. [ bib | .pdf ] |
[481] | Alexandre Frey. Satisfying subtype inequalities in polynomial space. In Static Analysis Symposium (SAS), number 1302 in Lecture Notes in Computer Science, pages 265--277. Springer, September 1997. [ bib | .html ] |
[482] | Alexandre Frey. Approche algébrique du typage d'un langage à la ML avec objets, sous-typage et multi-méthodes. PhD thesis, École des Mines de Paris, June 2004. [ bib | .pdf ] |
[483] | Daniel P. Friedman and Mitchell Wand. Essentials of programming languages, 3rd edition. MIT Press, 2008. [ bib | http ] |
[484] | Matteo Frigo and Steven G. Johnson. The design and implementation of FFTW3. Proceedings of the IEEE, 93(2):216--231, 2005. [ bib | .pdf ] |
[485] | Alain Frisch, Giuseppe Castagna, and Véronique Benzaken. Semantic subtyping. In Logic in Computer Science (LICS), pages 137--146, July 2002. [ bib | .ps.gz ] |
[486] | Alain Frisch, Giuseppe Castagna, and Véronique Benzaken. Semantic subtyping: Dealing set-theoretically with function, union, intersection, and negation types. Journal of the ACM, 55(4), 2008. [ bib | .pdf ] |
[487] | You-Chin Fuh and Prateek Mishra. Type inference with subtypes. In European Symposium on Programming (ESOP), volume 300 of Lecture Notes in Computer Science, pages 94--114. Springer, 1988. [ bib | http ] |
[488] | You-Chin Fuh and Prateek Mishra. Polymorphic subtype inference: Closing the theory-practice gap. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 167--183. Springer, March 1989. [ bib | http ] |
[489] | Jun Furuse. Extensional polymorphism by flow graph dispatching. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science. Springer, November 2003. [ bib | .ps.gz ] |
[490] | Jun P. Furuse and Jacques Garrigue. A label-selective lambda-calculus with optional arguments and its compilation method. RIMS Preprint 1041, Kyoto University, October 1995. [ bib | .pdf ] |
[491] | Manuel Fähndrich. Bane: A library for scalable constraint-based program analysis. PhD thesis, University of California at Berkeley, 1999. [ bib | .pdf ] |
[492] | Manuel Fähndrich, Mark Aiken, Chris Hawblitzel, Orion Hodson, Galen Hunt, James R. Larus, and Steven Levi. Language support for fast and reliable message-based communication in Singularity OS. In EuroSys, pages 177--190, 2006. [ bib | .pdf ] |
[493] | Manuel Fähndrich and Robert DeLine. Adoption and focus: practical linear types for imperative programming. In Programming Language Design and Implementation (PLDI), pages 13--24, June 2002. [ bib | .pdf ] |
[494] | Manuel Fähndrich, Jeffrey S. Foster, Zhendong Su, and Alexander S. Aiken. Partial online cycle elimination in inclusion constraint graphs. In Programming Language Design and Implementation (PLDI), pages 85--96, June 1998. [ bib | .pdf ] |
[495] | Manuel Fähndrich and Rustan Leino. Heap monotonic typestates. In International Workshop on Alias Confinement and Ownership (IWACO), July 2003. [ bib | .pdf ] |
[496] | Manuel Fähndrich, Jakob Rehof, and Manuvir Das. Scalable context-sensitive flow analysis using instantiation constraints. In Programming Language Design and Implementation (PLDI), June 2000. [ bib | .ps ] |
[497] | Murdoch J. Gabbay. A theory of inductive definitions with α-equivalence. PhD thesis, Cambridge University, 2001. [ bib | .pdf ] |
[498] | Murdoch J. Gabbay. A general mathematics of names in syntax. Submitted for publication, March 2004. [ bib | .pdf ] |
[499] | Murdoch J. Gabbay and Andrew M. Pitts. A new approach to abstract syntax with variable binding. Formal Aspects of Computing, 13(3--5):341--363, July 2002. [ bib | .pdf ] |
[500] | Zvi Galil and Giuseppe F. Italiano. Data structures and algorithms for disjoint set union problems. ACM Computing Surveys, 23(3):319--344, 1991. [ bib | http ] |
[501] | Bernard A. Galler and Michael J. Fischer. An improved equivalence algorithm. Communications of the ACM, 7(5):301--303, 1964. [ bib | http ] |
[502] | Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. Design patterns: Elements of reusable object-oriented software. Addison-Wesley, 1995. [ bib ] |
[503] | Vladimir Gapeyev, Michael Levin, and Benjamin Pierce. Recursive subtyping revealed. Journal of Functional Programming, 12(6):511--548, November 2002. [ bib | http ] |
[504] | Philippa Gardner, Gian Ntzik, and Adam Wright. Local reasoning for the POSIX file system. In European Symposium on Programming (ESOP), volume 8410 of Lecture Notes in Computer Science, pages 169--188. Springer, April 2014. [ bib | .pdf ] |
[505] | Michael R. Garey and David S. Johnson. Computers and intractability: A guide to the theory of NP-completeness. W. H. Freeman and Company, 1979. [ bib ] |
[506] | Jacques Garrigue. Programming with polymorphic variants. In ACM Workshop on ML, September 1998. [ bib | .ps.gz ] |
[507] | Jacques Garrigue. Code reuse through polymorphic variants. In Workshop on Foundations of Software Engineering, November 2000. [ bib | .ps.gz ] |
[508] | Jacques Garrigue. Simple type inference for structural polymorphism. In Foundations of Object-Oriented Languages (FOOL), January 2002. [ bib | .ps.gz ] |
[509] | Jacques Garrigue. Relaxing the value restriction. In Functional and Logic Programming, volume 2998 of Lecture Notes in Computer Science, pages 196--213. Springer, April 2004. [ bib | .pdf ] |
[510] | Jacques Garrigue and Didier Rémy. Extending ML with semi-explicit higher-order polymorphism. Information and Computation, 155(1):134--169, 1999. [ bib | .pdf ] |
[511] | Jacques Garrigue and Didier Rémy. Ambivalent types for principal type inference with GADTs. In Asian Symposium on Programming Languages and Systems (APLAS), December 2013. [ bib | .pdf ] |
[512] | Benedict R. Gaster. Records, variants and qualified types. PhD thesis, University of Nottingham, July 1998. [ bib | .ps ] |
[513] | Benedict R. Gaster and Mark P. Jones. A polymorphic type system for extensible records and variants. Technical Report NOTTCS-TR-96-3, Department of Computer Science, University of Nottingham, November 1996. [ bib | .html ] |
[514] | Nadji Gauthier and François Pottier. Numbering matters: First-order canonical forms for second-order recursive types. In International Conference on Functional Programming (ICFP), pages 150--161, September 2004. [ bib | .pdf ] |
[515] | Simon J. Gay, Vasco Thudichum Vasconcelos, António Ravara, Nils Gesbert, and Alexandre Z. Caldeira. Modular session types for distributed object-oriented programming. In Principles of Programming Languages (POPL), pages 299--312, January 2010. [ bib | .pdf ] |
[516] | Steven German, Edmund Clarke, and Joseph Halpern. Reasoning about procedures as parameters. In Logic of Programs, volume 164 of Lecture Notes in Computer Science, pages 206--220. Springer, 1983. [ bib | http ] |
[517] | Alfons Geser, Jens Knoop, Gerald Lüttgen, Oliver Rüthing, and Bernhard Steffen. Chaotic fixed point iterations. MIP-Bericht 9403, Fakultät für Mathematik und Informatik, Universität Passau, 1994. [ bib | .html ] |
[518] | Giorgio Ghelli. Divergence of F_{<=} type checking. Theoretical Computer Science, 139(1--2):131--162, March 1995. [ bib | .ps.gz ] |
[519] | Cristian Gherghina, Cristina David, Shengchao Qin, and Wei-Ngan Chin. Structured specifications for better verification of heap-manipulating programs. In Formal Methods (FM), volume 6664 of Lecture Notes in Computer Science, pages 386--401. Springer, June 2011. [ bib | .pdf ] |
[520] | Jeremy Gibbons. Datatype-generic programming. In International Spring School on Datatype-Generic Programming, volume 4719 of Lecture Notes in Computer Science, pages 1--71. Springer, April 2006. [ bib | .pdf ] |
[521] | Jürgen Giesl, Cornelius Aschermann, Marc Brockschmidt, Fabian Emmes, Florian Frohn, Carsten Fuhs, Jera Hensel, Carsten Otto, Martin Plücker, Peter Schneider-Kamp, Thomas Ströder, Stephanie Swiderski, and René Thiemann. Analyzing program termination and complexity automatically with AProVE. Journal of Automated Reasoning, 58(1):3--31, 2017. [ bib | .pdf ] |
[522] | David K. Gifford, Pierre Jouvelot, John M. Lucassen, and Mark A. Sheldon. FX-87 reference manual. Technical Report MIT/LCS/TR-407, Massachusetts Institute of Technology, January 1987. [ bib ] |
[523] | David K. Gifford, Pierre Jouvelot, Mark A. Sheldon, and James W. O'Toole. Report on the FX-91 programming language. Technical Report MIT/LCS/TR-531, Massachusetts Institute of Technology, February 1992. [ bib | http ] |
[524] | Jean-Yves Girard. Interprétation fonctionnelle et élimination des coupures de l'arithmétique d'ordre supérieur. Thèse d'état, Université Paris 7, June 1972. [ bib ] |
[525] | Jean-Yves Girard. Linear logic. Theoretical Computer Science, 50(1):1--102, 1987. [ bib | .pdf ] |
[526] | Jean-Yves Girard, Yves Lafont, and Paul Taylor. Proofs and types. Cambridge University Press, 1990. [ bib | .pdf ] |
[527] | Neal Glew. Object closure conversion. In Higher Order Operational Techniques in Semantics (HOOTS), volume 26 of Electronic Notes in Theoretical Computer Science, pages 52--68, September 1999. [ bib | .ps.gz ] |
[528] | Neal Glew. An efficient class and object encoding. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 311--324, October 2000. [ bib | .ps.gz ] |
[529] | Neal Glew. A theory of second-order trees. In European Symposium on Programming (ESOP), volume 2305 of Lecture Notes in Computer Science, pages 147--161. Springer, April 2002. [ bib | .pdf ] |
[530] | Andreas Goerdt. A Hoare calculus for functions defined by recursion on higher types. In Logic of Programs, volume 193 of Lecture Notes in Computer Science, pages 106--117. Springer, 1985. [ bib | http ] |
[531] | Joseph Goguen and José Meseguer. Security policies and security models. In IEEE Symposium on Security and Privacy (S&P), pages 11--20, April 1982. [ bib ] |
[532] | Li Gong, Gary Ellison, and Mary Dageforde. Inside Java 2 platform security, second edition. Addison-Wesley, 2003. [ bib | http ] |
[533] | Li Gong, Marianne Mueller, Hemma Prafullchandra, and Roland Schemers. Going beyond the sandbox: An overview of the new security architecture in the Java Development Kit 1.2. In USENIX Symposium on Internet Technologies and Systems, pages 103--112, December 1997. [ bib | .ps ] |
[534] | Li Gong and Roland Schemers. Implementing protection domains in the Java development kit 1.2. In Internet Society Symposium on Network and Distributed System Security, March 1998. [ bib | .pdf ] |
[535] | Andrew D. Gordon and Tom Melham. Five axioms of alpha-conversion. In Theorem Proving in Higher Order Logics (TPHOLs), volume 1125 of Lecture Notes in Computer Science, pages 173--191. Springer, August 1996. [ bib | .ps.gz ] |
[536] | Colin S. Gordon, Matthew J. Parkinson, Jared Parsons, Aleks Bromfield, and Joe Duffy. Uniqueness and reference immutability for safe parallelism. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 21--40, October 2012. [ bib | .pdf ] |
[537] | Donald Gordon and James Noble. Dynamic ownership in a dynamic language. In Symposium on Dynamic Languages, pages 41--52, 2007. [ bib | http ] |
[538] | James Gosling, Bill Joy, Guy Steele, and Gilad Bracha. The Java language specification, second edition. Addison-Wesley, 2000. [ bib | http ] |
[539] | Alexey Gotsman, Josh Berdine, Byron Cook, Noam Rinetzky, and Mooly Sagiv. Local reasoning for storable locks and threads. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 19--37. Springer, November 2007. [ bib | http ] |
[540] | Alexey Gotsman, Josh Berdine, Byron Cook, Noam Rinetzky, and Mooly Sagiv. Local reasoning for storable locks and threads. Technical Report MSR-TR-2007-39, Microsoft Research, September 2007. [ bib | .pdf ] |
[541] | Jean Goubault. Inférence d'unités physiques en ML. In Journées Françaises des Langages Applicatifs (JFLA), pages 3--20, 1994. [ bib ] |
[542] | Ronald L. Graham, Donald E. Knuth, and Oren Patashnik. Concrete mathematics: a foundation for computer science. Addison-Wesley, 1994. [ bib | .html ] |
[543] | David Gries. Describing an algorithm by Hopcroft. Acta Informatica, 2:97--109, 1973. [ bib | http ] |
[544] | Jessica Gronski, Kenneth Knowles, Aaron Tomb, Stephen N. Freund, and Cormac Flanagan. Sage: Hybrid checking for flexible specifications. In Scheme and Functional Programming, pages 93--104, September 2006. [ bib | .pdf ] |
[545] | Josef Grosch. Efficient and comfortable error recovery in recursive descent parsers. Structured Programming, 11(3):129--140, 1990. [ bib | .pdf ] |
[546] | Dan Grossman. Quantified types in an imperative language. ACM Transactions on Programming Languages and Systems, 28(3):429--475, May 2006. [ bib | .pdf ] |
[547] | Dan Grossman, Greg Morrisett, Trevor Jim, Michael Hicks, Yanling Wang, and James Cheney. Region-based memory management in Cyclone. In Programming Language Design and Implementation (PLDI), pages 282--293, June 2002. [ bib | .pdf ] |
[548] | Dick Grune and Ceriel J. H. Jacobs. Parsing techniques: a practical guide. Ellis Horwood, 1990. [ bib | .html ] |
[549] | Dick Grune and Ceriel J. H. Jacobs. Parsing techniques: a practical guide, second edition. Monographs in computer science. Springer, 2008. [ bib | .html ] |
[550] | Louis-Julien Guillemette and Stefan Monnier. A type-preserving closure conversion in Haskell. In Haskell workshop, pages 83--92, September 2007. [ bib | .pdf ] |
[551] | Louis-Julien Guillemette and Stefan Monnier. Type-safe code transformations in Haskell. Electronic Notes in Theoretical Computer Science, 174(7):23--39, 2007. [ bib | http ] |
[552] | Louis-Julien Guillemette and Stefan Monnier. One vote for type families in Haskell! In Trends in Functional Programming (TFP), 2008. [ bib | .pdf ] |
[553] | Louis-Julien Guillemette and Stefan Monnier. A type-preserving compiler in Haskell. In International Conference on Functional Programming (ICFP), pages 75--86, September 2008. [ bib | .pdf ] |
[554] | Sumit Gulwani. SPEED: symbolic complexity bound analysis. In Computer Aided Verification (CAV), volume 5643 of Lecture Notes in Computer Science, pages 51--62. Springer, July 2009. [ bib | http ] |
[555] | Sumit Gulwani, Krishna K. Mehra, and Trishul M. Chilimbi. SPEED: precise and efficient static estimation of program computational complexity. In Principles of Programming Languages (POPL), pages 127--139, January 2009. [ bib | http ] |
[556] | Adam Gundry. Type inference, Haskell and dependent types. PhD thesis, University of Strathclyde, 2013. [ bib | .pdf ] |
[557] | Adam Gundry, Conor McBride, and James McKinna. Type inference in context. In ACM SIGPLAN Workshop on Mathematically Structured Functional Programming (MSFP), pages 43--54, September 2010. [ bib | .pdf ] |
[558] | Kartik Gupta and V. Krishna Nandivada. Lexical state analyzer for JavaCC grammars. Software: Practice and Experience, 2015. [ bib | http ] |
[559] | Jörgen Gustavsson and Josef Svenningsson. Constraint abstractions. In Symposium on Programs as Data Objects, volume 2053 of Lecture Notes in Computer Science. Springer, May 2001. [ bib | .pdf ] |
[560] | Juan Carlos Guzmán and Ascánder Suárez. An extended type system for exceptions. In ACM Workshop on ML and its Applications, number 2265 in INRIA Research Reports, pages 127--135. INRIA, June 1994. [ bib ] |
[561] | Armaël Guéneau, Arthur Charguéraud, and François Pottier. A fistful of dollars: Formalizing asymptotic complexity claims via deductive program verification. In European Symposium on Programming (ESOP), volume 10801 of Lecture Notes in Computer Science, pages 533--560. Springer, April 2018. [ bib | .pdf ] |
[562] | Armaël Guéneau, Magnus O. Myreen, Ramana Kumar, and Michael Norrish. Verified characteristic formulae for CakeML. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 584--610. Springer, April 2017. [ bib | .pdf ] |
[563] | Armaël Guéneau, François Pottier, and Jonathan Protzenko. The ins and outs of iteration in Mezzo. Higher-Order Programming and Effects (HOPE), September 2013. http://goo.gl/NrgKc4. [ bib ] |
[564] | Christian Haack, Marieke Huisman, and Clément Hurlin. Reasoning about Java's reentrant locks. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5356 of Lecture Notes in Computer Science, pages 171--187. Springer, December 2008. [ bib | .pdf ] |
[565] | Christian Haack and Clément Hurlin. Resource usage protocols for iterators. Journal of Object Technology, 8(4):55--83, 2009. [ bib | .pdf ] |
[566] | Christian Haack and J. B. Wells. Type error slicing in implicitly typed, higher-order languages. In European Symposium on Programming (ESOP), volume 2618 of Lecture Notes in Computer Science. Springer, 2003. [ bib | .pdf ] |
[567] | Cordelia Hall, Kevin Hammond, Simon Peyton Jones, and Philip Wadler. Type classes in Haskell. In European Symposium on Programming (ESOP), volume 788 of Lecture Notes in Computer Science, pages 241--256. Springer, April 1994. [ bib | .ps.gz ] |
[568] | Cordelia Hall, Kevin Hammond, Simon Peyton Jones, and Philip Wadler. Type classes in Haskell. ACM Transactions on Programming Languages and Systems, 18(2):109--138, March 1996. [ bib | http ] |
[569] | Philipp Haller and Martin Odersky. Capabilities for uniqueness and borrowing. In European Conference on Object-Oriented Programming (ECOOP), volume 6183 of Lecture Notes in Computer Science, pages 354--378. Springer, June 2010. [ bib | .pdf ] |
[570] | Joseph J. Hallett and Assaf J. Kfoury. Programming examples needing polymorphic recursion. Technical Report BUCS-TR-2004-004, Department of Computer Science, Boston University, January 2004. [ bib | .pdf ] |
[571] | Thomas Hallgren, James Hook, Mark P. Jones, and Richard Kieburtz. An overview of the Programatica toolset. High Confidence Software and Systems Conference (HCSS), 2004. [ bib | .pdf ] |
[572] | Michael Hanus. Horn clause specifications with polymorphic types. PhD thesis, Fachbereich Informatik, Universität Dortmund, 1988. [ bib | .dvi.Z ] |
[573] | Michael Hanus. Horn clause programs with polymorphic types: Semantics and resolution. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 225--240. Springer, 1989. [ bib | .ps ] |
[574] | Norm Hardy. The confused deputy (or why capabilities might have been invented). ACM Operating Systems Review, 22(4):36--38, October 1988. [ bib | .html ] |
[575] | Gregory C. Harfst and Edward M. Reingold. A potential-based amortized analysis of the union-find data structure. SIGACT News, 31(3):86--95, 2000. [ bib | http ] |
[576] | Bob Harper and Mark Lillibridge. ML with callcc is unsound. Message to the TYPES mailing list, July 1991. [ bib | .html ] |
[577] | Robert Harper. A simplified account of polymorphic references. Information Processing Letters, 51(4):201--206, 1994. [ bib | .pdf ] |
[578] | Robert Harper. Proof-directed debugging. Journal of Functional Programming, 9(4):463--469, 1999. [ bib | http ] |
[579] | Robert Harper, Furio Honsell, and Gordon D. Plotkin. A framework for defining logics. Journal of the ACM, 40(1):143--184, 1993. [ bib | .pdf ] |
[580] | Robert Harper and Daniel R. Licata. Mechanizing metatheory in a logical framework. Journal of Functional Programming, 17(4--5):613--673, 2007. [ bib | .pdf ] |
[581] | Robert Harper and Mark Lillibridge. Polymorphic type assignment and CPS conversion. Lisp and Symbolic Computation, 6(3--4):361--380, 1993. [ bib | .pdf ] |
[582] | Robert Harper and Benjamin Pierce. A record calculus based on symmetric concatenation. In Principles of Programming Languages (POPL), pages 131--142, January 1991. [ bib | .ps ] |
[583] | Robert Harper and Benjamin C. Pierce. Design considerations for ML-style module systems. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 8, pages 293--345. MIT Press, 2005. [ bib ] |
[584] | John Harrison. Handbook of practical logic and automated reasoning. Cambridge University Press, 2009. [ bib | http ] |
[585] | Michael A. Harrison, Walter L. Ruzzo, and Jeffrey D. Ullman. Protection in operating systems. Communications of the ACM, 19(8):461--471, August 1976. [ bib | http ] |
[586] | Maximilian P. L. Haslbeck and Tobias Nipkow. Hoare logics for time bounds: A study in meta theory. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 10805 of Lecture Notes in Computer Science, pages 155--171. Springer, April 2018. [ bib | .pdf ] |
[587] | Chris Hawblitzel. Linear types for aliased resources. Technical Report MSR-TR-2005-141, Microsoft Research, October 2005. [ bib | .pdf ] |
[588] | Matthew S. Hecht and Jeffrey D. Ullman. Analysis of a simple algorithm for global data flow problems. In Principles of Programming Languages (POPL), pages 207--217, 1973. [ bib | http ] |
[589] | Bastiaan Heeren and Jurriaan Hage. Parametric type inferencing for Helium. Technical Report UU-CS-2002-035, University of Utrecht, Institute of Information and Computing Science, August 2002. [ bib | .pdf ] |
[590] | Bastiaan Heeren, Jurriaan Hage, and Doaitse Swierstra. Generalizing Hindley-Milner type inference algorithms. Technical Report UU-CS-2002-031, University of Utrecht, Institute of Information and Computing Science, July 2002. [ bib | .pdf ] |
[591] | Bastiaan Heeren, Johan Jeuring, Doaitse Swierstra, and Pablo Azero Alcocer. Improving type-error messages in functional languages. Technical Report UU-CS-2002-009, University of Utrecht, Institute of Information and Computing Science, February 2002. [ bib | .pdf ] |
[592] | Eric C. R. Hehner. Abstractions of time, pages 191--210. Prentice Hall, 1994. [ bib | .pdf ] |
[593] | Eric C. R. Hehner. Formalization of time and space. Formal Aspects of Computing, 10:290--206, 1998. [ bib | .pdf ] |
[594] | Nevin Heintze. Set based analysis of ML programs. Technical Report CMU-CS-93-193, Carnegie Mellon University, School of Computer Science, July 1993. [ bib | .ps ] |
[595] | Nevin Heintze and David McAllester. Linear-time subtransitive control flow analysis. In Programming Language Design and Implementation (PLDI), pages 261--272, 1997. [ bib | .ps ] |
[596] | Nevin Heintze and Jon G. Riecke. The SLam calculus: Programming with secrecy and integrity. In Principles of Programming Languages (POPL), pages 365--377, January 1998. [ bib | .ps ] |
[597] | Nevin Heintze and Olivier Tardieu. Ultra-fast aliasing analysis using CLA: A million lines of C code in a second. In Programming Language Design and Implementation (PLDI), pages 254--263, 2001. [ bib | .ps ] |
[598] | Simon Helsen and Peter Thiemann. Syntactic type soundness for the region calculus. In Higher Order Operational Techniques in Semantics (HOOTS), volume 41(3) of Electronic Notes in Theoretical Computer Science, pages 1--19, 2000. [ bib | .pdf ] |
[599] | Fergus Henderson. Strong modes can change the world! Technical Report 96/11, Department of Computer Science, University of Melbourne, November 1992. [ bib | .ps.gz ] |
[600] | Dimitri Hendriks and Vincent van Oostrom. Adbmal. In International Conference on Automated Deduction (CADE), volume 2741 of Lecture Notes in Computer Science, pages 136--150. Springer, 2003. [ bib | http ] |
[601] | Fritz Henglein. Polymorphic type inference and semi-unification. PhD thesis, Rutgers University, April 1989. [ bib | .ps.gz ] |
[602] | Fritz Henglein. Efficient type inference for higher-order binding-time analysis. In Functional Programming Languages and Computer Architecture (FPCA), volume 523 of Lecture Notes in Computer Science, pages 448--472. Springer, 1991. [ bib | .dvi.gz ] |
[603] | Fritz Henglein. Type inference with polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):253--289, April 1993. [ bib | http ] |
[604] | Fritz Henglein. Breaking through the n^{3} barrier: Faster object type inference. In Foundations of Object-Oriented Languages (FOOL), 1997. [ bib ] |
[605] | Fritz Henglein. Breaking through the n^{3} barrier: Faster object type inference. Theory and Practice of Object Systems, 5(1):57--72, 1999. [ bib | .ps.gz ] |
[606] | Fritz Henglein and Jakob Rehof. The complexity of subtype entailment for simple types. In Logic in Computer Science (LICS), pages 352--361, June 1997. [ bib | .ps ] |
[607] | Fritz Henglein and Jakob Rehof. Constraint automata and the complexity of recursive subtype entailment. In International Colloquium on Automata, Languages and Programming, July 1998. [ bib | .ps ] |
[608] | Matthew Hennessy. The security picalculus and non-interference. Technical Report 2000:05, University of Sussex, November 2000. [ bib | .ps.Z ] |
[609] | Matthew Hennessy and James Riely. Information flow vs. resource access in the asynchronous pi-calculus. In International Colloquium on Automata, Languages and Programming, Lecture Notes in Computer Science. Springer, July 2000. [ bib | .ps.gz ] |
[610] | Mark Hepburn and David Wright. Trust in the pi-calculus. In Principles and Practice of Declarative Programming (PPDP), September 2001. [ bib ] |
[611] | Brian Herlihy, Peter Schachte, and Harald Søndergaard. Un-Kleene Boolean equation solving. International Journal of Foundations of Computer Science, 18(2):227--250, 2007. [ bib | http ] |
[612] | Stefan Heule, K. Rustan M. Leino, Peter Müller, and Alexander J. Summers. Abstract read permissions: Fractional permissions without the fractions. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 7737 of Lecture Notes in Computer Science, pages 315--334. Springer, 2013. [ bib | .pdf ] |
[613] | Tomoyuki Higuchi and Atsushi Ohori. A static type system for JVM access control. In International Conference on Functional Programming (ICFP), pages 227--237, August 2003. [ bib | http ] |
[614] | Daniel Hillerström and Sam Lindley. Liberating effects with rows and handlers. In International Workshop on Type-Driven Development (TyDe@ICFP), pages 15--27, September 2016. [ bib | .pdf ] |
[615] | J. Roger Hindley. The principal type-scheme of an object in combinatory logic. Transactions of the American Mathematical Society, 146:29--60, 1969. [ bib | http ] |
[616] | Ralf Hinze. Fun with phantom types. In Jeremy Gibbons and Oege de Moor, editors, The Fun of Programming, pages 245--262. Palgrave Macmillan, March 2003. [ bib | .pdf ] |
[617] | Ralf Hinze, Johan Jeuring, and Andres Löh. Comparing approaches to generic programming in Haskell. Technical Report UU-CS-2006-022, Department of Information and Computing Sciences, Utrecht University, 2006. [ bib | .pdf ] |
[618] | Ralf Hinze and Andres Löh. “scrap your boilerplate” revolutions. In Mathematics of Program Construction (MPC), volume 4014 of Lecture Notes in Computer Science, pages 180--208. Springer, July 2006. [ bib | .pdf ] |
[619] | Ralf Hinze, Andres Löh, and Bruno C. d. S. Oliveira. “scrap your boilerplate” reloaded. In Functional and Logic Programming, volume 3945 of Lecture Notes in Computer Science, pages 13--29. Springer, April 2006. [ bib | .pdf ] |
[620] | Ralf Hinze and Ross Paterson. Derivation of a typed functional LR parser. Unpublished, November 2005. [ bib | .pdf ] |
[621] | Ralf Hinze and Ross Paterson. Finger trees: a simple general-purpose data structure. Journal of Functional Programming, 16(2):197--217, 2006. [ bib | .pdf ] |
[622] | Ralf Hinze and Simon Peyton Jones. Derivable type classes. In Haskell workshop, 2000. [ bib | .pdf ] |
[623] | Tom Hirschowitz and Xavier Leroy. Mixin modules in a call-by-value setting. ACM Transactions on Programming Languages and Systems, 2004. To appear. [ bib | .ps.gz ] |
[624] | Tom Hirschowitz, Xavier Leroy, and J. B. Wells. Call-by-value mixin modules: Reduction semantics, side effects, types. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 64--78. Springer, April 2004. [ bib | .ps.gz ] |
[625] | My Hoang and John C. Mitchell. Lower bounds on type inference with subtypes. In Principles of Programming Languages (POPL), pages 176--185, January 1995. [ bib | http ] |
[626] | C. A. R. Hoare. Algorithm 65: find. Communications of the ACM, 4(7):321--322, July 1961. [ bib | http ] |
[627] | C. A. R. Hoare. An axiomatic basis for computer programming. Communications of the ACM, 12(10):576--580, 1969. [ bib | http ] |
[628] | C. A. R. Hoare. Proof of a program: FIND. Communications of the ACM, 14(1):39--45, January 1971. [ bib | http ] |
[629] | C. A. R. Hoare. Proof of correctness of data representations. Acta Informatica, 4:271--281, 1972. [ bib | http ] |
[630] | Aquinas Hobor, Andrew W. Appel, and Francesco Zappa Nardelli. Oracle semantics for concurrent separation logic. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 353--367. Springer, April 2008. [ bib | .pdf ] |
[631] | Aquinas Hobor, Robert Dockins, and Andrew W. Appel. A theory of indirection via approximation. In Principles of Programming Languages (POPL), January 2010. [ bib | .pdf ] |
[632] | Aquinas Hobor and Cristian Gherghina. Barriers in concurrent separation logic. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, March 2011. [ bib | .pdf ] |
[633] | Jan Hoffmann, Klaus Aehlig, and Martin Hofmann. Multivariate amortized resource analysis. ACM Transactions on Programming Languages and Systems, 34(3):14:1--14:62, 2012. [ bib | http ] |
[634] | Jan Hoffmann, Klaus Aehlig, and Martin Hofmann. Resource aware ML. In Computer Aided Verification (CAV), volume 7358 of Lecture Notes in Computer Science, pages 781--786. Springer, July 2012. [ bib | http ] |
[635] | Jan Hoffmann, Ankush Das, and Shu-Chun Weng. Towards automatic resource bound analysis for OCaml. In Principles of Programming Languages (POPL), pages 359--373, January 2017. [ bib | .pdf ] |
[636] | Jan Hoffmann and Martin Hofmann. Amortized resource analysis with polynomial potential. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 287--306. Springer, March 2010. [ bib | .pdf ] |
[637] | Jan Hoffmann, Michael Marmar, and Zhong Shao. Quantitative reasoning for proving lock-freedom. In Logic in Computer Science (LICS), pages 124--133, June 2013. [ bib | .pdf ] |
[638] | Martin Hofmann. A type system for bounded space and functional in-place update. Nordic Journal of Computing, 7(4):258--289, 2000. [ bib | .ps.gz ] |
[639] | Martin Hofmann and Steffen Jost. Static prediction of heap space usage for first-order functional programs. In Principles of Programming Languages (POPL), pages 185--197, January 2003. [ bib | .pdf ] |
[640] | Martin Hofmann, Aleksandr Karbyshev, and Helmut Seidl. Verifying a local generic solver in Coq. In Static Analysis Symposium (SAS), volume 6337 of Lecture Notes in Computer Science, pages 340--355. Springer, September 2010. [ bib | .pdf ] |
[641] | Martin Hofmann, Aleksandr Karbyshev, and Helmut Seidl. What is a pure functional? In International Colloquium on Automata, Languages and Programming, volume 6199 of Lecture Notes in Computer Science, pages 199--210. Springer, July 2010. [ bib | .pdf ] |
[642] | Martin Hofmann and Georg Moser. Amortised resource analysis and typed polynomial interpretations. In Typed Lambda Calculi and Applications (TLCA), volume 8560 of Lecture Notes in Computer Science, pages 272--286. Springer, July 2014. [ bib | .pdf ] |
[643] | Martin Hofmann and Mariela Pavlova. Elimination of ghost variables in program logics. In Trustworthy Global Computing, volume 4912 of Lecture Notes in Computer Science, pages 1--20. Springer, 2008. [ bib | .pdf ] |
[644] | Martin Hofmann and Benjamin Pierce. A unifying type-theoretic framework for objects. Journal of Functional Programming, 5(4):593--635, October 1995. 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. [ bib | .ps ] |
[645] | John Hogg. Islands: Aliasing protection in object-oriented languages. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 271--285, 1991. [ bib | http ] |
[646] | Kohei Honda, Vasco Vasconcelos, and Nobuko Yoshida. Secure information flow as typed process behaviour. Technical Report QMW-DCS-1999-767, Queen Mary and Westfield College, University of London, December 1999. [ bib | .ps.gz ] |
[647] | Kohei Honda, Vasco Vasconcelos, and Nobuko Yoshida. Secure information flow as typed process behaviour. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 180--199. Springer, March 2000. [ bib | .ps.gz ] |
[648] | Kohei Honda and Nobuko Yoshida. A uniform type structure for secure information flow. In Principles of Programming Languages (POPL), pages 81--92, January 2002. [ bib | .ps.gz ] |
[649] | Kohei Honda and Nobuko Yoshida. A compositional logic for polymorphic higher-order functions. In Principles and Practice of Declarative Programming (PPDP), pages 191--202, August 2004. [ bib | .pdf.gz ] |
[650] | Furio Honsell, Marino Miculan, and Ivan Scagnetto. An axiomatic approach to metareasoning on nominal algebras in HOAS. In International Colloquium on Automata, Languages and Programming, volume 2076 of Lecture Notes in Computer Science, pages 963--978. Springer, 2001. [ bib | .pdf ] |
[651] | John E. Hopcroft. An nlogn algorithm for minimizing states in a finite automaton. In Z. Kohavi, editor, Theory of Machines and Computations, pages 189--196. Academic Press, 1971. [ bib ] |
[652] | John E. Hopcroft. Computer science: The emergence of a discipline. Communications of the ACM, 30(3):198--202, 1987. [ bib | http ] |
[653] | John E. Hopcroft, Rajeev Motwani, and Jeffrey D. Ullman. Introduction to automata theory, languages, and computation. Addison-Wesley, 2000. [ bib | .html ] |
[654] | John E. Hopcroft and Jeffrey D. Ullman. Set merging algorithms. SIAM Journal on Computing, 2(4):294--303, 1973. [ bib | http ] |
[655] | James J. Horning. What the compiler should tell the user. In Compiler Construction (CC), volume 21 of Lecture Notes in Computer Science, pages 525--548. Springer, 1974. [ bib | http ] |
[656] | R. Nigel Horspool and Michael Whitney. Even faster LR parsing. Software: Practice and Experience, 20(6):515--535, June 1990. [ bib | .pdf ] |
[657] | Susan Horwitz, Thomas Reps, and Mooly Sagiv. Demand interprocedural dataflow analysis. In ACM Symposium on the Foundations of Software Engineering (FSE), October 1995. [ bib | .ps ] |
[658] | Haruo Hosoya and Benjamin C. Pierce. Regular expression pattern matching for XML. Journal of Functional Programming, 13(6):961--1004, November 2003. [ bib | http ] |
[659] | Rodney R. Howell. On asymptotic notation with multiple variables. Technical Report 2007-4, Kansas State University, January 2008. [ bib | .pdf ] |
[660] | Rodney R. Howell. Algorithms: A top-down approach, July 2012. Draft. [ bib | http ] |
[661] | Thierry Hubert and Claude Marché. Separation analysis for deductive verification. In Heap Analysis and Verification (HAV), March 2007. [ bib | .pdf ] |
[662] | Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler. A history of Haskell: being lazy with class. In History of Programming Languages, June 2007. [ bib | .pdf ] |
[663] | Gérard Huet. Résolution d'équations dans des langages d'ordre 1, 2, ..., ω. PhD thesis, Université Paris 7, September 1976. [ bib ] |
[664] | Gérard Huet. The zipper. Journal of Functional Programming, 7(5):549--554, 1997. [ bib | .pdf ] |
[665] | Gérard Huet. Regular Böhm trees. Mathematical Structures in Computer Science, 8:671--680, 1998. [ bib | .pdf ] |
[666] | Brian Huffman and Christian Urban. A new foundation for Nominal Isabelle. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 35--50. Springer, July 2010. [ bib | .pdf ] |
[667] | John Hughes. Why functional programming matters. Computer Journal, 32(2):98--107, 1989. [ bib | .pdf ] |
[668] | John Hughes. Generalising monads to arrows. Science of Computer Programming, 37(1--3):67--111, 2000. [ bib | .pdf ] |
[669] | John Hughes, Lars Pareto, and Amr Sabry. Proving the correctness of reactive systems using sized types. In Principles of Programming Languages (POPL), pages 410--423, January 1996. [ bib | http ] |
[670] | Graham Hutton. A tutorial on the universality and expressiveness of fold. Journal of Functional Programming, 9(4):355--372, 1999. [ bib | .pdf ] |
[671] | Atsushi Igarashi and Naoki Kobayashi. Type reconstruction for linear π-calculus with I/O subtyping. Information and Computation, 161:1--44, August 2000. [ bib | .ps.gz ] |
[672] | Samin S. Ishtiaq and Peter W. O'Hearn. BI as an assertion language for mutable data structures. In Principles of Programming Languages (POPL), pages 14--26, January 2001. [ bib | .pdf ] |
[673] | Daniel Jackson and Mandana Vaziri. Finding bugs with a constraint solver. In International Symposium on Software Testing and Analysis (ISSTA), August 2000. [ bib | .pdf ] |
[674] | Bart Jacobs, Dragan Bosnacki, and Ruurd Kuipe. Modular termination verification. In European Conference on Object-Oriented Programming (ECOOP), Leibniz International Proceedings in Informatics, pages 99--1023, July 2015. [ bib | .pdf ] |
[675] | Bart Jacobs and Frank Piessens. The VeriFast program verifier. Technical Report CW-520, Department of Computer Science, Katholieke Universiteit Leuven, August 2008. [ bib | .pdf ] |
[676] | Suresh Jagannathan and Andrew Wright. Effective flow analysis for avoiding run-time checks. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science. Springer, September 1995. [ bib | .ps.gz ] |
[677] | Patrik Jansson. Functional polytypic programming. PhD thesis, Chalmers University of Technology, 2000. [ bib | .pdf ] |
[678] | C. Barry Jay. The pattern calculus. ACM Transactions on Programming Languages and Systems, 26(6):911--937, November 2004. [ bib | .pdf ] |
[679] | Clinton L. Jeffery. Merr user's guide, July 2002. [ bib | .pdf ] |
[680] | Clinton L. Jeffery. Generating LR syntax error messages from examples. ACM Transactions on Programming Languages and Systems, 25(5):631--640, 2003. [ bib | http ] |
[681] | Jonas Braband Jensen, Nick Benton, and Andrew Kennedy. High-level separation logic for low-level code. In Principles of Programming Languages (POPL), pages 301--314, January 2013. [ bib | .pdf ] |
[682] | Jonas Braband Jensen and Lars Birkedal. Fictional separation logic. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 377--396. Springer, March 2012. [ bib | .pdf ] |
[683] | Thomas Jensen. Inference of polymorphic and conditional strictness properties. In Principles of Programming Languages (POPL), pages 209--221. ACM Press, January 1998. [ bib | .ps ] |
[684] | Thomas Jensen, Daniel Le Métayer, and Tommy Thorn. Verifying security properties of control-flow graphs. In IEEE Symposium on Security and Privacy (S&P), pages 89--105, May 1999. [ bib | .ps ] |
[685] | Thomas Jensen, Florimond Ployette, and Olivier Ridoux. Iteration schemes for fixed point computation. In International workshop on Fixed Points in Computer Science (FICS), pages 69--76, 2002. [ bib | .ps ] |
[686] | Johan Jeuring, Sean Leather, José Pedro Magalhães, and Alexey Rodriguez Yakushev. Libraries for generic programming in Haskell. In Advanced Functional Programming, volume 5832 of Lecture Notes in Computer Science, pages 165--229. Springer, May 2008. [ bib | .pdf ] |
[687] | Somesh Jha, Jens Palsberg, and Tian Zhao. Efficient type matching. In Foundations of Software Science and Computation Structures (FOSSACS), volume 2303 of Lecture Notes in Computer Science, pages 187--204. Springer, April 2002. [ bib | .pdf ] |
[688] | Limin Jia, Frances Spalding, David Walker, and Neal Glew. Certifying compilation for a language with stack allocation. In Logic in Computer Science (LICS), pages 407--416, June 2005. [ bib | .pdf ] |
[689] | Limin Jia and David Walker. ILC: A foundation for automated reasoning about pointer programs. In European Symposium on Programming (ESOP), volume 3924 of Lecture Notes in Computer Science, pages 131--145. Springer, March 2006. [ bib | .pdf ] |
[690] | Trevor Jim. What are principal typings and what are they good for? Technical Report MIT/LCS TM-532, Massachusetts Institute of Technology, August 1995. [ bib | .ps.gz ] |
[691] | Trevor Jim. A polar type system. In Workshop on Intersection Types and Related Systems (ITRS), volume 8 of Proceedings in Informatics. Carleton Scientific, 2000. [ bib | .ps.gz ] |
[692] | Trevor Jim and Jens Palsberg. Type inference in systems of recursive types with subtyping. Manuscript, 1999. [ bib | .pdf ] |
[693] | Gregory F. Johnson and Janet A. Walz. A maximum-flow approach to anomaly isolation in unification-based incremental type inference. In Principles of Programming Languages (POPL), pages 44--57, January 1986. [ bib ] |
[694] | Stephen C. Johnson. Yacc: Yet another compiler-compiler. Computing Science Technical Report 32, Bell Laboratories, 1975. [ bib | .ps ] |
[695] | Steven C. Johnson. Yacc: Yet another compiler compiler. In UNIX Programmer's Manual, volume 2, pages 353--387. Holt, Rinehart, and Winston, 1979. [ bib | http ] |
[696] | Thomas Johnsson. Lambda lifting: Transforming programs to recursive equations. In Jean-Pierre Jouannaud, editor, Functional Programming Languages and Computer Architecture (FPCA), volume 201 of Lecture Notes in Computer Science, pages 190--203. Springer, 1985. [ bib | http ] |
[697] | Mark P. Jones. A theory of qualified types. In European Symposium on Programming (ESOP), volume 582 of Lecture Notes in Computer Science. Springer, February 1992. [ bib | .html ] |
[698] | Mark P. Jones. Dictionary-free overloading by partial evaluation. In ACM Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), June 1994. [ bib | .ps ] |
[699] | Mark P. Jones. Qualified types: Theory and practice. Cambridge University Press, November 1994. [ bib ] |
[700] | Mark P. Jones. Simplifying and improving qualified types. Technical Report YALEU/DCS/RR-1040, Yale University, June 1994. [ bib | .ps.Z ] |
[701] | Mark P. Jones. From Hindley-Milner types to first-class structures. Research Report YALEU/DCS/RR-1075, Yale University, June 1995. [ bib | .html ] |
[702] | Mark P. Jones. Using parameterized signatures to express modular structure. In Principles of Programming Languages (POPL), January 1996. [ bib | .html ] |
[703] | Mark P. Jones. Typing Haskell in Haskell. In Haskell workshop, October 1999. [ bib | http ] |
[704] | Mark P. Jones. jacc: Just another compiler compiler for Java, February 2004. [ bib | .pdf ] |
[705] | Mark P. Jones and Simon Peyton Jones. Lightweight extensible records for Haskell. In Haskell workshop, October 1999. [ bib | .ps.gz ] |
[706] | Steffen Jost, Kevin Hammond, Hans-Wolfgang Loidl, and Martin Hofmann. Static determination of quantitative resource usage for higher-order programs. In Principles of Programming Languages (POPL), pages 223--236, January 2010. [ bib | .pdf ] |
[707] | Steffen Jost, Hans-Wolfgang Loidl, Kevin Hammond, Norman Scaife, and Martin Hofmann. "carbon credits" for resource-bounded computations using amortised analysis. In Formal Methods (FM), volume 5850 of Lecture Notes in Computer Science, pages 354--369. Springer, November 2009. [ bib | .pdf ] |
[708] | Jean-Pierre Jouannaud and Claude Kirchner. Solving equations in abstract algebras: a rule-based survey of unification. Technical Report 561, Université Paris-Sud, April 1990. [ bib ] |
[709] | Jean-Pierre Jouannaud and Claude Kirchner. Solving equations in abstract algebras: a rule-based survey of unification. In Jean-Louis Lassez and Gordon Plotkin, editors, Computational Logic. Essays in honor of Alan Robinson, chapter 8, pages 257--321. MIT Press, 1991. [ bib ] |
[710] | Jacques-Henri Jourdan, Vincent Laporte, Sandrine Blazy, Xavier Leroy, and David Pichardie. A formally-verified C static analyzer. In Principles of Programming Languages (POPL), pages 247--259, January 2015. [ bib | .pdf ] |
[711] | Jacques-Henri Jourdan, François Pottier, and Xavier Leroy. Validating LR(1) parsers. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 397--416. Springer, March 2012. [ bib | .pdf ] |
[712] | Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer. RustBelt: securing the foundations of the Rust programming language. PACMPL, 2(POPL):66:1--66:34, 2018. [ bib | .pdf ] |
[713] | Ralf Jung, Robbert Krebbers, Lars Birkedal, and Derek Dreyer. Higher-order ghost state. In International Conference on Functional Programming (ICFP), pages 256--269, September 2016. [ bib | .pdf ] |
[714] | Ralf Jung, Robbert Krebbers, Jacques-Henri Jourdan, Aleš Bizjak, Lars Birkedal, and Derek Dreyer. Iris from the ground up: A modular foundation for higher-order concurrent separation logic. Journal of Functional Programming, 28:e20, 2018. [ bib | .pdf ] |
[715] | Ralf Jung, David Swasey, Filip Sieczkowski, Kasper Svendsen, Aaron Turon, Lars Birkedal, and Derek Dreyer. Iris: monoids and invariants as an orthogonal basis for concurrent reasoning. In Principles of Programming Languages (POPL), pages 637--650, January 2015. [ bib | .pdf ] |
[716] | Niels Jørgensen. Chaotic fixpoint iteration guided by dynamic dependency. In International Workshop on Static Analysis (WSA), volume 724 of Lecture Notes in Computer Science, pages 27--44. Springer, 1993. [ bib | .ps ] |
[717] | Jan-Oliver Kaiser, Hoang-Hai Dang, Derek Dreyer, Ori Lahav, and Viktor Vafeiadis. Strong logic for weak memory: Reasoning about release-acquire consistency in Iris. In European Conference on Object-Oriented Programming (ECOOP), pages 17:1--17:29, June 2017. [ bib | .pdf ] |
[718] | Jonas Kaiser, Tobias Tebbi, and Gert Smolka. Equivalence of System F and λ2 in Coq based on context morphism lemmas. In Certified Programs and Proofs (CPP), pages 222--234, January 2017. [ bib | .pdf ] |
[719] | John B. Kam and Jeffrey D. Ullman. Global data flow analysis and iterative algorithms. Journal of the ACM, 23(1):158--171, January 1976. [ bib | http ] |
[720] | John B. Kam and Jeffrey D. Ullman. Monotone data flow analysis frameworks. Acta Informatica, 7(3):305--317, September 1977. [ bib | http ] |
[721] | Ohad Kammar, Sam Lindley, and Nicolas Oury. Handlers in action. In International Conference on Functional Programming (ICFP), pages 145--158, September 2013. [ bib | .pdf ] |
[722] | Johannes Kanig. Specification and proof of higher-order programs. PhD thesis, Université Paris-Sud, November 2010. [ bib | .pdf ] |
[723] | E. Kantorowitz and H. Laor. Automatic generation of useful syntax error messages. Software: Practice and Experience, 16(7):627--640, 1986. [ bib | http ] |
[724] | Haim Kaplan, Nira Shafrir, and Robert E. Tarjan. Union-find with deletions. In Symposium on Discrete Algorithms (SODA), pages 19--28, January 2002. [ bib | http ] |
[725] | Haim Kaplan and Robert E. Tarjan. Purely functional, real-time deques with catenation. Journal of the ACM, 46(5):577--603, 1999. [ bib | .ps ] |
[726] | Deepak Kapur and Hantao Zhang. An overview of Rewrite Rule Laboratory (RRL). J. Comput. Appl. Math., 29(2):91--114, 1995. [ bib | .ps.gz ] |
[727] | Aleksandr Karbyshev. Monadic parametricity of second-order functionals. PhD thesis, Technische Universität München, 2013. [ bib | http ] |
[728] | Yugo Kashiwagi and David S. Wise. Graph algorithms in a lazy functional programming language. Technical Report 330, Indiana University, April 1991. [ bib | .pdf ] |
[729] | Ioannis T. Kassios. Dynamic frames: Support for framing, dependencies and sharing without restrictions. In Formal Methods (FM), volume 4085 of Lecture Notes in Computer Science, pages 268--283. Springer, August 2006. [ bib | .pdf ] |
[730] | Misa Keinänen. Techniques for solving Boolean equation systems. PhD thesis, Helsinki University of Technology, 2006. Research Report HUT-TCS-A105. [ bib | .pdf ] |
[731] | Torbjörn Keisu. Finite and rational tree constraints. Bulletin of the IGPL, 2(2):167--204, 1994. [ bib | .ps.gz ] |
[732] | Torbjörn Keisu. Tree constraints. PhD thesis, The Royal Institute of Technology (KTH), May 1994. [ bib | .ps.gz ] |
[733] | Andrew Kennedy. Dimension types. In European Symposium on Programming (ESOP), volume 788 of Lecture Notes in Computer Science. Springer, 1994. [ bib | .pdf ] |
[734] | Andrew Kennedy. Type inference and equational theories. Technical Report LIX/RR/96/09, École Polytechnique, September 1996. [ bib ] |
[735] | Andrew Kennedy. Compiling with continuations, continued. In International Conference on Functional Programming (ICFP), pages 177--190, September 2007. [ bib | .pdf ] |
[736] | Ken W. Kennedy. Node listings applied to data flow analysis. In Principles of Programming Languages (POPL), pages 10--21, January 1975. [ bib | http ] |
[737] | Manfred Kerber. How to prove higher order theorems in first order logic. In International Joint Conferences on Artificial Intelligence, pages 137--142, 1991. [ bib | .pdf ] |
[738] | Brian W. Kernighan and Dennis Ritchie. The C programming language, second edition. Prentice Hall, 1988. [ bib ] |
[739] | Steven Keuchel and Tom Schrijvers. InBound: simple yet powerful specification of syntax with binders. Unpublished, February 2015. [ bib | .pdf ] |
[740] | Steven Keuchel, Stephanie Weirich, and Tom Schrijvers. Needle & knot: Binder boilerplate tied up. In European Symposium on Programming (ESOP), volume 9632 of Lecture Notes in Computer Science, pages 419--445. Springer, April 2016. [ bib | .pdf ] |
[741] | A. J. Kfoury, J. Tiuryn, and P. Urzyczyn. Type reconstruction in the presence of polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):290--311, 1993. [ bib | http ] |
[742] | Assaf J. Kfoury, Jerzy Tiuryn, and Pawel Urzyczyn. ML typability is DEXPTIME-complete. In Colloquium on Trees in Algebra and Programming, volume 431 of Lecture Notes in Computer Science, pages 206--220. Springer, May 1990. [ bib | http ] |
[743] | Assaf J. Kfoury and J. B. Wells. Principality and type inference for intersection types using expansion variables. Theoretical Computer Science, 311(1--3):1--70, 2004. [ bib | .html ] |
[744] | Richard B. Kieburtz. Taming effects with monadic typing. In International Conference on Functional Programming (ICFP), pages 51--62, 1998. [ bib | http ] |
[745] | Richard B. Kieburtz. P-logic: Property verification for Haskell programs. Draft, August 2002. [ bib | .pdf ] |
[746] | Gary A. Kildall. A unified approach to global program optimization. In Principles of Programming Languages (POPL), pages 194--206, October 1973. [ bib | http ] |
[747] | Ik-Soon Kim, Kwangkeun Yi, and Cristiano Calcagno. A polymorphic modal type system for Lisp-like multi-staged languages. In Principles of Programming Languages (POPL), pages 257--268, 2006. [ bib | .pdf ] |
[748] | David King and Philip Wadler. Combining monads. In Workshop on Functional Programming. Springer, 1992. [ bib | .ps.gz ] |
[749] | Oleg Kiselyov and Chung-chieh Shan. A substructural type system for delimited continuations. In Typed Lambda Calculi and Applications (TLCA), volume 4583 of Lecture Notes in Computer Science, pages 223--239. Springer, June 2007. [ bib | .pdf ] |
[750] | Gerwin Klein, June Andronick, Kevin Elphinstone, Gernot Heiser, David Cock, Philip Derrin, Dhammika Elkaduwe, Kai Engelhardt, Rafal Kolanski, Michael Norrish, Thomas Sewell, Harvey Tuch, and Simon Winwood. seL4: formal verification of an operating-system kernel. Communications of the ACM, 53(6):107--115, 2010. [ bib | .pdf ] |
[751] | Paul Klint, Ralf Lämmel, and Chris Verhoef. Toward an engineering discipline for grammarware. ACM Transactions on Software Engineering and Methodology, 14(3):331--380, 2005. [ bib | .pdf ] |
[752] | Johannes Kloos, Rupak Majumdar, and Viktor Vafeiadis. Asynchronous liquid separation types. In European Conference on Object-Oriented Programming (ECOOP), pages 396--420, July 2015. [ bib | .pdf ] |
[753] | Edward Kmett. Bound. Blog post, November 2014. [ bib | http ] |
[754] | Kevin Knight. Unification: a multidisciplinary survey. ACM Computing Surveys, 21(1):93--124, March 1989. [ bib | http ] |
[755] | Donald E. Knuth. On the translation of languages from left to right. Information & Control, 8(6):607--639, December 1965. [ bib | http ] |
[756] | Donald E. Knuth. A generalization of Dijkstra's algorithm. Information Processing Letters, 6(1):1--5, February 1977. [ bib ] |
[757] | Naoki Kobayashi. A partially deadlock-free typed process calculus. ACM Transactions on Programming Languages and Systems, 20(2):436--482, March 1998. [ bib | http ] |
[758] | Naoki Kobayashi. Type-based useless variable elimination. In ACM Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 84--93, January 2000. [ bib | .ps.gz ] |
[759] | Naoki Kobayashi, Benjamin C. Pierce, and David N. Turner. Linearity and the Pi-Calculus. ACM Transactions on Programming Languages and Systems, 21(5):914--947, September 1999. [ bib | http ] |
[760] | Naoki Kobayashi, Shin Saito, and Eijiro Sumii. An implicitly-typed deadlock-free process calculus. In International Conference on Concurrency Theory (CONCUR), volume 1877 of Lecture Notes in Computer Science, pages 489--503. Springer, August 2000. [ bib | .ps.gz ] |
[761] | Yasunori Koda and Frank Ruskey. A Gray code for the ideals of a forest poset. Journal of Algorithms, 15(2):324--340, September 1993. [ bib | .ps ] |
[762] | Eugene Kohlbecker, Daniel P. Friedman, Matthias Felleisen, and Bruce Duba. Hygienic macro expansion. In ACM Symposium on Lisp and Functional Programming (LFP), pages 151--161, 1986. [ bib | http ] |
[763] | Eugene E. Kohlbecker and Mitchell Wand. Macro-by-example: Deriving syntactic transformations from their specifications. In Principles of Programming Languages (POPL), pages 77--84, January 1987. [ bib | http ] |
[764] | Gabriël Konat, Lennart Kats, Guido Wachsmuth, and Eelco Visser. Declarative name binding and scope rules. In Software Language Engineering, volume 7745 of Lecture Notes in Computer Science, pages 311--331. Springer, September 2013. [ bib | .pdf ] |
[765] | Adam Koprowski and Henri Binsztok. TRX: A formally verified parser interpreter. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 345--365. Springer, March 2010. [ bib | .pdf ] |
[766] | Adam Koprowski and Henri Binsztok. TRX: A formally verified parser interpreter. Logical Methods in Computer Science, 7(2), 2011. [ bib | http ] |
[767] | Larry Koved, Marco Pistoia, and Aaron Kershenbaum. Access rights analysis for Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 359--372, November 2002. [ bib | .pdf ] |
[768] | Dexter Kozen, Jens Palsberg, and Michael I. Schwartzbach. Efficient recursive subtyping. Mathematical Structures in Computer Science, 5(1):113--125, 1995. [ bib | .pdf ] |
[769] | Dexter C. Kozen. The design and analysis of algorithms. Texts and Monographs in Computer Science. Springer, 1992. [ bib | .pdf ] |
[770] | Robbert Krebbers, Ralf Jung, Aleš Bizjak, Jacques-Henri Jourdan, Derek Dreyer, and Lars Birkedal. The essence of higher-order concurrent separation logic. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 696--723. Springer, April 2017. [ bib | .pdf ] |
[771] | Robert Krebbers, Amin Timany, and Lars Birkedal. Interactive proofs in higher-order concurrent separation logic. In Principles of Programming Languages (POPL), January 2017. [ bib | .pdf ] |
[772] | Shriram Krishnamurthi, Matthias Felleisen, and Bruce F. Duba. From macros to reusable generative programming. In Generative and Component-Based Software Engineering, volume 1799 of Lecture Notes in Computer Science, pages 105--120. Springer, September 1999. [ bib | .ps ] |
[773] | Neelakantan R. Krishnaswami. Verifying higher-order imperative programs with higher-order separation logic. PhD thesis, School of Computer Science, Carnegie Mellon University, 2012. [ bib | .pdf ] |
[774] | Neelakantan R. Krishnaswami, Jonathan Aldrich, Lars Birkedal, Kasper Svendsen, and Alexandre Buisse. Design patterns in separation logic. In Types in Language Design and Implementation (TLDI), pages 105--116, January 2009. [ bib | .pdf ] |
[775] | Neelakantan R. Krishnaswami, Aaron Turon, Derek Dreyer, and Deepak Garg. Superficially substructural types. In International Conference on Functional Programming (ICFP), pages 41--54, September 2012. [ bib | .pdf ] |
[776] | Daniel Kroening and Ofer Strichman. Decision procedures -- an algorithmic point of view. Springer, 2008. [ bib | http ] |
[777] | George Kuan and David MacQueen. Efficient type inference using ranked type variables. In ACM Workshop on ML, pages 3--14, October 2007. [ bib | .pdf ] |
[778] | Viktor Kuncak and Martin Rinard. On the theory of structural subtyping. Technical Report 879, MIT Laboratory for Computer Science, January 2003. [ bib | .ps ] |
[779] | Viktor Kuncak and Martin Rinard. Structural subtyping of non-recursive types is decidable. In Logic in Computer Science (LICS), June 2003. [ bib | .pdf ] |
[780] | Charlie Lai, Li Gong, Larry Koved, Anthony J. Nadalin, and Roland Schemers. User authentication and authorization in the Java platform. In Annual Computer Security Applications Conference, pages 285--290, December 1999. [ bib | .pdf ] |
[781] | Ralf Lämmel and Simon Peyton Jones. Scrap your boilerplate: a practical design pattern for generic programming. In Types in Language Design and Implementation (TLDI), pages 26--37, January 2003. [ bib | .pdf ] |
[782] | Ralf Lämmel and Simon Peyton Jones. Scrap more boilerplate: reflection, zips, and generalised casts. In International Conference on Functional Programming (ICFP), pages 244--255, September 2004. [ bib | http ] |
[783] | Ralf Lämmel and Simon Peyton Jones. Scrap your boilerplate with class: extensible generic functions. In International Conference on Functional Programming (ICFP), pages 204--215, September 2005. [ bib | .pdf ] |
[784] | Peter Lammich. Automatic data refinement. In Interactive Theorem Proving (ITP), volume 7998 of Lecture Notes in Computer Science, pages 84--99. Springer, July 2013. [ bib | .pdf ] |
[785] | Peter Lammich. Verified efficient implementation of Gabow's strongly connected component algorithm. In Interactive Theorem Proving (ITP), volume 8558 of Lecture Notes in Computer Science, pages 325--340. Springer, July 2014. [ bib | .pdf ] |
[786] | Peter Lammich. Refinement to Imperative/HOL. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 253--269. Springer, August 2015. [ bib | .pdf ] |
[787] | Peter Lammich. Refinement based verification of imperative data structures. In Certified Programs and Proofs (CPP), pages 27--36, January 2016. [ bib | .pdf ] |
[788] | Peter Lammich and Andreas Lochbihler. The Isabelle collections framework. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 339--354. Springer, July 2010. [ bib | .pdf ] |
[789] | Peter Lammich and Rene Meis. A separation logic framework for Imperative HOL. Archive of Formal Proofs, 2012. [ bib | http ] |
[790] | Peter Lammich and René Neumann. A framework for verifying depth-first search algorithms. In Certified Programs and Proofs (CPP), pages 137--146, January 2015. [ bib | .pdf ] |
[791] | Butler W. Lampson. A note on the confinement problem. Communications of the ACM, 16(10):613--615, October 1973. [ bib | .html ] |
[792] | Peter J. Landin. The mechanical evaluation of expressions. Computer Journal, 6(4):308--320, January 1964. [ bib ] |
[793] | Peter J. Landin. Correspondence between ALGOL 60 and Church's lambda-notation: part I. Communications of the ACM, 8(2):89--101, 1965. [ bib | http ] |
[794] | James Richard Larus. Restructuring symbolic programs for concurrent execution on multiprocessors. PhD thesis, EECS Department, University of California, Berkeley, May 1989. Technical Report UCB/CSD-89-502. [ bib | .pdf ] |
[795] | Soren B. Lassen. Bisimulation in untyped lambda calculus: Böhm trees and bisimulation up to context. In Mathematical Foundations of Programming Semantics, volume 20 of Electronic Notes in Theoretical Computer Science, pages 346--374. Elsevier Science, April 1999. [ bib | .ps ] |
[796] | Soren B. Lassen. Head normal form bisimulation for pairs and the λμ-calculus. In Logic in Computer Science (LICS), pages 297--306, August 2006. [ bib | .pdf ] |
[797] | Jean-Louis Lassez, Michael J. Maher, and Kim G. Marriott. Unification revisited. In Jack Minker, editor, Foundations of Deductive Databases and Logic Programming, chapter 15, pages 587--625. Morgan Kaufmann, 1988. [ bib ] |
[798] | Jean-Louis Lassez, V. L. Nguyen, and Liz Sonenberg. Fixed point theorems and semantics: a folk tale. Information Processing Letters, 14(3):112--116, May 1982. [ bib | http ] |
[799] | Konstantin Läufer and Martin Odersky. Polymorphic type inference and abstract data types. ACM Transactions on Programming Languages and Systems, 16(5):1411--1430, September 1994. [ bib | .pdf ] |
[800] | John Launchbury and Simon Peyton Jones. State in Haskell. LISP and Symbolic Computation, 8(4):293--341, 1995. [ bib | http ] |
[801] | Vincent Laviron, Bor-Yuh Evan Chang, and Xavier Rival. Separating shape graphs. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 387--406. Springer, March 2010. [ bib | .pdf ] |
[802] | Julia L. Lawall and Olivier Danvy. Separating stages in the continuation-passing style transformation. In Principles of Programming Languages (POPL), pages 124--136, January 1993. [ bib | .ps.gz ] |
[803] | Didier Le Botlan and Didier Rémy. MLF: Raising ML to the power of system F. In International Conference on Functional Programming (ICFP), pages 27--38, August 2003. [ bib | .pdf ] |
[804] | Baudouin Le Charlier and Pascal Van Hentenryck. A universal top-down fixpoint algorithm. Technical Report CS-92-25, Brown University, May 1992. [ bib | .ps.gz ] |
[805] | Fabrice Le Fessant and Luc Maranget. Optimizing pattern matching. In International Conference on Functional Programming (ICFP), 2001. [ bib | .ps.gz ] |
[806] | Daniel Le Métayer. ACE: an automatic complexity evaluator. ACM Transactions on Programming Languages and Systems, 10(2):248--266, 1988. [ bib | http ] |
[807] | Christopher League, Zhong Shao, and Valery Trifonov. Representing Java classes in a typed intermediate language. In International Conference on Functional Programming (ICFP), pages 183--196, September 1999. [ bib | .html ] |
[808] | Christopher League, Zhong Shao, and Valery Trifonov. Type-preserving compilation of Featherweight Java. ACM Transactions on Programming Languages and Systems, 24(2):112--152, March 2002. [ bib | .html ] |
[809] | Christopher League, Zhong Shao, and Valery Trifonov. Precision in practice: a type-preserving Java compiler. In Compiler Construction (CC), volume 2622 of Lecture Notes in Computer Science, pages 106--120. Springer, April 2003. [ bib | .html ] |
[810] | Gary T. Leavens and Albert L. Baker. Enhancing the pre- and postcondition technique for more expressive specifications. In Formal Methods (FM), volume 1709 of Lecture Notes in Computer Science, pages 1087--1106. Springer, January 1999. [ bib | http ] |
[811] | Gary T. Leavens, Erik Poll, Curtis Clifton, Yoonsik Cheon, Clyde Ruby, David Cok, Peter Müller, Joseph Kiniry, Patrice Chalin, and Daniel M. Zimmerman. JML reference manual, May 2008. [ bib | .pdf ] |
[812] | Sylvain Lebresne. A system F with call-by-name exceptions. In International Colloquium on Automata, Languages and Programming, volume 5126 of Lecture Notes in Computer Science, pages 323--335. Springer, June 2008. [ bib | .pdf ] |
[813] | Gyesik Lee, Bruno C. d. S. Oliveira, Sungkeun Cho, and Kwangkeun Yi. GMeta: A generic formal metatheory framework for first-order representations. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 436--455. Springer, April 2012. [ bib | .pdf ] |
[814] | Oukseh Lee and Kwangkeun Yi. Proofs about a folklore let-polymorphic type inference algorithm. ACM Transactions on Programming Languages and Systems, 20(4):707--723, 1998. [ bib | http ] |
[815] | Daan Leijen. Algebraic effects for functional programming. Technical Report MSR-TR-2016-29, Microsoft Research, August 2016. [ bib | http ] |
[816] | K. Rustan M. Leino. Efficient weakest preconditions. Information Processing Letters, 93(6):281--288, 2005. [ bib | .pdf ] |
[817] | K. Rustan M. Leino. Dafny: An automatic program verifier for functional correctness. In Logic for Programming Artificial Intelligence and Reasoning (LPAR), volume 6355 of Lecture Notes in Computer Science, pages 348--370. Springer, April 2010. [ bib | .pdf ] |
[818] | K. Rustan M. Leino and Michal Moskal. VACID-0: Verification of ample correctness of invariants of data-structures, edition 0. Manuscript KRML 209, July 2010. [ bib | .pdf ] |
[819] | K. Rustan M. Leino and Peter Müller. A basis for verifying multi-threaded programs. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 378--393. Springer, March 2009. [ bib | .pdf ] |
[820] | K. Rustan M. Leino, Peter Müller, and Jan Smans. Verification of concurrent programs with Chalice. In Foundations of Security Analysis and Design, volume 5705 of Lecture Notes in Computer Science, pages 195--222. Springer, 2009. [ bib | .pdf ] |
[821] | K. Rustan M. Leino, Peter Müller, and Jan Smans. Deadlock-free channels and locks. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 407--426. Springer, March 2010. [ bib | .pdf ] |
[822] | K. Rustan M. Leino and Greg Nelson. Data abstraction and information hiding. ACM Transactions on Programming Languages and Systems, 24(5):491--553, 2002. [ bib | .pdf ] |
[823] | K. Rustan M. Leino and Wolfram Schulte. Using history invariants to verify observers. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 80--94. Springer, 2007. [ bib | .pdf ] |
[824] | Xavier Leroy. Polymorphic typing of an algorithmic language. Research Report 1778, INRIA, October 1992. [ bib | .ps.gz ] |
[825] | Xavier Leroy. Typage polymorphe d'un langage algorithmique. PhD thesis, Université Paris 7, June 1992. [ bib | .ps.gz ] |
[826] | Xavier Leroy. Formal certification of a compiler back-end or: programming a compiler with a proof assistant. In Principles of Programming Languages (POPL), pages 42--54, January 2006. [ bib | .pdf ] |
[827] | Xavier Leroy. The CompCert C compiler. http://compcert.inria.fr/, 2015. [ bib ] |
[828] | Xavier Leroy, Damien Doligez, Alain Frisch, Jacques Garrigue, Didier Rémy, and Jérôme Vouillon. The OCaml system: documentation and user's manual, 2019. [ bib | http ] |
[829] | Xavier Leroy, Damien Doligez, Jacques Garrigue, Didier Rémy, and Jérôme Vouillon. The Objective Caml system, October 2005. [ bib | http ] |
[830] | Xavier Leroy, Damien Doligez, Michel Mauny, and Pierre Weis. The Caml Light system, release 0.75, 2002. [ bib | http ] |
[831] | Xavier Leroy and François Pottier. Notes du cours de DEA « typage et programmation », December 2002. [ bib | .ps.gz ] |
[832] | Stéphane Lescuyer. First-class containers in Coq. Studia Informatica Universalis, 9(1):87--127, 2011. [ bib | .pdf ] |
[833] | Stéphane Lescuyer. Codage de la logique du premier ordre polymorphe multi-sortée dans la logique sans sortes. Master's thesis, Master Parisien de Recherche en Informatique, 2006. [ bib | .pdf ] |
[834] | Pierre Letouzey. Programmation fonctionnelle certifiée -- l'extraction de programmes dans l'assistant Coq. PhD thesis, Université Paris 11, July 2004. [ bib | .ps.gz ] |
[835] | Paul Blain Levy. Possible world semantics for general storage in call-by-value. In Computer Science Logic, volume 2471 of Lecture Notes in Computer Science. Springer, 2002. [ bib | .ps ] |
[836] | Jeffrey Lewis, Mark Shields, Erik Meijer, and John Launchbury. Implicit parameters: Dynamic scoping with static types. In Principles of Programming Languages (POPL), pages 108--118, January 2000. [ bib | .ps ] |
[837] | Ruy Ley-Wild and Aleksandar Nanevski. Subjective auxiliary state for coarse-grained concurrency. In Principles of Programming Languages (POPL), pages 561--574, January 2013. [ bib | .pdf ] |
[838] | Daniel R. Licata and Robert Harper. A universe of binding and computation. In International Conference on Functional Programming (ICFP), pages 123--134, September 2009. [ bib | .pdf ] |
[839] | Daniel R. Licata, Noam Zeilberger, and Robert Harper. Focusing on binding and computation. In Logic in Computer Science (LICS), pages 241--252, June 2008. [ bib | .pdf ] |
[840] | Daniel R. Licata, Noam Zeilberger, and Robert Harper. Focusing on binding and computation. Technical Report CMU-CS-08-101, Carnegie Mellon University, February 2008. [ bib | .pdf ] |
[841] | Sam Lindley, Conor McBride, and Craig McLaughlin. Do be do be do. In Principles of Programming Languages (POPL), January 2017. [ bib | .pdf ] |
[842] | Nathan Linger and Tim Sheard. Programming with static invariants in Ωmega. Unpublished, September 2004. [ bib | .ps ] |
[843] | Barbara Liskov and John V. Guttag. Program development in Java -- abstraction, specification, and object-oriented design. Addison-Wesley, 2001. [ bib | http ] |
[844] | Barbara Liskov and Jeannette M. Wing. A behavioral notion of subtyping. ACM Transactions on Programming Languages and Systems, 16(6):1811--1841, 1994. [ bib | .pdf ] |
[845] | Xinxin Liu and Scott A. Smolka. Simple linear-time algorithms for minimal fixed points. In International Colloquium on Automata, Languages and Programming, volume 1443 of Lecture Notes in Computer Science, pages 53--66. Springer, July 1998. [ bib | http ] |
[846] | Andreas Lochbihler. Light-weight containers for Isabelle: efficient, extensible, nestable. In Interactive Theorem Proving (ITP), volume 7998 of Lecture Notes in Computer Science, pages 116--132. Springer, July 2013. [ bib | .pdf ] |
[847] | John Longley. When is a functional program not a functional program? In International Conference on Functional Programming (ICFP), pages 1--7, September 1999. [ bib | http ] |
[848] | John Longley and Randy Pollack. Reasoning about CBV functional programs in Isabelle/HOL. In Theorem Proving in Higher Order Logics (TPHOLs), volume 3223 of Lecture Notes in Computer Science, pages 201--216. Springer, September 2004. [ bib | .pdf ] |
[849] | John M. Lucassen and David K. Gifford. Polymorphic effect systems. In Principles of Programming Languages (POPL), pages 47--57, January 1988. [ bib | .pdf ] |
[850] | Ralf Lämmel and Simon Peyton Jones. Scrap your boilerplate with class: extensible generic functions. Submitted, April 2005. [ bib | .ps ] |
[851] | Ralf Lämmel, Joost Visser, and Jan Kort. Dealing with large bananas. In Workshop on Generic Programming, pages 46--59, July 2000. [ bib | .ps ] |
[852] | Kenneth MacKenzie and Nicholas Wolverson. Camelot and Grail: resource-aware functional programming for the JVM. In Trends in Functional Programming (TFP), volume 4, pages 29--46, September 2003. [ bib | .ps ] |
[853] | David B. MacQueen, Gordon D. Plotkin, and Ravi Sethi. An ideal model for recursive polymorphic types. Information and Control, 71(1--2):95--130, October--November 1986. [ bib ] |
[854] | Angelika Mader. Verification of modal properties using Boolean equation systems. PhD thesis, Technische Universität München, 1997. [ bib | .pdf ] |
[855] | Ravichandhran Madhavan, Sumith Kulal, and Viktor Kuncak. Contract-based resource verification for higher-order functions with memoization. In Principles of Programming Languages (POPL), pages 330--343, January 2017. [ bib | .pdf ] |
[856] | Magnus Madsen, Ming-Ho Yee, and Ondrej Lhoták. From Datalog to Flix: a declarative language for fixed points on lattices. In Programming Language Design and Implementation (PLDI), pages 194--208, June 2016. [ bib | .pdf ] |
[857] | Toshiyuki Maeda, Haruki Sato, and Akinori Yonezawa. Extended alias type system using separating implication. In Types in Language Design and Implementation (TLDI), pages 29--42, January 2011. [ bib | http ] |
[858] | Michael J. Maher. Complete axiomatizations of the algebras of finite, rational and infinite trees. In Logic in Computer Science (LICS), pages 348--357, July 1988. [ bib ] |
[859] | Harry G. Mairson. Deciding ML typability is complete for deterministic exponential time. In Principles of Programming Languages (POPL), pages 382--401, 1990. [ bib | http ] |
[860] | Harry G. Mairson, Paris C. Kanellakis, and John C. Mitchell. Unification and ML type reconstruction. In J.-L. Lassez and G. Plotkin, editors, Computational Logic: Essays in Honor of Alan Robinson, pages 444--478. MIT Press, 1991. [ bib ] |
[861] | Claude Marché, Christine Paulin-Mohring, and Xavier Urbain. The Krakatoa tool for certification of Java/JavaCard programs annotated in JML. Journal of Logic and Algebraic Programming, 58(1--2):89--106, 2004. [ bib | .ps.gz ] |
[862] | Filip Marić. Formalization and implementation of modern SAT solvers. Journal of Automated Reasoning, 43:81--119, 2009. [ bib | .pdf ] |
[863] | Filip Marić. Formal verification of a modern SAT solver. Unpublished, January 2010. [ bib | .pdf ] |
[864] | Simon Marlow and Andy Gill. Happy: the parser generator for Haskell, April 2004. [ bib | http ] |
[865] | Simon Marlow and Philip Wadler. A practical subtyping system for Erlang. In International Conference on Functional Programming (ICFP), pages 136--149, June 1997. [ bib ] |
[866] | Kim Marriott and Martin Odersky. Negative Boolean constraints. Technical Report 94/203, Monash University, August 1994. [ bib | .ps.gz ] |
[867] | Alberto Martelli and Ugo Montanari. An efficient unification algorithm. ACM Transactions on Programming Languages and Systems, 4(2):258--282, April 1982. [ bib | http ] |
[868] | Radu Mateescu and Mihaela Sighireanu. Efficient on-the-fly model-checking for regular alternation-free mu-calculus. Science of Computer Programming, 46(3):255--281, 2003. [ bib | .pdf ] |
[869] | Nicholas D. Matsakis and Felix S. Klock,II. The Rust language. In ACM SIGAda Annual Conference on High Integrity Language Technology (HILT), pages 103--104, 2014. [ bib | http ] |
[870] | Michel Mauny and François Pottier. An implementation of Caml Light with existential types. Technical Report 2183, INRIA, 1993. [ bib | .ps.gz ] |
[871] | Karl Mazurak, Jianzhou Zhao, and Steve Zdancewic. Lightweight linear types in system F^{o}. In Types in Language Design and Implementation (TLDI), pages 77--88, January 2010. [ bib | .pdf ] |
[872] | Bruce J. McAdam. On the Unification of Substitutions in Type Inference. In Implementation of Functional Languages (IFL), volume 1595 of Lecture Notes in Computer Science, pages 139--154. Springer, September 1998. [ bib | .ps ] |
[873] | David McAllester. On the complexity analysis of static analyses. Journal of the ACM, 49(4):512--537, July 2002. [ bib | http ] |
[874] | David McAllester. A logical algorithm for ML type inference. In Rewriting Techniques and Applications (RTA), volume 2706 of Lecture Notes in Computer Science, pages 436--451. Springer, June 2003. [ bib | .ps ] |
[875] | Conor McBride. The derivative of a regular type is its type of one-hole contexts. Unpublished. [ bib | .pdf ] |
[876] | Conor McBride. First-order unification by structural recursion. Journal of Functional Programming, 13(6):1061--1075, 2003. [ bib | .ps.gz ] |
[877] | Conor McBride and James McKinna. I am not a number: I am a free variable. In Haskell workshop, September 2004. [ bib | .pdf ] |
[878] | Conor McBride and Ross Paterson. Applicative programming with effects. Journal of Functional Programming, 18(1):1--13, 2008. [ bib | .pdf ] |
[879] | Jay A. McCarthy, Burke Fetscher, Max S. New, Daniel Feltey, and Robert Bruce Findler. A Coq library for internal verification of running-times. In Functional and Logic Programming, volume 9613 of Lecture Notes in Computer Science, pages 144--162. Springer, March 2016. [ bib | .pdf ] |
[880] | James McKinna and Randy Pollack. Pure type systems formalized. In Typed Lambda Calculi and Applications (TLCA), number 664 in Lecture Notes in Computer Science, pages 289--305. Springer, March 1993. [ bib | .ps.gz ] |
[881] | James McKinna and Randy Pollack. Some lambda calculus and type theory formalized. Journal of Automated Reasoning, 23(3--4):373--409, 1999. [ bib ] |
[882] | John McLean. A general theory of composition for trace sets closed under selective interleaving functions. In IEEE Symposium on Security and Privacy (S&P), 1994. [ bib | .ps ] |
[883] | John McLean. Security models. In John Marciniak, editor, Encyclopedia of Software Engineering. John Wiley & Sons, 1994. [ bib | .ps ] |
[884] | Catherine Meadows. Formal verification of cryptographic protocols: A survey. In Advances in Cryptology -- ASIACRYPT'94, volume 917 of Lecture Notes in Computer Science, pages 133--150. Springer, 1995. [ bib | .ps ] |
[885] | Farhad Mehta and Tobias Nipkow. Proving pointer programs in higher-order logic. Information and Computation, 199(1--2):200--227, 2005. [ bib | .ps.gz ] |
[886] | Thomas F. Melham. The HOL logic extended with quantification over type variables. Formal Methods in System Design, 3(1--2):7--24, August 1993. [ bib | .pdf ] |
[887] | David Melski and Thomas Reps. Interconvertibility of a class of set constraints and context-free language reachability. Theoretical Computer Science, 248(1--2), November 2000. [ bib | .ps ] |
[888] | Stephan Merz. Model checking: A tutorial overview. In Fourth Summer School on Modeling and Verification of Parallel Processes, volume 2067 of Lecture Notes in Computer Science, pages 3--38. Springer, 2001. [ bib | .pdf ] |
[889] | Stephan Merz. An introduction to model checking. In N. Navet and S. Merz, editors, Modeling and Verification of Real-Time Systems: Formalisms and Software Tools, pages 77--109. ISTE Publishing, 2008. [ bib | .pdf ] |
[890] | Albert R. Meyer and Mitchell Wand. Continuation semantics in typed lambda-calculi. In Logics of Programs, volume 193 of Lecture Notes in Computer Science, pages 219--224. Springer, June 1985. [ bib | .ps ] |
[891] | Dale Miller. An extension to ML to handle bound variables in data structures. In Logical Frameworks BRA Workshop, May 1990. [ bib | .pdf ] |
[892] | Dale Miller. Unification under a mixed prefix. Journal of Symbolic Computation, 14(4):321--358, 1992. [ bib | .pdf ] |
[893] | Dale Miller. Abstract syntax for variable binders: An overview. In Computational Logic, volume 1861 of Lecture Notes in Computer Science, pages 239--253. Springer, July 2000. [ bib | .pdf ] |
[894] | Todd Millstein and Craig Chambers. Modular statically typed multimethods. In European Conference on Object-Oriented Programming (ECOOP), volume 1628 of Lecture Notes in Computer Science, pages 279--303. Springer, June 1999. [ bib | .ps ] |
[895] | Todd Millstein and Craig Chambers. Modular statically typed multimethods. Information and Computation, 175(1):76--118, May 2002. [ bib | .ps ] |
[896] | Robin Milner. Implementation and applications of Scott's logic for computable functions. In Proceedings of the ACM conference on proving assertions about programs, pages 1--6, January 1972. [ bib | http ] |
[897] | Robin Milner. Logic for computable functions -- description of a machine implementation. Technical Report CS-TR-72-288, Stanford University, Department of Computer Science, May 1972. [ bib | .pdf ] |
[898] | Robin Milner. Models of LCF. Technical Report CS-TR-73-332, Stanford University, Department of Computer Science, January 1973. [ bib | .pdf ] |
[899] | Robin Milner. A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17(3):348--375, December 1978. [ bib | http ] |
[900] | Robin Milner. The polyadic π-calculus: a tutorial. Technical Report ECS--LFCS--91--180, Laboratory for Foundations of Computer Science, Department of Computer Science, University of Edinburgh, October 1991. [ bib | .ps.Z ] |
[901] | Robin Milner, Joachim Parrow, and David Walker. A calculus of mobile processes, part 2. Technical Report ECS-LFCS-89-86, Laboratory for Foundations of Computer Science, School of Informatics at the University of Edinburgh, 1989. [ bib | .ps ] |
[902] | Robin Milner and Davide Sangiorgi. Barbed bisimulation. In International Colloquium on Automata, Languages and Programming, volume 623 of Lecture Notes in Computer Science, pages 685--695. Springer, July 1992. [ bib | .ps.gz ] |
[903] | Robin Milner, Mads Tofte, Robert Harper, and David MacQueen. The definition of Standard ML -- revised. MIT Press, May 1997. [ bib ] |
[904] | Yasuhiko Minamide. A functional representation of data structures with a hole. In Principles of Programming Languages (POPL), pages 75--84, January 1998. [ bib | .pdf ] |
[905] | Yasuhiko Minamide, Greg Morrisett, and Robert Harper. Typed closure conversion. In Principles of Programming Languages (POPL), pages 271--283, January 1996. [ bib | .pdf ] |
[906] | Yasuhiko Minamide and Koji Okuma. Verifying CPS transformations in Isabelle/HOL. In ACM Workshop on Mechanized Reasoning about Languages with Variable Binding, 2003. [ bib | http ] |
[907] | Yaron Minsky, Anil Madhavapeddy, and Jason Hickey. Real world OCaml: Functional programming for the masses. O'Reilly, 2013. [ bib | http ] |
[908] | David G. Mitchell. A SAT solver primer. Bulletin of the EATCS, 85:112--133, February 2005. [ bib | .pdf ] |
[909] | John C. Mitchell. Coercion and type inference. In Principles of Programming Languages (POPL), pages 175--185, January 1984. [ bib | http ] |
[910] | John C. Mitchell. Representation independence and data abstraction. In Principles of Programming Languages (POPL), pages 263--276, 1986. [ bib | http ] |
[911] | John C. Mitchell. Polymorphic type inference and containment. Information and Computation, 76(2--3):211--249, 1988. [ bib | http ] |
[912] | John C. Mitchell. Type inference with simple subtypes. Journal of Functional Programming, 1(3):245--286, July 1991. [ bib ] |
[913] | John C. Mitchell. Foundations for programming languages. MIT Press, 1996. [ bib ] |
[914] | John C. Mitchell and Gordon D. Plotkin. Abstract types have existential type. ACM Transactions on Programming Languages and Systems, 10(3):470--502, 1988. [ bib | .pdf ] |
[915] | Masaaki Mizuno and David A. Schmidt. A security flow control algorithm and its denotational semantics correctness proof. Formal Aspects of Computing, 4(6A):727--754, 1992. [ bib | .ps.Z ] |
[916] | Eugenio Moggi. An abstract view of programming languages. Technical Report ECS-LFCS-90-113, University of Edinburgh, June 1989. [ bib | .ps.gz ] |
[917] | Eugenio Moggi. Computational λ-calculus and monads. In Logic in Computer Science (LICS), pages 14--23, June 1989. [ bib | .ps.gz ] |
[918] | Eugenio Moggi. Notions of computation and monads. Information and Computation, 93(1), 1991. [ bib | .pdf ] |
[919] | Eugenio Moggi and Amr Sabry. An abstract monadic semantics for value recursion. Informatique théorique et applications, 38(4):377--400, 2004. [ bib | .pdf ] |
[920] | Anders Møller and Michael I. Schwartzbach. The pointer assertion logic engine. In Programming Language Design and Implementation (PLDI), pages 221--231, June 2001. [ bib | .pdf ] |
[921] | Stefan Monnier. Statically tracking state with typed regions. Unpublished, May 2008. [ bib | .pdf ] |
[922] | Benoît Montagu and Didier Rémy. Modeling abstract types in modules with open existential types. In Principles of Programming Languages (POPL), pages 63--74, January 2009. [ bib | .pdf ] |
[923] | Andrew Moran and David Sands. Improvement in a lazy context: An operational theory for call-by-need. In Principles of Programming Languages (POPL), pages 43--56, January 1999. [ bib | .pdf ] |
[924] | James H. Morris, Donald E. Knuth, and Vaughan R. Pratt. Fast pattern matching in strings. SIAM Journal on Computing, 6(2):323--350, June 1977. [ bib | .pdf ] |
[925] | Greg Morrisett and Robert Harper. Typed closure conversion for recursively-defined functions (extended abstract). In Higher Order Operational Techniques in Semantics (HOOTS), volume 10 of Electronic Notes in Theoretical Computer Science. Elsevier Science, 1998. [ bib | .ps ] |
[926] | Greg Morrisett, David Walker, Karl Crary, and Neal Glew. From system F to typed assembly language. ACM Transactions on Programming Languages and Systems, 21(3):528--569, May 1999. [ bib | .pdf ] |
[927] | Matthew W. Moskewicz, Conor F. Madigan, Ying Zhao, Lintao Zhang, and Sharad Malik. Chaff: Engineering an efficient SAT solver. In Design Automation Conference (DAC), July 2001. [ bib | .pdf ] |
[928] | Peter D. Mosses. Modular structural operational semantics. Journal of Logic and Algebraic Programming, 60--61:195--228, 2004. [ bib | .pdf ] |
[929] | Gilles Muller, Renaud Marlet, Eugen-Nicolae Volanschi, Charles Consel, Calton Pu, and Ashvin Goel. Fast, optimized Sun RPC using automatic program specialization. In International Conference on Distributed Computing Systems (CDCS), pages 240--249, May 1998. [ bib | .pdf ] |
[930] | Martin Müller. A constraint-based recast of ML-polymorphism. In International Workshop on Unification, June 1994. Technical Report 94-R-243, CRIN, Nancy, France. [ bib | .ps ] |
[931] | Martin Müller. Notes on HM(X). Unpublished, August 1998. [ bib | .ps.gz ] |
[932] | Martin Müller, Joachim Niehren, and Ralf Treinen. The first-order theory of ordering constraints over feature trees. Discrete Mathematics and Theoretical Computer Science, 4(2):193--234, 2001. [ bib | .ps ] |
[933] | Martin Müller and Susumu Nishimura. Type inference for first-class messages with feature constraints. In Asian Computer Science Conference (ASIAN), volume 1538 of Lecture Notes in Computer Science, pages 169--187. Springer, December 1998. [ bib | .ps ] |
[934] | Martin Müller and Susumu Nishimura. Type inference for first-class messages with feature constraints. International Journal of Foundations of Computer Science, 11(1):29--63, 2000. [ bib ] |
[935] | Peter Müller and Arnd Poetzsch-Heffter. Universes: A type system for alias and dependency control. Technical Report 279, Fernuniversität Hagen, 2001. [ bib | .pdf ] |
[936] | Peter Müller and Arsenii Rudich. Ownership transfer in universe types. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 461--478, October 2007. [ bib | http ] |
[937] | Peter Müller, Malte Schwerhoff, and Alexander J. Summers. Automatic verification of iterated separating conjunctions using symbolic execution. In Computer Aided Verification (CAV), volume 9779 of Lecture Notes in Computer Science, pages 405--425. Springer, July 2016. [ bib | http ] |
[938] | Peter Müller, Malte Schwerhoff, and Alexander J. Summers. Viper: A verification infrastructure for permission-based reasoning. In Dependable Software Systems Engineering, pages 104--125. 2017. [ bib | http ] |
[939] | Alan Mycroft. Polymorphic type schemes and recursive definitions. In International Symposium on Programming, volume 167 of Lecture Notes in Computer Science, pages 217--228. Springer, April 1984. [ bib | http ] |
[940] | Andrew C. Myers. JFlow: practical mostly-static information flow control. In Principles of Programming Languages (POPL), pages 228--241, January 1999. [ bib | .ps.gz ] |
[941] | Andrew C. Myers. Mostly-static decentralized information flow control. PhD thesis, Massachusetts Institute of Technology, January 1999. Technical Report MIT/LCS/TR-783. [ bib | .ps.gz ] |
[942] | Andrew C. Myers and Barbara Liskov. A decentralized model for information flow control. ACM Operating Systems Review, 31(5):129--142, October 1997. [ bib | .html ] |
[943] | Andrew C. Myers and Barbara Liskov. Complete, safe information flow with decentralized labels. In IEEE Symposium on Security and Privacy (S&P), pages 186--197, May 1998. [ bib | .html ] |
[944] | Andrew C. Myers and Barbara Liskov. Protecting privacy using the decentralized label model. ACM Transactions on Software Engineering and Methodology, 9(4):410--442, October 2000. [ bib | .ps.gz ] |
[945] | Andrew C. Myers and Andrei Sabelfeld. Language-based information-flow security. IEEE Journal on Selected Areas in Communications, 21(1):5--19, January 2003. [ bib | .pdf ] |
[946] | Rasmus Ejlers Møgelberg and Sam Staton. Full abstraction in a metalanguage for state. In Workshop on Syntax and Semantics of Low Level Languages, July 2010. [ bib ] |
[947] | Martin Müller, Joachim Niehren, and Andreas Podelski. Ordering constraints over feature trees. Constraints, an International Journal, 5(1--2):7--42, 2000. [ bib | .ps.gz ] |
[948] | Olaf Müller, Tobias Nipkow, David von Oheimb, and Oskar Slotosch. HOLCF = HOL + LCF. Journal of Functional Programming, 9:191--223, 1999. [ bib | .ps.gz ] |
[949] | Gopalan Nadathur and Dale Miller. An overview of lambda-prolog. In Logic Programming, pages 810--827, August 1988. [ bib | http ] |
[950] | Gopalan Nadathur and Xiaochu Qi. Explicit substitutions in the reduction of lambda terms. In Principles and Practice of Declarative Programming (PPDP), pages 195--206, August 2003. [ bib | .ps ] |
[951] | Karl Naden, Robert Bocchino, Jonathan Aldrich, and Kevin Bierhoff. A type system for borrowing permissions. In Principles of Programming Languages (POPL), pages 557--570, January 2012. [ bib | .pdf ] |
[952] | Maurice Naftalin and Philip Wadler. Java generics and collections. O'Reilly, 2006. [ bib | http ] |
[953] | Hiroshi Nakano. A modality for recursion. In Logic in Computer Science (LICS), pages 255--266, June 2000. [ bib | .ps.gz ] |
[954] | Hiroshi Nakano. Fixed-point logic with the approximation modality and its Kripke completeness. In International Symposium on Theoretical Aspects of Computer Software (TACS), volume 2215 of Lecture Notes in Computer Science, pages 165--182. Springer, October 2001. [ bib | .pdf ] |
[955] | Aleksandar Nanevski. Meta-programming with names and necessity. Technical Report CMU-CS-02-123R, School of Computer Science, Carnegie Mellon University, November 2002. [ bib | .ps ] |
[956] | Aleksandar Nanevski, Amal Ahmed, Greg Morrisett, and Lars Birkedal. Abstract predicates and mutable ADTs in Hoare type theory. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 189--204. Springer, March 2007. [ bib | .pdf ] |
[957] | Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal. Polymorphism and separation in Hoare type theory. In International Conference on Functional Programming (ICFP), pages 62--73, September 2006. [ bib | .pdf ] |
[958] | Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal. Hoare type theory, polymorphism and separation. Journal of Functional Programming, 18(5--6):865--911, 2008. [ bib | .pdf ] |
[959] | Aleksandar Nanevski, Greg Morrisett, Avraham Shinnar, Paul Govereau, and Lars Birkedal. Ynot: dependent types for imperative programs. In International Conference on Functional Programming (ICFP), pages 229--240, September 2008. [ bib | .pdf ] |
[960] | Aleksandar Nanevski, Viktor Vafeiadis, and Josh Berdine. Structuring the verification of heap-manipulating programs. In Principles of Programming Languages (POPL), pages 261--274, January 2010. [ bib | .pdf ] |
[961] | Wolfgang Naraschewski and Tobias Nipkow. Type inference verified: Algorithm W in Isabelle/HOL. Journal of Automated Reasoning, 23:299--318, 1999. [ bib | .ps.gz ] |
[962] | David A. Naumann. On assertion-based encapsulation for object invariants and simulations. Formal Aspects of Computing, 19(2):205--224, 2007. [ bib | .pdf ] |
[963] | Juan Antonio Navarro Pérez and Andrey Rybalchenko. Separation logic + superposition calculus = heap theorem prover. In Programming Language Design and Implementation (PLDI), pages 556--566, June 2011. [ bib | .pdf ] |
[964] | Pierre Neron, Andrew P. Tolmach, Eelco Visser, and Guido Wachsmuth. A theory of name resolution. In European Symposium on Programming (ESOP), volume 9032 of Lecture Notes in Computer Science, pages 205--231. Springer, April 2015. [ bib | .pdf ] |
[965] | René Neumann. A framework for verified depth-first algorithms. In ATx/WInG: Joint Proceedings of the Workshops on Automated Theory eXploration and on Invariant Generation, volume 17 of EPiC Series, pages 36--45. EasyChair, June 2012. [ bib | http ] |
[966] | Huu Hai Nguyen, Cristina David, Shengchao Qin, and Wei-Ngan Chin. Automated verification of shape and size properties via separation logic. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 4349 of Lecture Notes in Computer Science, pages 251--266. Springer, January 2007. [ bib | .pdf ] |
[967] | Jan Nicklisch and Simon Peyton Jones. An exploration of modular programs. In Functional Programming Workshop, July 1996. [ bib | .ps.gz ] |
[968] | Joachim Niehren, Martin Müller, and Andreas Podelski. Inclusion constraints over non-empty sets of trees. In Theory and Practice of Software Development (TAPSOFT), volume 1214 of Lecture Notes in Computer Science, pages 217--231. Springer, April 1997. [ bib | .ps ] |
[969] | Joachim Niehren and Tim Priesnitz. Non-structural subtype entailment in automata theory. In International Symposium on Theoretical Aspects of Computer Software (TACS). Springer, October 2001. [ bib | .ps.gz ] |
[970] | Joachim Niehren and Tim Priesnitz. Non-structural subtype entailment in automata theory. Information and Computation, 186(2):319--354, 2003. [ bib | .pdf ] |
[971] | Lasse R. Nielsen. A denotational investigation of defunctionalization. Technical Report RS-00-47, BRICS, December 2000. [ bib | http ] |
[972] | Flemming Nielson and Hanne Riis Nielson. Two-level semantics and code generation. Theoretical Computer Science, 56(1):59--133, January 1988. [ bib | http ] |
[973] | Flemming Nielson, Hanne Riis Nielson, and Helmut Seidl. A succinct solver for ALFP. Nordic Journal of Computing, 9(4):335--372, 2002. [ bib | .pdf ] |
[974] | Robert Nieuwenhuis, Albert Oliveras, and Cesare Tinelli. Solving SAT and SAT Modulo Theories: From an abstract Davis--Putnam--Logemann--Loveland procedure to DPLL(T). Journal of the ACM, 53(6):937--977, 2006. [ bib | .pdf ] |
[975] | Tobias Nipkow. Amortized complexity verified. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 310--324. Springer, August 2015. [ bib | .pdf ] |
[976] | Susumu Nishimura. Static typing for dynamic messages. In Principles of Programming Languages (POPL), pages 266--278, January 1998. [ bib | .ps.gz ] |
[977] | Gian Ntzik and Philippa Gardner. Reasoning about the POSIX file system: local update and global pathnames. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 201--220, October 2015. [ bib | .pdf ] |
[978] | Russell O'Connor. Assembly: Circular programming with recursive do. The Monad.Reader, 6, January 2007. [ bib | .pdf ] |
[979] | Martin Odersky. Observers for linear types. In European Symposium on Programming (ESOP), volume 582 of Lecture Notes in Computer Science, pages 390--407. Springer, 1992. [ bib | .ps.gz ] |
[980] | Martin Odersky. A functional theory of local names. In Principles of Programming Languages (POPL), pages 48--59, January 1994. [ bib | .ps.gz ] |
[981] | Martin Odersky and Konstantin Läufer. An extension of ML with first-class abstract types. In ACM Workshop on ML and its Applications, pages 78--91, June 1992. [ bib | .pdf ] |
[982] | Martin Odersky and Konstantin Läufer. Putting type annotations to work. In Principles of Programming Languages (POPL), pages 54--67, January 1996. [ bib | .ps.gz ] |
[983] | Martin Odersky, Lex Spoon, and Bill Venners. Programming in Scala, third edition: A comprehensive step-by-step guide. Artima Incorporation, 2016. [ bib | http ] |
[984] | Martin Odersky, Martin Sulzmann, and Martin Wehr. Type inference with constrained types. Theory and Practice of Object Systems, 5(1):35--55, 1999. [ bib | .pdf ] |
[985] | Martin Odersky, Philip Wadler, and Martin Wehr. A second look at overloading. In Functional Programming Languages and Computer Architecture (FPCA), pages 135--146, June 1995. [ bib | .ps.gz ] |
[986] | Martin Odersky, Christoph Zenger, Matthias Zenger, and Gang Chen. A functional view of join. Technical Report ACRC-99-016, University of South Australia, 1999. [ bib | .ps.gz ] |
[987] | Martin Odersky and Matthias Zenger. Scalable component abstractions. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 41--57, October 2005. [ bib | .pdf ] |
[988] | Martin Odersky, Matthias Zenger, and Christoph Zenger. Colored local type inference. In Principles of Programming Languages (POPL), pages 41--53, 2001. [ bib | .ps.gz ] |
[989] | Peter O'Hearn. On bunched typing. Journal of Functional Programming, 13(4):747--796, 2003. [ bib | .pdf ] |
[990] | Peter W. O'Hearn. Resources, concurrency and local reasoning. Theoretical Computer Science, 375(1--3):271--307, May 2007. [ bib | .pdf ] |
[991] | Peter W. O'Hearn, John Power, Makoto Takeyama, and Robert D. Tennent. Syntactic control of interference revisited. Theoretical Computer Science, 228(1-2):211--252, 1999. [ bib | http ] |
[992] | Peter W. O'Hearn and John C. Reynolds. From Algol to polymorphic linear lambda-calculus. Journal of the ACM, 47(1):167--223, 2000. [ bib | .ps ] |
[993] | Peter W. O'Hearn, Hongseok Yang, and John C. Reynolds. Separation and information hiding. In Principles of Programming Languages (POPL), pages 268--280, January 2004. [ bib | .pdf ] |
[994] | Peter W. O'Hearn, Hongseok Yang, and John C. Reynolds. Separation and information hiding. ACM Transactions on Programming Languages and Systems, 31(3), 2009. [ bib | .pdf ] |
[995] | Atsushi Ohori. A polymorphic record calculus and its compilation. ACM Transactions on Programming Languages and Systems, 17(6):844--895, November 1995. [ bib | http ] |
[996] | Atsushi Ohori and Peter Buneman. Type inference in a database programming language. In ACM Symposium on Lisp and Functional Programming (LFP), pages 174--183, 1988. [ bib | .pdf ] |
[997] | Chris Okasaki. Purely functional data structures. Technical Report CMU-CS-96-177, School of Computer Science, Carnegie Mellon University, September 1996. [ bib | .pdf ] |
[998] | Chris Okasaki. The role of lazy evaluation in amortized data structures. In International Conference on Functional Programming (ICFP), pages 62--72, May 1996. [ bib | .ps ] |
[999] | Chris Okasaki. Views for Standard ML. In ACM Workshop on ML, pages 14--23, September 1998. [ bib | .ps ] |
[1000] | Chris Okasaki. Purely functional data structures. Cambridge University Press, 1999. [ bib | http ] |
[1001] | Chris Okasaki and Andy Gill. Fast mergeable integer maps. In ACM Workshop on ML, pages 77--86, September 1998. [ bib | .ps ] |
[1002] | Ernst-Rüdiger Olderog. A characterization of Hoare's logic for programs with Pascal-like procedures. In ACM Symposium on Theory of Computing, pages 320--329, 1983. [ bib | http ] |
[1003] | Oswaldo Olivo, Isil Dillig, and Calvin Lin. Static detection of asymptotic performance bugs in collection traversals. In Programming Language Design and Implementation (PLDI), pages 369--378, June 2015. [ bib | .pdf ] |
[1004] | Peter Ørbæk and Jens Palsberg. Trust in the λ-calculus. Journal of Functional Programming, 7(6):557--591, November 1997. [ bib | .pdf ] |
[1005] | Joseph O'Rourke. Computational geometry in C, second edition. Cambridge University Press, 1998. [ bib | .html ] |
[1006] | James William O'Toole, Jr. and David K. Gifford. Type reconstruction with first-class polymorphic values. In Programming Language Design and Implementation (PLDI), pages 207--217, 1989. [ bib | .ps ] |
[1007] | Scott Owens, John H. Reppy, and Aaron Turon. Regular-expression derivatives re-examined. Journal of Functional Programming, 19(2):173--190, 2009. [ bib | .pdf ] |
[1008] | David Pager. A practical general method for constructing LR(k) parsers. Acta Informatica, 7:249--268, 1977. [ bib | http ] |
[1009] | Robert Paige and Fritz Henglein. Mechanical translation of set theoretic problem specifications into efficient RAM code -- A case study. Journal of Symbolic Computation, 4(2):207--232, 1987. [ bib | http ] |
[1010] | Robert Paige and Robert E. Tarjan. Three partition refinement algorithms. SIAM Journal on Computing, 16(6):973--989, December 1987. [ bib | .pdf ] |
[1011] | Jens Palsberg. Efficient inference of object types. Information and Computation, 123(2):198--209, 1995. [ bib | .pdf ] |
[1012] | Jens Palsberg and Patrick M. O'Keefe. A type system equivalent to flow analysis. ACM Transactions on Programming Languages and Systems, 17(4):576--599, July 1995. [ bib | .pdf ] |
[1013] | Jens Palsberg and Peter Ørbæk. Trust in the λ-calculus. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science, pages 314--330, September 1995. [ bib | .dvi.gz ] |
[1014] | Jens Palsberg and Scott Smith. Constrained types and their expressiveness. ACM Transactions on Programming Languages and Systems, 18(5):519--527, September 1996. [ bib | .pdf ] |
[1015] | Jens Palsberg, Mitchell Wand, and Patrick M. O'Keefe. Type inference with non-structural subtyping. Formal Aspects of Computing, 9:49--67, 1997. [ bib | .pdf ] |
[1016] | Jens Palsberg and Tian Zhao. Efficient and flexible matching of recursive types. Information and Computation, 171:364--387, 2001. [ bib | .pdf ] |
[1017] | Jens Palsberg and Tian Zhao. Efficient type inference for record concatenation and subtyping. In Logic in Computer Science (LICS), pages 125--136, July 2002. [ bib ] |
[1018] | Jens Palsberg and Tian Zhao. Type inference for record concatenation and subtyping. Information and Computation, 189:54--86, 2004. [ bib | .pdf ] |
[1019] | Matthew Parkinson and Gavin Bierman. Separation logic and abstraction. In Principles of Programming Languages (POPL), pages 247--258, January 2005. [ bib | http ] |
[1020] | Matthew Parkinson and Gavin Bierman. Separation logic, abstraction and inheritance. In Principles of Programming Languages (POPL), pages 75--86, January 2008. [ bib | http ] |
[1021] | David Lorge Parnas. Information distribution aspects of design methodology. In Information Processing 71, volume 1, pages 339--344, 1971. [ bib | .PDF ] |
[1022] | David Lorge Parnas. On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12):1053--1058, 1972. [ bib | http ] |
[1023] | Terence Parr. The definitive ANTLR 4 reference, 2nd edition. Pragmatic Bookshelf, 2013. [ bib ] |
[1024] | Pašalić and Nathan Linger. Meta-programming with typed object-language representations. In Generative Programming and Component Engineering (GPCE), pages 136--167, October 2004. [ bib | .ps ] |
[1025] | Emir Pašalić, Tim Sheard, and Walid Taha. DALI: An untyped, CBV functional language supporting first-order datatypes with binders (technical development). Technical Report 00-007, Oregon Graduate Institute, March 2000. [ bib | .pdf ] |
[1026] | Emir Pašalić, Walid Taha, and Tim Sheard. Tagless staged interpreters for typed languages. In International Conference on Functional Programming (ICFP), pages 218--229, October 2002. [ bib | .pdf ] |
[1027] | M. S. Paterson and M. N. Wegman. Linear unification. In Annual ACM Symposium on Theory of Computing, pages 181--186, 1976. [ bib ] |
[1028] | Md. Mostofa Ali Patwary, Jean Blair, and Fredrik Manne. Experiments on union-find algorithms for the disjoint-set data structure. In International Symposium on Experimental Algorithms (SEA), volume 6049 of Lecture Notes in Computer Science, pages 411--423. Springer, May 2010. [ bib | .pdf ] |
[1029] | Christine Paulin-Mohring. Extracting F_{ω}'s programs from proofs in the calculus of constructions. In Principles of Programming Languages (POPL), pages 89--104, January 1989. [ bib | http ] |
[1030] | Christine Paulin-Mohring. Inductive definitions in the system Coq: rules and properties. Research Report RR1992-49, ENS Lyon, 1992. [ bib | .ps.Z ] |
[1031] | Thomas J. Pennello. Very fast LR parsing. In Symposium on Compiler Construction, pages 145--151, 1986. [ bib | http ] |
[1032] | François Pessaux and Xavier Leroy. Type-based analysis of uncaught exceptions. ACM Transactions on Programming Languages and Systems, 22(2):340--377, 2000. [ bib | .ps.gz ] |
[1033] | John Peterson and Mark P. Jones. Implementing type classes. In Programming Language Design and Implementation (PLDI), pages 227--236, June 1993. [ bib | .ps ] |
[1034] | Simon Peyton Jones. The implementation of functional programming languages. Prentice Hall, 1987. [ bib | http ] |
[1035] | Simon Peyton Jones, editor. Haskell 98 language and libraries: The revised report. Cambridge University Press, April 2003. [ bib | http ] |
[1036] | Simon Peyton Jones. Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell. Online lecture notes, January 2009. [ bib | .pdf ] |
[1037] | Simon Peyton Jones and Simon Marlow. Secrets of the Glasgow Haskell Compiler inliner. Journal of Functional Programming, 12(4&5):393--433, 2002. [ bib | .ps.gz ] |
[1038] | Simon Peyton Jones and Mark Shields. Lexically-scoped type variables. Manuscript, April 2004. [ bib | http ] |
[1039] | Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Mark Shields. Practical type inference for arbitrary-rank types. Journal of Functional Programming, 17(1):1--82, 2007. [ bib | .pdf ] |
[1040] | Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey Washburn. Simple unification-based type inference for GADTs. In International Conference on Functional Programming (ICFP), pages 50--61, September 2006. [ bib | .pdf ] |
[1041] | Simon Peyton Jones and Philip Wadler. Imperative functional programming. In Principles of Programming Languages (POPL), pages 71--84, January 1993. [ bib | .ps.gz ] |
[1042] | Simon Peyton Jones, Geoffrey Washburn, and Stephanie Weirich. Wobbly types: type inference for generalised algebraic data types. Technical Report MS-CIS-05-26, University of Pennsylvania, July 2004. [ bib | .pdf ] |
[1043] | Frank Pfenning and Conal Elliott. Higher-order abstract syntax. In Programming Language Design and Implementation (PLDI), pages 199--208, June 1988. [ bib | http ] |
[1044] | Frank Pfenning and Peter Lee. LEAP: A language with eval and polymorphism. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 345--359. Springer, 1989. [ bib | http ] |
[1045] | Brigitte Pientka. Proof pearl: The power of higher-order encodings in the logical framework LF. In Theorem Proving in Higher Order Logics (TPHOLs), volume 4732 of Lecture Notes in Computer Science, pages 246--261. Springer, September 2007. [ bib | .pdf ] |
[1046] | Brigitte Pientka. A type-theoretic foundation for programming with higher-order abstract syntax and first-class substitutions. In Principles of Programming Languages (POPL), pages 371--382, January 2008. [ bib | .pdf ] |
[1047] | Brigitte Pientka and Joshua Dunfield. Programming with proofs and explicit contexts. In Principles and Practice of Declarative Programming (PPDP), pages 163--173, July 2008. [ bib | .pdf ] |
[1048] | Benjamin Pierce and Davide Sangiorgi. Typing and subtyping for mobile processes. In Logic in Computer Science (LICS), pages 376--385, June 1993. [ bib | .ps ] |
[1049] | Benjamin C. Pierce. Bounded quantification is undecidable. Information and Computation, 112(1):131--165, July 1994. [ bib | .ps ] |
[1050] | Benjamin C. Pierce. Types and programming languages. MIT Press, 2002. [ bib | http ] |
[1051] | Benjamin C. Pierce. Types and programming languages. MIT Press, 2002. [ bib ] |
[1052] | Benjamin C. Pierce and David N. Turner. Statically typed friendly functions via partially abstract types. Technical Report ECS-LFCS-93-256, University of Edinburgh, LFCS, April 1993. Also available as INRIA Research Report 1899. [ bib | .ps ] |
[1053] | Benjamin C. Pierce and David N. Turner. Simple type-theoretic foundations for object-oriented programming. Journal of Functional Programming, 4(2):207--247, April 1994. [ bib | .ps ] |
[1054] | Benjamin C. Pierce and David N. Turner. Local type inference. ACM Transactions on Programming Languages and Systems, 22(1):1--44, January 2000. [ bib | http ] |
[1055] | Alexandre Pilkiewicz and François Pottier. The essence of monotonic state. In Types in Language Design and Implementation (TLDI), January 2011. [ bib | .pdf ] |
[1056] | Ruzica Piskac, Thomas Wies, and Damien Zufferey. Automating separation logic using SMT. In Computer Aided Verification (CAV), volume 8044 of Lecture Notes in Computer Science, pages 773--789. Springer, July 2013. [ bib | .pdf ] |
[1057] | Ruzica Piskac, Thomas Wies, and Damien Zufferey. Automating separation logic with trees and data. In Computer Aided Verification (CAV), volume 8559 of Lecture Notes in Computer Science, pages 711--728. Springer, July 2014. [ bib | .pdf ] |
[1058] | Andrew M. Pitts. Parametric polymorphism and operational equivalence. Mathematical Structures in Computer Science, 10:321--359, 2000. [ bib | .pdf ] |
[1059] | Andrew M. Pitts. Nominal logic, A first order theory of names and binding. Information and Computation, 186:165--193, 2003. [ bib | .pdf ] |
[1060] | Andrew M. Pitts. Alpha-structural recursion and induction. In Theorem Proving in Higher Order Logics (TPHOLs), Lecture Notes in Computer Science. Springer, August 2005. [ bib | .pdf ] |
[1061] | Andrew M. Pitts. Alpha-structural recursion and induction. Journal of the ACM, 53:459--506, 2006. [ bib | .pdf ] |
[1062] | Andrew M. Pitts. Nominal System T. In Principles of Programming Languages (POPL), pages 159--170, January 2010. [ bib | .pdf ] |
[1063] | Andrew M. Pitts and Murdoch J. Gabbay. A metalanguage for programming with bound names modulo renaming. In Mathematics of Program Construction (MPC), volume 1837 of Lecture Notes in Computer Science, pages 230--255. Springer, 2000. [ bib | .pdf ] |
[1064] | Gordon Plotkin. An illative theory of relations. In Situation Theory and its Applications, number 22 in CSLI Lecture Notes, pages 133--146. Stanford University, 1990. [ bib | .pdf ] |
[1065] | Gordon D. Plotkin. Call-by-name, call-by-value and the λ-calculus. Theoretical Computer Science, 1(2):125--159, 1975. [ bib | .pdf ] |
[1066] | Gordon D. Plotkin. LCF considered as a programming language. Theoretical Computer Science, 5(3):225--255, 1977. [ bib | .pdf ] |
[1067] | Nadia Polikarpova, Julian Tschannen, and Carlo A. Furia. A fully verified container library. In Formal Methods (FM), volume 9109 of Lecture Notes in Computer Science, pages 414--434. Springer, June 2015. [ bib | .pdf ] |
[1068] | Randy Pollack, Masahiko Sato, and Wilmer Ricciotti. A canonical locally named representation of binding. Journal of Automated Reasoning, 49(2):185--207, 2012. [ bib | .pdf ] |
[1069] | Satya Kiran Popuri. Understanding C parsers generated by GNU Bison, September 2006. [ bib | .html ] |
[1070] | Adam Poswolsky and Carsten Schürmann. Practical programming with higher-order encodings and dependent types. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 93--107. Springer, March 2008. [ bib | .pdf ] |
[1071] | Adam Poswolsky and Carsten Schürmann. System description: Delphin -- A functional programming language for deductive systems. Electronic Notes in Theoretical Computer Science, 228:113--120, 2009. [ bib | .pdf ] |
[1072] | Alex Potanin, Johan Östlund, Yoav Zibin, and Michael D. Ernst. Immutability. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 233--269. Springer, 2013. [ bib | .pdf ] |
[1073] | François Pottier. Implémentation d'un système de modules évolué en Caml-Light. Research Report 2449, INRIA, 1995. [ bib | .ps.gz ] |
[1074] | François Pottier. Type inference and simplification for recursively constrained types. In Actes du GDR Programmation 1995 (journée du pôle Programmation Fonctionnelle), November 1995. [ bib | .ps.gz ] |
[1075] | François Pottier. Simplifying subtyping constraints. In International Conference on Functional Programming (ICFP), pages 122--133, January 1996. [ bib | .ps.gz ] |
[1076] | François Pottier. A framework for type inference with subtyping. In International Conference on Functional Programming (ICFP), pages 228--238, September 1998. [ bib | .ps.gz ] |
[1077] | François Pottier. Synthèse de types en présence de sous-typage: de la théorie à la pratique. PhD thesis, Université Paris 7, July 1998. [ bib | .ps.gz ] |
[1078] | François Pottier. Type inference in the presence of subtyping: from theory to practice. Research Report 3483, INRIA, September 1998. [ bib | .pdf ] |
[1079] | François Pottier. A 3-part type inference engine. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 320--335. Springer, March 2000. [ bib | .ps.gz ] |
[1080] | François Pottier. A versatile constraint-based type inference system. Nordic Journal of Computing, 7(4):312--347, November 2000. [ bib | .ps.gz ] |
[1081] | François Pottier. Wallace: an efficient implementation of type inference with subtyping, February 2000. [ bib | http ] |
[1082] | François Pottier. A semi-syntactic soundness proof for HM(X). Research Report 4150, INRIA, March 2001. [ bib | .pdf ] |
[1083] | François Pottier. Simplifying subtyping constraints: a theory. Information and Computation, 170(2):153--183, November 2001. [ bib | .ps.gz ] |
[1084] | François Pottier. A simple view of type-secure information flow in the π-calculus. In IEEE Computer Security Foundations Workshop, pages 320--330, June 2002. [ bib | .ps.gz ] |
[1085] | François Pottier. A constraint-based presentation and generalization of rows. In Logic in Computer Science (LICS), pages 331--340, June 2003. [ bib | .ps.gz ] |
[1086] | François Pottier. Cαml, June 2005. [ bib | http ] |
[1087] | François Pottier. An overview of Cαml. In ACM Workshop on ML, volume 148(2) of Electronic Notes in Theoretical Computer Science, pages 27--52, March 2006. [ bib | .pdf ] |
[1088] | François Pottier. Static name control for FreshML. In Logic in Computer Science (LICS), pages 356--365, July 2007. [ bib | .pdf ] |
[1089] | François Pottier. Hiding local state in direct style: a higher-order anti-frame rule. In Logic in Computer Science (LICS), pages 331--340, June 2008. [ bib | .pdf ] |
[1090] | François Pottier. Generalizing the higher-order frame and anti-frame rules. Unpublished, July 2009. [ bib | .pdf ] |
[1091] | François Pottier. Lazy least fixed points in ML. Unpublished, December 2009. [ bib | .pdf ] |
[1092] | François Pottier. Three comments on the anti-frame rule. Unpublished, July 2009. [ bib | .pdf ] |
[1093] | François Pottier. Syntactic soundness proof of a type-and-capability system with hidden state. Journal of Functional Programming, 23(1):38--144, January 2013. [ bib | .pdf ] |
[1094] | François Pottier. Depth-first search and strong connectivity in Coq. In Journées Françaises des Langages Applicatifs (JFLA), January 2015. [ bib | .pdf ] |
[1095] | François Pottier. Reachability and error diagnosis in LR(1) automata. In Journées Françaises des Langages Applicatifs (JFLA), January 2016. [ bib | .pdf ] |
[1096] | François Pottier. Reachability and error diagnosis in LR(1) parsers. In Compiler Construction (CC), pages 88--98, March 2016. [ bib | .pdf ] |
[1097] | François Pottier. AlphaLib. https://gitlab.inria.fr/fpottier/alphaLib, 2017. [ bib ] |
[1098] | François Pottier. The visitors package. https://gitlab.inria.fr/fpottier/visitors, April 2017. [ bib ] |
[1099] | François Pottier. Verifying a hash table and its iterators in higher-order separation logic. In Certified Programs and Proofs (CPP), pages 3--16, January 2017. [ bib | .pdf ] |
[1100] | François Pottier and Sylvain Conchon. Information flow inference for free. In International Conference on Functional Programming (ICFP), pages 46--57, September 2000. [ bib | .ps.gz ] |
[1101] | François Pottier and Nadji Gauthier. Polymorphic typed defunctionalization. In Principles of Programming Languages (POPL), pages 89--98, January 2004. [ bib | .pdf ] |
[1102] | François Pottier and Nadji Gauthier. Polymorphic typed defunctionalization and concretization. Higher-Order and Symbolic Computation, 19:125--162, March 2006. [ bib | .pdf ] |
[1103] | François Pottier and Jonathan Protzenko. Programming with permissions in Mezzo. In International Conference on Functional Programming (ICFP), pages 173--184, September 2013. [ bib | .pdf ] |
[1104] | François Pottier and Jonathan Protzenko. A few lessons from the Mezzo project. In Summit on Advances in Programming Languages (SNAPL), May 2015. [ bib | .pdf ] |
[1105] | François Pottier and Yann Régis-Gianas. The Menhir parser generator. http://gallium.inria.fr/~fpottier/menhir/. [ bib ] |
[1106] | François Pottier and Yann Régis-Gianas. Stratified type inference for generalized algebraic data types. In Principles of Programming Languages (POPL), pages 232--244, January 2006. [ bib | .pdf ] |
[1107] | François Pottier and Yann Régis-Gianas. Towards efficient, typed LR parsers. Electronic Notes in Theoretical Computer Science, 148(2):155--180, 2006. [ bib | .pdf ] |
[1108] | François Pottier and Didier Rémy. The essence of ML type inference. Draft of an extended version. Unpublished, September 2003. [ bib | .pdf ] |
[1109] | François Pottier and Didier Rémy. The essence of ML type inference. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 10, pages 389--489. MIT Press, 2005. [ bib | .pdf ] |
[1110] | François Pottier and Vincent Simonet. Information flow inference for ML. In Principles of Programming Languages (POPL), pages 319--330, January 2002. [ bib | .ps.gz ] |
[1111] | François Pottier and Vincent Simonet. Information flow inference for ML. ACM Transactions on Programming Languages and Systems, 25(1):117--158, January 2003. [ bib | .ps.gz ] |
[1112] | François Pottier, Christian Skalka, and Scott Smith. A systematic approach to static access control. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 30--45. Springer, April 2001. [ bib | .ps.gz ] |
[1113] | François Pottier, Christian Skalka, and Scott Smith. A systematic approach to static access control. ACM Transactions on Programming Languages and Systems, 27(2):344--382, 2005. [ bib | .ps.gz ] |
[1114] | Garrel Pottinger. A type assignment for the strongly normalizable λ-terms. In J. Roger Hindley and Jonathan P. Seldin, editors, To H. B. Curry: Essays on Combinatory Logic, Lambda Calculus, and Formalism, pages 561--577. Academic Press, 1980. [ bib ] |
[1115] | Nicolas Pouillard. Nameless, painless. In International Conference on Functional Programming (ICFP), pages 320--332, September 2011. [ bib | .pdf ] |
[1116] | Nicolas Pouillard and François Pottier. A fresh look at programming with names and binders. In International Conference on Functional Programming (ICFP), pages 217--228, September 2010. [ bib | .pdf ] |
[1117] | Nicolas Pouillard and François Pottier. A unified treatment of syntax with binders. Journal of Functional Programming, 22(4--5):614--704, September 2012. [ bib | .pdf ] |
[1118] | Vaughan Pratt and Jerzy Tiuryn. Satisfiability of inequalities in a poset. Fundamenta Informaticæ, 28(1--2):165--182, 1996. [ bib | .ps.gz ] |
[1119] | Matija Pretnar. An introduction to algebraic effects and handlers. Electronic Notes in Theoretical Computer Science, 319:19--35, 2015. [ bib | .pdf ] |
[1120] | Jonathan Protzenko. Mezzo: a typed language for safe effectful concurrent programs. PhD thesis, Université Paris Diderot, September 2014. [ bib | http ] |
[1121] | William Pugh and Grant Weddell. Two-directional record layout for multiple inheritance. In Programming Language Design and Implementation (PLDI), pages 85--91, 1990. [ bib | http ] |
[1122] | Paul Purdom. The size of LALR(1) parsers. BIT Numerical Mathematics, 14(3):326--337, 1974. [ bib | http ] |
[1123] | Zhenyu Qian. Unification of higher-order patterns in linear time and space. Journal of Logic and Computation, 6(3):315--341, 1996. [ bib ] |
[1124] | Christophe Raffalli. Type checking in system F^{η}. Prépublication 98-05a, LAMA, Université de Savoie, 1998. [ bib | .ps ] |
[1125] | Christophe Raffalli. An optimized complete semi-algorithm for system F^{η}. Unpublished, 1999. [ bib | .ps ] |
[1126] | Viswanath Ramachandran and Pascal Van Hentenryck. Incremental algorithms for constraint solving and entailment over rational trees. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 205--217, 1993. [ bib ] |
[1127] | G. Ramalingam, Alex Varshavsky, John Field, Deepak Goyal, and Shmuel Sagiv. Deriving specialized program analyses for certifying component-client conformance. In Programming Language Design and Implementation (PLDI), pages 83--94, June 2002. [ bib | .pdf ] |
[1128] | Eric Reed. Patina: A formalization of the Rust programming language. Technical Report UW-CSE-15-03-02, University of Washington, March 2015. [ bib | .pdf ] |
[1129] | Franz Regensburger. HOLCF: Higher order logic of computable functions. In Theorem Proving in Higher Order Logics (TPHOLs), volume 971 of Lecture Notes in Computer Science, pages 293--307. Springer, September 1995. [ bib | .pdf ] |
[1130] | Jakob Rehof. Minimal typings in atomic subtyping. Technical Report D-278, Department of Computer Science, University of Copenhagen, 1996. [ bib | .ps.gz ] |
[1131] | Jakob Rehof. Minimal typings in atomic subtyping. In Principles of Programming Languages (POPL), pages 278--291, January 1997. [ bib | .ps ] |
[1132] | Jakob Rehof and Manuel Fähndrich. Type-based flow analysis: From polymorphic subtyping to CFL-reachability. In Principles of Programming Languages (POPL), pages 54--66, January 2001. [ bib | .ps ] |
[1133] | Brian Reistad and David K. Gifford. Static dependent costs for estimating execution time. In ACM Symposium on Lisp and Functional Programming (LFP), pages 65--78, 1994. [ bib | .pdf ] |
[1134] | Didier Rémy. Extending ML type system with a sorted equational theory. Technical Report 1766, INRIA, 1992. [ bib | .pdf ] |
[1135] | Didier Rémy. Projective ML. In ACM Symposium on Lisp and Functional Programming (LFP), pages 66--75, 1992. [ bib | .pdf ] |
[1136] | Didier Rémy. Syntactic theories and the algebra of record terms. Research Report 1869, INRIA, 1993. [ bib | .pdf ] |
[1137] | Didier Rémy. Programming objects with ML-ART: An extension to ML with abstract and record types. In International Symposium on Theoretical Aspects of Computer Software (TACS), pages 321--346. Springer, April 1994. [ bib | .pdf ] |
[1138] | Didier Rémy. Type inference for records in a natural extension of ML. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
[1139] | Didier Rémy. Typing record concatenation for free. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming. Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
[1140] | Didier Rémy. A case study of typechecking with constrained types: Typing record concatenation. Workshop on Advances in Types for Computer Science, August 1995. [ bib | .dvi.gz ] |
[1141] | Didier Rémy. From classes to objects via subtyping. In European Symposium on Programming (ESOP), volume 1381 of Lecture Notes in Computer Science, pages 200--220. Springer, March 1998. [ bib | .pdf ] |
[1142] | Didier Rémy and Jérôme Vouillon. Objective ML: A simple object-oriented extension of ML. In Principles of Programming Languages (POPL), pages 40--53, January 1997. [ bib | .pdf ] |
[1143] | Didier Rémy and Jérôme Vouillon. Objective ML: An effective object-oriented extension to ML. Theory and Practice of Object Systems, 4(1):27--50, 1998. [ bib | .pdf ] |
[1144] | Didier Rémy and Boris Yakobowski. A Church-style intermediate language for MLF. Theoretical Computer Science, 435(1):77--105, June 2012. [ bib | .pdf ] |
[1145] | Thomas Reps. Program analysis via graph reachability. Information and Software Technology, 40(11--12):701--726, 1998. [ bib | .pdf ] |
[1146] | William S. Retert. Implementing permission analysis. PhD thesis, University of Wisconsin-Milwaukee, May 2009. [ bib ] |
[1147] | Bernhard Reus and Jan Schwinghammer. Separation logic for higher-order store. In Computer Science Logic, volume 4207 of Lecture Notes in Computer Science, pages 575--590. Springer, September 2006. [ bib | .pdf ] |
[1148] | Dominique Revuz. Minimization of acyclic deterministic automata in linear time. Theoretical Computer Science, 92(1):181--189, 1992. [ bib ] |
[1149] | John C. Reynolds. Automatic computation of data set definitions. In Information Processing 68, volume 1, pages 456--461. North Holland, 1969. [ bib ] |
[1150] | John C. Reynolds. Towards a theory of type structure. In Colloque sur la Programmation, volume 19 of Lecture Notes in Computer Science, pages 408--425. Springer, April 1974. [ bib | http ] |
[1151] | John C. Reynolds. User-defined types and procedural data structures as complementary approaches to data abstraction. Technical Report 1278, Carnegie Mellon University, August 1975. [ bib | http ] |
[1152] | John C. Reynolds. Syntactic control of interference. In Principles of Programming Languages (POPL), pages 39--46, January 1978. [ bib | http ] |
[1153] | John C. Reynolds. Types, abstraction and parametric polymorphism. In Information Processing 83, pages 513--523. Elsevier Science, 1983. [ bib | .pdf ] |
[1154] | John C. Reynolds. Three approaches to type structure. In Theory and Practice of Software Development (TAPSOFT), volume 185 of Lecture Notes in Computer Science, pages 97--138. Springer, March 1985. [ bib | http ] |
[1155] | John C. Reynolds. An introduction to the polymorphic lambda calculus. In Gérard Huet, editor, Logical Foundations of Functional Programming, pages 77--86. Addison-Wesley, 1990. [ bib | http ] |
[1156] | John C. Reynolds. The discoveries of continuations. Lisp and Symbolic Computation, 6(3--4):233--248, 1993. [ bib | .pdf ] |
[1157] | John C. Reynolds. User defined types and procedural data structures as complementary approaches to data abstraction. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design, pages 13--23. MIT Press, 1994. [ bib ] |
[1158] | John C. Reynolds. Definitional interpreters for higher-order programming languages. Higher-Order and Symbolic Computation, 11(4):363--397, December 1998. [ bib | http ] |
[1159] | John C. Reynolds. Definitional interpreters revisited. Higher-Order and Symbolic Computation, 11(4):355--361, December 1998. [ bib | http ] |
[1160] | John C. Reynolds. Separation logic: A logic for shared mutable data structures. In Logic in Computer Science (LICS), pages 55--74, 2002. [ bib | .pdf ] |
[1161] | Morten Rhiger. A foundation for embedded languages. ACM Transactions on Programming Languages and Systems, 25(3):291--315, May 2003. [ bib | http ] |
[1162] | Colin Riba. On the values of reducibility candidates. In Typed Lambda Calculi and Applications (TLCA), volume 5608 of Lecture Notes in Computer Science, pages 264--278. Springer, July 2009. [ bib | .pdf ] |
[1163] | Michael F. Ringenburg and Dan Grossman. Types for describing coordinated data structures. In Types in Language Design and Implementation (TLDI), pages 25--36, January 2005. [ bib | .pdf ] |
[1164] | Mikael Rittri. Using types as search keys in function libraries. Journal of Functional Programming, 1(1):71--89, 1991. [ bib ] |
[1165] | Mikael Rittri. Retrieving library functions by unifying types modulo linear isomorphism. RAIRO Theoretical Informatics and Applications, 27(6):523--540, 1993. [ bib ] |
[1166] | Xavier Rival. Abstract domains for the static analysis of programs manipulating complex data structures. Habilitation à diriger des recherches, École Normale Supérieure, 2011. [ bib | .pdf ] |
[1167] | J. Alan Robinson. A machine-oriented logic based on the resolution principle. Journal of the ACM, 12(1):23--41, 1965. [ bib | http ] |
[1168] | Tiark Rompf and Nada Amin. Type soundness for dependent object types (DOT). In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 624--641, November 2016. [ bib | .pdf ] |
[1169] | Mads Rosendahl. Automatic complexity analysis. In Functional Programming Languages and Computer Architecture (FPCA), pages 144--156, 1989. [ bib | http ] |
[1170] | John L. Ross and Mooly Sagiv. Building a bridge between pointer aliases and program dependences. Nordic Journal of Computing, 5(4):361--386, 1998. [ bib | .ps ] |
[1171] | Andreas Rossberg. 1ML -- core and modules united (F-ing first-class modules). In International Conference on Functional Programming (ICFP), pages 35--47, September 2015. [ bib | .pdf ] |
[1172] | Andreas Rossberg, Claudio V. Russo, and Derek Dreyer. F-ing modules. Journal of Functional Programming, 24(5):529--607, 2014. [ bib | .pdf ] |
[1173] | Andreas Rossberg, Peter J. Stuckey, Martin Sulzmann, and Jeremy Wazny. The Chameleon language. [ bib | http ] |
[1174] | Colin Runciman and Ian Toyn. Retrieving re-usable software components by polymorphic type. Journal of Functional Programming, 1(2):191--211, 1991. [ bib ] |
[1175] | Stuart Russell and Peter Norvig. Artificial intelligence: A modern approach. Prentice Hall, 2009. [ bib | http ] |
[1176] | Claudio V. Russo. Types for modules. PhD thesis, University of Edinburgh, 1998. [ bib | .html ] |
[1177] | Yann Régis-Gianas. Des types aux assertions logiques : preuve automatique ou assistée de propriétés sur les programmes fonctionnels. PhD thesis, Université Paris 7, November 2007. [ bib | .pdf ] |
[1178] | Yann Régis-Gianas. The Pangolin programming language, 2008. http://code.google.com/p/pangolin-programming-language/. [ bib | http ] |
[1179] | Yann Régis-Gianas and François Pottier. A Hoare logic for call-by-value functional programs. In Mathematics of Program Construction (MPC), volume 5133 of Lecture Notes in Computer Science, pages 305--335. Springer, July 2008. [ bib | .pdf ] |
[1180] | Didier Rémy. Type checking records and variants in a natural extension of ML. In Principles of Programming Languages (POPL), pages 77--88, 1989. [ bib | http ] |
[1181] | Didier Rémy. Efficient representation of extensible records. In ACM Workshop on ML and its Applications, June 1992. [ bib | .pdf ] |
[1182] | Didier Rémy. Simple, partial type inference for system F based on type containment. In International Conference on Functional Programming (ICFP), September 2005. [ bib | .pdf ] |
[1183] | Didier Rémy. Simple, partial type inference for system F based on type containment. In International Conference on Functional Programming (ICFP), September 2005. [ bib | .pdf ] |
[1184] | Andrei Sabelfeld and David Sands. A PER model of secure information flow in sequential programs. In European Symposium on Programming (ESOP), volume 1575 of Lecture Notes in Computer Science, pages 40--58. Springer, 1999. [ bib | .ps ] |
[1185] | Daniel Sabin and Eugene C. Freuder. Contradicting conventional wisdom in constraint satisfaction. In International Workshop on Principles and Practice of Constraint Programming (PPCP), volume 874 of Lecture Notes in Computer Science, pages 10--20. Springer, May 1994. [ bib | .pdf ] |
[1186] | Amr Sabry. What is a purely functional language? Journal of Functional Programming, 8(1):1--22, January 1998. [ bib | http ] |
[1187] | Amr Sabry and Matthias Felleisen. Reasoning about programs in continuation-passing style. Lisp and Symbolic Computation, 6(3--4):289--360, 1993. [ bib | .ps.gz ] |
[1188] | Bratin Saha, Nevin Heintze, and Dino Oliva. Subtransitive CFA using types. Technical Report YALEU/DCS/TR-1166, Yale University, October 1998. [ bib | .ps.gz ] |
[1189] | David Sands. Complexity analysis for a lazy higher-order language. In European Symposium on Programming (ESOP), volume 432 of Lecture Notes in Computer Science, pages 361--376. Springer, May 1990. [ bib | http ] |
[1190] | David Sands, Jörgen Gustavsson, and Andrew Moran. Lambda calculi and linear speedups. In The Essence of Computation, Complexity, Analysis, Transformation. Essays Dedicated to Neil D. Jones, volume 2566 of Lecture Notes in Computer Science, pages 60--84. Springer, 2002. [ bib | .pdf ] |
[1191] | Davide Sangiorgi. On the bisimulation proof method. Mathematical Structures in Computer Science, 8(5):447--479, 1998. [ bib | .ps.gz ] |
[1192] | Patrick M. Sansom. Time profiling a lazy functional compiler. In Functional Programming, Workshops in Computing. Springer, July 1993. [ bib | .ps.gz ] |
[1193] | Olivier Savary Belanger, Stefan Monnier, and Brigitte Pientka. Programming type-safe transformations using higher-order abstract syntax. In Certified Programs and Proofs (CPP), volume 8307 of Lecture Notes in Computer Science, pages 243--258. Springer, December 2013. [ bib | http ] |
[1194] | Olivier Savary Belanger, Stefan Monnier, and Brigitte Pientka. Programming type-safe transformations using higher-order abstract syntax. Journal of Formalized Reasoning, 8(1), December 2015. [ bib | http ] |
[1195] | Steven Schäfer, Gert Smolka, and Tobias Tebbi. Completeness and decidability of de Bruijn substitution algebra in Coq. In Certified Programs and Proofs (CPP), pages 67--73, January 2015. [ bib | http ] |
[1196] | Steven Schäfer, Tobias Tebbi, and Gert Smolka. Autosubst: Reasoning with de Bruijn terms and parallel substitutions. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 359--374. Springer, August 2015. [ bib | .pdf ] |
[1197] | Karl Max Schimpf. Construction methods of LR parsers. PhD thesis, University of Pennsylvania, May 1981. [ bib | http ] |
[1198] | Fred B. Schneider. On concurrent programming. Springer, 1997. [ bib ] |
[1199] | Fred B. Schneider. Enforceable security policies. ACM Transactions on Information and System Security, 3(1):1--50, February 2000. [ bib | .pdf ] |
[1200] | Lutz Schröder and Till Mossakowski. HasCASL: Towards integrated specification and development of functional programs. In International Conference on Algebraic Methodology and Software Technology (AMAST), volume 2422 of Lecture Notes in Computer Science, pages 99--116. Springer, September 2002. [ bib | .ps ] |
[1201] | Lenhart K. Schubert, Mary Angela Papalaskaris, and Jay Taugher. Determining type, part, color, and time relationships. Computer, 16(10):53--60, October 1983. [ bib ] |
[1202] | Michael I. Schwartzbach. Polymorphic type inference. Technical Report BRICS-LS-95-3, BRICS, June 1995. [ bib | .ps.gz ] |
[1203] | Jan Schwinghammer, Lars Birkedal, François Pottier, Bernhard Reus, Kristian Støvring, and Hongseok Yang. A step-indexed Kripke model of hidden state. Mathematical Structures in Computer Science, January 2012. To appear. [ bib | .pdf ] |
[1204] | Jan Schwinghammer, Lars Birkedal, Bernhard Reus, and Hongseok Yang. Nested Hoare triples and frame rules for higher-order store. In Computer Science Logic, volume 5771 of Lecture Notes in Computer Science, pages 440--454. Springer, September 2009. [ bib | .pdf ] |
[1205] | Jan Schwinghammer, Lars Birkedal, and Kristian Støvring. A step-indexed Kripke model of hidden state via recursive properties on recursively defined metric spaces. In Foundations of Software Science and Computation Structures (FOSSACS), number 6604 in Lecture Notes in Computer Science, pages 305--319. Springer, March 2011. [ bib | .pdf ] |
[1206] | Jan Schwinghammer, Hongseok Yang, Lars Birkedal, François Pottier, and Bernhard Reus. A semantic foundation for hidden state. In Foundations of Software Science and Computation Structures (FOSSACS), volume 6014 of Lecture Notes in Computer Science, pages 2--17. Springer, March 2010. [ bib | .pdf ] |
[1207] | Stefan Schwoon. Model-checking pushdown systems. PhD thesis, Technische Universität München, 2002. [ bib | .pdf ] |
[1208] | Carsten Schürmann, Adam Poswolsky, and Jeffrey Sarnat. The -calculus: Functional programming with higher-order encodings. Technical Report YALEU/DCS/TR-1272, Yale University, November 2004. [ bib | .pdf ] |
[1209] | Carsten Schürmann, Adam Poswolsky, and Jeffrey Sarnat. The -calculus: Functional programming with higher-order encodings. In Typed Lambda Calculi and Applications (TLCA), volume 3461 of Lecture Notes in Computer Science, pages 339--353. Springer, April 2005. [ bib | .pdf ] |
[1210] | Dana S. Scott. A type-theoretical alternative to ISWIM, CUCH, OWHY. Theoretical Computer Science, 121(1--2):411--440, 1993. [ bib | http ] |
[1211] | Robert Sedgewick and Michael Schidlowsky. Algorithms in Java: Graph algorithms. Addison-Wesley, 2003. [ bib ] |
[1212] | Raimund Seidel and Micha Sharir. Top-down analysis of path compression. SIAM Journal on Computing, 34(3):515--525, 2005. [ bib | http ] |
[1213] | R. C. Sekar, R. Ramesh, and I. V. Ramakrishnan. Adaptive pattern matching. SIAM Journal on Computing, 24(6):1207--1234, December 1995. [ bib | .ps ] |
[1214] | Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee. Mechanized verification of fine-grained concurrent programs. In Programming Language Design and Implementation (PLDI), pages 77--87, June 2015. [ bib | .pdf ] |
[1215] | Ravi Sethi and J. D. Ullman. The generation of optimal code for arithmetic expressions. Journal of the ACM, 17(4):715--728, 1970. [ bib | http ] |
[1216] | Peter Sewell and Jan Vitek. Secure composition of untrusted code: Wrappers and causality types. Technical Report 478, Computer Laboratory, University of Cambridge, November 1999. [ bib | .ps ] |
[1217] | Peter Sewell and Jan Vitek. Secure composition of untrusted code: Wrappers and causality types. In IEEE Computer Security Foundations Workshop, July 2000. [ bib | .ps ] |
[1218] | Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine, Thomas Ridge, Susmit Sarkar, and Rok Strnisa. Ott: Effective tool support for the working semanticist. Journal of Functional Programming, 20(1):71--122, 2010. [ bib | .pdf ] |
[1219] | Edwin Hsing-Mean Sha and Kenneth Steiglitz. Maintaining bipartite matchings in the presence of failures. Networks, 23(5):459--471, August 1993. [ bib | .ps ] |
[1220] | Zhong Shao, Valery Trifonov, Bratin Saha, and Nikolaos Papaspyrou. A type system for certified binaries. ACM Transactions on Programming Languages and Systems, 27(1):1--45, 2005. [ bib | .pdf ] |
[1221] | Tim Sheard. Using MetaML: A staged programming language. In Advanced Functional Programming, volume 1608 of Lecture Notes in Computer Science, pages 207--239. Springer, September 1998. [ bib | .ps ] |
[1222] | Tim Sheard. Accomplishments and research challenges in meta-programming. In International Workshop on Semantics, Applications, and Implementation of Program Generation (SAIG), volume 2196 of Lecture Notes in Computer Science, pages 2--44. Springer, 2001. [ bib | .pdf ] |
[1223] | Tim Sheard. Languages of the future. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 116--119, October 2004. [ bib | http ] |
[1224] | Tim Sheard. Ωmega, November 2005. [ bib | http ] |
[1225] | Tim Sheard. Putting Curry-Howard to work. In Haskell workshop, pages 74--85, September 2005. [ bib | .ps ] |
[1226] | Tim Sheard and Emir Pašalić. Meta-programming with built-in type equality. In Workshop on Logical Frameworks and Meta-Languages (LFM), July 2004. [ bib | .pdf ] |
[1227] | Tim Sheard and Simon Peyton Jones. Template metaprogramming for Haskell. In Haskell workshop, pages 1--16, October 2002. [ bib | .pdf ] |
[1228] | Mark B. Shields and Simon Peyton Jones. First class modules for Haskell. In Foundations of Object-Oriented Languages (FOOL), pages 28--40, January 2002. [ bib | .pdf ] |
[1229] | Mark R. Shinwell. The fresh approach: functional programming with names and binders. PhD thesis, University of Cambridge, February 2005. [ bib | .pdf ] |
[1230] | Mark R. Shinwell. Fresh O'Caml: nominal abstract syntax for the masses. Electronic Notes in Theoretical Computer Science, 148(2):53--77, 2006. [ bib | http ] |
[1231] | Mark R. Shinwell and Andrew M. Pitts. Fresh Objective Caml user manual. Technical Report 621, University of Cambridge, February 2005. [ bib | .pdf ] |
[1232] | Mark R. Shinwell and Andrew M. Pitts. On a monadic semantics for freshness. Theoretical Computer Science, 342:28--55, 2005. [ bib | .pdf ] |
[1233] | Mark R. Shinwell, Andrew M. Pitts, and Murdoch J. Gabbay. FreshML: Programming with binders made simple. In International Conference on Functional Programming (ICFP), pages 263--274, August 2003. [ bib | .pdf ] |
[1234] | Olin Shivers. A universal scripting framework or, Lambda: the ultimate “little language”. In Concurrency and Parallelism: Programming, Networking and Security, volume 1179 of Lecture Notes in Computer Science, pages 254--265. Springer, 1996. [ bib | .ps ] |
[1235] | Vincent Simonet. Fine-grained information flow analysis for a λ-calculus with sum types. In IEEE Computer Security Foundations Workshop, pages 223--237, June 2002. [ bib | .ps.gz ] |
[1236] | Vincent Simonet. An extension of HM(X) with bounded existential and universal data-types. In International Conference on Functional Programming (ICFP), June 2003. [ bib | .ps.gz ] |
[1237] | Vincent Simonet. The Flow Caml system: documentation and user's manual. Technical Report 0282, INRIA, July 2003. [ bib | http ] |
[1238] | Vincent Simonet. Type inference with structural subtyping: a faithful formalization of an efficient constraint solver. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science. Springer, November 2003. [ bib | .pdf ] |
[1239] | Vincent Simonet. Inférence de flots d'information pour ML: formalisation et implantation. PhD thesis, Université Paris 7, March 2004. [ bib | .pdf ] |
[1240] | Vincent Simonet and François Pottier. Constraint-based type inference for guarded algebraic data types. Research Report 5462, INRIA, January 2005. [ bib | .html ] |
[1241] | Christian Skalka. Types for programming language-based security. PhD thesis, The Johns Hopkins University, August 2002. [ bib | .ps ] |
[1242] | Christian Skalka and François Pottier. Syntactic type soundness for HM(X). In Workshop on Types in Programming (TIP), volume 75 of Electronic Notes in Theoretical Computer Science, July 2002. [ bib | .ps.gz ] |
[1243] | Christian Skalka and Scott Smith. Static enforcement of security with types. In International Conference on Functional Programming (ICFP), pages 34--45, September 2000. [ bib | .ps ] |
[1244] | Jan Smans, Bart Jacobs, and Frank Piessens. Implicit dynamic frames: Combining dynamic frames and separation logic. In European Conference on Object-Oriented Programming (ECOOP), volume 5653 of Lecture Notes in Computer Science, pages 148--172. Springer, July 2009. [ bib | .pdf ] |
[1245] | Sjaak Smetsers, Erik Barendsen, Marko C. J. D. van Eekelen, and Marinus J. Plasmeijer. Guaranteeing safe destructive updates through a type system with uniqueness information for graphs. In Dagstuhl Seminar on Graph Transformations in Computer Science, volume 776 of Lecture Notes in Computer Science, pages 358--379. Springer, 1994. [ bib | .pdf ] |
[1246] | Frederick Smith, David Walker, and Greg Morrisett. Alias types. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 366--381. Springer, March 2000. [ bib | .pdf ] |
[1247] | Geoffrey Smith and Dennis Volpano. Secure information flow in a multi-threaded imperative language. In Principles of Programming Languages (POPL), pages 355--364, January 1998. [ bib | .ps.Z ] |
[1248] | Geoffrey S. Smith. Polymorphic type inference with overloading and subtyping. In Theory and Practice of Software Development (TAPSOFT), volume 668 of Lecture Notes in Computer Science, pages 671--685. Springer, April 1993. [ bib | http ] |
[1249] | Geoffrey S. Smith. Principal type schemes for functional programs with overloading and subtyping. Science of Computer Programming, 23(2--3):197--226, December 1994. [ bib | .pdf ] |
[1250] | Geoffrey S. Smith. A new type system for secure information flow. In IEEE Computer Security Foundations Workshop, pages 115--125, June 2001. [ bib | .pdf ] |
[1251] | Scott Smith and Tiejun Wang. Polyvariant flow analysis with constrained types. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 382--396. Springer, March 2000. [ bib | .pdf ] |
[1252] | Scott Fraser Smith. Partial objects in type theory. PhD thesis, Cornell University, January 1989. [ bib | .pdf ] |
[1253] | Gert Smolka and Ralf Treinen. Records for logic programming. Journal of Logic Programming, 18(3):229--258, April 1994. [ bib | .ps ] |
[1254] | Michael B. Smyth and Gordon D. Plotkin. The category-theoretic solution of recursive domain equations. SIAM Journal on Computing, 11(4):761--783, 1982. [ bib | .pdf ] |
[1255] | Alan Snyder. Encapsulation and inheritance in object-oriented programming languages. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 38--45, 1986. [ bib | http ] |
[1256] | Jonathan Sobel and Daniel P. Friedman. Recycling continuations. In International Conference on Functional Programming (ICFP), pages 251--260, September 1998. [ bib | .ps ] |
[1257] | Eljas Soisalon-Soininen. Inessential error entries and their use in LR parser optimization. ACM Transactions on Programming Languages and Systems, 4(2):179--195, April 1982. [ bib | http ] |
[1258] | Marvin H. Solomon. Type definitions with parameters. In Principles of Programming Languages (POPL), pages 31--38, January 1978. [ bib | http ] |
[1259] | Sergei V. Soloviev. The category of finite sets and cartesian closed categories. Journal of Soviet Mathematics, 22(3):1387--1400, 1983. [ bib ] |
[1260] | Matthieu Sozeau. Subset coercions in Coq. In Types for Proofs and Programs, volume 4502, pages 237--252, 2006. [ bib | .pdf ] |
[1261] | Matthieu Sozeau. Program-ing finger trees in Coq. In International Conference on Functional Programming (ICFP), pages 13--24, September 2007. [ bib | .pdf ] |
[1262] | Matthieu Sozeau and Nicolas Tabareau. Universe polymorphism in Coq. In Interactive Theorem Proving (ITP), volume 8558 of Lecture Notes in Computer Science, pages 499--514. Springer, July 2014. [ bib | .pdf ] |
[1263] | Mike Spivey. A functional theory of exceptions. Science of Computer Programming, 14:25--42, 1990. [ bib ] |
[1264] | R. Stata and M. Abadi. A type system for Java bytecode subroutines. In Principles of Programming Languages (POPL), pages 149--160, January 1998. [ bib | .html ] |
[1265] | Paul A. Steckler and Mitchell Wand. Lightweight closure conversion. ACM Transactions on Programming Languages and Systems, 19(1):48--86, 1997. [ bib | .ps ] |
[1266] | Bjarne Steensgaard. Points-to analysis in almost linear time. In Principles of Programming Languages (POPL), pages 32--41, January 1996. [ bib | .ps ] |
[1267] | Bernhard Steffen, Andreas Claßen, Marion Klein, Jens Knoop, and Tiziana Margaria. The fixpoint-analysis machine. In International Conference on Concurrency Theory (CONCUR), volume 962 of Lecture Notes in Computer Science, pages 72--87. Springer, August 1995. [ bib | http ] |
[1268] | Mark-Oliver Stehr. CINNI -- A generic calculus of explicit substitutions and its application to λ-, σ- and π-calculi. In International Workshop on Rewriting Logic and its Applications (WRLA), volume 36 of Electronic Notes in Theoretical Computer Science. Elsevier Science, September 2000. [ bib | .ps ] |
[1269] | Gordon Stewart, Lennart Beringer, and Andrew W. Appel. Verified heap theorem prover by paramodulation. In International Conference on Functional Programming (ICFP), pages 3--14, September 2012. [ bib | .pdf ] |
[1270] | Allen Stoughton. Access flow: A protection model which integrates access control and information flow. In IEEE Symposium on Security and Privacy (S&P), pages 9--18, 1981. [ bib ] |
[1271] | Christopher Strachey. Fundamental concepts in programming languages. Higher-Order and Symbolic Computation, 13(1--2):11--49, April 2000. [ bib | http ] |
[1272] | Robert E. Strom and Shaula Yemini. Typestate: A programming language concept for enhancing software reliability. IEEE Transactions on Software Engineering, 12(1):157--171, 1986. [ bib | .pdf ] |
[1273] | Peter J. Stuckey and Martin Sulzmann. A theory of overloading. In International Conference on Functional Programming (ICFP), pages 167--178, 2002. [ bib | http ] |
[1274] | Peter J. Stuckey, Martin Sulzmann, and Jeremy Wazny. Interactive type debugging in Haskell. In Haskell workshop, pages 72--83, 2003. [ bib | .pdf ] |
[1275] | Zhendong Su and Alexander Aiken. Entailment with conditional equality constraints. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 170--189, April 2001. [ bib | .pdf ] |
[1276] | Zhendong Su, Alexander Aiken, Joachim Niehren, Tim Priesnitz, and Ralf Treinen. The first-order theory of subtyping constraints. In Principles of Programming Languages (POPL), pages 203--216, January 2002. [ bib | .pdf ] |
[1277] | Martin Sulzmann. Designing record systems. Research Report YALEU/DCS/RR-1128, Yale University, April 1997. [ bib | .ps.gz ] |
[1278] | Martin Sulzmann. A general framework for Hindley/Milner type systems with constraints. PhD thesis, Yale University, Department of Computer Science, May 2000. [ bib | http ] |
[1279] | Martin Sulzmann. A general type inference framework for Hindley/Milner style systems. In International Symposium on Functional and Logic Programming, volume 2024 of Lecture Notes in Computer Science, pages 246--263. Springer, March 2001. [ bib | .pdf ] |
[1280] | Martin Sulzmann, Martin Müller, and Christoph Zenger. Hindley/Milner style type systems in constraint form. Research Report ACRC--99--009, University of South Australia, School of Computer and Information Science, July 1999. [ bib | .ps.gz ] |
[1281] | Martin Sulzmann, Martin Odersky, and Martin Wehr. Type inference with constrained types. In Foundations of Object-Oriented Languages (FOOL), January 1997. [ bib | .ps.gz ] |
[1282] | Martin Sulzmann and Meng Wang. A systematic translation of guarded recursive data types to existential types. Technical Report TR22/04, National University of Singapore, 2004. [ bib | .ps.gz ] |
[1283] | Eijiro Sumii. A complete characterization of observational equivalence in polymorphic lambda-calculus with general references. In Computer Science Logic, volume 5771 of Lecture Notes in Computer Science, pages 455--469. Springer, September 2009. [ bib | .pdf ] |
[1284] | Eijiro Sumii and Naoki Kobayashi. A generalized deadlock-free process calculus. In High-Level Concurrent Languages (HLCL), volume 16 of Electronic Notes in Theoretical Computer Science, pages 55--77. Elsevier Science, September 1998. [ bib | .ps ] |
[1285] | Kasper Svendsen and Lars Birkedal. Impredicative concurrent abstract predicates. In European Symposium on Programming (ESOP), volume 8410 of Lecture Notes in Computer Science, pages 149--168. Springer, April 2014. [ bib | .pdf ] |
[1286] | Kasper Svendsen, Lars Birkedal, and Matthew J. Parkinson. Joins: A case study in modular specification of a concurrent reentrant higher-order library. In European Conference on Object-Oriented Programming (ECOOP), volume 7920 of Lecture Notes in Computer Science, pages 327--351. Springer, July 2013. [ bib | .pdf ] |
[1287] | Kasper Svendsen, Lars Birkedal, and Matthew J. Parkinson. Modular reasoning about separation of concurrent data structures. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 169--188. Springer, March 2013. [ bib | .pdf ] |
[1288] | Nikhil Swamy, Juan Chen, Cédric Fournet, Pierre-Yves Strub, Karthik Bhargavan, and Jean Yang. Secure distributed programming with value-dependent types. In International Conference on Functional Programming (ICFP), pages 266--278, September 2011. [ bib | .pdf ] |
[1289] | Nikhil Swamy, Michael Hicks, Greg Morrisett, Dan Grossman, and Trevor Jim. Safe manual memory management in Cyclone. Science of Computer Programming, 62(2):122--144, October 2006. [ bib | .pdf ] |
[1290] | S. Doaitse Swierstra and Luc Duponcheel. Deterministic, error-correcting combinator parsers. In Advanced Functional Programming, volume 1129 of Lecture Notes in Computer Science, pages 184--207. Springer, August 1996. [ bib | .pdf ] |
[1291] | Walid Taha. Multi-stage programming: Its theory and applications. PhD thesis, Oregon Graduate Institute, November 1999. [ bib | .pdf ] |
[1292] | Walid Taha. A gentle introduction to multi-stage programming. In Domain-Specific Program Generation (DSPG), volume 3016 of Lecture Notes in Computer Science, pages 30--50. Springer, November 2004. [ bib | .pdf ] |
[1293] | Walid Taha and Michael Florentin Nielsen. Environment classifiers. In Principles of Programming Languages (POPL), pages 26--37, January 2003. [ bib | .pdf ] |
[1294] | Masako Takahashi. Parallel reductions in λ-calculus. Information and Computation, 118(1):120--127, 1995. [ bib | http ] |
[1295] | Carolyn Talcott. A theory of binding structures and applications to rewriting. Theoretical Computer Science, 112(1):99--143, 1993. [ bib | http ] |
[1296] | Jean-Pierre Talpin and Pierre Jouvelot. The type and effect discipline. Information and Computation, 11(2):245--296, 1994. [ bib | .pdf ] |
[1297] | Gang Tan, Zhong Shao, Xinyu Feng, and Hongxu Cai. Weak updates and separation logic. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 178--193. Springer, December 2009. [ bib | .pdf ] |
[1298] | Yong Kiam Tan, Magnus O. Myreen, Ramana Kumar, Anthony C. J. Fox, Scott Owens, and Michael Norrish. A new verified compiler backend for CakeML. In International Conference on Functional Programming (ICFP), pages 60--73, September 2016. [ bib | .pdf ] |
[1299] | David R. Tarditi and Andrew W. Appel. ML-Yacc user's manual, April 2000. [ bib | http ] |
[1300] | Robert Tarjan. Depth-first search and linear graph algorithms. SIAM Journal on Computing, 1(2):146--160, June 1972. [ bib | http ] |
[1301] | Robert E. Tarjan. Class notes: Disjoint set union. 1999. [ bib | .pdf ] |
[1302] | Robert E. Tarjan and Jan van Leeuwen. Worst-case analysis of set union algorithms. Journal of the ACM, 31(2):245--281, April 1984. [ bib | http ] |
[1303] | Robert E. Tarjan and Mihalis Yannakakis. Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs. SIAM Journal on Computing, 13(3):566--579, August 1984. [ bib | http ] |
[1304] | Robert Endre Tarjan. Efficiency of a good but not linear set union algorithm. Journal of the ACM, 22(2):215--225, April 1975. [ bib | .pdf ] |
[1305] | Robert Endre Tarjan. Applications of path compression on balanced trees. Journal of the ACM, 26(4):690--715, October 1979. [ bib | http ] |
[1306] | Robert Endre Tarjan. Amortized computational complexity. SIAM Journal on Algebraic and Discrete Methods, 6(2):306--318, 1985. [ bib | http ] |
[1307] | Robert Endre Tarjan. Algorithmic design. Communications of the ACM, 30(3):204--212, 1987. [ bib | http ] |
[1308] | Robert Endre Tarjan and Andrew Chi-Chih Yao. Storing a sparse table. Communications of the ACM, 22(11):606--611, 1979. [ bib | http ] |
[1309] | The GHC team. The Glasgow Haskell compiler, March 2005. [ bib | http ] |
[1310] | Robert D. Tennent and Dan Ghica. Abstract models of storage. Higher-Order and Symbolic Computation, 13:119--129, 2000. [ bib | http ] |
[1311] | Satish R. Thatté. Automated synthesis of interface adapters for reusable classes. In Principles of Programming Languages (POPL), pages 174--187, January 1994. [ bib | http ] |
[1312] | The Coq development team. The Coq proof assistant, 2019. [ bib | http ] |
[1313] | The Mozilla foundation. The Rust programming language, 2014. [ bib | http ] |
[1314] | Hayo Thielecke. Comparing control constructs by double-barrelled CPS. Higher-Order and Symbolic Computation, 15(2--3):141--160, 2002. [ bib | .pdf ] |
[1315] | Hayo Thielecke. From control effects to typed continuation passing. In Principles of Programming Languages (POPL), pages 139--149, January 2003. [ bib | .pdf ] |
[1316] | Hayo Thielecke. Frame rules from answer types for code pointers. In Principles of Programming Languages (POPL), pages 309--319, January 2006. [ bib | .pdf ] |
[1317] | Peter Thiemann. ML-style typing, lambda lifting, and partial evaluation. In Latin American Conference on Functional Programming, March 1999. [ bib | .ps.gz ] |
[1318] | Peter Thiemann. Enforcing security properties using type specialization. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, April 2001. [ bib | .ps.gz ] |
[1319] | Simon J. Thompson and Huiqing Li. Refactoring tools for functional languages. Journal of Functional Programming, 23(3):293--350, 2013. [ bib | http ] |
[1320] | Ye Henry Tian. Mechanically verifying correctness of CPS compilation. In Computing: The Australasian Theory Symposium (CATS), volume 51 of CRPIT, pages 41--51. Australian Computer Society, January 2006. [ bib | .pdf ] |
[1321] | Jerzy Tiuryn. Subtype inequalities. In Logic in Computer Science (LICS), pages 308--317, June 1992. [ bib ] |
[1322] | Jerzy Tiuryn and Pawel Urzyczyn. The subtyping problem for second-order types is undecidable. Information and Computation, 179(1):1--18, 2002. [ bib | http ] |
[1323] | Jerzy Tiuryn and Mitchell Wand. Type reconstruction with recursive types and atomic subtyping. In Theory and Practice of Software Development (TAPSOFT), volume 668 of Lecture Notes in Computer Science, pages 686--701. Springer, April 1993. [ bib | .dvi ] |
[1324] | Mads Tofte. Operational semantics and polymorphic type inference. PhD thesis, University of Edinburgh, 1988. [ bib | .ps ] |
[1325] | Mads Tofte, Lars Birkedal, Martin Elsman, and Niels Hallenberg. A retrospective on region-based memory management. Higher-Order and Symbolic Computation, 17(3):245--265, September 2004. [ bib | .ps.gz ] |
[1326] | Mads Tofte and Jean-Pierre Talpin. Implementation of the typed call-by-value λ-calculus using a stack of regions. In Principles of Programming Languages (POPL), pages 188--201, January 1994. [ bib | .pdf ] |
[1327] | Mads Tofte and Jean-Pierre Talpin. Region-based memory management. Information and Computation, 132(2):109--176, 1997. [ bib | .pdf ] |
[1328] | Andrew Tolmach. Combining closure conversion with closure analysis using algebraic types. In Types in Compilation (TIC), June 1997. [ bib | .ps ] |
[1329] | Andrew Tolmach and Dino P. Oliva. From ML to Ada: Strongly-typed language interoperability via source translation. Journal of Functional Programming, 8(4):367--412, July 1998. [ bib | http ] |
[1330] | Rodney W. Topor. A note on error recovery in recursive descent parsers. ACM SIGPLAN Notices, 17(2):37--40, February 1982. [ bib | http ] |
[1331] | Jesse A. Tov and Riccardo Pucella. Stateful contracts for affine types. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 550--569. Springer, March 2010. [ bib | .pdf ] |
[1332] | Jesse A. Tov and Riccardo Pucella. Practical affine types. In Principles of Programming Languages (POPL), pages 447--458, January 2011. [ bib | http ] |
[1333] | Valery Trifonov and Scott Smith. Subtyping constrained types. In Static Analysis Symposium (SAS), volume 1145 of Lecture Notes in Computer Science, pages 349--365. Springer, September 1996. [ bib | .pdf ] |
[1334] | Matthew S. Tschantz and Michael D. Ernst. Javari: adding reference immutability to Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 211--230, October 2005. [ bib | .pdf ] |
[1335] | Stephen Tse and Steve Zdancewic. Run-time principals in information-flow type systems. In IEEE Symposium on Security and Privacy (S&P), May 2004. [ bib | .pdf ] |
[1336] | Hideki Tsuiki. On typed calculi with a merge operator. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 880 of Lecture Notes in Computer Science, pages 101--112. Springer, 1994. [ bib | .ps.gz ] |
[1337] | Thomas Tuerk. Local reasoning about while-loops. Unpublished, August 2010. [ bib | .pdf ] |
[1338] | David N. Turner. The polymorphic pi-calculus: Theory and implementation. PhD thesis, University of Edinburgh, 1995. [ bib | http ] |
[1339] | David N. Turner, Philip Wadler, and Christian Mossin. Once upon a type. In Functional Programming Languages and Computer Architecture (FPCA), pages 1--11. ACM Press, June 1995. [ bib | .dvi ] |
[1340] | Aaron Turon, Derek Dreyer, and Lars Birkedal. Unifying refinement and Hoare-style reasoning in a logic for higher-order concurrency. In International Conference on Functional Programming (ICFP), pages 377--390, September 2013. [ bib | .pdf ] |
[1341] | Christian Urban. Nominal techniques in Isabelle/HOL. Journal of Automated Reasoning, 40(4):327--356, 2008. [ bib | .pdf ] |
[1342] | Christian Urban and Tobias Nipkow. Nominal verification of algorithm W. Unpublished, March 2008. [ bib | .pdf ] |
[1343] | Christian Urban, Andrew Pitts, and Murdoch Gabbay. Nominal unification. Theoretical Computer Science, 323:473--497, 2004. [ bib | .pdf ] |
[1344] | Christian Urban and Christine Tasson. Nominal techniques in Isabelle/HOL. In International Conference on Automated Deduction (CADE), volume 3632 of Lecture Notes in Computer Science, pages 38--53. Springer, July 2005. [ bib | .ps ] |
[1345] | Viktor Vafeiadis. Concurrent separation logic and operational semantics. Electronic Notes in Theoretical Computer Science, 276:335--351, 2011. [ bib | .pdf ] |
[1346] | Eelis van der Weegen and James McKinna. A machine-checked proof of the average-case complexity of Quicksort in Coq. In Types for Proofs and Programs, volume 5497 of Lecture Notes in Computer Science, pages 256--271. Springer, March 2008. [ bib | .pdf ] |
[1347] | Vincent van Oostrom. Confluence by decreasing diagrams. Theoretical Computer Science, 126(2):259--280, April 1994. [ bib | .ps.Z ] |
[1348] | Eric van Wyk, Oege de Moor, and Simon Peyton Jones. Aspect-oriented compilers. In Generative and Component-Based Software Engineering, volume 1799 of Lecture Notes in Computer Science, pages 121--133. Springer, September 1999. [ bib | .pdf ] |
[1349] | Mandana Vaziri and Daniel Jackson. Checking heap-manipulating procedures with a constraint solver. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 2619 of Lecture Notes in Computer Science. Springer, April 2003. [ bib | .pdf ] |
[1350] | Bart Vergauwen and Johan Lewi. Efficient local correctness checking for single and alternating Boolean equation systems. In International Colloquium on Automata, Languages and Programming, volume 820 of Lecture Notes in Computer Science, pages 304--315. Springer, 1994. [ bib | http ] |
[1351] | Bart Vergauwen, Johan Lewi, I. Avau, and A. Poté. Efficient computation of nested fix-points, with applications to model checking. In International Conference on Temporal Logic (ICTL), volume 827 of Lecture Notes in Computer Science, pages 165--179. Springer, July 1994. [ bib | http ] |
[1352] | Bart Vergauwen, J. Wauman, and Johan Lewi. Efficient fixpoint computation. In Static Analysis Symposium (SAS), volume 864 of Lecture Notes in Computer Science, pages 314--328. Springer, 1994. [ bib | http ] |
[1353] | Jules Villard, Étienne Lozes, and Cristiano Calcagno. Proving copyless message passing. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 194--209. Springer, December 2009. [ bib | .pdf ] |
[1354] | Jules Villard, Étienne Lozes, and Cristiano Calcagno. Tracking heaps that hop with Heap-Hop. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 6015 of Lecture Notes in Computer Science, pages 275--279. Springer, March 2010. [ bib | .pdf ] |
[1355] | Jan Vitek and Boris Bokowski. Confined types in Java. Software: Practice and Experience, 31(6):507--532, 2001. [ bib | .pdf ] |
[1356] | Dennis Volpano. Provably-secure programming languages for remote evaluation. ACM SIGPLAN Notices, 32(1):117--119, January 1997. [ bib ] |
[1357] | Dennis Volpano and Geoffrey Smith. Eliminating covert flows with minimum typings. In IEEE Computer Security Foundations Workshop, pages 156--168, June 1997. [ bib | .ps.Z ] |
[1358] | Dennis Volpano and Geoffrey Smith. A type-based approach to program security. Lecture Notes in Computer Science, 1214:607--621, April 1997. [ bib | .ps.Z ] |
[1359] | Dennis Volpano, Geoffrey Smith, and Cynthia Irvine. A sound type system for secure flow analysis. Journal of Computer Security, 4(3):167--187, 1996. [ bib | .ps.Z ] |
[1360] | Sergei G. Vorobyov. An improved lower bound for the elementary theories of trees. In International Conference on Automated Deduction (CADE), volume 1104 of Lecture Notes in Computer Science, pages 275--287. Springer, 1996. [ bib | .ps.Z ] |
[1361] | Jérôme Vouillon and Paul-André Melliès. Semantic types: a fresh look at the ideal model for types. In Principles of Programming Languages (POPL), pages 52--63, January 2004. [ bib | .ps.gz ] |
[1362] | Dimitrios Vytiniotis, Simon Peyton Jones, Tom Schrijvers, and Martin Sulzmann. OutsideIn(X): Modular type inference with local assumptions. Journal of Functional Programming, 21(4--5):333--412, 2011. [ bib | .pdf ] |
[1363] | Dimitrios Vytiniotis and Stephanie Weirich. Dependent types: Easy as PIE. In Trends in Functional Programming (TFP), April 2007. [ bib | .pdf ] |
[1364] | Dimitrios Vytiniotis, Stephanie Weirich, and Simon Peyton Jones. Boxy types: type inference for higher-rank types and impredicativity. Manuscript, April 2005. [ bib | http ] |
[1365] | Philip Wadler. Theorems for free! In Functional Programming Languages and Computer Architecture (FPCA), pages 347--359, September 1989. [ bib | .ps.gz ] |
[1366] | Philip Wadler. Linear types can change the world! In M. Broy and C. Jones, editors, Programming Concepts and Methods. North Holland, April 1990. [ bib | .ps ] |
[1367] | Philip Wadler. Comprehending monads. Mathematical Structures in Computer Science, 2:461--493, 1992. [ bib | .ps.gz ] |
[1368] | Philip Wadler. The essence of functional programming. In Principles of Programming Languages (POPL), pages 1--14, 1992. Invited talk. [ bib | .ps ] |
[1369] | Philip Wadler. The Girard-Reynolds isomorphism (second edition). Theoretical Computer Science, 375(1--3):201--226, May 2007. [ bib | .pdf ] |
[1370] | Philip Wadler and Stephen Blott. How to make ad-hoc polymorphism less ad-hoc. In Principles of Programming Languages (POPL), pages 60--76, January 1989. [ bib | .ps.gz ] |
[1371] | Philip Wadler and Peter Thiemann. The marriage of effects and monads. ACM Transactions on Computational Logic, 4(1):1--32, January 2003. [ bib | .ps.gz ] |
[1372] | Philip L. Wadler. How to replace failure by a list of successes. In Functional Programming Languages and Computer Architecture (FPCA), volume 201 of Lecture Notes in Computer Science, pages 113--128. Springer, September 1985. [ bib | http ] |
[1373] | David Walker. A type system for expressive security policies. In Principles of Programming Languages (POPL), pages 254--267, January 2000. [ bib | http ] |
[1374] | David Walker. Substructural type systems. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 1, pages 3--43. MIT Press, 2005. [ bib ] |
[1375] | David Walker, Karl Crary, and Greg Morrisett. Typed memory management via static capabilities. ACM Transactions on Programming Languages and Systems, 22(4):701--771, 2000. [ bib | .pdf ] |
[1376] | David Walker and Greg Morrisett. Alias types for recursive data structures. In Types in Compilation (TIC), volume 2071 of Lecture Notes in Computer Science, pages 177--206. Springer, September 2000. [ bib | .pdf ] |
[1377] | Dan S. Wallach. A new approach to mobile code security. PhD thesis, Princeton University, January 1999. [ bib | .html ] |
[1378] | Dan S. Wallach, Andrew W. Appel, and Edward W. Felten. Safkasi: A security mechanism for language-based systems. ACM Transactions on Software Engineering and Methodology, 9(4):341--378, October 2000. [ bib | .ps ] |
[1379] | Dan S. Wallach and Edward Felten. Understanding Java stack inspection. In IEEE Symposium on Security and Privacy (S&P), May 1998. [ bib | http ] |
[1380] | Mitchell Wand. Continuation-based program transformation strategies. Journal of the ACM, 27(1):164--180, 1980. [ bib | http ] |
[1381] | Mitchell Wand. Embedding type structure in semantics. In Principles of Programming Languages (POPL), pages 1--6, January 1985. [ bib | http ] |
[1382] | Mitchell Wand. Finding the source of type errors. In Principles of Programming Languages (POPL), pages 38--43, January 1986. [ bib | http ] |
[1383] | Mitchell Wand. A simple algorithm and proof for type inference. Fundamenta Informaticæ, 10:115--122, 1987. [ bib | .pdf ] |
[1384] | Mitchell Wand. Correctness of procedure representations in higher-order assembly language. In Mathematical Foundations of Programming Semantics, volume 598 of Lecture Notes in Computer Science, pages 294--311. Springer, March 1991. [ bib | .dvi ] |
[1385] | Mitchell Wand. Type inference for record concatenation and multiple inheritance. Information and Computation, 93(1):1--15, July 1991. [ bib | .dvi ] |
[1386] | Mitchell Wand. Type inference for objects with instance variables and inheritance. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design, pages 97--120. MIT Press, 1994. [ bib | .dvi ] |
[1387] | Mitchell Wand and Paul A. Steckler. Selective and lightweight closure conversion. In Principles of Programming Languages (POPL), pages 435--445, January 1994. [ bib | http ] |
[1388] | Peng Wang, Di Wang, and Adam Chlipala. TiML: A functional language for practical complexity analysis with invariants. Proceedings of the ACM on Programming Languages, 1(OOPSLA):79:1--79:26, October 2017. [ bib | .pdf ] |
[1389] | Martin Ward. Derivation of data intensive algorithms by formal transformation -- the Schorr-Waite graph marking algorithm. IEEE Transactions on Software Engineering, 22(9):665--686, September 1996. [ bib | .pdf ] |
[1390] | D. H. D. Warren. Higher-order extensions to PROLOG: are they needed? In J. E. Hayes, D. Michie, and Y-H. Pao, editors, Machine Intelligence 10, pages 441--454. Ellis Horwood, 1982. [ bib ] |
[1391] | Alessandro Warth, James R. Douglass, and Todd D. Millstein. Packrat parsers can support left recursion. In ACM Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 103--110, January 2008. [ bib | .pdf ] |
[1392] | Ben Wegbreit. Mechanical program analysis. Communications of the ACM, 18(9):528--539, September 1975. [ bib | http ] |
[1393] | Ingo Wegener. A simplified correctness proof for a well-known algorithm computing strongly connected components. Information Processing Letters, 83(1):17--19, 2002. [ bib | .pdf ] |
[1394] | Stephanie Weirich. Type-safe cast: Functional pearl. In International Conference on Functional Programming (ICFP), pages 58--67, September 2000. [ bib | .pdf ] |
[1395] | Stephanie Weirich. A typechecker that produces a typed term from an untyped source. Part of the Glasgow Haskell compiler's test suite, September 2004. [ bib | http ] |
[1396] | Stephanie Weirich. RepLib: a library for derivable type classes. In Haskell workshop, pages 1--12, 2006. [ bib | .pdf ] |
[1397] | Stephanie Weirich. Type-safe run-time polytypic programming. Journal of Functional Programming, 16(10):681--710, November 2006. [ bib | .pdf ] |
[1398] | Stephanie Weirich, Brent A. Yorgey, and Tim Sheard. Binders unbound. In International Conference on Functional Programming (ICFP), pages 333--345, September 2011. [ bib | .pdf ] |
[1399] | J. B. Wells. The undecidability of Mitchell's subtyping relation. Technical Report 95-019, Computer Science Department, Boston University, December 1995. [ bib | .ps.gz ] |
[1400] | J. B. Wells. Typability and type checking in system F are equivalent and undecidable. Annals of Pure and Applied Logic, 98(1--3):111--156, 1999. [ bib | .ps.gz ] |
[1401] | J. B. Wells. The essence of principal typings. In International Colloquium on Automata, Languages and Programming, volume 2380 of Lecture Notes in Computer Science, pages 913--925. Springer, 2002. [ bib | .pdf ] |
[1402] | Benjamin Werner. Une théorie des constructions inductives. PhD thesis, Université Paris 7, 1994. [ bib ] |
[1403] | Edwin Westbrook, Aaron Stump, and Ian Wehrman. A language-based approach to functionally correct imperative programming. In International Conference on Functional Programming (ICFP), pages 268--279, 2005. [ bib | .pdf ] |
[1404] | Edwin M. Westbrook. Higher-order encodings with constructors. PhD thesis, Washington University, December 2008. [ bib | .pdf ] |
[1405] | J. W. J. Williams. Algorithm 232: Heapsort. Communications of the ACM, 7(6):347--348, June 1964. [ bib | http ] |
[1406] | Simon Wimmer, Shuwei Hu, and Tobias Nipkow. Verified memoization and dynamic programming. In Interactive Theorem Proving (ITP), volume 10895 of Lecture Notes in Computer Science, pages 579--596. Springer, July 2018. [ bib | .pdf ] |
[1407] | Jeannette M. Wing, Eugene Rollins, and Amy Moormann Zaremski. Thoughts on a Larch/ML and a new application for LP. In First International Workshop on Larch, pages 297--312, July 1992. [ bib | .ps ] |
[1408] | Niklaus Wirth. Algorithms + data structures = programs. Prentice Hall, 1978. [ bib ] |
[1409] | Ryan Wisnesky, Gregory Malecha, and Greg Morrisett. Certified web services in Ynot. In Workshop on Automated Specification and Verification of Web Systems, July 2009. [ bib | .pdf ] |
[1410] | Roger Wolff, Ronald Garcia, Éric Tanter, and Jonathan Aldrich. Gradual typestate. In European Conference on Object-Oriented Programming (ECOOP), volume 6813 of Lecture Notes in Computer Science, pages 459--483. Springer, July 2011. [ bib | .pdf ] |
[1411] | J. P. L. Woodward. Applications for multilevel secure operating systems. In Proceedings NCC, volume 48, pages 319--328. AFIPS Press, June 1979. [ bib ] |
[1412] | Andrew K. Wright. Polymorphism for imperative languages without imperative types. Technical Report 93-200, Rice University, February 1993. [ bib ] |
[1413] | Andrew K. Wright. Simple imperative polymorphism. Lisp and Symbolic Computation, 8(4):343--356, December 1995. [ bib | .ps.gz ] |
[1414] | Andrew K. Wright and Robert Cartwright. A practical soft type system for Scheme. ACM Transactions on Programming Languages and Systems, 19(1):87--152, January 1997. [ bib | http ] |
[1415] | Andrew K. Wright and Matthias Felleisen. A syntactic approach to type soundness. Information and Computation, 115(1):38--94, November 1994. [ bib | .ps.gz ] |
[1416] | Hongwei Xi. Dependent types in practical programming. PhD thesis, Carnegie Mellon University, December 1998. [ bib | .ps ] |
[1417] | Hongwei Xi. Dead code elimination through dependent types. In Practical Aspects of Declarative Languages (PADL), volume 1551 of Lecture Notes in Computer Science, pages 228--242. Springer, January 1999. [ bib | .ps ] |
[1418] | Hongwei Xi. Dependent ML, 2001. [ bib | .html ] |
[1419] | Hongwei Xi. Dependently Typed Pattern Matching. Journal of Universal Computer Science, 9(8):851--872, 2003. [ bib | .pdf ] |
[1420] | Hongwei Xi. Applied type system. In TYPES 2003, volume 3085 of Lecture Notes in Computer Science, pages 394--408. Springer, February 2004. [ bib | .pdf ] |
[1421] | Hongwei Xi. Dependent ML: an approach to practical programming with dependent types. Journal of Functional Programming, 17(2):215--286, 2007. [ bib | .pdf ] |
[1422] | Hongwei Xi, Chiyan Chen, and Gang Chen. Guarded recursive datatype constructors. In Principles of Programming Languages (POPL), pages 224--235, January 2003. [ bib | .ps ] |
[1423] | Hongwei Xi and Frank Pfenning. Dependent types in practical programming. In Principles of Programming Languages (POPL), pages 214--227, January 1999. [ bib | .ps ] |
[1424] | Hongwei Xi and Carsten Schürmann. CPS transform for Dependent ML. In Workshop on Logic, Language, Information and Computation (WoLLIC), August 2001. [ bib | .pdf ] |
[1425] | Yichen Xie and Alex Aiken. Scalable error detection using Boolean satisfiability. In Principles of Programming Languages (POPL), pages 351--363, January 2005. [ bib | .pdf ] |
[1426] | Dana N. Xu. Extended static checking for Haskell. In Haskell workshop, pages 48--59. ACM Press, 2006. [ bib | .ps ] |
[1427] | Dana N. Xu, Simon Peyton Jones, and Koen Claessen. Static contract checking for Haskell. In Principles of Programming Languages (POPL), pages 41--52, January 2009. [ bib | .ps ] |
[1428] | Hongseok Yang, Oukseh Lee, Josh Berdine, Cristiano Calcagno, Byron Cook, Dino Distefano, and Peter W. O'Hearn. Scalable shape analysis for systems code. In Computer Aided Verification (CAV), volume 5123 of Lecture Notes in Computer Science, pages 385--398. Springer, July 2008. [ bib | .pdf ] |
[1429] | Kwangkeun Yi. Educational pearl: 'proof-directed debugging' revisited for a first-order version. Journal of Functional Programming, 16(6):663--670, 2006. [ bib | .pdf ] |
[1430] | Nobuko Yoshida. Graph types for monadic mobile processes. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 1180 of Lecture Notes in Computer Science, pages 371--386. Springer, 1996. [ bib | .ps.gz ] |
[1431] | Nobuko Yoshida. Graph types for monadic mobile processes. Technical Report ECS-LFCS-96-350, University of Edinburgh, 1996. [ bib | http ] |
[1432] | Nobuko Yoshida, Kohei Honda, and Martin Berger. Linearity and bisimulation. Technical Report MSC-2001/48, University of Leicester, December 2001. [ bib | .ps.gz ] |
[1433] | Nobuko Yoshida, Kohei Honda, and Martin Berger. Linearity and bisimulation. In Foundations of Software Science and Computation Structures (FOSSACS), Lecture Notes in Computer Science. Springer, April 2002. [ bib | .ps.gz ] |
[1434] | Nobuko Yoshida, Kohei Honda, and Martin Berger. Logical reasoning for higher-order functions with local state. In Foundations of Software Science and Computation Structures (FOSSACS), volume 4423 of Lecture Notes in Computer Science, pages 361--377. Springer, April 2007. [ bib | .pdf ] |
[1435] | Steve Zdancewic and Andrew C. Myers. Secure information flow and CPS. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, April 2001. [ bib | .ps ] |
[1436] | Steve Zdancewic and Andrew C. Myers. Secure information flow via linear continuations. Higher Order and Symbolic Computation, 15(2--3):209--234, September 2002. [ bib | .pdf ] |
[1437] | Olivier Zendra, Dominique Colnet, and Suzanne Collin. Efficient dynamic dispatch without virtual function tables. the SmallEiffel compiler. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 125--141, October 1997. [ bib | .ps.gz ] |
[1438] | Christoph Zenger. Indexed types. Theoretical Computer Science, 187(1--2):147--165, 1997. [ bib | http ] |
[1439] | Christoph Zenger. Indizierte typen. PhD thesis, Universität Karlsruhe, July 1998. [ bib | .ps.gz ] |
[1440] | Bohua Zhan and Maximilian P. L. Haslbeck. Verifying asymptotic time complexity of imperative programs in Isabelle. In International Joint Conference on Automated Reasoning, July 2018. [ bib | http ] |
[1441] | Hongbo Zhang and Steve Zdancewic. Fan: compile-time metaprogramming for OCaml. Unpublished, March 2013. [ bib | .pdf ] |
[1442] | Yang Zhao. Concurrency analysis based on fractional permission system. PhD thesis, University of Wisconsin, August 2007. [ bib | .pdf ] |
[1443] | Lantian Zheng and Andrew C. Myers. Dynamic security labels and noninterference. Technical Report 2004-1924, Cornell University, January 2004. [ bib | .pdf ] |
[1444] | Dengping Zhu and Hongwei Xi. A typeful and tagless representation for XML documents. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science, pages 89--104. Springer, November 2003. [ bib | .pdf ] |
[1445] | Dengping Zhu and Hongwei Xi. Safe programming with pointers through stateful views. In Practical Aspects of Declarative Languages (PADL), volume 3350 of Lecture Notes in Computer Science, pages 83--97. Springer, January 2005. [ bib | .pdf ] |
[1446] | Yoav Zibin and Yossi Gil. Theory and practice of incremental subtyping tests and message dispatching, December 2001. [ bib | .ps.gz ] |
[1447] | Yoav Zibin and Yossi Gil. Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 142--160, November 2002. [ bib | .pdf ] |
[1448] | Yoav Zibin and Yossi Gil. Incremental algorithms for dispatching in dynamically typed languages. In Principles of Programming Languages (POPL), January 2003. [ bib | .pdf ] |
[1449] | Jan Zwanenburg. A type system for record concatenation and subtyping. Technical report, Eindhoven University of Technology, July 1997. [ bib | .ps ] |
This file was generated by bibtex2html 1.99.