Copyright ©1998-2010 Glenn Fleishman. Send in your comments. Bibliographic information on isbn.nu licensed from Baker & Taylor. Contact them for corrections and licensing, or read more about our data.
Tables of Contents for Haskell
Chapter/Section Title
Page #
Page Count
Preface
xii
Introducing functional programming
1
18
Computers and modelling
2
1
What is a function?
3
1
Pictures and functions
4
1
Types
5
1
The Haskell programming language
6
1
Expressions and evaluation
7
1
Definitions
8
1
Function definitions
9
3
Looking forward: a model of pictures
12
2
Proof
14
2
Type and functional programming
16
1
Calculation and evaluation
17
2
Getting started with Haskell and Hugs
19
13
A first Haskell program
19
3
Using Hugs
22
4
The standard prelude and the Haskell libraries
26
1
Modules
26
1
A second example: Pictures
27
3
Errors and error messages
30
2
Basic types and definitions
32
21
The Booleans: Bool
33
2
The integers: Int
35
2
Overloading
37
1
Guards
38
3
The characters: Char
41
2
Floating-point numbers: Float
43
3
Syntax
46
7
Designing and writing programs
53
18
Where do I start? Designing a program in Haskell
53
5
Recursion
58
4
Primitive recursion in practice
62
3
General forms of recursion
65
2
Program testing
67
4
Data types: tuples and lists
71
25
Introducing tuples, lists and strings
72
1
Tuple types
73
4
Our approach to lists
77
1
Lists in Haskell
78
1
List comprehensions
79
4
A library database
83
4
Generic functions: polymorphism
87
3
Haskell list functions in Prelude.hs
90
2
The String type
92
4
Programming with lists
96
19
The Picture example, revisited
96
4
Extended exercise: positioned pictures
100
3
Local definitions
103
5
Extended exercise: supermarket billing
108
7
Defining functions over lists
115
20
Pattern matching revisited
115
2
Lists and list patterns
117
2
Primitive recursion over lists
119
1
Finding primitive recursive definitions
120
5
General recursions over lists
125
3
Example: text processing
128
7
Reasoning about programs
135
17
Understanding definitions
136
1
Testing and proof
137
1
Definedness, termination and finiteness
138
2
A little logic
140
1
Induction
141
3
Further examples of proofs by induction
144
4
Generalizing the proof goal
148
4
Generalization: patterns of computation
152
15
Patterns of computation over lists
153
2
Higher-order functions: functions as arguments
155
6
Folding and primitive recursion
161
4
Generalizing: splitting up lists
165
2
Functions as values
167
35
Function-level definitions
168
1
Function composition
169
2
Functions as values and results
171
4
Partial application
175
6
Revisiting the Picture example
181
3
Further examples
184
1
Currying and uncurrying
185
1
Example: creating an index
186
7
Verification and general functions
193
9
Program development
202
8
The development cycle
202
4
Development in practice
206
4
Overloading and type classes
210
17
Why overloading?
211
1
Introducing classes
212
3
Signatures and instances
215
5
A tour of the built-in Haskell classes
220
5
Types and classes
225
2
Checking types
227
15
Monomorphic type checking
228
2
Polymorphic type checking
230
8
Type checking and classes
238
4
Algebraic types
242
38
Introducing algebraic types
243
7
Recursive algebraic types
250
7
Polymorphic algebraic types
257
4
Case study: program errors
261
4
Design with algebraic data types
265
4
Algebraic types and type classes
269
5
Reasoning about algebraic types
274
6
Case study: Huffman codes
280
19
Modules in Haskell
280
4
Modular design
284
1
Coding and decoding
285
2
Implementation - I
287
3
Building Huffman trees
290
1
Design
291
2
Implementation - II
293
6
Abstract data types
299
38
Type representations
299
2
The Haskell abstract data type mechanism
301
3
Queues
304
3
Design
307
2
Simulation
309
2
Implementing the simulation
311
4
Search trees
315
6
Sets
321
6
Relations and graphs
327
8
Commentary
335
2
Lazy programming
337
46
Lazy evaluation
338
2
Calculation rules and lazy evaluation
340
4
List comprehensions revisited
344
7
Data-directed programming
351
3
Case study: parsing expressions
354
10
Infinite lists
364
6
Why infinite lists?
370
3
Case study: simulation
373
2
Proof revisited
375
8
Programming with actions
383
30
Why is I/O an issue?
384
1
The basics of input/output
385
2
The do notation
387
4
Iteration and recursion
391
5
The calculator
396
2
Further I/O
398
2
The do construct revisited
400
1
Monads for functional programming
401
6
Example: monadic computation over trees
407
6
Time and space behaviour
413
23
Complexity of functions
414
4
The complexity of calculations
418
4
Implementations of sets
422
1
Space behaviour
423
3
Folding revisited
426
3
Avoiding recomputation: memorization
429
7
Conclusion
436
33
Appendices
A Functional, imperative and OO programming
442
8
B Glossary
450
7
C Haskell operators
457
2
D Understanding programs
459
3
E Implementations of Haskell
462
2
F Hugs errors
464
5
Bibliography
469
3
Index
472