Books
Contents
 1 Language Definition
 2 Textbooks
 3 Papers available on the Web
 3.1 General Introductions to Haskell
 3.2 References
 3.3 Motivation for Using Haskell
 3.4 Analysis and Design Methods
 3.5 Teaching Haskell
 3.6 Proving Program Correctness
 3.7 Debugging Programs
 3.8 Using Monads
 3.9 Separation of Concerns
 3.10 Categorical Programming
 3.11 Side Effects in a Pure Language
 3.12 Data Structures
 3.13 Arrays
 3.14 Graphs
 3.15 Others
 3.16 Parser Combinators
 3.17 Schools on Advanced Funtional Programming
 4 Foundations
Language Definition
 Simon Peyton Jones: Haskell 98 Language and Libraries, Cambridge University Press, 2003, Hardback, 272 pages, ISBN: 0521826144, £35.00
Book Description
Haskell is the world's leading lazy functional programming language, widely used for teaching, research, and applications. The language continues to develop rapidly, but in 1998 the community decided to capture a stable snapshot of the language: Haskell 98. All Haskell compilers support Haskell 98, so practitioners and educators alike have a stable base for their work. This book constitutes the agreed definition of the Haskell 98, both the language itself and its supporting libraries. It has been considerably revised and refined since the original definition, and appears in print for the first time. It should be a standard reference work for anyone involved in research, teaching, or application of Haskell.
Textbooks
 Paul Hudak: The Haskell School of Expression: Learning Functional Programming through Multimedia, Cambridge University Press, New York, 2000, 416
pp, 15 line diagrams, 75 exercises, Paperback $29.95, ISBN:
0521644089, Hardback $74.95, ISBN: 0521643384
Book Description
This book teaches functional programming as a way of thinking and problem solving, using Haskell, the most popular purely functional language. Rather than using the conventional mathematical examples commonly found in other programming language textbooks, the author draws examples from multimedia applications, including graphics, animation, and computer music, thus rewarding the reader with working programs for inherently more interesting applications. Aimed at both beginning and advanced programmers, this tutorial begins with a gentle introduction to functional programming and moves rapidly on to more advanced topics. An underlying theme is the design and implementation of domain specific languages, using three examples: FAL (a Functional Animation Language), IRL (an Imperative Robot Language), and MDL (a Music Description Language). Details about programming in Haskell are presented in boxes throughout the text so they can be easily referred to and found quickly.The book's Web Site contains source files for all programs in the text, as well as the graphics libraries to run them under Windows and Linux platforms. It also contains PowerPoint slides useful for teaching a course using the textbook.
 Simon Thompson: Haskell: The Craft of Functional Programming, Second Edition,
AddisonWesley, 507 pages, paperback, 1999. ISBN
0201342758.
Book Description
The second edition of Haskell: The Craft of Functional Programming is essential reading for beginners to functional programming and newcomers to the Haskell programming language. The emphasis is on the process of crafting programs and the text contains many examples and running case studies, as well as advice an program design, testing, problem solving and how to avoid common pitfalls.Building on the strengths of the first edition, the book includes many new and improved features:
 Complete coverage of Haskell 98, the standard version of Haskell which will be stable and supported by implementations for years to come.
 An emphasis on software engineering principles, encouraging a disciplined approach to building reusable libraries of software components.
 Detailed coverage of the Hugs interpreter with an appendix covering other implementations.
 A running case study of pictures emphasizes the builtin functions which appear in the standard prelude and libraries. It is also used to give an early preview of some of the more complex language features, such as highorder functions.
 List comprehensions and the standard functions over lists are covered before recursion.
 Early coverage of polymorphism supporting the "toolkit" approach and encouraging the resuse of builtin functions and types.
 Extensive reference material containing details of further reading in books, journals and on the World Wide Web.
 Accompanying Web Site supporting the book, containing all the program code, further teaching materials and other useful resources.
