Haskell : the craft of functional programming / Simon Thompson.

By:

Thompson, Simon

Material type: Text

TextPublication details: Harlow, England ; New York : Addison Wesley, 2011.Edition: 3rd edDescription: xxii, 585 pages : illustrations ; 24 cmISBN:

9780201882957
0201882957

Subject(s):

Functional programming (Computer science)

DDC classification:

005.133 THO

Contents:

Introducing functional programming -- Getting started with Haskell and GHCi -- Basic types and definitions -- Designing and writing programs -- Data types, tuples and lists -- Programming with lists -- Defining functions over lists -- Playing the game : I/O in Haskell -- Reasoning about programs -- Generalization : patterns of computation -- Higher-order functions -- Developing higher-order programs -- Overloading, type classes and type checking -- Algebraic types -- Case study : Huffman codes -- Abstract data types -- Lazy programming -- Programming with monads -- Domain-specific languages -- Time and space behaviour.

Holdings
Item type	Current library	Call number	Copy number	Status	Date due	Barcode
Standard Loan	Moylish Library Main Collection	005.133 THO (Browse shelf(Opens below))	1	Missing		39002100620781

Enhanced descriptions from Syndetics:

Introducing functional programming in the Haskell language, this book is written for students and programmers with little or no experience.nbsp; It emphasises the process of crafting programmes, problem solving and avoiding common programming pitfalls.

Covering basic functional programming, through abstraction to larger scale programming, students are lead step by step through the basics, before being introduced to more advanced topics.

This edition includes new material on testing and domain-specific languages and a variety of new examples and case studies, including simple games. Existing material has been expanded and re-ordered, so that some concepts #150; such as simple data types and input/output #150; are presented at an earlier stage.

Includes bibliographical references (pages 567-569) and index (pages 571-585).

Table of contents provided by Syndetics

