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.

RWH is a solid book that gives the read a good idea of how Haskell works and why its unique. The book has its fault, largely because its a first draft that tries to cover a LOT of material. Don Stewart however has actively tried to aid in any deficiencies found by fixing errors on the web-version of this book so I'm not bothered by errors or things left out in the book.

The biggest complaint people have is that it tends to introduce concepts without really ever mentioning why something is being done. On one hand I agree with that assessment, however I also think that the book was marketed somewhat improperly. I would not call this book a good book for a beginner or your average intermediate programmer. At the very least I would say this book is better suited for experienced programmers or intermediate programmers with a passion for learning about languages.

That said, of the Functional Programming books I own, this is one of the best and most practical. It does not require a doctorate in Denotational Semantics to understand and it does not burn the first half of the book on typed/untyped lambda calculi (not that these things aren't important).

In short, if you want to get down to business working with a functional language, you have some experience with programming and are comfortable with a few errors then this book is for you.

I picked up Real World Haskell for the purpose of learning functional programming. I have had experience with Lisp before but was never able to get particularly far off the ground with it. I decided I wanted to revisit this area of computing and since I had played around with a bit of Haskell already and had some friends who recommended it I chose this language as my foundation.

This book is definitely not a book for beginners. It jumps right into the "why" of using Haskell and glosses over a lot of the "how" to do things. The book is exceptionally good at its goal, though, and I found it very useful to further my understanding of Haskell. I would definitely recommend having experience with functional programming before reading, and it's even better to have some introductory knowledge of the Haskell syntax when jumping into this book. It was also very handy to have syntax and function cheat sheets next to me for things I hadn't learned yet.

I would recommend this book to anyone serious about learning Haskell or becoming better at functional programming. The authors do an excellent job of conveying why Haskell does things in certain ways, which leads to a better understanding of the language.

Real World Haskell is the first Haskell introduction I've read that actually helped me understand why anyone would want to use the language. The focus on programming methods instead of just syntax made it much easier to think of practical applications for the language.

Useful features of the book:
- Some haskell constructs were explained similar constructs in other languages (C, Java, and Python).
- Great excercises throughout each chapter. The only downside is that if you don't stop to do the excercises when they appear, you're sure to see a simpler method and miss what should have been learned from the excercise.
- Long code examples were displayed with explanatory prose between lines of code.

Could have been better:
- There were at least three times I spent a few minutes staring at a paragraph or code sample that didn't seem to make sense, only to find that a typo had changed the meaning. Nothing major and I probably wouldn't have seen most of them if I were more comfortable with Haskell.
- The introduction to functional programming covered a lot of material very quickly. I know this is just a book on a specific functional language, but I got lost frequently here. Not sure how I would make that better.

Learning Haskell is an intriguing exercise. Foundational concepts--syntax, monads, byzantine compiler error messages and various bits of jargon--are as puzzling and subtle as they are legion. Resources are scattered through various papers, books, and tutorials, and despite the wide efforts of volunteers in the Haskell community to consolidate introductory information, the Haskell community has always needed a practical, hands on, go-to tutorial-oriented book. In this, the authors delivered.

Although the book can be digested a la carte, as a set of unrelated, specialized tutorials, the authors also take care to use syntax, idioms, and library functions only once they have been clearly introduced, and to build upon these concepts, making it a pleasant read straight through---a difficult feat in a language rife with many foreign yet intertwined foundational concepts (at least, foreign to even the typical smart program of imperative background).

Many chapter titles in the book sound like they would focus on a narrow topic that may not be of interest to the general aspiring Haskell programmer, such as:

Chapter 5. Writing a Library: Working with JSON Data
Chapter 8. Efficient File Processing, Regular Expressions, and Filename Matching
Chapter 10. Code Case Study: Parsing a Binary Data Format
Chapter 12. Barcode Recognition
Chapter 22. Extended Example: Web Client Programming
Chapter 26. Advanced Library Design: Building a Bloom Filter

In fact, I found that these chapters flowed gracefully with the overall narrative of the book. Typically compelling, and full of carefully grown and expanded examples of appropriate length, they reinforced prior principles and practices, interjecting nuggets of generally useful advice, such as:

"If you find yourself proudly thinking that a particular piece of code is fiendishly clever, stop and consider whether you'll be able to understand it again after you've stepped away from it for a month."
(p.232)

The well explained examples grow organically like real code out in the wild---not just born, fully formed from some genius professor's head. Code is refactored, features are added, style improved.

The book seems to target multiple levels of Haskell programmer. I would consider myself somewhere in the intermediate Haskell programmer range but am constantly impressed at the useful pointers and subtle approaches I seemed to have missed along my own Haskell learning journey, for example library functions I should have known about years ago but never managed to run into in the wild. The authors' consistent use of ghci for prototyping, debugging, and API lookup reminds Haskell programmers of all stripes to use the powerful tools provided by GHC.

Deeper concepts are often injected throughout the stream of tutorial and not skipped over entirely; they are either reserved for later in the book, or are at least given an appropriate footnote or reference, such as this deep gem in the beginning of the book (Chapter 2: Types and Functions):

"There is a deep mathematical sense in which any non-pathological [pure] function of type (a,b) -> a must do exactly what fst does. Moreover, this line of reasoning extends to more complicated polymorphic functions. The paper [Theorems for Free, Wadler89] covers this procedure in depth."

I would expect the depth of this to be missed by all but the most mathematically minded of novice Haskell programmers, but it's great to see that even in a tutorial oriented, practical book, the authors still manage to plumb some of the depths of Haskell's beautiful theoretical core.

Other sticky concepts, for example, Overlapping Instances and other pragmatic type-fu, are explained from a practical point of view without dwelling unnecessarily on their weirdness or asymmetry: the goal is clearly to get work done.

Despite the fact that the text is available online, it's great to have a copy of this book in hand, to bookmark and highlight its 600+ pages. I just finished it once through and I'm already relishing reading and referencing it again and again.