Synopsis
This books introduces Haskell at a level appropriate for those with little or no prior experience of functional programming. The emphasis is on the process of crafting programs, solving problems, and avoiding common errors.  Richard Bird: Introduction to Functional Programming using Haskell, 2nd edition, Prentice Hall Press, 1998, 460 pp., ISBN: 0134843460.
From the cover:
After the success of the first edition, Introduction to Functional Programming using Haskell has been thoroughly updated and revised to provide a complete grounding in the principles and techniques of programming with functions.
The second edition uses the popular language Haskell to express functional programs. There are new chapters on program optimisation, abstract datatypes in a functional setting, and programming in a monadic style. There are completely new case studies, and many new exercises.
As in the first edition, there is an emphasis on the fundamental techniques for reasoning about functional programs, and for deriving them systematically from their specifications.
The book is selfcontained, assuming no prior knowledge of programming, and is suitable as an introductory undergraduate text for first or secondyear students.
 Antony Davie: An Introduction to Functional Programming Systems Using Haskell, Cambridge University Press, 1992. ISBN 0521258308 (hardback). ISBN 0521277248 (paperback).
Cover:
Functional programming is a style of programming that has become increasingly popular during the past few years. Applicative programs have the advantage of being almost immediately expressible as functional descriptions; they can be proved correct and transformed through the referential transparency property.
This book presents the basic concepts of functional programming, using the language Haskell for examples. The author incorporates a discussion of lambda calculus and its relationship with Haskell, exploring the implications for parallelism. Contents: SASL for Beginners / Examples of SASL Programming / More Advanced Applicative Programming Techniques / Lambda Calculus / The Relationship Between Lambda Calculus and SASL / Program Transformation and Efficiency / Correctness, Equivalence and Program Verification / Landin's SECD Machine and Related Implementations / Further Implementation Techniques / Special Purpose Hardware / The Applicative Style of Semantics / Other Applicative Languages / Implications for Parallelism / Functional Programming in Von Neumann Languages
 Fethi Rabhi and Guy Lapalme: Algorithms: A functional programming approach,
AddisonWesley, 235 pages, paperback, 1999. ISBN
0201596040
Book Description
The authors challenge more traditional methods of teaching algorithms by using a functional programming context, with Haskell as an implementation language. This leads to smaller, clearer and more elegant programs which enable the programmer to understand the algorithm more quickly and to use that understanding to explore alternative solutions.
Key features: Most chapters are selfcontained and can be taught independently from each other.
 All programs are in Haskell'98 and provided on a WWW site.
 End of chapter exercises throughout.
 Comprehensive index and bibliographical notes.
Synopsis
The book is organised as a classic algorithms book according to topics such as Abstract Data Types, sorting and searching. It uses a succession of practical programming examples to develop in the reader problemsolving skills which can be easily transferred to other language paradigms. It also introduces the idea of capturing algorithmic design strategies (e.g. DivideandConquer, Dynamic Programming) through higherorder functions.
Target audience
The book is intended for computer science students taking algorithms and/or (basic or advanced) functional programming courses.  Jeremy Gibbons and Oege de Moor (eds.): The Fun of Programming,Palgrave, 2002, 288 pages. ISBN 0333992857.
Book description:
In this textbook, leading researchers give tutorial expositions on the current state of the art of functional programming. The text is suitable for an undergraduate course immediately following an introduction to functional programming, and also for selfstudy. All new concepts are illustrated by plentiful examples, as well as exercises. A website gives access to accompanying software.  Cordelia Hall and John O'Donnell: Discrete Mathematics Using a Computer,
Springer, 2000, 360 pages. ISBN 1852330899.
Book description:
This book introduces the main topics of discrete mathematics with a strong emphasis on applications to computer science. It uses computer programs to implement and illustrate the mathematical ideas, helping the reader to gain a concrete understanding of the abstract mathematics. The programs are also useful for practical calculations, and they can serve as a foundation for larger software packages.Designed for first and second year undergraduate students, the book is also ideally suited to selfstudy. No prior knowledge of functional programming is required; the book and the online documentation provide everything you will need.
 Kees Doets and Jan van Eijck: The Haskell Road to Logic, Maths and Programming. King's College Publications, London, 2004. ISBN 0954300696 (14.00 pounds, $25.00).
