Programming in Haskell

It's hard not to run into Graham Hutton's work when reading about functional programming, so reading a book on Haskell written by him sounded like a good opportunity to learn from a real expert. It turned out to be a good choice - this is definitely the best Haskell book I read so far. The author's deep understanding of functional programming concepts and Haskell shines through the writing on many occasions. He carefully sets up explanations and examples that build one on top of another, and manages to explain some of the thorniest ideas of Haskell (applicatives and monads, I'm looking at you) very clearly; most importantly, the why of things is often explained, along with some important historical background that sheds some light on the design choices made by the language. There's even space in this book for a few extended programming examples and exercises, both of which are very important for a programming book. Some of the exercises come with solutions in an appendix - a truly impressive information density for a ~250 page book. My favorite chapter is Monadic Parsers; parser combinators is a very interesting topic, and I went through several resources that tried to explain it in Haskell. The treatment in this book is much better than anything I read before (it even inspired a blog post to document my understanding). On the flip side, the last two chapters - on automatically proving programs correct, as well as deriving correct programs from definitions - were puzzling. Felt too academic and somewhat out of place in a book teaching a programming language. I suppose that when you write a book, it's your prerogative to include some of the research topics you're excited about and pitch them to a more general audience :-)

As someone else in the reviews said, the pedagogical density of this book is amazing. What I mean by that, in 250 pages it goes from a gentle hand holding of the basics of Haskell and then goes on to treat a number of advanced computer science concepts. My first reading through the book was like a tourist in a new country, I looked at the chapters on Monadic Parsing and Compiler Correctness and thought them curious and interesting but didn't think much. On my second reading of the book, as I was working through another compilers book, I decided to simultaneous write my compiler in Java and Haskell, I was blown away at how powerful a punch the Monadic Parsing chapter packed in it's mere 15 pages. The author has clearly spent much time and effort in putting this book together to make the exposition simple and clear! To give a better analogy, the first time I read this book quickly and it was like visiting a Karate class that I wanted to join. I saw the different types of forms that existed that one could practice and found them interesting. My second time, I actually joined the Karate class and put in some time and effort to practice the forms and the experience was very rewarding. It exercised and strengthened my (brain) muscles in many new ways and taught me things my body (brain) didn't think possible before :-)

A very good intro, but confusing because Haskell itself is confusing to run. It took a while for me to get VS Code working with the GHC compiler. And sorting out getting extensions like hlint and hie to work. And then seeing that I had a 20gig of "stack" files. There is a difference between GHC, the compiler, and GHCi, the interactive interface. To compile, you need a "main" function. None of this is discussed in the book, so I had to do much Googling to get anything to work, even the very first examples. Some more help in the book about the actual environment and tools like stack, cabal, etc. would have been good.

I have bought many Haskell books, never know that what this little operator <*> do is simply helping currying. It solves any mystery about applicative functor. Other books may spend many pages and examples in explaining this but still confusing. That's why this book is thin. Other concepts are equally well explained in this book, but I don't want to spoil them. Not many exercises, but all of them are very helpful and to the point. GHC changes a bit in these years, Haskell platform is abandoned, check out the -? option and Haskell official pages to see how to install and use them. If you are using win7 you might have a little trouble in installing. Upgrade to win10 or switch to linux.

This is the first Haskell book I have read and my very first encounter with the language itself was from reading this book. The author has done an amazing work by his succinct writing that captures the foundations of Haskell through to more advanced components of the language like Functors, Applicatives, and Monads, and more. The exercises are well posed problems and help extend and test your understanding of the materials covered. I'm now reading Programming Haskell from first principles because I want another text that will show me examples of building [large] projects. The skills I picked up from PiH are no doubt showing to be useful as I read PHffp. I am delighted that I am learning Haskell, thanks to beauty of the language and to Graham's superior authorship of this text.

This book is a good introduction to Haskell and functional programming. It is probably most useful to those who have little to no prior knowledge in Haskell and functional programming. That is to say: this is a fairly accessible book. It is very well written and has plenty of practice problems. Almost half of the problems are solved at the end of the book. It is also full of great references for those who want to dive deeper in a particular topic.

I ordered this book in the hope that the code listings in the book would run as is in the Glasgow Haskell Compiler. Two other books on Haskell had code snippets that elicited all sorts of "out of scope" errors which were impossible to interpret and correct leading me to conclude that the code had not been tested against the GHC.. Very frustrating. So far the code has worked and that is a very encouraging sign. Maybe, just maybe, this time it will be possible to learn Haskell in an orderly manner. Here's hoping. Also, the explanations in the book are very clearly written. The author knows whereof he writes and he avoids being "cute" or making "know-it-all" assumptions. That's a great relief.

I don’t normally comment unless something is just beyond terrible and I want to go out of my way and let it be known that it sucks, but I must say I am really satisfied with the book. It’s not cut and dry that you will feel bored reading and it not filled with convoluted explanations and poor examples that don’t work. Nor does it assume previous knowledge like most introductory books to a language do, which makes no sense but hey authors can do what they want. This book is really fair, builds up chapter by chapter and doesn’t have you jumping around the book to understand it. Whatever is relevant to a topic will be displayed with that topic.