Haskell The Craft of Functional Programming

ISBN-10: 0201882957
ISBN-13: 9780201882957
Edition: 3rd 2012 (Revised)
Authors: Simon Thompson
List price: $51.99
eBook available
This item qualifies for FREE shipping

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy

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

eBooks Starting from $65.99
Buy
what's this?
Rush Rewards U
Members Receive:
coins
coins
You have reached 400 XP and carrot coins. That is the daily max!

Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
SQL Online content $4.95 $1.99
Add to cart
Study Briefs
MS Excel® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS Word® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS PowerPoint® 2010 Online content $4.95 $1.99

Customers also bought

Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading
Loading

Book details

List price: $51.99
Edition: 3rd
Copyright year: 2012
Publisher: Pearson Education, Limited
Publication date: 6/16/2011
Binding: Paperback
Pages: 608
Size: 6.75" wide x 9.75" long x 1.50" tall
Weight: 2.442
Language: English

Introducing functional programming in the Haskell language, this book is written for students and programmers with little or no experience. 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.

Simon Thompson is Professor of Logic and Computation in the Computing Laboratory of the University of Kent, where he has taught computing at undergraduate and postgraduate levels for the past twenty five years, and where he has been department head for the last six. His research work has centered on functional programming: program verification, type systems, and most recently development of software tools for functional programming languages. His team has built the HaRe tool for refactoring Haskell programs, and is currently developing Wrangler to do the same for Erlang. His research has been funded by various agencies including EPSRC and the European Framework programme. His training is as a mathematician: he has an MA in Mathematics from Cambridge and a D.Phil. in mathematical logic from Oxford. He has written three books in his field of interest; Type Theory and Functional Programming published in 1991; Miranda: The Craft of Functional Programming (1995) and Haskell: The Craft of Functional Programming (2nd ed. 1999). These are all published by Addison Wesley.

Preface
Introducing functional programming
Computers and modelling
What is a function?
Pictures and functions
Types
The Haskell programming language
Expressions and evaluation
Definitions
Function definitions
Types and functional programming
Calculation and evaluation
The essence of Haskell programming
Domain-specific languages
Two models of Pictures
Tests, properties and proofs
Getting started with Haskell and GHCi
A first Haskell program
Using Haskell in practice
Using GHCi
The standard prelude and the Haskell libraries
Modules
A second example: pictures
Errors and error messages
Basic types and definitions
The Booleans: Bool
The integers: Integer and Int
Overloading
Guards
Characters and strings
Floating-point numbers: Float
Syntax
Designing and writing programs
Where do I start? Designing a program in Haskell
Solving a problem in steps: local definitions
Defining types for ourselves: enumerated types
Recursion
Primitive recursion in practice
Extended exercise: pictures
General forms of recursion
Program testing
Data types, tuples and lists
Introducing tuples and lists
Tuple types
Introducing algebraic types
Our approach to lists
Lists in Haskell
List comprehensions
A library database
Programming with lists
Generic functions: polymorphism
Haskell list functions in the Prelude
Finding your way around the Haskell libraries
The Picture example: implementation
Extended exercise: alternative implementations of pictures
Extended exercise: positioned pictures
Extended exercise: supermarket billing
Extended exercise: cards and card games
Defining functions over lists
Pattern matching revisited
Lists and list patterns
Primitive recursion over lists
Finding primitive recursive definitions
General recursions over lists
Example: text processing
Playing the game: I/O in Haskell
Rock - Paper - Scissors: strategies
Why is I/O an issue?
The basics of input/output
The do notation
Loops and recursion
Rock - Paper - Scissors: playing the game
Reasoning about programs
Understanding definitions
Testing and proof
Definedness, termination and finiteness
A little logic
Induction
Further examples of proofs by induction
Generalizing the proof goal
Generalization: patterns of computation
Patterns of computation over lists
Higher-order functions: functions as arguments
Folding and primitive recursion
Generalizing: splitting up lists
Case studies revisited
Higher-order functions
Operators: function composition and application
Expressions for functions: lambda abstractions
Partial application
Under the hood: curried functions
Defining higher-order functions
Verification and general functions
Developing higher-order programs
Revisiting the Picture example
Functions as data: strategy combinators
Functions as data: recognizing regular expressions
Case studies: functions as data
Example: creating an index
Development in practice
Understanding programs
Overloading, type classes and type checking
Why overloading?
Introducing classes
Signatures and instances
A tour of the built-in Haskell classes
Type checking and type inference: an overview
Monomorphic type checking
Polymorphic type checking
Type checking and classes
Algebraic types
Algebraic type definitions revisited
Recursive algebraic types
Polymorphic algebraic types
Modelling program errors
Design with algebraic data types
Algebraic types and type classes
Reasoning about algebraic types
Case study: Huffman codes
Modules in Haskell
Modular design
Coding and decoding
Implementation - I
Building Huffman trees
Design
Implementation - II
Abstract data types
Type representations
The Haskell abstract data type mechanism
Queues
Design
Simulation
Implementing the simulation
Search trees
Sets
Relations and graphs
Commentary
Lazy programming
Lazy evaluation
Calculation rules and lazy evaluation
List comprehensions revisited
Data-directed programming
Case study: parsing expressions
Infinite lists
Why infinite lists?
Case study: simulation
Proof revisited
Programming with monads
I/O programming
Further I/O
The calculator
The do notation revisited
Monads: languages for functional programming
Example: monadic computation over trees
Domain-specific languages
Programming languages everywhere
Why DSLs in Haskell?
Shallow and deep embeddings
A DSL for regular expressions
Monadic DSLs
DSLs for computation: generating data in QuickCheck
Taking it further
Time and space behaviour
Complexity of functions
The complexity of calculations
Implementations of sets
Space behaviour
Folding revisited
Avoiding recomputation: memoization
Conclusion
Appendices
Functional, imperative and OO programming
Glossary
Haskell operators
Haskell practicalities
GHCi errors
Project ideas
Bibliography

×
Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.

×