Real World Haskell

Larger Cover

Real World Haskell

Code You Can Believe In

By Bryan O'Sullivan, John Goerzen, Donald Bruce Stewart

Publisher: O'Reilly Media

Released: November 2008

Pages: 720

Chapter 1 Getting Started
1. Your Haskell Environment
2. Getting Started with ghci, the Interpreter
3. Basic Interaction: Using ghci as a Calculator
4. Command-Line Editing in ghci
5. Lists
6. Strings and Characters
7. First Steps with Types
8. A Simple Program
Chapter 2 Types and Functions
1. Why Care About Types?
2. Haskell’s Type System
3. What to Expect from the Type System
4. Some Common Basic Types
5. Function Application
6. Useful Composite Data Types: Lists and Tuples
7. Functions over Lists and Tuples
8. Function Types and Purity
9. Haskell Source Files, and Writing Simple Functions
10. Understanding Evaluation by Example
11. Polymorphism in Haskell
12. The Type of a Function of More Than One Argument
13. Why the Fuss over Purity?
14. Conclusion
Chapter 3 Defining Types, Streamlining Functions
1. Defining a New Data Type
2. Type Synonyms
3. Algebraic Data Types
4. Pattern Matching
5. Record Syntax
6. Parameterized Types
7. Recursive Types
8. Reporting Errors
9. Introducing Local Variables
10. The Offside Rule and Whitespace in an Expression
11. The case Expression
12. Common Beginner Mistakes with Patterns
13. Conditional Evaluation with Guards
Chapter 4 Functional Programming
1. Thinking in Haskell
2. A Simple Command-Line Framework
3. Warming Up: Portably Splitting Lines of Text
4. Infix Functions
5. Working with Lists
6. How to Think About Loops
7. Anonymous (lambda) Functions
8. Partial Function Application and Currying
9. As-patterns
10. Code Reuse Through Composition
11. Tips for Writing Readable Code
12. Space Leaks and Strict Evaluation
Chapter 5 Writing a Library: Working with JSON Data
1. A Whirlwind Tour of JSON
2. Representing JSON Data in Haskell
3. The Anatomy of a Haskell Module
4. Compiling Haskell Source
5. Generating a Haskell Program and Importing Modules
6. Printing JSON Data
7. Type Inference Is a Double-Edged Sword
8. A More General Look at Rendering
9. Developing Haskell Code Without Going Nuts
10. Pretty Printing a String
11. Arrays and Objects, and the Module Header
12. Writing a Module Header
13. Fleshing Out the Pretty-Printing Library
14. Creating a Package
15. Practical Pointers and Further Reading
Chapter 6 Using Typeclasses
1. The Need for Typeclasses
2. What Are Typeclasses?
3. Declaring Typeclass Instances
4. Important Built-in Typeclasses
5. Automatic Derivation
6. Typeclasses at Work: Making JSON Easier to Use
7. Living in an Open World
8. How to Give a Type a New Identity
9. JSON Typeclasses Without Overlapping Instances
10. The Dreaded Monomorphism Restriction
11. Conclusion
Chapter 7 I/O
1. Classic I/O in Haskell
2. Working with Files and Handles
3. Extended Example: Functional I/O and Temporary Files
4. Lazy I/O
5. The IO Monad
6. Is Haskell Really Imperative?
7. Side Effects with Lazy I/O
8. Buffering
9. Reading Command-Line Arguments
10. Environment Variables
Chapter 8 Efficient File Processing, Regular Expressions, and Filename Matching
1. Efficient File Processing
2. Filename Matching
3. Regular Expressions in Haskell
4. More About Regular Expressions
5. Translating a glob Pattern into a Regular Expression
6. An important Aside: Writing Lazy Functions
7. Making Use of Our Pattern Matcher
8. Handling Errors Through API Design
9. Putting Our Code to Work
Chapter 9 I/O Case Study: A Library for Searching the Filesystem
1. The find Command
2. Starting Simple: Recursively Listing a Directory
3. A Naive Finding Function
4. Predicates: From Poverty to Riches, While Remaining Pure
5. Sizing a File Safely
6. A Domain-Specific Language for Predicates
7. Controlling Traversal
8. Density, Readability, and the Learning Process
9. Another Way of Looking at Traversal
10. Useful Coding Guidelines
Chapter 10 Code Case Study: Parsing a Binary Data Format
1. Grayscale Files
2. Parsing a Raw PGM File
3. Getting Rid of Boilerplate Code
4. Implicit State
5. Introducing Functors
6. Writing a Functor Instance for Parse
7. Using Functors for Parsing
8. Rewriting Our PGM Parser
9. Future Directions
Chapter 11 Testing and Quality Assurance
1. QuickCheck: Type-Based Testing
2. Testing Case Study: Specifying a Pretty Printer
3. Measuring Test Coverage with HPC
Chapter 12 Barcode Recognition
1. A Little Bit About Barcodes
2. Introducing Arrays
3. Encoding an EAN-13 Barcode
4. Constraints on Our Decoder
5. Divide and Conquer
6. Turning a Color Image into Something Tractable
7. What Have We Done to Our Image?
8. Finding Matching Digits
9. Life Without Arrays or Hash Tables
10. Turning Digit Soup into an Answer
11. Working with Row Data
12. Pulling It All Together
13. A Few Comments on Development Style
Chapter 13 Data Structures
1. Association Lists
2. Maps
3. Functions Are Data, Too
4. Extended Example: /etc/passwd
5. Extended Example: Numeric Types
6. Taking Advantage of Functions as Data
7. General-Purpose Sequences
Chapter 14 Monads
2. Revisiting Earlier Code Examples
3. Looking for Shared Patterns
4. The Monad Typeclass
5. And Now, a Jargon Moment
6. Using a New Monad: Show Your Work!
7. Mixing Pure and Monadic Code
8. Putting a Few Misconceptions to Rest
9. Building the Logger Monad
10. The Maybe Monad
11. The List Monad
12. Desugaring of do Blocks
13. The State Monad
14. Monads and Functors
15. The Monad Laws and Good Coding Style
Chapter 15 Programming with Monads
1. Golfing Practice: Association Lists
2. Generalized Lifting
3. Looking for Alternatives
4. Adventures in Hiding the Plumbing
5. Separating Interface from Implementation
6. The Reader Monad
7. A Return to Automated Deriving
8. Hiding the IO Monad
Chapter 16 Using Parsec
1. First Steps with Parsec: Simple CSV Parsing
2. The sepBy and endBy Combinators
3. Choices and Errors
4. Extended Example: Full CSV Parser
5. Parsec and MonadPlus
6. Parsing a URL-Encoded Query String
7. Supplanting Regular Expressions for Casual Parsing
8. Parsing Without Variables
9. Applicative Functors for Parsing
10. Applicative Parsing by Example
11. Parsing JSON Data
12. Parsing a HTTP Request
Chapter 17 Interfacing with C: The FFI
1. Foreign Language Bindings: The Basics
2. Regular Expressions for Haskell: A Binding for PCRE
3. Passing String Data Between Haskell and C
4. Matching on Strings
Chapter 18 Monad Transformers
1. Motivation: Boilerplate Avoidance
2. A Simple Monad Transformer Example
3. Common Patterns in Monads and Monad Transformers
4. Stacking Multiple Monad Transformers
5. Moving Down the Stack
6. Understanding Monad Transformers by Building One
7. Transformer Stacking Order Is Important
8. Putting Monads and Monad Transformers into Perspective
Chapter 19 Error Handling
1. Error Handling with Data Types
2. Exceptions
3. Error Handling in Monads
Chapter 20 Systems Programming in Haskell
1. Running External Programs
2. Directory and File Information
3. Program Termination
4. Dates and Times
5. Extended Example: Piping
Chapter 21 Using Databases
1. Overview of HDBC
2. Installing HDBC and Drivers
3. Connecting to Databases
4. Transactions
5. Simple Queries
6. SqlValue
7. Query Parameters
8. Prepared Statements
9. Reading Results
10. Database Metadata
11. Error Handling
Chapter 22 Extended Example: Web Client Programming
1. Basic Types
2. The Database
3. The Parser
4. Downloading
5. Main Program
Chapter 23 GUI Programming with gtk2hs
1. Installing gtk2hs
2. Overview of the GTK+ Stack
3. User Interface Design with Glade
4. Event-Driven Programming
5. Initializing the GUI
6. The Add Podcast Window
7. Long-Running Tasks
8. Using Cabal
Chapter 24 Concurrent and Multicore Programming
1. Defining Concurrency and Parallelism
2. Concurrent Programming with Threads
3. Simple Communication Between Threads
4. The Main Thread and Waiting for Other Threads
5. Communicating over Channels
6. Useful Things to Know About
7. Shared-State Concurrency Is Still Hard
8. Using Multiple Cores with GHC
9. Parallel Programming in Haskell
10. Parallel Strategies and MapReduce
Chapter 25 Profiling and Optimization
1. Profiling Haskell Programs
2. Controlling Evaluation
3. Understanding Core
4. Advanced Techniques: Fusion
Chapter 26 Advanced Library Design: Building a Bloom Filter
1. Introducing the Bloom Filter
2. Use Cases and Package Layout
3. Basic Design
4. The ST Monad
5. Designing an API for Qualified Import
6. Creating a Mutable Bloom Filter
7. The Immutable API
8. Creating a Friendly Interface
9. Creating a Cabal Package
10. Testing with QuickCheck
11. Performance Analysis and Tuning
Chapter 27 Sockets and Syslog
1. Basic Networking
2. Communicating with UDP
3. Communicating with TCP
Chapter 28 Software Transactional Memory
1. The Basics
2. Some Simple Examples
3. STM and Safety
4. Retrying a Transaction
5. Choosing Between Alternatives
6. I/O and STM
7. Communication Between Threads
8. A Concurrent Web Link Checker
9. Practical Aspects of STM