Preface (p. xiii)
1 Introducing functional programming (p. 1)
1.1 Computers and modelling (p. 2)
1.2 What is a function? (p. 3)
1.3 Pictures and functions (p. 4)
1.4 Types (p. 5)
1.5 The Haskell programming language (p. 7)
1.6 Expressions and evaluation (p. 8)
1.7 Definitions (p. 9)
1.8 Function definitions (p. 11)
1.9 Types and functional programming (p. 14)
1.10 Calculation and evaluation (p. 15)
1.11 The essence of Haskell programming (p. 16)
1.12 Domain-specific languages (p. 17)
1.13 Two models of Pictures (p. 18)
1.14 Tests, properties and proofs (p. 22)
2 Getting started with Haskell and GHCi (p. 27)
2.1 A first Haskell program (p. 27)
2.2 Using Haskell in practice (p. 28)
2.3 Using GHCi (p. 29)
2.4 The standard prelude and the Haskell libraries (p. 33)
2.5 Modules (p. 34)
2.6 A second example: pictures (p. 35)
2.7 Errors and error messages (p. 38)
3 Basic types and definitions (p. 41)
3.1 The Booleans: Bool (p. 42)
3.2 The integers: Integer and Int (p. 45)
3.3 Overloading (p. 47)
3.4 Guards (p. 48)
3.5 Characters and strings (p. 52)
3.6 Floating-point numbers: Float (p. 56)
3.7 Syntax (p. 60)
4 Designing and writing programs (p. 67)
4.1 Where do I start? Designing a program in Haskell (p. 67)
4.2 Solving a problem in steps: local definitions (p. 72)
4.3 Defining types for ourselves: enumerated types (p. 78)
4.4 Recursion (p. 81)
4.5 Primitive recursion in practice (p. 84)
4.6 Extended exercise: pictures (p. 87)
4.7 General forms of recursion (p. 89)
4.8 Program testing (p. 91)
5 Data types, tuples and lists (p. 97)
5.1 Introducing tuples and lists (p. 97)
5.2 Tuple types (p. 100)
5.3 Introducing algebraic types (p. 103)
5.4 Our approach to lists (p. 109)
5.5 Lists in Haskell (p. 109)
5.6 List comprehensions (p. 111)
5.7 A library database (p. 116)
6 Programming with lists (p. 123)
6.1 Generic functions: polymorphism (p. 123)
6.2 Haskell list functions in the Prelude (p. 126)
6.3 Finding your way around the Haskell libraries (p. 129)
6.4 The Picture example: implementation (p. 135)
6.5 Extended exercise: alternative implementations of pictures (p. 140)
6.6 Extended exercise: positioned pictures (p. 144)
6.7 Extended exercise: supermarket billing (p. 147)
6.8 Extended exercise: cards and card games (p. 152)
7 Defining functions over lists (p. 155)
7.1 Pattern matching revisited (p. 155)
7.2 Lists and list patterns (p. 157)
7.3 Primitive recursion over lists (p. 160)
7.4 Finding primitive recursive definitions (p. 161)
7.5 General recursions over lists (p. 167)
7.6 Example: text processing (p. 170)
8 Playing the game: I/O in Haskell (p. 177)
8.1 Rock - Paper - Scissors: strategies (p. 177)
8.2 Why is I/O an issue? (p. 181)
8.3 The basics of input/output (p. 182)
8.4 The do notation (p. 185)
8.5 Loops and recursion (p. 189)
8.6 Rock - Paper - Scissors: playing the game (p. 191)
9 Reasoning about programs (p. 195)
9.1 Understanding definitions (p. 196)
9.2 Testing and proof (p. 197)
9.3 Definedness, termination and finiteness (p. 199)
9.4 A little logic (p. 200)
9.5 Induction (p. 201)
9.6 Further examples of proofs by induction (p. 205)
9.7 Generalizing the proof goal (p. 209)
10 Generalization: patterns of computation (p. 213)
10.1 Patterns of computation over lists (p. 214)
10.2 Higher-order functions: functions as arguments (p. 216)
10.3 Folding and primitive recursion (p. 221)
10.4 Generalizing: splitting up lists (p. 226)
10.5 Case studies revisited (p. 227)
11 Higher-order functions (p. 231)
11.1 Operators: function composition and application (p. 232)
11.2 Expressions for functions: lambda abstractions (p. 235)
11.3 Partial application (p. 239)
11.4 Under the hood: curried functions (p. 242)
11.5 Defining higher-order functions (p. 247)
11.6 Verification and general functions (p. 253)
12 Developing higher-order programs (p. 263)
12.1 Revisiting the Picture example (p. 263)
12.2 Functions as data: strategy combinators (p. 266)
12.3 Functions as data: recognizing regular expressions (p. 269)
12.4 Case studies: functions as data (p. 272)
12.5 Example: creating an index (p. 275)
12.6 Development in practice (p. 281)
12.7 Understanding programs (p. 284)
13 Overloading, type classes and type checking (p. 287)
13.1 Why overloading? (p. 287)
13.2 Introducing classes (p. 288)
13.3 Signatures and instances (p. 292)
13.4 A tour of the built-in Haskell classes (p. 299)
13.5 Type checking and type inference: an overview (p. 308)
13.6 Monomorphic type checking (p. 309)
13.7 Polymorphic type checking (p. 312)
13.8 Type checking and classes (p. 320)
14 Algebraic types (p. 323)
14.1 Algebraic type definitions revisited (p. 324)
14.2 Recursive algebraic types (p. 326)
14.3 Polymorphic algebraic types (p. 333)
14.4 Modelling program errors (p. 337)
14.5 Design with algebraic data types (p. 341)
14.6 Algebraic types and type classes (p. 345)
14.7 Reasoning about algebraic types (p. 350)
15 Case study: Huffman codes (p. 357)
15.1 Modules in Haskell (p. 357)
15.2 Modular design (p. 361)
15.3 Coding and decoding (p. 362)
15.4 Implementation - I (p. 364)
15.5 Building Huffman trees (p. 367)
15.6 Design (p. 368)
15.7 Implementation - II (p. 369)
16 Abstract data types (p. 377)
16.1 Type representations (p. 377)
16.2 The Haskell abstract data type mechanism (p. 379)
16.3 Queues (p. 383)
16.4 Design (p. 386)
16.5 Simulation (p. 388)
16.6 Implementing the simulation (p. 390)
16.7 Search trees (p. 394)
16.8 Sets (p. 400)
16.9 Relations and graphs (p. 405)
16.10 Commentary (p. 413)
17 Lazy programming (p. 415)
17.1 Lazy evaluation (p. 416)
17.2 Calculation rules and lazy evaluation (p. 418)
17.3 List comprehensions revisited (p. 421)
17.4 Data-directed programming (p. 428)
17.5 Case study: parsing expressions (p. 432)
17.6 Infinite lists (p. 442)
17.7 Why infinite lists? (p. 447)
17.8 Case study: simulation (p. 450)
17.9 Proof revisited (p. 452)
18 Programming with monads (p. 459)
18.1 I/O programming (p. 459)
18.2 Further I/O (p. 462)
18.3 The calculator (p. 465)
18.4 The do notation revisited (p. 468)
18.5 Monads: languages for functional programming (p. 469)
18.6 Example: monadic computation over trees (p. 476)
19 Domain-specific languages (p. 483)
19.1 Programming languages everywhere (p. 483)
19.2 Why DSLs in Haskell? (p. 486)
19.3 Shallow and deep embeddings (p. 487)
19.4 A DSL for regular expressions (p. 490)
19.5 Monadic DSLs (p. 495)
19.6 DSLs for computation: generating data in QuickCheck (p. 498)
19.7 Taking it further (p. 503)
20 Time and space behaviour (p. 505)
20.1 Complexity of functions (p. 505)
20.2 The complexity of calculations (p. 509)
20.3 Implementations of sets (p. 513)
20.4 Space behaviour (p. 514)
20.5 Folding revisited (p. 517)
20.6 Avoiding recomputation: memoization (p. 523)
21 Conclusion (p. 529)
Appendices
A Functional, imperative and OO programming (p. 535)
B Glossary (p. 543)
C Haskell operators (p. 551)
D Haskell practicalities (p. 553)
E GHCi errors (p. 555)
F Project ideas (p. 561)
Bibliography (p. 567)

Author notes provided by Syndetics

Simon Thompson is Professor of Logic and Computation in the School of Computing at the University of Kent. His research and teaching interests include functional programming and logical aspects of computer science. Simon has written three other books: Erlang Programming (co-authored with Francesco Cesarini), Miranda: The Craft of Functional Programming and Type Theory and Functional Programming.