Article

A history of Haskell: being lazy with class

Authors:

Simon Peyton Jones,

Philip WadlerAuthors Info & Claims

HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages

Pages 12-1 - 12-55

https://doi.org/10.1145/1238844.1238856

Published: 09 June 2007 Publication History

Abstract

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

Supplementary Material

JPG File (m12-peyton_jones-h.jpg)

Download
24.30 KB

slides.pdf (haskell.pdf)

A history of Haskell slides

Download
2.45 MB

MOV File (m12-peyton_jones-h.mov)

Download
247.98 MB

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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[9]

Augustsson, L. (1984). A compiler for lazy ML. In (LFP84, 1984), pages 218--227.

Digital Library

[10]

Augustsson, L. (1998). Cayenne --- a language with dependent types. In (ICFP98, 1998), pages 239--250.

Digital Library

[11]

Baars, A., Lh, A., and Swierstra, D. (2004). Parsing pemutation phrases. Journal of Functional Programming, 14:635--646.

Digital Library

[12]

Baars, A. L. and Swierstra, S. D. (2002). Typing dynamic typing. In (ICFP02, 2002), pages 157--166.

Digital Library

[13]

Backus, J. (1978a). Can programming be liberated from the von Neumann style? Communications of the ACM, 21(8).

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[20]

Bird, R. and Wadler, P. (1988). Introduction to Functional Programming. Prentice Hall.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[42]

Chakravarty, M., editor (2002). Proceedings of the 2002 Haskell Workshop, Pittsburgh.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[49]

Claessen, K. (2004). Parallel parsing processes. Journal of Functional Programming, 14:741--757.

Digital Library

[50]

Claessen, K. and Hughes, J. (2000). QuickCheck: a lightweight tool for random testing of Haskell programs. In (ICFP00, 2000), pages 268--279.

Digital Library

[51]

Claessen, K. and Hughes, J. (2002). Testing monadic code with QuickCheck. In (Chakravarty, 2002).

Digital Library

