Have one to sell? Sell yours here
Tell the Publisher!
Id like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Haskell: The Craft of Functional Programming (International computer science series) [Paperback]

Thompson
3.4 out of 5 stars  See all reviews (7 customer reviews)

Available from these sellers.


‹  Return to Product Overview

Table of Contents

I. BASIC FUNCTIONAL PROGRAMMING.

1. Introducing Functional Programming.
What is Functional Programming?
Haskell.
Gofer and Hugs.
Practical work.

2. Basic Types and Simple Programs.
The numbers: Integers.
Programming with integers.
Syntax.
Operators.
Definitions: Patterns.
Programming with Booleans.
Characters and Strings.
Floating point numbers.
Programming with numbers and strings.
Data structures: Tuples.
Function Definitions.
Programming with local definitions.
Example: Quadratic equations.
Design.

3. Reasoning About Programs.
Informal proof: an introduction.
Proof by Induction.
Building induction proofs.

4. Data Structures: Lists.
Lists in Haskell.
Defining functions over lists.
Designing functions over lists.
Pattern matching.
A library database.
List comprehensions.
Extended exercise: supermarket billing.
Example: Text Processing.
Definition forms.
Program design.

5. Reasoning About Lists.
Structural induction.
Proofs by structural induction.
Case studies.
Generalizing the proof goal.

II. ABSTRACTION.

6. Generalization.
Functions as arguments.
Polymorphism.
Putting the two together.
Using the higher-order functions.
Generalizing: splitting up lists.

7. Functions as Values.
Function composition.
Functions as values and results.
Partial Application.
Examples.
Currying and uncurrying.
Example: creating an index.
Design revisited.
Verification.

8. Classes in Haskell.
Introducing classes.
Signatures and Instances.
A tour of the built-in Haskell classes.
More advanced features.

9. Checking Types.
Monomorphic types.
Polymorphic types.
Polymorphic Type Checking.
Type checking & classes.

III. LARGER-SCALE PROGRAMMING.

10. Algebraic types.
Introduction.
Recursive Types.
Polymorphic algebraic types.
Case study: Program Errors.
Design with Algebraic Data Types.
Algebraic types and type classes.
Reasoning about algebraic types.

11. Case study: Huffman Codes.
Modules in Haskell.
Modular design.
Coding and decoding.
Implementation — I.
Building Huffman trees.
Design.
Implementation — II.

12. Abstract Data Types.
Type representations.
The Gofer abstract data type mechanism.
Example: queues.
The Haskell ADT mechanism.
Design.
Example: Simulation.
Implementing the simulation.
Example: Search trees.
Case Study: Sets.
Relations and graphs.
Commentary.

13. Lazy Programming.
Lazy evaluation.
Calculation Rules.
List comprehensions revisited.
Data on demand.
Case study: Parsing expressions.
Infinite lists.
Why infinite lists?
Case study: Simulation.
Proof revisited.

14. Input/Output and Interaction.
Stream-based interactive programs.
Using Monads for I/O.
Monads for Functional Programming.

15. Program Behaviour.
Complexity of functions.
The complexity of calculations.
Implementations of sets.
Space behaviour.
Folding revisited.
Avoiding re-computation: memorization.

Appendices.
A: Functional and imperative programming.
B: Further reading.
C: Glossary.
D: Understanding programs.
E: Haskell operators.
F: Implementations of Haskell.
G: Gofer and Hugs errors.
H: Some Useful Functions.

Bibliography.
Index. 0201403579T04062001

‹  Return to Product Overview