Appendix Installing GHC and Haskell Libraries
1. Installing GHC
2. Installing Haskell Software
Appendix Characters, Strings, and Escaping Rules
1. Writing Character and String Literals
2. International Language Support
3. Escaping Text
Colophon

Title:

Real World Haskell

By:

Bryan O'Sullivan, John Goerzen, Donald Bruce Stewart

Publisher:

O'Reilly Media

Formats:

Print
Ebook
Safari Books Online

Print:

November 2008

Ebook:

November 2008

Pages:

720

Print ISBN:

978-0-596-51498-3

| ISBN 10:

0-596-51498-0

Ebook ISBN:

978-0-596-15692-3

| ISBN 10:

0-596-15692-8

Bryan O'Sullivan

Bryan O'Sullivan is an Irish hacker and writer who likes distributed systems, open source software, and programming languages. He was a member of the initial design team for the Jini network service architecture (subsequently open sourced as Apache River). He has made significant contributions to, and written a book about, the popular Mercurial revision control system. He lives in San Francisco with his wife and sons. Whenever he can, he runs off to climb rocks.

View Bryan O'Sullivan's full profile page.
John Goerzen

John Goerzen is an American hacker and author. He has written a number of real-world Haskell libraries and applications, including the HDBC database interface, the ConfigFile configuration file interface, a podcast downloader, and various other libraries relating to networks, parsing, logging, and POSIX code. John has been a developer for the Debian GNU/Linux operating system project for over 10 years and maintains numerous Haskell libraries and code for Debian. He also served as President of Software in the Public Interest, Inc., the legal parent organization of Debian. John lives in rural Kansas with his wife and son, where he enjoys photography and geocaching.

