A history of Haskell: being lazy with class

ABSTRACT

This paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.

References

1. Achten, P. and Peyton Jones, S. (2000). Porting the Clean Object I/O library to Haskell. In Mohnen, M. and Koopman, P., editors, Proceedings of the 12th International Workshop on the Implementation of Functional Languages, Aachen (IFL'00), selected papers, number 2011 in Lecture Notes in Computer Science, pages 194--213. Springer.
2. Achten, P. and Plasmeijer, R. (1995). The ins and outs of clean I/O. Journal of Functional Programming, 5(1):81--110.
3. Achten, P., van Groningen, J., and Plasmeijer, M. (1992). High-level specification of I/O in functional languages. In (Launchbury and Sansom, 1992), pages 1--17.
4. Angelov, K. and Marlow, S. (2005). Visual Haskell: a full-featured Haskell development environment. In Proceedings of ACM Workshop on Haskell, Tallinn, Tallinn, Estonia. ACM.
5. Appel, A. and MacQueen, D. (1987). A standard ML compiler. In Kahn, G., editor, Proceedings of the Conference on Functional Programming and Computer Architecture, Portland. LNCS 274, Springer Verlag.
6. Arts, T., Hughes, J., Johansson, J., and Wiger, U. (2006). Testing telecoms software with quviq quickcheck. In Trinder, P., editor, ACM SIGPLAN Erlang Workshop, Portland, Oregon. ACM SIGPLAN.
7. Arvind and Nikhil, R. (1987). Executing a program on the MIT tagged-token dataflow architecture. In Proc PARLE (Parallel Languages and Architectures, Europe) Conference, Eindhoven. Springer Verlag LNCS.
8. Atkins, D., Ball, T., Bruns, G., and Cox, K. (1999). Mawl: A domain-specific language for form-based services. IEEE Transactions on Software Engineering, 25(3):334--346.
9. Augustsson, L. (1984). A compiler for lazy ML. In (LFP84, 1984), pages 218--227.
10. Augustsson, L. (1998). Cayenne --- a language with dependent types. In (ICFP98, 1998), pages 239--250.
11. Baars, A., Lh, A., and Swierstra, D. (2004). Parsing pemutation phrases. Journal of Functional Programming, 14:635--646.
12. Baars, A. L. and Swierstra, S. D. (2002). Typing dynamic typing. In (ICFP02, 2002), pages 157--166.
13. Backus, J. (1978a). Can programming be liberated from the von Neumann style? Communications of the ACM, 21(8).
14. Backus, J. (1978b). Can programming be liberated from the von Neumann style? A functional style and its algebra of programs. Communications of the ACM, 21(8):613--41.
15. Barendsen, E. and Smetsers, S. (1996). Uniqueness typing for functional languages with graph rewriting semantics. Mathematical Structures in Computer Science, 6:579--612.
16. Barron, D., Buxton, J., Hartley, D., Nixon, E., and Strachey, C. (1963). The main features of cpl. The Computer Journal, 6(2): 134--143.
17. Barth, P., Nikhil, R., and Arvind (1991). M-structures: extending a parallel, non-strict functional language with state. In Hughes, R., editor, ACM Conference on Functional Programming and Computer Architecture (FPCA'91), volume 523 of Lecture Notes in Computer Science, pages 538--568. Springer Verlag, Boston.
18. Barton, D. (1995). Advanced modeling features of MHDL. In Proceedings of International Conference on Electronic Hardware Description Languages.
19. Bird, R. and Paterson, R. (1999). De Bruijn notation as a nested datatype. Journal of Functional Programming, 9(1):77--91.
20. Bird, R. and Wadler, P. (1988). Introduction to Functional Programming. Prentice Hall.
21. Bjesse, P., Claessen, K., Sheeran, M., and Singh, S. (1998). Lava: Hardware design in haskell. In International Conference on Functional Programming, pages 174--184.
22. Bloss, A. (1988). Path Analysis: Using Order-of-Evaluation Information to Optimize Lazy Functional Languages. PhD thesis, Yale University, Department of Computer Science.
23. Bloss, A., Hudak, P., and Young, J. (1988a). Code optimizations for lazy evaluation. Lisp and Symbolic Computation: An International Journal, 1(2): 147--164.
24. Bloss, A., Hudak, P., and Young, J. (1988b). An optimizing compiler for a modern functional language. The Computer Journal, 31(6):152--161.
25. Blott, S. (1991). Type Classes. PhD thesis, Department of Computing Science, Glasgow University.
26. Blumofe, R. D., Joerg, C. F., Kuszmaul, B. C., Leiserson, C. E., Randall, K. H., and Zhou, Y (1996). Cilk: An efficient multithreaded runtime system. Journal of Parallel and Distributed Computing, 37(1):55--69.
27. Boquist, U. (1999). Code Optimisation Techniques for Lazy Functional Languages. PhD thesis, Chalmers University of Technology, Sweden.
28. Bracha, G., Odersky, M., Stoutamire, D., and Wadler, P. (1998). Making the future safe for the past: Adding genericity to the Java programming language. In Chambers, C., editor, ACM Symposium on Object Oriented Programming: Systems, Languages, and Applications (OOPSLA), pages 183--200, Van-couver, BC.
29. Brus, T., van Eckelen, M., van Leer, M., and Plasmeijer, M. (1987). Clean --- a language for functional graph rewriting. In Kahn, G., editor, Functional Programming Languages and Computer Architecture, pages 364--384. LNCS 274, Springer Verlag.
30. Burge, W. (1975). Recursive Programming Techniques. Addison Wesley.
31. Burstall, R. (1969). Proving properties of programs by structural induction. The Computer Journal, pages 41--48.
32. Burstall, R. (1977). Design considerations for a functional programming language. In The Software Revolution. Infotech.
33. Burstall, R. and Darlington, J. (1977). A transformation system for developing recursive programs. JACM, 24(1):44--67.
34. Burstall, R. M., MacQueen, D. B., and Sannella, D. T. (1980). HOPE: An experimental applicative language. In Conference Record of the 1980 LISP Conference, pages 136--143.
35. Burton, W., Meijer, E., Sansom, P., Thompson, S., and Wadler, P. (1996). Views: An extension to Haskell pattern matching, http://haskell.org/development/views.html.
36. Callaghan, P. (1998). An Evaluation of LOLITA and Related Natural Language Processing Systems. PhD thesis, Department of Computer Science, University of Durham.
37. Carlier, S. and Bobbio, J. (2004). hop.
38. Carlson, W., Hudak, P., and Jones, M. (1993). An experiment using Haskell to prototype "geometric region servers" for Navy command and control. Research Report 1031, Department of Computer Science, Yale University.
39. Carlsson, M. and Hallgren, T. (1993). Fudgets --- a graphical user interface in a lazy functional language. In (FPCA93, 1993), pages 321--330.
40. Chakravarty, M. (1999a). C -> Haskell: yet another interfacing tool. In Koopman, P. and Clack, C., editors, International Workshop on Implementing Functional Languages (IFL'99), number 1868 in Lecture Notes in Computer Science, Lochem, The Netherlands. Springer Verlag.
41. Chakravarty, M. (1999b). Lazy lexing is fast. In Middeldorp, A. and Sato, T., editors, Fourth Fuji International Symposium on Functional and Logic Programming, Lecture Notes in Computer Science. Springer Verlag.
42. Chakravarty, M., editor (2002). Proceedings of the 2002 Haskell Workshop, Pittsburgh.
43. Chakravarty, M., Keller, G., and Peyton Jones, S. (2005a). Associated type synonyms. In ACM SIGPLAN International Conference on Functional Programming (ICFP'05), Tallinn, Estonia.
44. Chakravarty, M., Keller, G., Peyton Jones, S., and Marlow, S. (2005b). Associated types with class. In ACM Symposium on Principles of Programming Languages (POPL'05). ACM Press.
45. Chen, K., Hudak, P., and Odersky, M. (1992). Parametric type classes. In Proceedings of ACM Conference on Lisp and Functional Programming, pages 170--181. ACM.
46. Cheney, J. and Hinze, R. (2003). First-class phantom types. CUCIS TR2003--1901, Cornell University.
47. Cheong, M. H. (2005). Functional Programming and 3D Games. Undergraduate thesis, University of New South Wales.
48. Church, A. (1941). The calculi of lambda-conversion. Annals of Mathematics Studies, 6.
49. Claessen, K. (2004). Parallel parsing processes. Journal of Functional Programming, 14:741--757.
50. Claessen, K. and Hughes, J. (2000). QuickCheck: a lightweight tool for random testing of Haskell programs. In (ICFP00, 2000), pages 268--279.
51. Claessen, K. and Hughes, J. (2002). Testing monadic code with QuickCheck. In (Chakravarty, 2002).
52. Claessen, K. and Sands, D. (1999). Observable sharing for functional circuit description. In Thiagarajan, P. and Yap, R., editors, Advances in Computing Science (ASIAN'99); 5th Asian Computing Science Conference, Lecture Notes in Computer Science, pages 62--73. Springer Verlag.
53. Cooper, G. and Krishnamurthi, S. (2006). Embedding dynamic dataflow in a call-by-value language. In 15th European Symposium on Programming, volume 3924 of LNCS. Springer-Verlag.
54. Courtney, A. (2004). Modelling User Interfaces in a Functional Language. PhD thesis, Department of Computer Science, Yale University.
55. Courtney, A. and Elliott, C. (2001). Genuinely functional user interfaces. In Proc. of the 2001 Haskell Workshop, pages 41--69.
56. Curry, H. and Feys, R. (1958). Combinatory Logic, Vol. 1. North-Holland, Amsterdam.
57. Damas, L. and Milner, R. (1982). Principal type-schemes for functional programs. In Conference Record of the 9th Annual ACM Symposium on Principles of Programming Languages, pages 207--12, New York. ACM Press.
58. Danielsson, N. A., Hughes, J., Jansson, P., and Gibbons, J. (2006). Fast and loose reasoning is morally correct. SIGPLAN Not., 41(1):206--217.
59. Darlington, J., Henderson, P., and Turner, D. (1982). Advanced Course on Functional Programming and its Applications. Cambridge University Press.
60. Darlington, J. and Reeve, M. (1981). ALICE --- a multiprocessor reduction machine for the parallel evaluation of applicative languages. In Proc Conference on Functional Programming Languages and Computer Architecture, Portsmouth, New Hampshire, pages 66--76. ACM.
61. Davis, A. (1977). The architecture of ddm 1: a recursively structured data driven machine. Technical Report UUCS-77-113, University of Utah.
62. de la Banda, M. G., Demoen, B., Marriott, K., and Stuckey, P. (2002). To the gates of HAL: a HAL tutorial. In Proceedings of the Sixth International Symposium on Functional and Logic Programming. Springer Verlag LNCS 2441.
63. Diatchki, I., Jones, M., and Hallgren, T. (2002). A formal specification of the Haskell 98 module system. In (Chakravarty, 2002).
64. Dijkstra, E. (1981). Trip report E. W Dijkstra, Newcastle, 19--25 July 1981. Dijkstra working note EWD798.
65. Dybjer, P. (1991). Inductive sets and families in Martin-Löf's type theory. In Huet, G. and Plotkin, G., editors, Logical Frameworks. Cambridge University Press.
66. Dybvig, K., Peyton Jones, S., and Sabry, A. (2005). A monadic framework for delimited continuations. To appear in the Journal of Functional Programming.
67. Elliott, C. (1996). A brief introduction to activevrml. Technical Report MSR-TR-96-05, Microsoft Research.
68. Elliott, C. (1997). Modeling interactive 3D and multimedia animation with an embedded language. In Proceedings of the first conference on Domain-Specific Languages, pages 285--296. USENIX.
69. Elliott, C. and Hudak, P. (1997). Functional reactive animation. In International Conference on Functional Programming, pages 263--273.
70. Elliott, C., Schechter, G., Yeung, R., and Abi-Ezzi, S. (1994). Tbag: A high level framework for interactive, animated 3d graphics applications. In Proceedings of SIGGRAPH '94, pages 421--434. ACM SIGGRAPH.
71. Ennals, R. and Peyton Jones, S. (2003). Optimistic evaluation: an adaptive evaluation strategy for non-strict programs. In (ICFP03, 2003).
72. Evans, A. (1968). Pal---a language designed for teaching programming linguistics. In Proceedings ACM National Conference.
73. Fairbairn, J. (1982). Ponder and its type system. Technical Report TR-31, Cambridge University Computer Lab.
74. Fairbairn, J. (1985). Design and implementation of a simple typed language based on the lambda-calculus. Technical Report 75, University of Cambridge Computer Laboratory.
75. Faxen, K.-F. (2002). A static semantics for Haskell. Journal of Functional Programming, 12(4&5).
76. Field, A., Hunt, L., and While, R. (1992). The semantics and implementation of various best-fit pattern matching schemes for functional languages. Technical Report Doc 92/13, Dept of Computing, Imperial College.
77. Finne, S., Leijen, D., Meijer, E., and Peyton Jones, S. (1998). H/Direct: a binary foreign language interface for Haskell. In ACM SIGPLAN International Conference on Functional Programming (ICFP'98), volume 34(1) of ACM SIGPLAN Notices, pages 153--162. ACM Press, Baltimore.
78. Finne, S. and Peyton Jones, S. (1995). Composing Haggis. In Proc 5th Eurographics Workshop on Programming Paradigms in Graphics, Maastricht.
79. Ford, B. (2002). Packrat parsing: simple, powerful, lazy, linear time. In (ICFP02, 2002), pages 36--47.
80. FPCA93 (1993). ACM Conference on Functional Programming and Computer Architecture (FPCA'93), Cophenhagen. ACM.
81. FPCA95 (1995). ACM Conference on Functional Programming and Computer Architecture (FPCA'95), La Jolla, California. ACM.
82. Friedman, D. and Wise, D. (1976). CONS should not evaluate its arguments. Automata, Languages, and Programming, pages 257--281.
83. Frost, R. (2006). Realization of natural-language interfaces using lazy functional programming. ACM Computing Surveys, 38(4). Article No. 11.
84. Gaster, B. (1998). Records, Variants, and Qualified Types. PhD thesis, Department of Computer Science, University of Nottingham.
85. Gaster, B. R. and Jones, M. P. (1996). A polymorphic type system for extensible records and variants. Technical Report TR-96-3, Department of Computer Science, University of Nottingham.
86. Gill, A. (2000). Debugging Haskell by observing intermediate data structures. In Haskell Workshop. ACM SIGPLAN.
87. Gill, A., Launchbury, J., and Peyton Jones, S. (1993). A short cut to deforestation. In ACM Conference on Functional Programming and Computer Architecture (FPCA'93), pages 223--232, Cophenhagen. ACM Press. ISBN 0-89791-595-X.
88. Girard, J.-Y. (1990). The system F of variable types: fifteen years later. In Huet, G., editor, Logical Foundations of Functional Programming. Addison-Wesley.
89. Glynn, K., Stuckey, P., and Sulzmann, M. (2000). Type classes and constraint handling rules. In First Workshop on Rule-Based Constraint Reasoning and Programming.
90. Gödel, K. (1931). Über formal unentscheidbare sätze der principia mathematica und verwandter Systeme I. Monatshefte für Mathematik und Physik, 38:173--198. Pages 596--616 of (van Heijenoort, 1967).
91. Gordon, M., Milner, R., and Wadsworth, C. (1979). Edinburgh LCF. Springer Verlag LNCS 78.
92. Graham, P. (2004). Beating the averages. In Hackers and Painters. O'Reilly.
93. Graunke, P., Krishnamurthi, S., Hoeven, S. V. D., and Felleisen, M. (2001). Programming the web with high-level programming languages. In Proceedings 10th European Symposium on Programming, pages 122--136. Springer Verlag LNCS 2028.
94. Hall, C. and O'Donnell, J. (1985). Debugging in a side-effect-free programming environment. In Proc ACM Symposium on Language Issues and Programming Environments. ACM, Seattle.
95. Hallgren, T. (2001). Fun with functional dependencies. In Proc Joint CS/CE Winter Meeting, Chalmers Univerity, Varberg, Sweden.
96. Hallgren, T., Jones, M. P., Leslie, R., and Tolmach, A. (2005). A principled approach to operating system construction in Haskell. In ICFP '05: Proceedings of the Tenth ACM SIGPLAN International Conference on Functional Programming, pages 116--128, New York, NY, USA. ACM Press.
97. Hanus, M., Kuchen, H., and Moreno-Navarro, J. (1995). Curry: A truly functional logic language. In Proceedings of the ILPS '95 Postconference Workshop on Visions for the Future of Logic Programming.
98. Harris, T., Marlow, S., Peyton Jones, S., and Herlihy, M. (2005). Composable memory transactions. In ACM Symposium on Principles and Practice of Parallel Programming (PPoPP'05).
99. Harrison, W. and Kamin, S. (1998). Modular compilers based on monad transformers. In Proc International Conference on Computer Languages, pages 122--131.
100. Hartel, P., Feeley, M., Alt, M., Augustsson, L., Bauman, P., Weis, P., and Wentworth, P. (1996). Pseudoknot: a float-intensive benchmark for functional compilers. Journal of Functional Programming, 6(4).
101. Haskell01 (2001). Proceedings of the 2001 Haskell Workshop, Florence.
102. Haskell04 (2004). Proceedings of ACM Workshop on Haskell, Snowbird, Snowbird, Utah. ACM.
103. Heeren, B., Hage, J., and Swierstra, S. (2003a). Scripting the type inference process. In (ICFP03, 2003), pages 3--14.
104. Heeren, B., Leijen, D., and van IJzendoorn, A. (2003b). Helium, for learning Haskell. In ACM Sigplan 2003 Haskell Workshop, pages 62 -- 71, New York. ACM Press.
105. Henderson, P. (1982). Functional geometry. In Proc ACM Symposium on Lisp and Functional Programming, pages 179--187. ACM.
106. Henderson, P. and Morris, J. (1976). A lazy evaluator. In In Proceedings of 3rd International Conference on Principles of Programming Languages (POPL'76), pages 95--103.
107. Herington, D. (2002). Hunit home page. http://hunit.sourceforge.net.
108. Hinze, R. (2000). A new approach to generic functional programming. In (POPL00, 2000), pages 119--132.
109. Hinze, R. (2001). Manufacturing datatypes. Journal of Functional Programming, 1.
110. Hinze, R. (2003). Fun with phantom types. In Gibbons, J. and de Moor, O., editors, The Fun of Programming, pages 245--262. Palgrave.
111. Hinze, R. (2004). Generics for the masses. In ACM SIGPLAN International Conference on Functional Programming (ICFP'04), Snowbird, Utah. ACM.
112. Hinze, R., Jeuring, J., and Lh, A. (2006). Comparing approaches to generic programming in Haskell. In Generic Programming, Advanced Lectures, LNCS. Springer-Verlag.
113. Hinze, R. and Peyton Jones, S. (2000). Derivable type classes. In Hutton, G., editor, Proceedings of the 2000 Haskell Workshop, Montreal. Nottingham University Department of Computer Science Technical Report NOTTCS-TR-00-1.
114. Hudak, P. (1984a). ALFL Reference Manual and Programmer's Guide. Research Report YALEU/DCS/RR-322, Second Edition, Yale University, Dept. of Computer Science.
115. Hudak, P. (1984b). Distributed applicative processing systems - project goals, motivation and status report. Research Report YALEU/DCS/RR-317, Yale University, Dept. of Computer Science.
116. Hudak, P. (1989). Conception, evolution, and application of functional programming languages. ACM Computing Surveys, 21(3):359--411.
117. Hudak, P. (1996a). Building domain-specific embedded languages. ACM Computing Surveys, 28A.
118. Hudak, P. (1996b). Haskore music tutorial. In Second International School on Advanced Functional Programming, pages 38--68. Springer Verlag, LNCS 1129.
119. Hudak, P. (1998). Modular domain specific languages and tools. In Proceedings of Fifth International Conference on Software Reuse, pages 134--142. IEEE Computer Society.
120. Hudak, P. (2000). The Haskell School of Expression - Learning Functional Programming Through Multimedia. Cambridge University Press, New York.
121. Hudak, P. (2003). Describing and interpreting music in Haskell. In Gibbons, J. and de Moor, O., editors, The Fun of Programming, chapter 4. Palgrave.
122. Hudak, P. (2004). Polymorphic temporal media. In Proceedings of PADL'04: 6th International Workshop on Practical Aspects of Declarative Languages. Springer Verlag LNCS.
123. Hudak, P., Courtney, A., Nilsson, H., and Peterson, J. (2003). Arrows, robots, and functional reactive programming. In Jeuring, J. and Jones, S. P., editors, Advanced Functional Programming, 4th International School, volume 2638 of Lecture Notes in Computer Science. Springer-Verlag.
124. Hudak, P., Makucevich, T., Gadde, S., and Whong, B. (1996). Haskore music notation - an algebra of music. Journal of Functional Programming, 6(3):465--483.
125. Hudak, P. and Sundaresh, R. (1989). On the expressiveness of purely-functional I/O systems. Research Report YALEU/DCS/RR-665, Department of Computer Science, Yale University.
126. Hudak, P. and Young, J. (1986). Higher-order strictness analysis in untyped lambda calculus. In ACM Symposium on Principles of Programming Languages, pages 97--109.
127. Huet, G. (1975). A unification algorithm for typed lambda-calculus. Theoretical Computer Science, 1:22--58.
128. Huet, G. and Levy, J. (1979). Call by need computations in non-ambiguous linear term-rewriting systems. Report 359, INRIA.
129. Hughes, J. (1989). Why functional programming matters. The Computer Journal, 32(2):98--107.
130. Hughes, J. (1995). The design of a pretty-printing library. In Jeuring, J. and Meijer, E., editors, Advanced Functional Programming, pages 53--96. Springer Verlag, LNCS 925.
131. Hughes, J. (2000). Generalising monads to arrows. Science of Computer Programming, 37:67--111.
132. Hughes, R. (1983). The Design and Implementation of Programming Languages. Ph.D. thesis, Programming Research Group, Oxford University.
133. Hutton, G. and Meijer, E. (1998). Monadic parsing in Haskell. Journal of Functional Programming, 8:437--444.
134. ICFP00 (2000). ACM SIGPLAN International Conference on Functional Programming (ICFP'00), Montreal. ACM.
135. ICFP02 (2002). ACM SIGPLAN International Conference on Functional Programming (ICFP'02), Pittsburgh. ACM.
136. ICFP03 (2003). ACM SIGPLAN International Conference on Functional Programming (ICFP'03) Uppsala, Sweden. ACM.
137. ICFP97 (1997). ACM SIGPLAN International Conference on Functional Programming (ICFP'97), Amsterdam. ACM.
138. ICFP98 (1998). ACM SIGPLAN International Conference on Functional Programming (ICFP'98), volume 34(1) of ACM SIGPLAN Notices, Baltimore. ACM.
139. ICFP99 (1999). ACM SIGPLAN International Conference on Functional Programming (ICFP'99), Paris. ACM.
140. Jansson, P. and Jeuring, J. (1997). PolyP --- a polytypic programming language extension. In 24th ACM Symposium on Principles of Programming Languages (POPL'97), pages 470--482, Paris. ACM.
141. Jansson, P. and Jeuring, J. (1999). Polytypic compact printing and parsing. In European Symposium on Programming, volume 1576 of Lecture Notes in Computer Science, pages 273--287. Springer-Verlag.
142. Johann, P. and Voigtländer, J. (2004). Free theorems in the presence of seq. In ACM Symposium on Principles of Programming Languages (POPL'04), pages 99--110, Charleston. ACM.
143. Johnson, S. (1984). Synthesis of Digital Designs from Recursive Equations. ACM Distinguished Dissertation. MIT Press.
144. Johnsson, T. (1984). Efficient compilation of lazy evaluation. In Proc SIGPLAN Symposium on Compiler Construction, Montreal. ACM.
145. Jones, M. (1991). Type inference for qualified types. PRG-TR-10-91, Programming Research Group, Oxford, Oxford University.
146. Jones, M. (1992). A theory of qualified types. In European Symposium on Programming (ESOP'92), number 582 in Lecture Notes in Computer Science, Rennes, France. Springer Verlag.
147. Jones, M. (1993). A system of constructor classes: overloading and implicit higher-order polymorphism. In (FPCA93, 1993).
148. Jones, M. (1994). Qualified Types: Theory and Practice. Cambridge University Press.
149. Jones, M. (1995). Simplifying and improving qualified types. In (FPCA95, 1995).
150. Jones, M. (1999). Typing Haskell in Haskell. In (Meijer, 1999). Available at ftp://ftp.cs.uu.nl/pub/RUU/CS/techreps/CS-1999/1999-28.pdf.
151. Jones, M. (2000). Type classes with functional dependencies. In European Symposium on Programming (ESOP'00), number 1782 in Lecture Notes in Computer Science, Berlin, Germany. Springer Verlag.
152. Jones, M. and Duponcheel, L. (1994). Composing monads. Technical Report YALEU/DCS/RR-1004, Yale University.
153. Jouannaud, J.-P., editor (1985). ACM Conference on Functional Programming and Computer Architecture (FPCA'85), volume 201 of Lecture Notes in Computer Science, Nancy, France. Springer-Verlag.
154. Kaes, S. (1988). Parametric overloading in polymorphic programming languages. In Proceedings of the 2nd European Symposium on Programming.
155. Keller, R., Lindstrom, G., and Patil, S. (1979). A loosely coupled applicative multiprocessing system. In AFIPS Conference Proceedings, pages 613--622.
156. Kelsey, R., Clinger, W., and Rees, J. (1998). Revised⁵ report on the algorithmic language Scheme. SIGPLAN Notices, 33(9):26--76.
157. Kiselyov, O., Lmmel, R., and Schupke, K. (2004). Strongly typed heterogeneous collections. In (Haskell04, 2004), pages 96--107.
158. Kiselyov, O. and Shan, K. (2004). Implicit configurations; or, type classes reflect the values of types. In (Haskell04, 2004), pages 33--44.
159. Knuth, D. (1984). Literate programming. Computer Journal, 27(2):97--111.
160. Kranz, D., Kelsey, R., Rees, J., Hudak, P., Philbin, J., and Adams, N. (1986). Orbit: an optimizing compiler for Scheme. In SIGPLAN '86 Symposium on Compiler Construction, pages 219--233. ACM. Published as SIGPLAN Notices Vol. 21, No. 7, July 1986.
161. Kranz, D., Kesley, R., Rees, J., Hudak, P., Philbin, J., and Adams, N. (2004). Retrospective on: Orbit: an optimizing compiler for Scheme. ACM SIGPLAN Notices, 20 Years of the ACM SIGPLAN Conference on Programming Language Design and Implementation (1979--1999): A Selection, 39(4).
162. Lämmel, R. and Peyton Jones, S. (2003). Scrap your boilerplate: a practical approach to generic programming. In ACM SIGPLAN International Workshop on Types in Language Design and Implementation (TLDI'03), pages 26--37, New Orleans. ACM Press.
163. Lämmel, R. and Peyton Jones, S. (2005). Scrap your boilerplate with class: Extensible generic functions. In ACM SIGPLAN International Conference on Functional Programming (ICFP'05), Tallinn, Estonia.
164. Landin, P. (1966). The next 700 programming languages. Communications of the ACM, 9(3):157--166.
165. Landin, P. J. (1964). The mechanical evaluation of expressions. Computer Journal, 6(4):308--320.
166. Läufer, K. (1996). Type classes with existential types. Journal of Functional Programming, 6(3):485--517.
167. Läufer, K. and Odersky, M. (1994). Polymorphic type inference and abstract data types. ACM Transactions on Programming Languages and Systems, 16(5): 1411--1430.
168. Launchbury, J. (1993). Lazy imperative programming. In Proc ACMSigplan Workshop on State in Programming Languages, Copenhagen (available as YALEU/DCS/RR-968, Yale University), pages pp46--56.
169. Launchbury, J. and Peyton Jones, S. (1995). State in Haskell. Lisp and Symbolic Computation, 8(4):293--342.
170. Launchbury, J. and Sabry, A. (1997). Monadic state: Axiomatization and type safety. In (ICFP97, 1997), pages 227--238.
171. Launchbury, J. and Sansom, P., editors (1992). Functional Programming, Glasgow 1992, Workshops in Computing. Springer Verlag.
172. Leijen, D. and Meijer, E. (1999). Domain-specific embedded compilers. In Proc 2nd Conference on Domain-Specific Languages (DSL'99), pages 109--122.
173. Lewis, J., Shields, M., Meijer, E., and Launchbury, J. (2000). Implicit parameters: dynamic scoping with static types. In (POPL00, 2000).
174. LFP84 (1984). ACM Symposium on Lisp and Functional Programming (LFP'84). ACM.
175. Li, H., Reinke, C., and Thompson, S. (2003). Tool support for refactoring functional programs. In Jeuring, J., editor, Proceedings of the 2003 Haskell Workshop, Uppsala.
176. Liang, S., Hudak, P., and Jones, M. (1995). Monad transformers and modular interpreters. In 22nd ACM Symposium on Principles of Programming Languages (POPL'95), pages 333--343. ACM.
177. Lindig, C. (2005). Random testing of C calling conventions. In AADEBUG, pages 3--12.
178. Lloyd, J. W. (1999). Programming in an integrated functional and logic language. Journal of Functional and Logic Programming.
179. Löh, A., Clarke, D., and Jeuring, J. (2003). Dependency-style Generic Haskell. In (ICFP03, 2003), pages 141--152.
180. Long, D. and Garigliano, R. (1993). Reasoning by Analogy and Causality (A Model and Application). Ellis Horwood.
181. Lüth, C. and Ghani, N. (2002). Composing monads using coproducts. In (ICFP02, 2002), pages 133--144.
182. Maessen, J.-W. (2002). Eager Haskell: Resource-bounded execution yields efficient iteration. In The Haskell Workshop, Pittsburgh.
183. Major, F. and Turcotte, M. (1991). The combination of symbolic and numerical computation for three-dimensional modelling of RNA. SCIENCE, 253:1255--1260.
184. Marlow, S., Peyton Jones, S., and Thaller, W. (2004). Extending the Haskell Foreign Function Interface with concurrency. In Proceedings of Haskell Workshop, Snowbird, Utah, pages 57--68.
185. Matthews, J., Cook, B., and Launchbury, J. (1998). Microprocessor specification in Hawk. In International Conference on Computer Languages, pages 90--101.
186. McBride, C. (2002). Faking it: Simulating dependent types in Haskell. Journal of Functional Programming, 12(4&5):375--392.
187. McCarthy, J. L. (1960). Recursive functions of symbolic expressions and their computation by machine, Part I. Communications of the ACM, 3(4):184--195. The original Lisp paper.
188. Meijer, E., editor (1999). Proceedings of the 1999 Haskell Workshop, number UU-CS-1999-28 in Technical Reports. Available at ftp://ftp.cs.uu.nl/pub/RUU/CS/techreps/CS-1999/1999-28.pdf.
189. Meijer, E. (2000). Server side web scripting in Haskell. Journal of Functional Programming, 10(1): 1--18.
190. Meijer, E. and Claessen, K. (1997). The design and implementation of Mondrian. In Launchbury, J., editor, Haskell Workshop, Amsterdam, Netherlands.
191. Milner, R. (1978). A theory of type polymorphism in programming. JCSS, 13(3).
192. Milner, R. (1984). A proposal for Standard ML. In ACM Symposium on LISP and Functional Programming, pages 184--197.
193. Milner, R. and Tofte, M. (1990). The Definition of Standard ML. MIT Press.
194. Milner, R., Tofte, M., Harper, R., and MacQueen, D. (1997). The Definition of Standard ML (Revised). MIT Press, Cambridge, Massachusetts.
195. Mitchell, J. and Plotkin, G. (1985). Abstract types have existential type. In Twelfth Annual ACM Symposium on Principles of Programming Languages (POPL'85), pages 37--51.
196. Moggi, E. (1989). Computational lambda calculus and monads. In Logic in Computer Science, California. IEEE.
197. Moggi, E. (1991). Notions of computation and monads. Information and Computation, 93:55--92.
198. Neubauer, M., Thiemann, P., Gasbichler, M., and Sperber, M. (2001). A functional notation for functional dependencies. In (Haskell01, 2001).
199. Neubauer, M., Thiemann, P., Gasbichler, M., and Sperber, M. (2002). Functional logic overloading. In ACM Symposium on Principles of Programming Languages (POPL'02), pages 233--244, Portland. ACM.
200. Nikhil, R. S. and Arvind (2001). Implicit Parallel Programming in pH. Morgan Kaufman.
201. Nilsson, H. and Fritzson, P. (1994). Algorithmic debugging for lazy functional languages. Journal of Functional Programming, 4(3):337--370.
202. Nilsson, H. and Sparud, J. (1997). The evaluation dependence tree as a basis for lazy functional debugging. Automated Software Engineering, 4(2): 121--150.
203. Nordin, T., Peyton Jones, S., and Reid, A. (1997). Green Card: a foreign-language interface for Haskell. In Launchbury, J., editor, Haskell Workshop, Amsterdam.
204. Odersky, M. (2006). Changes between Scala version 1.0 and 2.0. Technical report, EPFL Lausanne.
205. Odersky, M., Altherr, P., Cremet, V., Emir, B., Maneth, S., Micheloud, S., Mihaylov, N., Schinz, M., Stenman, E., and Zenger, M. (2004). An overview of the Scala programming language. Technical Report IC/2004/640, EPFL Lausanne.
206. O'Donnell, J. (1995). From transistors to computer architecture: teaching functional circuit specification in Hydra. In Symposium on Functional Programming Languages in Education, volume 1022 of LNCS. Springer-Verlag.
207. Ohori, A. (1995). A polymorphic record calculus and its compilation. ACM Transactions on Programming Languages and Systems, 17:844--895.
208. Okasaki, C. (1998a). Purely functional data structures. Cambridge University Press.
209. Okasaki, C. (1998b). Views for Standard ML. In ACM SIGPLAN Workshop on ML, Baltimore, Maryland.
210. Okasaki, C. (1999). From fast exponentiation to square matrices: an adventure in types. In (ICFP99, 1999), pages 28--35.
211. Page, R. (2003). Software is discrete mathematics. In (ICFP03, 2003), pages 79--86.
212. Page, R. and Moe, B. (1993). Experience with a large scientific application in a functional language. In (FPCA93, 1993).
213. Paterson, R. (2001). A new notation for arrows. In International Conference on Functional Programming, pages 229--240. ACM Press.
214. Paterson, R. (2003). Arrows and computation. In Gibbons, J. and de Moor, O., editors, The Fun of Programming, pages 201--222. Palgrave.
215. Paulson, L. (2004). Organizing numerical theories using axiomatic type classes. Journal of Automated Reasoning, 33(1):29--49.
216. Perry, N. (1991a). An extended type system supporting polymorphism, abstract data types, overloading and inference. In Proc 15th Australian Computer Science Conference.
217. Perry, N. (1991b). The Implementation of Practical Functional Programming Languages. Ph.D. thesis, Imperial College, London.
218. Peterson, J., Hager, G., and Hudak, P. (1999a). A language for declarative robotic programming. In International Conference on Robotics and Automation.
219. Peterson, J., Hudak, P., and Elliott, C. (1999b). Lambda in motion: Controlling robots with Haskell. In First International Workshop on Practical Aspects of Declarative Languages. SIGPLAN.
220. Peyton Jones, S. (1987). The Implementation of Functional Programming Languages. Prentice Hall.
221. Peyton Jones, S. (2001). Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell. In Hoare, C., Broy, M., and Steinbrueggen, R., editors, Engineering Theories of Software Construction, Marktoberdorf Summer School 2000, NATO ASI Series, pages 47--96. IOS Press.
222. Peyton Jones, S., Eber, J.-M., and Seward, J. (2000). Composing contracts: an adventure in financial engineering. In ACM SIGPLAN International Conference on Functional Programming (ICFP'00), pages 280--292, Montreal. ACM Press.
223. Peyton Jones, S., Gordon, A., and Finne, S. (1996). Concurrent Haskell. In 23rd ACM Symposium on Principles of Programming Languages (POPL'96), pages 295--308, St Petersburg Beach, Florida. ACM Press.
224. Peyton Jones, S., Hall, C., Hammond, K., Partain, W., and Wadler, P. (1993). The Glasgow Haskell Compiler: a technical overview. In Proceedings of Joint Framework for Information Technology Technical Conference, Keele, pages 249--257. DTI/SERC.
225. Peyton Jones, S., Jones, M., and Meijer, E. (1997). Type classes: an exploration of the design space. In Launchbury, J., editor, Haskell workshop, Amsterdam.
226. Peyton Jones, S. and Launchbury, J. (1991). Unboxed values as first class citizens. In Hughes, R., editor, ACM Conference on Functional Programming and Computer Architecture (FPCA'91), volume 523 of Lecture Notes in Computer Science, pages 636--666, Boston. Springer.
227. Peyton Jones, S., Reid, A., Hoare, C., Marlow, S., and Henderson, F. (1999). A semantics for imprecise exceptions. In ACM Conference on Programming Languages Design and Implementation (PLDI'99), pages 25--36, Atlanta. ACM Press.
228. Peyton Jones, S., Vytiniotis, D., Weirich, S., and Shields, M. (2007). Practical type inference for arbitrary-rank types. Journal of Functional Programming, 17:1--82.
229. Peyton Jones, S. and Wadler, P. (1993). Imperative functional programming. In 20th ACM Symposium on Principles of Programming Languages (POPL'93), pages 71--84. ACM Press.
230. Peyton Jones, S., Washburn, G., and Weirich, S. (2004). Wobbly types: type inference for generalised algebraic data types. Microsoft Research.
231. Peyton Jones, S. L. (1992). Implementing lazy functional languages on stock hardware: The spineless tagless G-machine. Journal of Functional Programming, 2(2): 127--202.
232. Pierce, B. (2002). Types and Programming Languages. MIT Press.
233. Pope, B. (2005). Declarative debugging with Buddha. In Vene, V. and Uustalu, T., editors, Advanced Functional Programming, 5th International School, AFP 2004, Tartu, Estonia, August 14-21, 2004, Revised Lectures, volume 3622 of Lecture Notes in Computer Science. Springer.
234. POPL00 (2000). 27th ACM Symposium on Principles of Programming Languages (POPL'00), Boston. ACM.
235. Pottier, F. and Régis-Gianas, Y. (2006). Stratified type inference for generalized algebraic data types. In ACM Symposium on Principles of Programming Languages (POPL'06), Charleston. ACM.
236. Queinnec, C. (2000). The influence of browsers on evaluators or, continuations to program web servers. In International Conference on Functional Programming.
237. Ranta, A. (2004). Grammatical framework. Journal of Functional Programming, 14(2):145--189.
238. Rees, J. and Clinger, W. (1986). Revised report on the algorithmic language scheme. ACM SIGPLAN Notices, 21:37--79.
239. Rojemo, N. (1995a). Garbage Collection and Memory Efficiency in Lazy Functional Languages. Ph.D. thesis, Department of Computing Science, Chalmers University.
240. Rojemo, N. (1995b). Highlights from nhc: a space-efficient Haskell compiler. In (FPCA95, 1995).
241. Roundy, D. (2005). Darcs homepage, http://www.darcs.net.
242. Runciman, C. and Wakeling, D. (1992). Heap profiling a lazy functional compiler. In (Launchbury and Sansom, 1992), pages 203--214.
243. Runciman, C. and Wakeling, D. (1993). Heap profiling of lazy functional programs. Journal of Functional Programming, 3(2):217--246.
244. Rjemo, N. and Runciman, C. (1996a). Lag, drag, void, and use: heap profiling and space-efficient compilation revisited. In ACM SIGPLAN International Conference on Functional Programming (ICFP'96), pages 34--41. ACM, Philadelphia.
245. Rjemo, N. and Runciman, C. (1996b). New dimensions in heap profiling. Journal of Functional Programming, 6(4).
246. Sage, M. (2000). FranTk: a declarative GUI language for Haskell. In (ICFP00, 2000).
247. Sansom, P. and Peyton Jones, S. (1995). Time and space profiling for non-strict, higher-order functional languages. In 22nd ACM Symposium on Principles of Programming Languages (POPL'95), pages 355--366. ACM Press.
248. Schechter, G., Elliott, C., Yeung, R., and Abi-Ezzi, S. (1994). Functional 3D graphics in C++--- with an object-oriented, multiple dispatching implementation. In Proceedings of the 1994 Eurographics Object-Oriented Graphics Workshop. Eurographics, Springer Verlag.
249. Scheevel, M. (1984). NORMA SASL manual. Technical report, Burroughs Corporation Austin Research Center.
250. Scheevel, M. (1986). NORMA --- a graph reduction processor. In Proc ACM Conference on Lisp and Functional Programming, pages 212--219.
251. Scholz, E. (1998). Imperative streams - a monadic combinator library for synchronous programming. In (ICFP98, 1998).
252. Scott, D. (1976). Data types as lattices. SIAM Journal on Computing, 5(3):522--587.
253. Scott, D. and Strachey, C. (1971). Towards a mathematical semantics for computer languages. PRG-6, Programming Research Group, Oxford University.
254. Shapiro, E. (1983). Algorithmic Debugging. MIT Press.
255. Sheard, T. (2004). Languages of the future. In ACM Conference on Object Oriented Programming Systems, Languages and Applicatioons (OOPSLA'04).
256. Sheard, T. and Pasalic, E. (2004). Meta-programming with built-in type equality. In Proceedings of the Fourth International Workshop on Logical Frameworks and Meta-languages (LFM'04), Cork.
257. Sheard, T. and Peyton Jones, S. (2002). Template metaprogramming for Haskell. In Chakravarty, M., editor, Proceedings of the 2002 Haskell Workshop, Pittsburgh.
258. Sheeran, M. (1983). μFP --- An Algebraic VLSI Design Language. PhD thesis, Programming Research Group, Oxford University.
259. Sheeran, M. (1984). μFP, a language for VLSI design. In Symp. on LISP and Functional Programming. ACM.
260. Sheeran, M. (2005). Hardware design and functional programming: a perfect match. Journal of Universal Computer Science, 11(7):1135--1158. http://www.jucs.org/jucs_11_7/hardware_design_and_functional.
261. Shields, M. and Peyton Jones, S. (2001). Object-oriented style overloading for Haskell. In Workshop on Multi-Language Infrastructure and Interoperability (BABEL'01), Florence, Italy.
262. Shields, M. and Peyton Jones, S. (2002). Lexically scoped type variables. Microsoft Research.
263. Sinclair, D. (1992). Graphical user intefaces for Haskell. In (Launchbury and Sansom, 1992), pages 252--257.
264. Singh, S. and Slous, R. (1998). Accelerating Adobe Photoshop with reconfigurable logic. In IEEE Symposium on Field-Programmable Custom Computing Machines. IEEE Computer Society Press.
265. Somogyi, Z., Henderson, F., and Conway, T. (1996). The execution algorithm of Mercury, an efficient purely declarative logic programming language. Journal of Logic Programming.
266. Sparud, J. and Runciman, C. (1997). Tracing lazy functional computations using redex trails. In International Symposium on Programming Languages Implementations, Logics, and Programs (PLILP'97), volume 1292 of Lecture Notes in Computer Science, pages 291--308. Springer Verlag.
267. Spivey, M. and Seres, S. (2003). Combinators for logic programming. In Gibbons, J. and de Moor, O., editors, The Fun of Programming, pages 177--200. Palgrave.
268. Steele, G. (1993). Building interpreters by composing monads. In 21st ACM Symposium on Principles of Programming Languages (POPL'94), pages 472--492, Charleston. ACM.
269. Steele, Jr., G. L. (1978). Rabbit: A compiler for Scheme. Technical Report AI-TR-474, Artificial Intelligence Laboratory, MIT, Cambridge, MA.
270. Stosberg, M. (2005). Interview with David Roundy of Darcs on source control. OSDir News.
271. Stoye, W., Clarke, T., and Norman, A. (1984). Some practical methods for rapid combinator reduction. In (LFP84, 1984), pages 159--166.
272. Strachey, C. (1964). Towards a formal semantics. In Formal Language Description Languages for Computer Programming, pages 198--220. North Holland. IFIP Working Conference.
273. Sulzmann, M. (2003). A Haskell programmer's guide to Chameleon. Available at http://www.comp.nus.edu.sg/~sulzmann/chameleon/download/haskell.html.
274. Sulzmann, M. (2006). Extracting programs from type class proofs. In International Symposium on Principles and Practice of Declarative Programming (PPDP'06), pages 97--108, Venice. ACM.
275. Sulzmann, M., Duck, G., Peyton Jones, S., and Stuckey, P. (2007). Understanding functional dependencies via constraint handling rules. Journal of Functional Programming, 17:83--130.
276. Sussman, G. and Steele, G. (1975). Scheme --- an interpreter for extended lambda calculus. AI Memo 349, MIT.
277. Swierstra, S. and Duponcheel, L. (1996). Deterministic, Error-Correcting Combinator Parsers, pages 184--207. Number 1129 in Lecture Notes in Computer Science. Springer Verlag, Olympia, Washington.
278. Syme, D. (2005). Initialising mutually-referential abstract objects: the value recursion challenge. In Benton, N. and Leroy, X., editors, Proc ACM Workshop on ML (ML'2005), pages 5--26, Tallinn, Estonia.
279. Taha, W. and Sheard, T. (1997). Multi-stage programming with explicit annotations. In ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM '97), volume 32 of SIGPLAN Notices, pages 203--217. ACM, Amsterdam.
280. Tang, A. (2005). Pugs home page, http://www.pugscode.org.
281. Tarditi, D., Morrisett, G., Cheng, P., Stone, C., Harper, R., and Lee, P. (1996). TIL: A type-directed optimizing compiler for ML. In ACM Conference on Programming Languages Design and Implementation (PLDI'96), pages 181--192. ACM, Philadelphia.
282. Thiemann, P. (2002a). A typed representation for HTML and XML documents in Haskell. Journal of Functional Programming, 12(5):435--468.
283. Thiemann, P. (2002b). Wash/cgi: Server-side web scripting with sessions and typed, compositional forms. In Practical Applications of Declarative Languages, pages 192--208. Springer Verlag LNCS 2257.
284. Turner, D. A. (1976). The SASL language manual. Technical report, University of St Andrews.
285. Turner, D. A. (1979a). Another algorithm for bracket abstraction. Journal of Symbolic Logic, 44(2):267--270.
286. Turner, D. A. (1979b). A new implementation technique for applicative languages. Software Practice and Experience, 9:31--49.
287. Turner, D. A. (1981). The semantic elegance of applicative languages. In Proceedings of the 1981 Conference on Functional Programming Languages and Computer Architecture, pages 85--92. ACM.
288. Turner, D. A. (1982). Recursion equations as a programming language. In Darlington, J., Henderson, P., and Turner, D., editors, Functional Programming and its Applications. CUP.
289. Turner, D. A. (1985). Miranda: A non-strict functional language with polymorphic types. In (Jouannaud, 1985), pages 1--16. This and other materials on Miranda are available at http://miranda.org.uk.
290. Turner, D. A. (1986). An overview of Miranda. SIGPLAN Notices, 21(12):158--166.
291. van Heijenoort, J. (1967). From Frege to Godel, A Sourcebook in Mathematical Logic. Harvard University Press.
292. van Rossum, G. (1995). Python reference manual. Technical Report Report CS-R9525, CWI, Amsterdam.
293. Vuillemin, J. (1974). Correct and optimal placement of recursion in a simple programming language. Journal of Computer and System Sciences, 9.
294. Wadler, P. (1985). How to replace failure by a list of successes. In (Jouannaud, 1985), pages 113--128.
295. Wadler, P. (1987). Views: a way for pattern matching to cohabit with data abstraction. In 14th ACM Symposium on Principles of Programming Languages, Munich.
296. Wadler, P. (1989). Theorems for free! In MacQueen, editor, Fourth International Conference on Functional Programming and Computer Architecture, London. Addison Wesley.
297. Wadler, P. (1990a). Comprehending monads. In Proc ACM Conference on Lisp and Functional Programming, Nice. ACM.
298. Wadler, P. (1990b). Deforestation: transforming programs to eliminate trees. Theoretical Computer Science, 73:231--248.
299. Wadler, P. (1992a). Comprehending monads. Mathematical Structures in Computer Science, 2:461--493.
300. Wadler, P. (1992b). The essence of functional programming. In 20th ACM Symposium on Principles of Programming Languages (POPL'92), pages 1--14. ACM, Albuquerque.
301. Wadler, P. (2003). A prettier printer. In Gibbons, J. and de Moor, O., editors, The Fun of Programming. Palgrave.
302. Wadler, P. and Blott, S. (1989). How to make ad-hoc polymorphism less ad hoc. In Proc 16th ACM Symposium on Principles of Programming Languages, Austin, Texas. ACM.
303. Wadler, P., Taha, W. and MacQueen, D. (1988). How to add laziness to a strict language, without even being odd. In Workshop on Standard ML, Baltimore.
304. Wadsworth, C. (1971). Semantics and Pragmatics of the Lambda Calculus. PhD thesis, Oxford University.
305. Wallace, M. (1998). The nhc98 web pages. Available at http://www.cs.york.ac.uk/fp/nhc98.
306. Wallace, M., Chitil, Brehm, T., and Runciman, C. (2001). Multiple-view tracing for Haskell: a new Hat. In (Haskell01, 2001).
307. Wallace, M. and Runciman, C. (1998). The bits between the lambdas: binary data in a lazy functional language. In International Symposium on Memory Management.
308. Wallace, M. and Runciman, C. (1999). Haskell and XML: Generic combinators or type-based translation. In (ICFP99, 1999), pages 148--159.
309. Wan, Z. (December 2002). Functional Reactive Programming for Real-Time Embedded Systems. PhD thesis, Department of Computer Science, Yale University.
310. Wan, Z. and Hudak, P. (2000). Functional reactive programming from first principles. In Proceedings of the ACM SIGPLAN '00 Conference on Programming Language Design and Implementation (PLDI), pages 242--252, Vancouver, BC, Canada. ACM.
311. Wan, Z., Taha, W., and Hudak, P. (2001). Real-time FRP. In Proceedings of Sixth ACM SIGPLAN International Conference on Functional Programming, Florence, Italy. ACM.
312. Wan, Z., Taha, W., and Hudak, P. (2002). Event-driven FRP. In Proceedings of Fourth International Symposium on Practical Aspects of Declarative Languages. ACM.
313. Watson, I. and Gurd, J. (1982). A practical data flow computer. IEEE Computer, pages 51--57.
314. Wile, D. (1973). A Generative, Nested-Sequential Basis for General Purpose Programming Languages. PhD thesis, Dept. of Computer Science, Carnegie-Mellon University. First use of *sections*, on page 30.
315. Xi, H., Chen, C., and Chen, G. (2003). Guarded recursive datatype constructors. In Proceedings of the 30th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 224--235. ACM Press.
316. Young, J. (1988). The Semantic Analysis of Functional Programs: Theory and Practice. PhD thesis, Yale University, Department of Computer Science.

Index Terms

• Social and professional topics

  • Professional topics

    • History of computing

      • History of software

• Software and its engineering

  • Software notations and tools

    • Formal language definitions

    • General programming languages

      • Language features

      • Language types

• Theory of computation

  • Formal languages and automata theory