FREE SHIPPING BOTH WAYS
ON EVERY ORDER!
LIST PRICE:
$62.00

Sorry, this item is currently unavailable.

Haskell The Craft of Functional Programming

ISBN: 9780201342758 | 0201342758
Edition: 2nd
Format: Paperback
Publisher: Addison-Wesley
Pub. Date: 3/29/1999

Why Rent from Knetbooks?

Because Knetbooks knows college students. Our rental program is designed to save you time and money. Whether you need a textbook for a semester, quarter or even a summer session, we have an option for you. Simply select a rental period, enter your information and your book will be on its way!

Top 5 reasons to order all your textbooks from Knetbooks:

  • We have the lowest prices on thousands of popular textbooks
  • Free shipping both ways on ALL orders
  • Most orders ship within 48 hours
  • Need your book longer than expected? Extending your rental is simple
  • Our customer support team is always here to help
SummaryTable of ContentsAuthor Biography
Simon Thompson is a Senior Lecturer in the Computing Laboratory at the University of Kent.
The second edition of Haskell: The Craft of Functional Programming is essential reading for beginners to functional programming and newcomers to the Haskell programming language. The emphasis is on the process of crafting programs and the text contains many examples and running case studies, as well as advice on program design, testing, problem solving and how to avoid common pitfalls.
Prefacexii
Introducing functional programming
1(18)
Computers and modelling
2(1)
... MORE
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)
Bibliography469(3)
Index472

Simon Thompson is a Senior Lecturer in Computer Science at the University of Kent. His research and teaching interests include functional programming and logical aspects of computer science.



0201342758AB04062001

Related Products


  • Haskell : The Craft of Functional Programming
    Haskell : The Craft of Functio...
  • Haskell:The Craft of Functional Programming
    Haskell:The Craft of Functiona...


Please wait while this item is added to your cart...