Book description:
The purpose of this book is to teach logic and mathematical reasoning in practice, and to connect logical reasoning with computer programming. Throughout the text, abstract concepts are linked to concrete representations in Haskell. Everything one has to know about programming in Haskell to understand the examples in the book is explained as we go along, but we do not cover every aspect of the language. Haskell is a marvelous demonstration tool for logic and maths because its functional character allows implementations to remain very close to the concepts that get implemented, while the laziness permits smooth handling of infinite data structures.We do not assume that our readers have previous experience with either programming or construction of formal proofs. We do assume previous acquaintance with mathematical notation, at the level of secondary school mathematics. Wherever necessary, we will recall relevant facts. Everything one needs to know about mathematical reasoning or programming is explained as we go along. We do assume that our readers are able to retrieve software from the Internet and install it, and that they know how to use an editor for constructing program texts.
After having worked through the material in the book, i.e., after having digested the text and having carried out a substantial number of the exercises, the reader will be able to write interesting programs, reason about their correctness, and document them in a clear fashion. The reader will also have learned how to set up mathematical proofs in a structured way, and how to read and digest mathematical proofs written by others.
The book can be used as a course textbook, but since it comes with solutions to all exercises (electronically available from the authors upon request) it is also well suited for private study. The source code of all programs discussed in the text, a list of errata, further relevant material and an email link to the authors can be found here.
 Simon Peyton Jones: Implementation of Functional Programming Language,PrenticeHall, 1987. ISBN 0134533259.
 Simon Peyton Jones, David Lester: Implementing Functional Languages, 1992.
The book is out of print. The full sources and a postscript version are available for free.
Papers available on the Web
General Introductions to Haskell
 [http://www.haskell.org/tutorial/ A
Gentle Introduction to Haskell] by Paul Hudak, John Peterson, and Joseph H. Fasel.
The title is a bit misleading. Some knowledge of another functional programming language is expected. The emphasis is on the type system and those features which are really new in Haskell (compared to other functional programming languages).  Beginning Haskell from IBM developerWorks
This tutorial targets programmers of imperative languages wanting to learn about functional programming in the language Haskell. If you have programmed in languages such as C, Pascal, Fortran, C++, Java, Cobol, Ada, Perl, TCL, REXX, JavaScript, Visual Basic, or many others, you have been using an imperative paradigm. This tutorial provides a gentle introduction to the paradigm of functional programming, with specific illustrations in the Haskell 98 language. (Free registration required.)  Yet Another Haskell Tutorial by Hal Daume III et al. (Postscript, Pdf)
A tutorial for Haskell that is still under construction but covers already much ground.  Haskell Companion by Jan Skibinski
A tutorial on most common concepts and definitions of functional language Haskell.  Online Haskell Course by Ralf Hinze (in German).
 Functional Programming
by Jeroen Fokker, 1995.(153 pages, 600 KB)
Textbook for learning functional programming with Gofer. Here without Chapters 6 and 7. Other Tutorial Papers in Functional Programming.  Two Dozen Short Lessons in Haskell by Rex Page. A draft of a textbook on functional programming, available by ftp. It calls for active participation from readers by omitting material at certain points and asking the reader to attempt to fill in the missing information based on knowledge they have already acquired. The missing information is then supplied on the reverse side of the page.
 [haskeller.dvi The Little Haskeller] by Cordelia Hall and John Hughes, 9. November 1993, 26 pages.
An introduction using the Chalmers Haskell B interpreter (hbi). Attention: it relies very much on the user interface of hbi which is quite different for other Haskell systems.  Haskell Tutorial by José Barros and João Almeida. From a course given at the 3rd International Summer School on Advanced Functional Programming.
 Haskell for Miranda Programmers by Kevin Glynn and Bernie Pope.
 PLEACHaskell