View John Goerzen's full profile page.
Donald Bruce Stewart

Don Stewart is an Australian hacker based in Portland, Oregon. Don has been involved in a diverse range of Haskell projects, including practical libraries, such as Data.ByteString and Data.Binary, as well as applying the Haskell philosophy to real-world applications including compilers, linkers, text editors, network servers, and systems software. His recent work has focused on optimizing Haskell for high-performance scenarios, using techniques from term rewriting.

View Donald Bruce Stewart's full profile page.

Description

Table of Contents

Product Details

About the Author

Colophon

Recommended for You

Recently Viewed

Erlang Programming

A Concurrent Approach to Software Development

By Francesco Cesarini, Simon Thompson

June 2009

Ebook: $39.99

Print & Ebook: $54.99

Print: $49.99

Free as in Freedom [Paperback]

Richard Stallman's Crusade for Free Software

By Sam Williams

March 2002

Ebook: $17.99

Print & Ebook: $25.25

Print: $22.95

JavaScript: The Definitive Guide, 5th Edition

Activate Your Web Pages

By David Flanagan

August 2006

Ebook: $39.99

Customer Reviews

REVIEW SNAPSHOT®

by PowerReviews

oreilly Real World Haskell

4.5

(based on 2 reviews)

Reviews

Reviewed by 2 customers

Sort by

Displaying reviews 1-2

11/6/2010

4.0

Next edition will probably be great

By JimmyRcom

from Texas

Comments about oreilly Real World Haskell:

I consider myself pretty decent in erlang after over a year now playing with it and I've been programming other languages for years. I had glanced at haskell every now and then, initially reading the first few chapters of this book online. I ordered the book later on but now I'm finding myself constantly going back to the online comments for elaboration, making me read the book online anyway. I don't think a lot of the examples are that great. The "learn you a haskell" tutorial by BONUS seems to have much better examples and was much more accessible for me. This is still a worthwhile read but mostly in combination with the online comments others have made on the site. I only give it 4 because I consider BONUS's online guide much better.

6/2/2009

(9 of 9 customers found this review helpful)

5.0

Good Book for those stepping into the Haskell world

By Jeff Bergman

from Undisclosed

Comments about oreilly Real World Haskell:

Real World Haskell is very ambitious in its scope. It tries to gradually introduce the Haskell way of doing things such that even someone coming from an imperative programming background can follow.

As a consequence some concepts are not formally explained until later in the book, like Monads. Instead the book shows you how to use Haskell's I/O facilities, without an understanding of Monads, first.

For some this approach is probably very practical but I found myself at times wanting the material to be presented in a different order.

However, I am still giving this book 5 stars because of the sheer breadth and quality of the content and examples. And the later chapters really do tie all the concepts together with some non-trivial examples.

The first four chapters and chapter six lay the foundation for the rest of the book. I found that a good understanding of this material was crucial for later chapters, where they combine different features of the language in more complicated ways.

After that I was particularly fond of chapters 10, 13,14, 15, 16, 18, and 26, as these chapters explained some of the more advanced concepts I was interested in like Monads, Parsing, and Functional Data Structures.

Overall, I learned a ton of new things from reading this book

even thought the material is quite challenging in places, and found myself wondering why more people don't use Haskell.

Displaying reviews 1-2

Save a Tree - Go Digital what is this?

Ebook: $39.99

Formats: APK, DAISY, ePub, Mobi, PDF

Print & Ebook: $54.99

Print: $49.99

Safari Books Online - Read now >

Chapter 1 Getting Started

Your Haskell Environment

Getting Started with ghci, the Interpreter

Basic Interaction: Using ghci as a Calculator

Command-Line Editing in ghci

Lists

Strings and Characters

First Steps with Types

A Simple Program

Chapter 2 Types and Functions

Why Care About Types?

Haskell’s Type System

What to Expect from the Type System

Some Common Basic Types

Function Application

Useful Composite Data Types: Lists and Tuples

Functions over Lists and Tuples

Function Types and Purity

Haskell Source Files, and Writing Simple Functions

Understanding Evaluation by Example

Polymorphism in Haskell

The Type of a Function of More Than One Argument

Why the Fuss over Purity?

Conclusion

Chapter 3 Defining Types, Streamlining Functions

Defining a New Data Type

Type Synonyms

Algebraic Data Types

Pattern Matching

Record Syntax

Parameterized Types

Recursive Types

Reporting Errors

Introducing Local Variables

The Offside Rule and Whitespace in an Expression

The case Expression

Common Beginner Mistakes with Patterns

Conditional Evaluation with Guards

Chapter 4 Functional Programming

Thinking in Haskell

A Simple Command-Line Framework

Warming Up: Portably Splitting Lines of Text

Infix Functions

Working with Lists

How to Think About Loops

Anonymous (lambda) Functions

Partial Function Application and Currying

As-patterns

Code Reuse Through Composition

Tips for Writing Readable Code

Space Leaks and Strict Evaluation

Chapter 5 Writing a Library: Working with JSON Data

A Whirlwind Tour of JSON

Representing JSON Data in Haskell

The Anatomy of a Haskell Module

Compiling Haskell Source

Generating a Haskell Program and Importing Modules

Printing JSON Data

Type Inference Is a Double-Edged Sword

A More General Look at Rendering

Developing Haskell Code Without Going Nuts

Pretty Printing a String

Arrays and Objects, and the Module Header

Writing a Module Header

Fleshing Out the Pretty-Printing Library

Creating a Package

Practical Pointers and Further Reading

Chapter 6 Using Typeclasses

The Need for Typeclasses

What Are Typeclasses?

Declaring Typeclass Instances

Important Built-in Typeclasses

Automatic Derivation

Typeclasses at Work: Making JSON Easier to Use

Living in an Open World

How to Give a Type a New Identity

JSON Typeclasses Without Overlapping Instances

The Dreaded Monomorphism Restriction

Conclusion

Chapter 7 I/O