[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.

Digital Library

[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.

Digital Library

[54]

Courtney, A. (2004). Modelling User Interfaces in a Functional Language. PhD thesis, Department of Computer Science, Yale University.

Digital Library

[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.

Digital Library

[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.

Digital Library

[59]

Darlington, J., Henderson, P., and Turner, D. (1982). Advanced Course on Functional Programming and its Applications. Cambridge University Press.

Digital Library

[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.

Digital Library

[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.

Digital Library

[63]

Diatchki, I., Jones, M., and Hallgren, T. (2002). A formal specification of the Haskell 98 module system. In (Chakravarty, 2002).

Digital Library

[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.

Digital Library

[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.

Digital Library

[69]

Elliott, C. and Hudak, P. (1997). Functional reactive animation. In International Conference on Functional Programming, pages 263--273.

Digital Library

[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.

Digital Library

[71]

Ennals, R. and Peyton Jones, S. (2003). Optimistic evaluation: an adaptive evaluation strategy for non-strict programs. In (ICFP03, 2003).

Digital Library

[72]

Evans, A. (1968). Pal---a language designed for teaching programming linguistics. In Proceedings ACM National Conference.

Digital Library

[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).

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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).

Digital Library

[99]

Harrison, W. and Kamin, S. (1998). Modular compilers based on monad transformers. In Proc International Conference on Computer Languages, pages 122--131.

Digital Library

[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.

Digital Library

[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.

Digital Library

[105]

Henderson, P. (1982). Functional geometry. In Proc ACM Symposium on Lisp and Functional Programming, pages 179--187. ACM.

Digital Library

[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.

Digital Library

[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.

Digital Library

[109]

Hinze, R. (2001). Manufacturing datatypes. Journal of Functional Programming, 1.

Digital Library

[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.

Digital Library

[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.

Digital Library

[117]

Hudak, P. (1996a). Building domain-specific embedded languages. ACM Computing Surveys, 28A.

Digital Library

[118]

Hudak, P. (1996b). Haskore music tutorial. In Second International School on Advanced Functional Programming, pages 38--68. Springer Verlag, LNCS 1129.

Digital Library

[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.

Digital Library

[120]

Hudak, P. (2000). The Haskell School of Expression - Learning Functional Programming Through Multimedia. Cambridge University Press, New York.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[131]

Hughes, J. (2000). Generalising monads to arrows. Science of Computer Programming, 37:67--111.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[143]

Johnson, S. (1984). Synthesis of Digital Designs from Recursive Equations. ACM Distinguished Dissertation. MIT Press.

Digital Library

[144]

Johnsson, T. (1984). Efficient compilation of lazy evaluation. In Proc SIGPLAN Symposium on Compiler Construction, Montreal. ACM.

Digital Library

[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.

Digital Library

[147]

Jones, M. (1993). A system of constructor classes: overloading and implicit higher-order polymorphism. In (FPCA93, 1993).

Digital Library

[148]

Jones, M. (1994). Qualified Types: Theory and Practice. Cambridge University Press.

Digital Library

[149]

Jones, M. (1995). Simplifying and improving qualified types. In (FPCA95, 1995).

Digital Library

[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.

Digital Library

[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.

Digital Library

[154]

Kaes, S. (1988). Parametric overloading in polymorphic programming languages. In Proceedings of the 2nd European Symposium on Programming.

Digital Library

[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.

Digital Library

[157]

Kiselyov, O., Lmmel, R., and Schupke, K. (2004). Strongly typed heterogeneous collections. In (Haskell04, 2004), pages 96--107.

Digital Library

[158]

Kiselyov, O. and Shan, K. (2004). Implicit configurations; or, type classes reflect the values of types. In (Haskell04, 2004), pages 33--44.

Digital Library

[159]

Knuth, D. (1984). Literate programming. Computer Journal, 27(2):97--111.

Digital Library

[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.

Digital Library

[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).

Digital Library

[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.

Digital Library

[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.

Digital Library

[164]

Landin, P. (1966). The next 700 programming languages. Communications of the ACM, 9(3):157--166.

Digital Library

[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.

Digital Library

[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.

Digital Library

[170]

Launchbury, J. and Sabry, A. (1997). Monadic state: Axiomatization and type safety. In (ICFP97, 1997), pages 227--238.

Digital Library

[171]

Launchbury, J. and Sansom, P., editors (1992). Functional Programming, Glasgow 1992, Workshops in Computing. Springer Verlag.

Digital Library

[172]

Leijen, D. and Meijer, E. (1999). Domain-specific embedded compilers. In Proc 2nd Conference on Domain-Specific Languages (DSL'99), pages 109--122.

Digital Library

[173]

Lewis, J., Shields, M., Meijer, E., and Launchbury, J. (2000). Implicit parameters: dynamic scoping with static types. In (POPL00, 2000).

Digital Library

[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.

Digital Library

[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.

Digital Library

[177]

Lindig, C. (2005). Random testing of C calling conventions. In AADEBUG, pages 3--12.

Digital Library

[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.

Digital Library

[180]

Long, D. and Garigliano, R. (1993). Reasoning by Analogy and Causality (A Model and Application). Ellis Horwood.

Digital Library

[181]

Lüth, C. and Ghani, N. (2002). Composing monads using coproducts. In (ICFP02, 2002), pages 133--144.

Digital Library

[182]

Maessen, J.-W. (2002). Eager Haskell: Resource-bounded execution yields efficient iteration. In The Haskell Workshop, Pittsburgh.

Digital Library

[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.

Digital Library

[185]

Matthews, J., Cook, B., and Launchbury, J. (1998). Microprocessor specification in Hawk. In International Conference on Computer Languages, pages 90--101.

Digital Library

[186]

McBride, C. (2002). Faking it: Simulating dependent types in Haskell. Journal of Functional Programming, 12(4&5):375--392.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[193]

Milner, R. and Tofte, M. (1990). The Definition of Standard ML. MIT Press.

Digital Library

[194]

Milner, R., Tofte, M., Harper, R., and MacQueen, D. (1997). The Definition of Standard ML (Revised). MIT Press, Cambridge, Massachusetts.

Digital Library

[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.

Digital Library

[196]

Moggi, E. (1989). Computational lambda calculus and monads. In Logic in Computer Science, California. IEEE.

Digital Library

[197]

Moggi, E. (1991). Notions of computation and monads. Information and Computation, 93:55--92.

Digital Library

[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.

Digital Library

[200]

Nikhil, R. S. and Arvind (2001). Implicit Parallel Programming in pH. Morgan Kaufman.

Digital Library

[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.

Digital Library

[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.

Digital Library

[207]

Ohori, A. (1995). A polymorphic record calculus and its compilation. ACM Transactions on Programming Languages and Systems, 17:844--895.

Digital Library

[208]

Okasaki, C. (1998a). Purely functional data structures. Cambridge University Press.

Digital Library

[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.

Digital Library

[211]

Page, R. (2003). Software is discrete mathematics. In (ICFP03, 2003), pages 79--86.

Digital Library

[212]

Page, R. and Moe, B. (1993). Experience with a large scientific application in a functional language. In (FPCA93, 1993).

Digital Library

[213]

Paterson, R. (2001). A new notation for arrows. In International Conference on Functional Programming, pages 229--240. ACM Press.

Digital Library

[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.

Digital Library

[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.

Digital Library

[220]

Peyton Jones, S. (1987). The Implementation of Functional Programming Languages. Prentice Hall.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[236]

Queinnec, C. (2000). The influence of browsers on evaluators or, continuations to program web servers. In International Conference on Functional Programming.

Digital Library

[237]

Ranta, A. (2004). Grammatical framework. Journal of Functional Programming, 14(2):145--189.

Digital Library

[238]

Rees, J. and Clinger, W. (1986). Revised report on the algorithmic language scheme. ACM SIGPLAN Notices, 21:37--79.

Digital Library

[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).

Digital Library

[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.

Digital Library

[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.

Digital Library

[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).

Digital Library

[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.

Digital Library

[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.

Digital Library

[251]

Scholz, E. (1998). Imperative streams - a monadic combinator library for synchronous programming. In (ICFP98, 1998).

Digital Library

[252]

Scott, D. (1976). Data types as lattices. SIAM Journal on Computing, 5(3):522--587.

Digital Library

[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).

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[269]

Steele, Jr., G. L. (1978). Rabbit: A compiler for Scheme. Technical Report AI-TR-474, Artificial Intelligence Laboratory, MIT, Cambridge, MA.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[276]

Sussman, G. and Steele, G. (1975). Scheme --- an interpreter for extended lambda calculus. AI Memo 349, MIT.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[282]

Thiemann, P. (2002a). A typed representation for HTML and XML documents in Haskell. Journal of Functional Programming, 12(5):435--468.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[290]

Turner, D. A. (1986). An overview of Miranda. SIGPLAN Notices, 21(12):158--166.

Digital Library

[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.

Digital Library

[293]

Vuillemin, J. (1974). Correct and optimal placement of recursion in a simple programming language. Journal of Computer and System Sciences, 9.

Digital Library

[294]

Wadler, P. (1985). How to replace failure by a list of successes. In (Jouannaud, 1985), pages 113--128.

Digital Library

[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.

Digital Library

[296]

Wadler, P. (1989). Theorems for free! In MacQueen, editor, Fourth International Conference on Functional Programming and Computer Architecture, London. Addison Wesley.

Digital Library

[297]

Wadler, P. (1990a). Comprehending monads. In Proc ACM Conference on Lisp and Functional Programming, Nice. ACM.

Digital Library

[298]

Wadler, P. (1990b). Deforestation: transforming programs to eliminate trees. Theoretical Computer Science, 73:231--248.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[308]

Wallace, M. and Runciman, C. (1999). Haskell and XML: Generic combinators or type-based translation. In (ICFP99, 1999), pages 148--159.

Digital Library

[309]

Wan, Z. (December 2002). Functional Reactive Programming for Real-Time Embedded Systems. PhD thesis, Department of Computer Science, Yale University.

Digital Library

[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.

Digital Library

[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.

Digital Library

[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.

Digital Library

[313]

Watson, I. and Gurd, J. (1982). A practical data flow computer. IEEE Computer, pages 51--57.

Digital Library

[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.

Digital Library

[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.

Digital Library

[316]

Young, J. (1988). The Semantic Analysis of Functional Programs: Theory and Practice. PhD thesis, Yale University, Department of Computer Science.

Cited By

Lund SVilladsen J(2024)On Verified Automated Reasoning in Propositional Logic: Teaching Sequent Calculus to Computer Science StudentsVietnam Journal of Computer Science10.1142/S2196888824500064(1-24)Online publication date: 2-May-2024
https://doi.org/10.1142/S2196888824500064
Spaits GUmann KPorkoláb Z(2024)A survey of tagged union type usage in modern C++ projects2024 7th International Conference on Software and System Engineering (ICoSSE)10.1109/ICoSSE62619.2024.00013(31-36)Online publication date: 19-Apr-2024
https://doi.org/10.1109/ICoSSE62619.2024.00013
Campos Ferreira Guimarães BQuintão Pereira FVerbrugge CLhoták OShen X(2023)Lazy Evaluation for the Lazy: Automatically Transforming Call-by-Value into Call-by-NeedProceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction10.1145/3578360.3580270(239-249)Online publication date: 17-Feb-2023
https://dl.acm.org/doi/10.1145/3578360.3580270
Show More Cited By

Index Terms

A history of Haskell: being lazy with class

Recommendations

A History of Milan Under the Sforza
A History of Milan Under the Sforza
Displaying cultural history: the Smithsonian institution and the world's fairs
Meet me at the Fair

Of all displays exhibited at World's Fairs, some of the most iconic centered on habitat or environmental displays that presented groups of figures--live or fake--performing tasks or reenacting historical tableaux. This essay explores the Smithsonian ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Conferences

HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages

June 2007

483 pages

ISBN:9781595937667

DOI:10.1145/1238844

Conference Chairs:
Barbara Ryder
Rutgers University
,
Brent Hailpern
IBM Research

Copyright © 2007 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 09 June 2007

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Qualifiers

Article

Conference

HOPL-III '07

Sponsor:

SIGPLAN

HOPL-III '07: ACM SIGPLAN History of Programming Languages Conference III

June 9 - 10, 2007

California, San Diego

Acceptance Rates

HOPL III Paper Acceptance Rate 12 of 12 submissions, 100%;

Overall Acceptance Rate 12 of 12 submissions, 100%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

116
Total Citations
View Citations
8,608
Total Downloads

Downloads (Last 12 months)204
Downloads (Last 6 weeks)29

Reflects downloads up to 22 Sep 2024

Other Metrics

View Author Metrics

Citations

Cited By

Lund SVilladsen J(2024)On Verified Automated Reasoning in Propositional Logic: Teaching Sequent Calculus to Computer Science StudentsVietnam Journal of Computer Science10.1142/S2196888824500064(1-24)Online publication date: 2-May-2024
https://doi.org/10.1142/S2196888824500064
Spaits GUmann KPorkoláb Z(2024)A survey of tagged union type usage in modern C++ projects2024 7th International Conference on Software and System Engineering (ICoSSE)10.1109/ICoSSE62619.2024.00013(31-36)Online publication date: 19-Apr-2024
https://doi.org/10.1109/ICoSSE62619.2024.00013
Campos Ferreira Guimarães BQuintão Pereira FVerbrugge CLhoták OShen X(2023)Lazy Evaluation for the Lazy: Automatically Transforming Call-by-Value into Call-by-NeedProceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction10.1145/3578360.3580270(239-249)Online publication date: 17-Feb-2023
https://dl.acm.org/doi/10.1145/3578360.3580270
Fu SDwyer TStuckey PWain JLinossier J(2023)ChameleonIDE: Untangling Type Errors Through Interactive Visualization and Exploration2023 IEEE/ACM 31st International Conference on Program Comprehension (ICPC)10.1109/ICPC58990.2023.00029(146-156)Online publication date: May-2023
https://doi.org/10.1109/ICPC58990.2023.00029
Chen ZPotanin A(2022)Towards a Verified Cost Model for Call-by-Push-ValueCompanion Proceedings of the 2022 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity10.1145/3563768.3565552(47-49)Online publication date: 29-Nov-2022
https://dl.acm.org/doi/10.1145/3563768.3565552
Pit-Claudel CPhilipoom JJamner DErbsen AChlipala AJhala RDillig I(2022)Relational compilation for performance-critical applications: extensible proof-producing translation of functional models into low-level codeProceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation10.1145/3519939.3523706(918-933)Online publication date: 9-Jun-2022
https://dl.acm.org/doi/10.1145/3519939.3523706
Jobczyk K(2022)The Fuzzy Natural Transformations, the Algebra P(ω)/fin and Generalized Encoding TheoryIEEE Access10.1109/ACCESS.2022.314716510(15135-15150)Online publication date: 2022
https://doi.org/10.1109/ACCESS.2022.3147165
Egi SKawata AKori MOgawa H(2022)Embedding Non-linear Pattern Matching with Backtracking for Non-free Data Types into HaskellNew Generation Computing10.1007/s00354-022-00177-z40:2(481-506)Online publication date: 1-Jul-2022
https://dl.acm.org/doi/10.1007/s00354-022-00177-z
Hirn DGrust TLi GLi ZIdreos SSrivastava D(2021)One WITH RECURSIVE is Worth Many GOTOsProceedings of the 2021 International Conference on Management of Data10.1145/3448016.3457272(723-735)Online publication date: 9-Jun-2021
https://dl.acm.org/doi/10.1145/3448016.3457272
Vanderbauwhede W(2021)Making legacy Fortran code type safe through automated program transformationThe Journal of Supercomputing10.1007/s11227-021-03839-9Online publication date: 14-Jul-2021
https://doi.org/10.1007/s11227-021-03839-9
Show More Cited By

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents