Practical foundations for programming languages

Practical Foundations for Programming Languages

Volumn 9781107029576, Issue , 2010, Pages 1-471

  Harper, Robert ^a  

^a Carnegie Mellon University ^*  (United States)

Author keywords

[No Author keywords available]

Indexed keywords

BUILDING BLOCKES; INTRODUCTION TO PROGRAMMING; LANGUAGE DESIGN; LANGUAGE FEATURES; PRACTICAL FOUNDATIONS; TYPE STRUCTURES; TYPE THEORY;

SEMANTICS;

EID: 84925677692     PISSN: None     EISSN: None     Source Type: Book    
DOI: 10.1017/CBO9781139342131     Document Type: Book

References (114)

1. Abadi, M. and L. Cardelli (1996). A Theory of Objects. Springer-Verlag.
2. Abadi, M. and C. Fournet (2001). Mobile values, new names, and secure communication. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 104–15, Association for Computing Machinery.
3. Aczel, P. (1977). An introduction to inductive definitions. In Jon Barwise, editor, Handbook of Mathematical Logic, chapter C.7, pp. 783–818. North-Holland.
4. Allen, J. (1978). The Anatomy of LISP. Computer Science Series. McGraw-Hill.
5. Allen, S. (1987). A non-type-theoretic definition of Martin-Löf’s types. In LICS, pp. 215– 21. IEEE Computer Society.
6. Allen, S. F., M. Bickford, R. L. Constable, R. Eaton, C. Kreitz, L. Lorigo, and E. Moran (2005). Innovations in computational type theory using NuPRL. J. Appl. Logic, 4: 428–69.
7. Andreoli, J.-M. (1992). Logic programming with focusing proofs in linear logic. J. Log. Comput., 2: 297–347.
8. Ariola, Z. M. and M. Felleisen (1997). The call-by-need lambda calculus. J. Funct. Prog., 7: 265–301.
9. Arvind, R., S. Nikhil, and K. Pingali (1986). I-structures: Data structures for parallel computing. In J. H. Fasel and R. M. Keller, editors, Graph Reduction, Volume 279 of Lecture Notes in Computer Science Series, pp. 336–69. Springer.
10. Avron, A. (1991). Simple consequence relations. Inf. Comput., 92:105–39.
11. Barendregt, H. (1984). The Lambda Calculus, Its Syntax and Semantics. Volume 103 of Studies in Logic and the Foundations of Mathematics. North-Holland.
12. Barendregt, H. (1992). Lambda calculi with types. In S. Abramsky, D. M. Gabbay, and T. S. E Maibaum, editors, Handbook of Logic in Computer Science, Volume 2 of Computational Structures Series. Oxford University Press.
13. Bertot, Y., G. Huet, J.-J. Lévy, and G. Plotkin (editors) (2009). From Semantics to Computer Science: Essays in Honor of Gilles Kahn. Cambridge University Press.
14. Blelloch, G. E. (1990). Vector Models for Data-Parallel Computing. MIT Pres.
15. Blelloch, G. E. and J. Greiner (1995). Parallelism in sequential functional languages. In FPCA, pp. 226–37.
16. Blelloch, G. E. and J. Greiner (1996). A provable time and space efficient implementation of NESL. In ICFP, pp. 213–25.
17. Brookes, S. D. (2002). The essence of parallel Algol. Inf. Comput., 179(1): 118–49.
18. Burstall, R. M., D. B. MacQueen, and D. Sannella (1980). Hope: An experimental applicative language. In LISP Conference, pp. 136–43.
19. Buss, S. R. (editor). (1998). Handbook of Proof Theory. Elsevier.
20. Cardelli, L. (1988). Structural subtyping and the notion of power type. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 70–9. Association for Computing Machinery.
21. Cardelli, L. (1997). Program fragments, linking, and modularization. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 266–77. Association for Computing Machinery.
22. Castagna, G. and B. C. Pierce (1994). Decidable bounded quantification. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 151–62. Association for Computing Machinery.
23. Church, A. (1941). The Calculi of Lambda-Conversion. Princeton University Press.
24. Colmerauer, A. and P. Roussel (1993). The birth of Prolog. In Proceedings of the Second ACM SIGPLAN Conference on the History of Programming Languages, HOPL-II, pp. 37–52. Association for Computing Machinery.
25. Constable, R. L. (1986). Implementing Mathematics with the Nupri Proof Development System. Prentice-Hall.
26. Constable, R. L. (1998). Types in logic, mathematics, and programming. In S. R. Buss, editor, Handbook of Proof Theory, chapter X. Elsevier.
27. Constable, R. L. and S. F. Smith (1987). Partial objects in constructive type theory. In LICS, pp. 183–93. IEEE Computer Society.
28. Cook, W. R. (2009). On understanding data abstraction, revisited. In OOPSLA, pp. 557– 72.
29. Cousineau, G. and M. Mauny (1998). The Functional Approach to Programming. Cambridge University Press.
30. Crary, K. (2009). A syntactic account of singleton types via hereditary substitution. In Proceedings of the Fourth International Workshop on Logical Frameworks and MetaLanguages: Theory and Practice, LFMTP’09, pp. 21–29. Association for Computing Machinary.
31. Dreyer, D. (2005). Understanding and Evolving the ML Module System. Ph.D. dissertation. Carnegie Mellon University.
32. Engberg, U. and M. Nielsen. (2000). A calculus of communicating systems with label passing – ten years after. In G. D. Plotkin, C. Stirling, and M. Tofte (editors), Proof, Language, and Interaction, Essays in Honour of Robin Milner, pp. 599–622. MIT Press.
33. Felleisen, M. and R. Hieb (1992). The revised report on the syntactic theories of sequential control and state. TCS: Theoretical Computer Science, 103.
34. Gelernter, D. (1985). Generative communication in Linda. ACM Trans. Prog. Lang. Syst., 7: 80–112.
35. Gentzen, G. (1969). Investigations into logical deduction. In M. E. Szabo, editor, The Collected Papers of Gerhard Gentzen, pp. 68–213. North-Holland.
36. Girard, J.-Y. (1972). Interpretation fonctionelle et elimination des coupures de l’arithmetique d’ordre superieur. These d’etat, Universite Paris VII.
37. Girard, J.-Y. (1989). Proofs and Types. Translated by P. Taylor and Y. Lafont. Cambridge University Press.
38. Gödel, K. (1980). On a hitherto unexploited extension of the finitary standpoint. Translated by W. Hodges and B. Watson. Philos. Logic, 9: 133–42.
39. Gordon, M. J., A. J. Milner, and C. P. Wadsworth. Edinburgh LCF, Volume 78 of Lecture Notes in Computer Science Series. Springer-Verlag.
40. Greiner, J. and G. E. Blelloch (1999). A provably time-efficient parallel implementation of full speculation. ACM Trans. Prog. Lang. Syst., 21: 240–85.
41. Griffin, T. (1990). A formulae-as-types notion of control. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 47–58. Association for Computing Machinery.
42. Halstead, R. H. Jr. (1985). Multilisp: A language for concurrent symbolic computation. ACM Trans. Prog. Lang. Syst., 7: 501–38.
43. Harper, R. (1992). Constructing type systems over an operational semantics. J. Symb. Comput., 14: 71–84.
44. Harper, R. (1994). A simplified account of polymorphic references. Inf. Process. Lett., 51: 201–6.
45. Harper, R. and M. Lillibridge (1994). A type-theoretic approach to higher order modules with sharing. In Proceecings of the ACM Symposium on Principles of Programming Languages, pp. 123–37. Association for Computing Machinery.
46. Harper, R., J. C. Mitchell, and E. Moggi (1990). Higher-order modules and the phase distinction. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 341–54. Association for Computing Machinery.
47. Harper, R., F. Honsell, and G. Plotkin (1993). A framework for defining logics. J. Assoc. Comput. Mach., 40: 194–204.
48. Hinze, R. and J. Jeuring (2003). Generic Haskell: practice and theory. In R. C. Backhouse and J. Gibbons, editors, Generic Programming, Volume 2793 of Lecture Notes in Computer Science, pp. 1–56. Springer.
49. Hoare, C. A. R. (1978). Communicating sequential processes. Commun. ACM, 21: 666– 77.
50. Hoare, T. (2009). Null references: the billion dollar mistake. Paper presented at QCon.
51. Jones, S. L. P. (2003). Haskell 98: Introduction. J. Funct. Program., 13: 0–6.
52. Kleene, S. C. (1952). Introduction to Metamathematics. van Nostrand.
53. Kowalski, R. A. (1988). The early years of logic programming. Commun. ACM, 31: 38–43.
54. Lakatos, I. (1976). Proofs and Refutations: The Logic of Mathematical Discovery. Cambridge University Press.
55. Landin, P. J. (1965). A correspondence between Algol 60 and Church’s lambda notation. Commun. ACM, 8: 89–101; 158–65.
56. Lee, D. K., K. Crary, and R. Harper (2007). Towards a mechanized metatheory of Standard ML. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 173–84. Association for Computing Machinery.
57. Leroy, X. (1994). Manifest types, modules, and separate compilation. In Pro. ACM Symposium on Principles of Programming Languages, pp. 109–22, 1994.
58. Leroy, X. (1995). Applicative functors and fully transparent higher-order modules. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 142–53. Association for Computing Machinery.
59. Licata, D. R. and R. Harper (2010). A monadic formalization of ML5. In K. Crary and M. Miculan, editors, Logical Frameworks and Metalanguages: Theory and Practice, Volume 34 of EPTCS Series, pp. 69–83. Association for Computing Mechinery.
60. Lillibridge, M. (1997). Translucent Sums: A Foundation for Higher-Order Module Systems. Ph.D. dissertation, Carnegie Mellon University School of Computer Science.
61. Liskov, B. and J. M. Wing (1994). A behavioral notion of subtyping. ACM Trans. Prog. Lang. Syst., 16: 1811–41.
62. MacLane, S. (1998). Categories for the Working Mathematician (2nd ed). Graduate Texts in Mathematics Series. Springer-Verlag.
63. MacQueen, D. B. (1986). Using dependent types to express modular structure. In Proceedings of the ACM Symposium on Principles of Programming Languges, pp. 277–86. Association for Computing Machinery.
64. MacQueen, D. B. (2009). Kahn networks at the dawn of functional programming. In Bertot et al., editors, From Semantics to Computer Science: Essays in Honor of Gilles Kahn, chapter 5. Cambridge University Press.
65. Martin-Löf, P. (1980). Constructive mathematics and computer programming. In Logic, Methodology and Philosophy of Science IV, pp. 153–75. North-Holland.
66. Martin-Löf, P. (1983). On the meanings of the logical constants and the justifications of the logical laws. Unpublished lecture notes.
67. Martin-Löf, P. (1984). Intuitionistic Type Theory. Studies in Proof Theory Series. Bibliopo-lis.
68. Martin-Löf, P. (1987). Truth of a proposition, evidence of a judgement, validity of a proof. Synthese, 73: 407–20.
69. McCarthy, J. (1965). LISP1.5 Programmer’s Manual. MIT Press.
70. Mendler, N. P. (1987). Recursive types and type constraints in second-order lambda calculus. In LICS, pp. 30–6. IEEE Computer Society.
71. Milner, R. (1978). A theory of type polymorphism in programming. JCSS, 17: 348–75.
72. Milner, R. (1999). Communicating and Mobile Systems – the Pi-Calculus. Cambridge University Press.
73. Milner, R., M. Tofte, R. Harper, and D. MacQueen (1997). The Definition of Standard ML (Revised). MIT Press.
74. Mitchell, J. C. (1984). Coercion and type inference. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 175–85. Association for Computing Machinery.
75. Mitchell, J. C. (1986). Representation independence and data abstraction. In Proceedings of the ACM Symposium on Principles of Programming Languages, pp. 263–76. Association for Computing Machinery.
76. Mitchell, J. C. (1996). Foundations for Programming Languages. MIT Press.
77. Mitchell, J. C. and G. D. Plotkin (1988). Abstract types have existential type. ACM Trans. Prog. Lang. Syst., 10: 470–502.
78. Murphy, T. VII, K. Crary, R. Harper, and F. Pfenning (2004). A symmetric modal lambda calculus for distributed computing. In LICS, pp. 286–95. IEEE Computer Society.
79. Murthy, C. R. (1991). An evaluation semantics for classical proofs. In LICS, pp. 96–107. IEEE Computer Society.
80. Nanevski, A. (2003). From dynamic binding to state via modal possibility. In PPDP, pp. 207–18. Association for Computing Machinery.
81. Nederpelt, R. P., J. H. Geuvers, and R. C. deVrijer (editors) (1994). Selected Papers on Automath, Volume 133 of Studies in Logic and the Foundations of Mathematics Series. North-Holland.
82. Ocaml (2012). Available at http://caml.inria.fr/ocaml/.
83. Park, D. M. R. (1981). Concurrency and automata on infinite sequences. In P. Deussen, editor, Theoretical Computer Science, Volume 104 of Lecture Notes in Computer Science Series, pp. 167–83. Springer.
84. Pierce, B. C. (2002). Types and Programming Languages. MIT Press.
85. Pierce, B. C. (2004). Advanced Topics in Types and Programming Languages. MIT Press.
86. Pitts, A. M. (1998). Existential types: Logical relations and operational equivalence. In K. G. Larsen, S. Skyum, and G. Winskel, editors, ICALP, Volume 1443 of Lecture Notes in Computer Science Series, pp. 309–26. Springer.
87. Pitts, A. M. (2000). Operational semantics and program equivalence. In G. Barthe, P. Dybjer, L. Pinto, and J. Saraiva, editors, APPSEM, Volume 2395 of Lecture Notes in Computer Science Series, pp. 378–412. Springer.
88. Pitts, A. M. and I. D. B. Stark (1993). Observable properties of higher order functions that dynamically create local names, or what’s new? In A. M. Borzyszkowski and S. Sokolowski, editors, MFCS, Volume 711 of Lecture Notes in Computer Science Series, pp. 122–141. Springer.
89. Plotkin, G. D. (1977). LCF considered as a programming language. Theor. Comput. Sci., 5: 223–55.
90. Plotkin, G. D. (1981). A structural approach to operational semantics. Technical Report DAIMIFN-19, Aarhus University, Computer Science Department.
91. Plotkin, G. D. (2004). The origins of structural operational semantics. J. Logic Algebraic Program., 60: 3–15.
92. Reppy, J. H. (1999). Concurrent Programming in ML. Cambridge University Press.
93. Reynolds, J. C. (1974). Towards a theory of type structure. In B. Robinet, editor, Symposium on Programming, Volume 19 of Lecture Notes in Computer Science Series, pp. 408– 23. Springer.
94. Reynolds, J. C. (1980). Using category theory to design implicit conversions and generic operators. In N. D. Jones, editor, Semantics-Directed Compiler Generation, Volume 94 of Lecture Notes in Computer Science Series, pp. 211–58. Springer.
95. Reynolds, J. C. (1981). The essence of Algol. In Proceedings of the 1981 International Symposium on Algorithmic Languages, pp. 345–72. North-Holland.
96. Reynolds, J. C. (1983). Types, abstraction, and parametric polymorphism. In Information Processing’83, pp. 513–23. North-Holland.
97. Reynolds, J. C. (1993). The discoveries of continuations. Lisp Symbol. Comput., 6: 233–48.
98. Reynolds, J. C. (1998). Theories of Programming Languages. Cambridge University Press, Cambridge, England.
99. Rossberg, A., C. V. Russo, and D. Dreyer (2010). F-ing modules. In A. Kennedy and N. Benton, editors, TLDI, pp. 89–102. ACM.
100. Scott, D. (1980). Lambda calculus: Some models, some philosophy. In J. Barwise, H. J. Keisler, and K. Kunen, editors, The Kleene Symposium, pp. 223–65. North-Holland, Amsterdam.
101. Scott, D. S. (1976). Data types as lattices. SIAM J. Comput., 5(3): 522–87.
102. Scott, D. S. (1982). Domains for denotational semantics. In M. Nielsen and E. M. Schmidt, editors, ICALP, volume 140 of Lecture Notes in Computer Science, pp. 577–613. Springer.
103. Smyth, M. B. and G. D. Plotkin (1982). The category-theoretic solution of recursive domain equations. SIAM J. Comput., 11(4): 761–83.
104. Statman, R. (1985). Logical relations and the typed lambda-calculus. Information and Control, 65(2/3): 85–97.
105. Steele, G. L. (1990). Common Lisp: The Language (2nd ed.). Digital Press.
106. Stone, C. A. and R. Harper (2006). Extensional equivalence and singleton types. ACM Trans. Comput. Log., 7: 676–722.
107. Taylor, P. (1999). Practical Foundations of Mathematics. Cambridge Studies in Advanced Mathematics. Cambridge University Press.
108. Turner, D. (1987). An overview of Miranda. Bull. EATCS, 33: 103–14.
109. Wadler, P. (1989). Theorems for free! In FPCA, pp. 347–59.
110. Wadler, P. (2003). Call-by-value is dual to call-by-name. In C. Runciman, and O. Shivers, editors, ICFP, pp. 189–201. Association for Computing Machinery.
111. Wand, M. (1979). Fixed-point constructions in order-enriched categories. Theor. Comput. Sci., 8: 13–30.
112. Watkins, K., I. Cervesato, F. Pfenning, and D. Walker (2008). Specifying properties of concurrent computations in clf. Electr. Notes Theor. Comput. Sci., 199: 67–87.
113. Wright, A. K. and M. Felleisen (1994). A syntactic approach to type soundness. Inf. Comput., 115: 38–94.
114. Zeilberger, N. (2008). On the unity of duality. Ann. Pure Appl. Logic, 153: 66–96.