The good news is, this is probably the best Haskell book yet. The bad news is, it's still a frustratingly confusing jumble. It starts out well, introducing expressions, type inference, recursion, pattern matching, algebraic types, and higher order functions, with an emphasis on maps and folds (the way real world Haskell code is actually written), and it contains exercises that range from simple to challenging. The first four chapters alone are worth the price.
Unfortunately, the problems start in chapter 5, and rarely let up. It starts by introducing a datatype for JSON data for the purpose of pretty-printing it. The way the pretty-printer is rolled out is confusing -- it constantly jumps between code snippets that won't even compile, because a type they depend on is not defined til nearly the end of the chapter. And while it stays away from excessive cleverness, function names are confusingly named. In fact the entire nature of the pretty-printer revolves around a "Doc" abstraction that is never clearly explained or rationalized.
Later chapters are also rich with useful information, such as explanations of various GHC language extensions to the type system (which are really de facto standard Haskell nowadays). Unfortunately (there are many "unfortunatelys" to use in this review) I would never have been able to follow these explanations had I not already known a little about them -- unlike the rest of the examples in the book, the examples stop being "real-world" and instead devolve into meaningless metasyntax like "Foo" and "Bar".
By the time monads are finally introduced (late, but rightly so -- I consider this delay in introducing them to be a plus), the reader has had to suffer through some very tedious projects, such as parsing an obscure binary format. The book really begins to redeem itself again here, and makes monads clear as a datatype that captures common concepts of encapsulating and sequencing, and completely avoids cutesy visual analogies (no spacesuits or toxic waste here!).
I've not finished the book (I'm still in Chapter 14) but I am eagerly looking forward to its later chapters introducing monad transformers, parallel programming, and software transactional memory. You get a lot of book for the price, but you'll need the support of the always-friendly haskell community on IRC or email to make the most of this tome, or even make any sense of several parts of it.