汤普森编著的《HaskeⅡ函数式编程基础》的目的是为计算机科学的功能规划介绍和其他的学生，主要是在大学的水平。它可用于初学者的计算机科学，或更有经验的学生学习的功能规划第一次；两组将找到的材料是新的和具有挑战性的。本书也可用于自学的程序员，软件工程师其他获得功能的编程接地感兴趣。本文的目的是独立的，但一些基本知识组件—命令，文件等需要使用任何HaskeⅡ的实现。一些逻辑符号的文字介绍中这是解释它。

汤普森编著的《HaskeⅡ函数式编程基础》是一本非常优秀的Haskeu函数式程序设计的入门书，各章依次介绍函数式程序设计的基本概念、编译器和解释器、函数的各种定义方式、简单程序的构造、多态和高阶函数、诸如数组和列表的结构化数据、列表上的原始递归和推理、输入输出的控制处理、类型分类与检测方法、代数数据类型、抽象数据类型、惰性计算等内容。书中包含大量的实例和习题，注重程序测试、程序证明和问题求解，易读易学。全书循序渐进，从基本的函数式程序设计直至高级专题，让读者对Haskell的学习不断深入。

《HaskeⅡ函数式编程基础》可作为计算机科学和其他相关学科的高年级本科生、研究生的教材，也可供对函数式程序设计感兴趣的程序员、软件工程师等参考学习。

Preface

1 Introducing functional programming

 1.1  Computers and modelling

 1.2  What is a function?

 1.3  Pictures and functions

 1.4  Types

 1.5  The Haskell programming language

 1.6  Expressions and evaluation

 1.7  Definitions

 1.8  Function definitions

 1.9  Types and functional programming

 1.10 Calculation and evaluation

 1.11 The essence of Haskell programming

 1.12 Domain-specific languages

 1.13 Two models of Pcturos

 1.14 Tests, properties and proofs

2 Getting started with Haskell and GHCi

 2.1  A first Haskell program

 2.2  Using Haskell in practice

 2.3  Using GHCi

 2.4  The standard prelude and the Haskell libraries

 2.5  Modules

 2.6  A second example: pictures

 2.7  Errors and error messages

3 Basic types and definitions

 3.1  The Booleans: Boo1

 3.2  The integers: Intogor and Int

 3.3  Overloading

 3.4  Guards

 3.5  Characters and strings

 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  Solving a problem in steps: local definitions

 4.3  Defining types for ourselves: enumerated types

 4.4  Recursion

 4.5  Primitive recursion in practice

 4.6  Extended exercise: pictures

 4.7  General forms of recursion

 4.8  Program testing

5 Data types, tuples and lists

 5.1  Introducing tuples and lists

 5.2  Tuple types

 5.3  Introducing algebraic types

 5.4  Our approach to lists

 5.5  Lists in Haskell

 5.6  List comprehensions

 5.7  A library database

6 Programming with lists

 6.1  Generic functions: polymorphism

 6.2  Haskell list functions in the Pre].udo

 6.3  Finding your way around the Haskell libraries

 6.4  The P~cturo example: implementation

 6.5  Extended exercise: alternative implementations of pictures

 6.6  Extended exercise: positioned pictures

 6.7  Extended exercise: supermarket billing

 6.8  Extended exercise: cards and card games

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 Playing the game: I/O in Haskell

 8.1  Rock - Paper - Scissors: strategies

 8.2  Why is I/O an issue?

 8.3  The basics of input/output

 8.4  The do notation

 8.5  Loops and recursion

 8.6  Rock - Paper - Scissors: playing the game

9 Reasoning about programs

 9.1  Understanding definitions

 9.2  Testing and proof

 9.3  Definedness, termination and finiteness

 9.4  A little logic

 9.5  Induction

 9.6  Further examples of proofs by induction

 9.7  Generalizing the proof goal

10 Generalization: patterns of computation

 10.1 Patterns of computation over lists

 10.2 Higher-order functions: functions as arguments

 10.3 Folding and primitive recursion

 10.4 Generalizing: splitting up lists

 10.5 Case studies revisited

11 Higher-order functions

 11.1 Operators: function composition and application 

 11.2 Expressions for functions: lambda abstractions

 11.3 Partial application

 11.4 Under the hood: curried functions

 11.5 Defining higher-order functions

 11.6 Verification and general functions

12 Developing higher-order programs

 12.1 Revisiting the Picture example

 12.2 Functions as data: strategy combinators

 12.3 Functions as data: recognizing regular expressions

 12.4 Case studies: functions as data

 12.5 Example: creating an index

 12.6 Development in practice

 12.7 Understanding programs

13 Overloading, type classes and type checking

 13.1 Why overloading?

 13.2 Introducing classes

 13.3 Signatures and instances

 13.4 A tour of the built-in Haskell classes

 13.5 Type checking and type inference: an overview 

 13.6 Monomorphic type checking

 13.7 Polymorphic type checking

 13.8 Type checking and classes

14 Algebraic types

 14.1  Algebraic type definitions revisited

 14.2 Recursive algebraic types

 14.3 Polymorphic algebraic types

 14.4 Modelling 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.10 Commentary

17 Lazy programming

 17.1 Lazy evaluation

 17.2 Calculation rules and lazy evaluation

 17.3 List comprehensions revisited

 17.4 Data-directed programming

 17.5 Case study: parsing expressions

 17.6 Infinite lists

 17.7 Why infinite lists?

 17.8 Case study: simulation

 17.9 Proof revisited

18 Programming with monads

 18.1 I/O programming

 18.2 Further I/O

 18.3 The calculator

 18.4 The do notation revisited

 18.5 Monads: languages for functional programming

 18.6 Example: monadic computation over trees

19 Domain-specific languages

 19.1 Programming languages everywhere

 19.2 Why DSLs in Haskell?

 19.3 Shallow and deep embeddings

 19.4 A DSL for regular expressions

 19.5 Monadic DSLs

 19.6 DSLs for computation: generating data in QuickCheck

 19.7 Taking it further

20 Time and space behaviour

 20.1 Complexity of functions

 20.2 The complexity of calculations

 20.3 Implementations of sets

 20.4 Space behaviour

 20.5 Folding revisited

 20.6 Avoiding recomputation: memoization

 21 Conclusion

Appendices

 A Functional, imperative and OO programming

 B Glossary

 C I-Iaskell operators

 D Haskell practicalities

 E GHCi errors

 F Project ideas

 Bibliography

 Index