Haskell Design Patterns

FIRST: This book has A LOT of syntax errors and errors that should have caught with very light editing. Embarrassingly simple and numerous errors.That said, if you already know Haskell, you will spot the errors right away and will not be confused. Beyond that, if you are in the process of moving to the intermediate level of Haskell, this book will give some of the information you need to move from beginner to intermediate.

I love this book; it is concise, interesting, insightful, and well written. Lots of food for thought in this book, regardless whether you use Haskell or not.It also provides a behind-the-scenes look at the evolution of Haskell as a language that is very worthwhile, fair, balanced, and objective.Judicious use of quotes is tastefully interjected, which helps to frame the discussion.The book eloquently ends with a quote (from "History of Haskell") which I will summarize in my own words as a conjecture about a day when Haskell will become a distant memory, but when that day comes it will live on in the genes of other technologies which it influenced.Well said!What a gem of a book. I'm glad I didn't miss it.

TL;DR: This is a terrible Haskell book, and a terrible book full stop. Don't waste your money.This book contains numerous grammar and spelling errors, to the point where I am convinced that it has not been edited at all. Some of the examples don't even parse. Others are nonsensical and could not possibly do what the author claims that they do. I am convinced that this book has not had any technical review whatsoever. The author makes basic mistakes like claiming that (a function equivalent to) `foldl` operates in constant space, which is a property of `foldl'` and requires strictness annotations. There isn't a single section of this book without inexcusable grammar, spelling, and technical errors.

The author teaches readers how to use Haskell Although you will not learn the Gang of Four design patterns, readers will benefit from learning functional programming with Haskell. FYI any reader must note that the book mainly uses the GHC compiler.I enjoyed the authors explanation of Recursion, pattern matching, and polymorphism.

I'm blown away by the things I'm learning, and the great way that concepts are explained. Examples: Currying and Tail Recursion. I thought I knew all there was to about currying - I learned it in my CS undergrad after all. But oh, it's totally possible to write functions in an uncurried style by wrapping the parameters in a tuple. That never occurred to me. And then the follow-up with advantages and disadvantages of that with a note about what's idiomatic. Perfect. The book doesn't insult the intelligence of the reader, who's most likely been doing development in other languages.And Tail Recursion --- I didn't quite remember how it works, and sort of had been ignoring this as an 'implementation detail' of programming libraries. But here the explanation and unrolled call stack make it plain of day what's happening, and what the difference is.Lol, two years in to Haskell development, I consider myself to be just an "advanced beginner".

This book starts with Haskell 98 and through the lens of patterns and idioms investigates the key advances and programming styles that together make "modern Haskell". Your journey begins with the three pillars of Haskell. Then you'll experience the problem with Lazy I/O, together with a solution. You'll also trace the hierarchy formed by Functor, Applicative, Arrow, and Monad. Next you'll explore how Fold and Map are generalized by Foldable and Traversable, which in turn is unified in a broader context by functional Lenses. You'll delve more deeply into the Type system, which will prepare you for an overview of Generic programming. In conclusion you go to the edge of Haskell by investigating the Kind system and how this relates to Dependently-typed programming.

Was helpful learning the design patterns, which is what it's title says it covers. The examples are clear enough to grasp the pattern. If you're new to Haskell, you may want to take it slowly to verify the programs. Functional programming requires a different approach, and this book helped enlighten me.

I enjoyed reading over this book, Haskell Design Patterns helps approach real world situations that you will experience at one time or another as a programmer. Recursion was covered nicely, my favorite functions are the I/O functions which are covered in Chapter 2.

So far the content has been very interesting, however there are inexcusable code formatting errors and erratic words left in, from presumably an earlier edit.This is such a shame as I was very excited about this book and paying over £20 for this book I expect it to have been better proofread.