《Haskell - The Craft of Functional Programming》 2nd Edition

【实例截图】

【核心代码】

Contents
Preface
1 Introducing functional programming
Computers and modelling
What is a function?
Pictures and functions
TY pes
The Haskell programming language
Expressions and evaluation
Definitions
Function definitions
Looking forward: a model of pictures
Proof
Types and functional programming
Calculation and evaluation
2 Getting started with Haskell and Hugs
2.1 A first Haskell program
2.2 Using Hugs
2.3 The standard prelude and the Haskell libraries
2.4 Modules
2.5 A second example: Pictures
2.6 Errors and error messages
xii
3 Basic types and definitions
vii
viii Contents
3.1 The Booleans: Boo1
3.2 The integers: Int
3.3 Overloading
3.4 Guards
3.5 The characters: Char
3.6 Floating-point numbers: Float
3.7 Syntax
4 Designing and writing programs
4.1 Where do I start? Designing a program in Haskell
4.2 Recursion
4.3 Primitive recursion in practice
4.4 General forms of recursion
4.5 Program testing
5 Data types: tuples and lists
5.1 Introducing tuples, lists and strings
5.2 Tuple types
5.3 Our approach to lists
5.4 Lists in Haskell
5.5 List comprehensions
5.6 A library database
5.7 Generic functions: polymorphism
5.8 Haskell list functions in Prelude. hs
5.9 The string type
6 Programming with lists
6.1 The Picture example, revisited
6.2 Extended exercise: positioned pictures
6.3 Local definitions
6.4 Extended exercise: supermarket billing
7 Defining functions over lists
7.1 Pattern matching revisited
7.2 Lists and list patterns
7.3 Primitive recursion over lists
7.4 Finding primitive recursive definitions
7.5 General recursions over lists
7.6 Example: text processing
8 Reasoning about programs
8.1 Understanding definitions
8.2 Testing and proof
Contents ix
8.3 Definedness, termination and finiteness
8.4 A little logic
8.5 Induction
8.6 Further examples of proofs by induction
8.7 Generalizing the proof goal
9 Generalization: patterns of computation
9.1 Patterns of computation over lists
9.2 Higher-order functions: functions as arguments
9.3 Folding and primitive recursion
9.4 Generalizing: splitting up lists
10 Functions as values
10.1 Function-level definitions
10.2 Function composition
1 0.3 Functions as values and results
10.4 Partial application
10.5 Revisiting the Picture example
10.6 Further examples
10.7 Currying and uncurrying
10.8 Example: creating an index
10.9 Verification and general functions
11 Program development
11.1 The development cycle
11.2 Development in practice
12 Overloading and type classes
1 2.1 Why overloading?
1 2.2 lntroducing classes
12.3 Signatures and instances
12.4 A tour of the built-in Haskell classes
12.5 Types and classes
13 Checking types
13.1 Monomorphic type checking
13.2 Polymorphic type checking
1 3.3 Type checking and classes
14 Algebraic types
14.1 lntroducing algebraic types
14.2 Recursive algebraic types
14.3 Polymorphic algebraic types
x Contents
14.4 Case study: program errors
14.5 Design with algebraic data types
14.6 Algebraic types and type classes
14.7 Reasoning about algebraic types
15 Case study: Huffman codes
15.1 Modules in Haskell
15.2 Modular design
15.3 Coding and decoding
15.4 Implementation - I
15.5 Building Huffman trees
15.6 Design
15.7 Implementation - II
16 Abstract data types
16.1 Type representations
16.2 The Haskell abstract data type mechanism
16.3 Queues
16.4 Design
16.5 Simulation
16.6 Implementing the simulation
16.7 Search trees
16.8 Sets
16.9 Relations and graphs
16.1 0 Commentary
17 Lazy programming
17.1 Lazy evaluation
17.2 Calculation rules and lazy evaluation
1 7.3 List comprehensions revisited
1 7.4 Data-directed programming
1 7.5 Case study: parsing expressions
17.6 Infinite lists
17.7 Why infinite lists?
17.8 Case study: simulation
1 7.9 Proof revisited
18 Programming with actions
18.1 Why is 1/0 an issue?
18.2 The basics of input/output
18.3 The do notation
18.4 Iteration and recursion
18.5 The calculator
18.6 Further 1/0
Contents xi
18.7 The do construct revisited
18.8 Monads for functional programming
18.9 Example: monadic computation over trees
19 Time and space behaviour
19.1 Complexity of functions
19.2 The complexity of calculations
19.3 Implementations of sets
1 9.4 Space behaviour
19.5 Folding revisited
19.6 Avoiding recomputation: memoization
20 Conclusion
Appendices
A Functional, imperative and 00 programming
B Glossary
C Haskell operators
D Understanding programs
E lmplementations of Haskell