Following the Perl Cookbook (by Tom Christiansen and Nathan Torkington, published by O'Reilly) spirit, the PLEAC Project aims to gather fans of programming, in order to implement the solutions in other programming languages.  HaskellTutorial by Damir Medak and Gerhard Navratil
The fundamentals of functional languages for beginners.  A Guide to Haskell's Foreign Function Interface A guide to using the foreign function interface extension, using the rich set of functions in the Foreign libraries, design issues, and FFI preprocessors.
 Programming Haskell Wikibook is a communal effort by several authors to produce the definitive Haskell textbook. Its very much a work in progress at the moment, and contributions are welcome.
 Video Lectures (in English) by Jürgen Giesl. About 30 hours in total, and great for learning Haskell. The lectures are 2005SSFP.V01 through 2005SSFP.V26. Videos 2005SSFP.U01 through 2005SSFP.U11 are exercise answer sessions, so you probably don't want those.
References
 Tour of the Haskell Syntax by Arjan van IJzendoorn.
 Haskell Reference by Miloslav Nic.
 A Tour of the Haskell Prelude by Bernie Pope and Arjan van IJzendoorn.
 Useful Haskell functions An explanation for beginners of many Haskell functions that are predefined in the Haskell Prelude.
Motivation for Using Haskell
 Why Functional Programming Matters by John Hughes, The Computer Journal, Vol. 32, No. 2, 1989, pp. 98  107. Also in: David A. Turner (ed.): Research Topics in Functional Programming, AddisonWesley, 1990, pp. 17  42.
Exposes the advantages of functional programming languages. Demonstrates how higherorder functions and lazy evaluation enable new forms of modularization of programs. 
Higherorder + Polymorphic = Reusable by Simon Thompson. Unpublished, May 1997.
Abstract: This paper explores how certain ideas in object oriented languages have their correspondents in functional languages. In particular we look at the analogue of the iterators of the C++ standard template library. We also give an example of the use of constructor classes which feature in Haskell 1.3 and Gofer.
Analysis and Design Methods
 FAD: A Functional Analysis and Design Methodology by Dan Russell.
Phd thesis, Computing Laboratory, University of Kent at Canterbury, January 2001.
Abstract: This thesis presents the functional analysis and design methodology FAD. By functional we mean that it naturally supports software development within the functional programming paradigm (FP). Every popular methodology has a graphical modelling language which presents various pictorial representations of a system. FAD's modelling language provides the typical elements of functional programming, types and functions, plus elements to support modular development such as modules, subsystems and two forms of signature which specify an interface or a behavioural requirement. The language also includes relationships and associations between these elements, and provides simple representations of functional designs. The methodology has an integrated set of techniques which guide the development of an implementable solution from the deliverables of requirements engineering. FAD's data dictionary provides an organised repository for entities during and after development. The thesis thus provides a development medium which has hitherto been absent from the functional programming paradigm.
Teaching Haskell

Where do I begin? A problem solving approach to teaching functional programming
by Simon Thompson.
In Krzysztof Apt, Pieter Hartel, and Paul Klint, editors, First International Conference on Declarative Programming Languages in Education. SpringerVerlag, September 1997.
Abstract: This paper introduces a problem solving method for teaching functional programming, based on Polya's `How To Solve It', an introductory investigation of mathematical method. We first present the language independent version, and then show in particular how it applies to the development of programs in Haskell. The method is illustrated by a sequence of examples and a larger case study. 
Functional programming through the curriculum by
Simon Thompsonand Steve Hill.
In Pieter H. Hartel and Rinus Plasmeijer, editors, Functional Programming
Languages in Education, LNCS 1022, pages 85102. SpringerVerlag, December 1995.
Abstract: This paper discusses our experience in using a functional language in topics across the computer science curriculum. After examining the arguments for taking a functional approach, we look in detail at four case studies from different areas: programming language semantics, machine architectures, graphics and formal languages.
Proving Program Correctness

Formulating Haskell by
Simon Thompson.
Technical Report 2992*, University of Kent, Computing Laboratory, University of Kent, Canterbury, UK, November 1992.
Abstract: The functional programming language Haskell is examined from the point of view of proving programs correct. Particular features explored include the data type definition facilities, classes, the behaviour of patterns and guards and the monad approach to IO in the Glasgow Haskell compiler.
Debugging Programs
 Buddha: A Declarative Debugger for Haskell by Bernie Pope. Honours Thesis.
 Freja, Hat and Hood  A Comparative Evaluation of Three Systems for Tracing and Debugging Lazy Functional Programs by Olaf Chitil, Colin Runciman and Malcolm Wallace.
Proceedings of the 12th International Workshop on Implementation of Functional
Languages, 2001.
Abstract: In this paper we compare three systems for tracing and debugging Haskell programs: Freja, Hat and Hood. We evaluate their usefulness in practice by applying them to a number of moderately complex programs in which errors had deliberately been introduced. We identify the strengths and weaknesses of each system and then form ideas on how the systems can be improved further.  Papers on declarative debugging
Using Monads
 The Haskell Programmer's Guide to the IO Monad  Don't Panic. Stefan Klinger.
This report scratches the surface of category theory, an abstract branch of algebra, just deep enough to find the monad structure. It seems well written.  All About Monads by Jeff Newbern
This tutorial aims to explain the concept of a monad and its application to functional programming in a way that is easy to understand and useful to beginning and intermediate Haskell programmers. Familiarity with the Haskell language is assumed, but no prior experience with monads is required.  What the hell are Monads? by Noel Winstanley
A basic introduction to monads, monadic programming and IO. This introduction is presented by means of examples rather than theory, and assumes a little knowledge of Haskell.  Monads for the Working Haskell Programmer  a short tutorial
by Theodore Norvell.
 Monadic I/O in Haskell 1.3 by Andrew Gordon and Kevin Hammond.
Abstract: We describe the design and use of monadic I/O in Haskell 1.3, the latest revision of the lazy functional programming language Haskell. Haskell 1.3 standardises the monadic I/O mechanisms now available in many Haskell systems. The new facilities allow fairly sophisticated textbased application programs to be written portably in Haskell. The standard provides implementors with a flexible framework for extending Haskell to incorporate new language features. Apart from the use of monads, the main advances over the previous standard are: character I/O based on handles (analogous to ANSI C file pointers), an error handling mechanism, terminal interrupt handling and a POSIX interface. Apart from a tutorial description of the new facilities we include a worked example: a derived monad for combinator parsing. <! "http://www.engr.uconn.edu/~jeffm/FuncProg/Papers/monad.html" Monads Made Easy by Ahmed Hammad From the Introduction: This paper is designed to help others who want to know about Monads, but don't want an overly technical explanation. Here I explain the basics, what monads are, what they are good for, and how to employ them. I do this by writing a simple exception handling system in Haskell using these features. >  How to Declare an Imperative by Philip Wadler, International Logic Programming Symposium '95, MIT Press, 1995.
An extended version will appear in ACM Computing Surveys.
Abstract: This tutorial describes the use of a monad to integrate interaction into a purely declarative language. This technique has been implemented in the higherorder functional language Haskell. A sketch is given of how it might be added to a firstorder language for logic programming.  Monads for functional programming by Philip Wadler, Marktoberdorf Summer School on Program Design Calculi,
Springer Verlag, NATO ASI Series F: Computer and systems sciences,
Volume 118, August 1992.
Abstract: The use of monads to structure functional programs is described. Monads provide a convenient framework for simulating effects found in other languages, such as global state, exception handling, output, or nondeterminism. Three case studies are looked at in detail: how monads ease the modification of a simple evaluator; how monads act as the basis of a datatype of arrays subject to inplace update; and how monads can be used to build parsers.  Comprehending monads by Philip Wadler, Mathematical Structures in Computer Science, Special issue of selected papers from 6'th Conference on Lisp and Functional Programming, 2:461493, 1992.
Abstract: Category theorists invented monads in the 1960's to concisely express certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to concisely express certain programs involving lists. This paper shows how list comprehensions may be generalised to an arbitrary monad, and how the resulting programming feature can concisely express in a pure functional language some programs that manipulate state, handle exceptions, parse text, or invoke continuations. A new solution to the old problem of destructive array update is also presented. No knowledge of category theory is assumed.  Combining monads by Philip Wadler, Glasgow Workshop on Functional Programming, Springer Verlag Workshops in Computing Series,
Ayr, July 1992.
Abstract: Monads provide a way of structuring functional programs. Most real applications require a combination of primitive monads. Here we describe how some monads may be combined with others to yield a combined monad.  Monadic Parser Combinators by <A NAME="Hutton&Meijer96 Graham Huttonand Erik Meijer],
Technical report NOTTCSTR964, Department of Computer Science, University of Nottingham, 1996.
A condensed version of this report will appear as a functional pearl in JFP.
Besides being a tutorial on parser combinators it is also an introduction to monads in general.
Separation of Concerns
Here I mean techniques, paradigms, concepts which can be used for achieving the goals of Aspect Oriented Programming: a powerful separation of concepts.
I know the title of this section is problemful: even pure lambda calculus can be regarded as a wonderful tool for modularity and reuse. I have thought of concepts like e.g.
 arrows
 attribute grammars
 catamorphisms
belonging here. Monads could belong here too, but they have already their special section above. Maybe this section could be titled as Other concepts used in Functional Programming concerning Category Theory, but this title is problemful too from the same reason: pure lambda calculus has also connections to Category Theory. So I have made a separate Categorical Programming section after this section.
Arrows
 Ross Paterson's page on Arrows: A General Interface to Computation
 HaWiki's UnderstandingArrows
Attribute Grammars
How can attribute grammars help at the separation of concerns, at things related to the goals of aspect oriented programming? How do they relate to other concepts like monads and arrows? Why are they important for the functional programmer? See Wouter Swierstra's WhyAttributeGrammarsMatter.
Utrecht University's Attribute Grammar System tools include also an attribute grammar compiler, UUAGC. The concept of attribute grammar was used in their Essential Haskell Compiler project, which gives us not only a working programming language, but also a good didactical material about using attribute grammars, e.g. in writing compilers.
Albeits these materials are selfcontained, they reveal that the theory of attribute grammars is related to these concepts:
 circular programming
 catamorphism
The next section contains links (among others) to materials on catamorphisms. And here is a HaWiki page on CircularProgramming.
Categorical Programming
Catamorphisms and related concepts, categorical approach to functional programming, categorical programming. Many materials cited here refer to category theory, so as an introduction to this discipline see the Foundations section at the end of this page.
 Erik Meijer, Maarten Fokkinga, Ross Paterson: Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire. See also related documents (in the CiteSeer page). Understanding the article does not require a category theory knowledge  a selfcontained material on the concept of catamorphism, anamoprhism and other related concepts.
 Varmo Vene and Tarmo Uustalu: Functional Programming with Apomorphisms / Corecursion
 Varmo Vene: Categorical Programming with Inductive and Coinductive Types. The book accompanies the deep categorical theory topic with Haskell examples.
 Tatsuya Hagino: A Categorical Programming Language
 Charity, a categorical programming language implementation.
Side Effects in a Pure Language
 Tackling the Awkward Squad: monadic I/O, concurrency, exceptions, and foreignlanguage calls in Haskell by Simon Peyton Jones
This tutorial focuses on explaining the "bits round the edges" of Haskell programs, rather than the beautiful functional core we all know and love. More specifically, it gives, in a single framework, an account of monadic input/output (the I/O monad)
 concurrency (threads, MVars)
 exceptions (both synchronous and asynchronous)
 foreign language interfaces
The common feature of all of these is, of course, the ubiquitous I/O monad. All except the first (basic I/O) involve proposed extensions to Haskell that are implemented in GHC, and I have tried hard to make the tutorial use exactly the same function names as GHC does. All of the extensions are described in conference papers (also available from my home page), but these papers are not tutorials, and were written with varying nomenclature over a period of several years. I hope that this tutorial gives a more comprehensible overview of the big picuture, using a common vocabulary.
Data Structures
 Chris Okasaki: Purely Functional Data Structures, 232 pp., Cambridge University Press, 1998. ISBN 0521631246
From the cover:Most books on data structures assume an imperative language like C or C++. However, data structures for these languages do not always translate well to functional languages such as Standard ML, Haskell, or Scheme. This book describes data structures and data structure design techniques from the point of view of functional languages. It includes code for a wide assortment both of classical data structures and of data structures developed exclusively for functional languages.This handy reference for professional programmers working with functional languages can also be used as a tutorial or for selfstudy.
 A probabilistic approach to the problem of automatic selection of data representations by TyngRuey Chuang and Wen L. Hwang, In Proceedings of the 1996 ACM SIGPLAN International Conference on Functional Programming, pages 190200. Philadephia, Pennsylvania, USA, May 1996.
Collections
 Bulk types with class by Simon Peyton Jones, (electronic) proceedings of the 1996 Glasgow Functional Programming Workshop.
Abstract: Bulk types  such as lists, bags, sets, finite maps, and priority queues  are ubiquitous in programming. Yet many languages don't support them well, even though they have received a great deal of attention, especially from the database community. Haskell is currently among the culprits. This paper has two aims: to identify some of the technical difficulties, and to attempt to address them using Haskell's constructor classes.
Listlike data structures
 Functional Data Structures by Chris Okasaki. Advanced Functional Programming, Second International Summer School on Advanced Functional Programming Techniques, Evergreen State College, WA, USA, LNCS 1126, 1996 (editors: J. Launchbury, E. Meijer, T. Sheard), p. 131158.
 Purely Functional RandomAccess Lists by Chris Okasaki. Functional Programming Languages and Computer Architecture, June 1995, pages 8695.
 Simple and Efficient Purely Functional Queues and Deques by Chris Okasaki. Journal of Functional Programming, 5(4):583592, October 1995.
 Optimal Purely Functional Priority Queues by Gerth Stølting Brodal and Chris Okasaki, Journal of Functional Programming, 6(6), December 1996.
 Realtime deques, multihead Turing machines, and purely functional programming. by TyngRuey Chuang and Benjamin Goldberg, In Conference on Functional Programming Languages and Computer Architecture, pages 289298. Copenhagen, Denmark, June 1993. ACM Press.
Arrays
 A randomized implementation of multiple functional arrays by TyngRuey Chuang, In Proceedings of the 1994 ACM Conference on Lisp and Functional Programming, pages 173184. Orlando, Florida, USA, June 1994.
 Fully persistent arrays for efficient incremental updates and voluminous reads by TyngRuey Chuang. In Bernd KriegBrueckner, editor, 4th European Symposium on Programming, pages 110129. Rennes, France, February 1992. LNCS 582. SpringerVerlag.
Graphs
 Graph Algorithms with a Functional Flavour by John Launchbury, Advanced Functional Programming, First International Spring School on Advanced Functional Programming Techniques, Bastad, Sweden, LNCS 925,p. 308331, 1995 (editors: J. Jeuring, E. Meijer).
 Structuring Depth First Search Algorithms in Haskell by David King and John Launchbury.
Proc. ACM Principles of Programming Languages, San Francisco, 1995.
Abstract: Depthfirst search is the key to a wide variety of graph algorithms. In this paper we express depthfirst search in a lazy functional language, obtaining a lineartime implementation. Unlike traditional imperative presentations, we use the structuring methods of functional languages to construct algorithms from individual reusable components. This style of algorithm construction turns out to be quite amenable to formal proof, which we exemplify through a calculationalstyle proof of a far from obvious stronglyconnected components algorithm.
Others
 Sparse matrix representations in a functional language by P.W. Grant, J.A. Sharp, M.F. Webster and X. Zhang, Journal of Functional Programming, 6(1):143170, January 1996.
Abstract: This paper investigates several sparse matrix representation schemes and associated algorithms in Haskell for solving linear systems of equations arising from solving realistic computational fluid dynamics problems using a finite element algorithm. This work complements that of Wainwright and Sexton [J. Functional Programming, 2(1):6172, 1992] in that a Choleski direct solver (with an emphasis on its forward/backward substitution steps) is examined. Experimental evidence comparing time and space efficiency of these matrix representation schemes is reported, together with associated forward/backward substitution implementations. Our results are in general agreement with Wainwright and Sexton's.
Parser Combinators
 How to Replace Failure by a List of Successes by <A NAME="Wadler85 Philip Wadler], Functional Programming Languages and Computer Architecture, LNCS 201, 1985.
 Higherorder functions for parsing by <A NAME="Hutton92 Graham Hutton], J. Functional Programming 2(3):323343, 1992.
 Monadic Parser Combinators by <A NAME="Hutton&Meijer96 Graham Huttonand Erik Meijer],
Technical report NOTTCSTR964, Department of Computer Science, University of Nottingham, 1996.
A condensed version of this report will appear as a functional pearl in JFP.
Besides being a tutorial on parser combinators it is also an introduction to monads in general.  Functional Parsers by <A NAME="Fokker95 Jeroen Fokker], First International Spring School on Advanced Functional Programming Techniques, LNCS 925, 1995.
 Predictive parser combinators need four values to report errors by <A NAME="Partridge&Wright96 Andrew Partridge, David Wright], J. Functional Programming 6(2): 355364, 1996.
 Combinators for parsing expressions by <A NAME="Hill96 Steve Hill], J. Functional Programming 6(3):445463, May 1996.
 Deterministic, ErrorCorrecting Combinator Parsers by <A NAME="Swierstra&Duponcheel96 S. Doaitse Swierstra and Luc Duponcheel], Second International Summer School on Advanced Functional Programming Techniques, LNCS 1126, 1996.
Schools on Advanced Funtional Programming
Advanced Functional Programming, First International Spring School on Advanced Functional Programming Techniques, Bastad, Sweden, LNCS 925, SpringerVerlag, 1995 (editors: J. Jeuring, E. Meijer).
 Functional Parsers by Jeroen Fokker, p. 123.
 Monads for functional programming by Philip Wadler, p. 2452.
 The Design of a Prettyprinting Library by John Hughes, p. 5296.
 Functional Programming with Overloading and HigherOrder Polymorphism, Mark P. Jones, p. 97136.
 Programming with Fudgets by Thomas Hallgren and Magnus Carlsson, p. 137182.
 Constructing Medium Sized Efficient Functional Programs in Clean by Marko C.J.D. van Eekelen and Rinus J. Plasmeijer, p. 183227.
 Merging Monads and Folds for Functional Programming by Erik Meijer and Johan Jeuring, p. 228266.
 Programming with Algebras by Richard B. Kieburtz and Jeffrey Lewis, p. 267307.
 Graph Algorithms with a Functional Flavour by John Launchbury, p. 308331.
Advanced Functional Programming, Second International Summer School on Advanced Functional Programming Techniques, Evergreen State College, WA, USA, LNCS 1126, SpringerVerlag, 1996 (editors: J. Launchbury, E. Meijer, T. Sheard).
 Composing the User Interface with Haggis by Sigbjorn Finne and Simon Peyton Jones, p. 137.
 Haskore Music Tutorial by Paul Hudak, p. 3867.
 Polytypic Programming by Johan Jeuring and Patrick Jansson, p. 68114.
 Implementing Threads in Standard ML by Peter Lee, p. 115130.
 Functional Data Structures by Chris Okasaki, p. 131158.
 Heap Profiling for Space Efficiency by Colin Runciman and Niklas Röjemo, p. 159183.
 Deterministic, ErrorCorrecting Combinator Parsers by S. Doaitse Swierstra and Luc Duponcheel, p. 184207.
 Essentials of Standard ML Modules by Mads Tofte, p. 208238.
Advanced Functional Programming, Third International School, AFP'98,
in Braga, Portugal from 12th to 19th September 1998, LNCS 1608, SpringerVerlag, 1999
(editors: D. Swierstra, P. Henriques and J. Oliveira).
All lecture notes and further material are available from the web site.
Foundations
 Paul Taylor: Practical Foundations of Mathematics
Cambridge University Press, ISBN: 0521631076, xii+576 pages, September 2000.  Michael Barr and Charles Wells: Toposes, Triples and Theories
The revised version of their formerly Springer Verlag published book is online for free download. Note that they use the name triple instead of monad.