--- product_id: 10340706 title: "Thinking Functionally with Haskell" price: "SAR 223" currency: SAR in_stock: true reviews_count: 11 url: https://www.desertcart.com.sa/products/10340706-thinking-functionally-with-haskell store_origin: SA region: Saudi Arabia --- # Thinking Functionally with Haskell **Price:** SAR 223 **Availability:** ✅ In Stock ## Quick Answers - **What is this?** Thinking Functionally with Haskell - **How much does it cost?** SAR 223 with free shipping - **Is it available?** Yes, in stock and ready to ship - **Where can I buy it?** [www.desertcart.com.sa](https://www.desertcart.com.sa/products/10340706-thinking-functionally-with-haskell) ## Best For - Customers looking for quality international products ## Why This Product - Free international shipping included - Worldwide delivery with tracking - 15-day hassle-free returns ## Description Thinking Functionally with Haskell [Bird, Richard] on desertcart.com. *FREE* shipping on qualifying offers. Thinking Functionally with Haskell Review: equational reasoning: realizing the dream of algebraic-like manipulation of code - This book is an important landmark in the evolution of Haskell and functional programming. When we speak of “functional” programming, we’re talking about mutation free computation: you can create all the new state you want; but you can’t mutate any existing state. This has a number of advantages that don’t fall on deaf ears these days: one is that mutation free computations are automagically thread safe; which is music to the ears of anyone that’s had to grapple with threading, concurrency, or parallel programming issues. However, another (perhaps more important consideration) is that when we don’t have mutation to worry about, we are free to do substitutions, and manipulate functions (a.k.a. “code”) in algebraic-like ways; and that is the focus of this book. Richard Bird is one of the pioneers of using equational reasoning to refactor existing code and to prove that one code expression is equivalent (or not equivalent) to a different code expression (wherein we are perhaps interested in reliability or improving performance without sacrificing semantic meaning). Or, to prove what a code expression really means; and to thereby be able to generalize it or otherwise reason about it. If you are new to seeing code manipulated in algebraic-like ways, it can seem like black magic until one gets acclimated to thinking about code in a purely functional way; and Haskell, as a programming language, is uniquely suited to that task. This book claims to be a replacement for other works, but it does not cover some material that was covered in past books which I consider very worthwhile. In the way of disclosure I want to mention that I read this book cover to cover (including the index); but did not do any of the exercises (other than to read through them). I also read the following cover to cover: “Introduction to Functional Programming using Haskell second edition” (Bird) and “Algebra of Programming” (Bird, De Moor); both of which I thought were outstanding. One criticism I have of this book is that in the last chapter’s concluding remarks, a pure functional style is recommended over monadic programming (especially when there is no concern about interacting with the outside world). That left me wanting more elaboration: there are many uses of monads; one being to “lift” partial functions to more sophisticated total counterparts (i.e. Maybe). Is there a “purely” functional equivalent for such purposes that is preferable to monads; or is that use of monads perfectly reasonable? (I presume the latter, but would have liked more discussion on the matter.) Also I would have liked to see more examples of how monadic programming can cause difficulties for equational reasoning that can be removed by refactoring to a more purely functional style. A past book did grapple with some negative aspects of monads (like the way they can cause problems when trying to compose them and enforce a coherent order in how things get evaluated). More material on the “sin bin” nature of monads and their potential overuse would be nice. Another comment: I missed the material on bignums; albeit I think the approach taken in a prior publication was flawed because it didn’t “normalize” numbers from least significant (in head position) to most significant (which makes everything much harder, IMO). I hope to see a sequel to this book as the author’s understanding (and the topic itself) evolve. Review: Book - Great ## Technical Specifications | Specification | Value | |---------------|-------| | Best Sellers Rank | #1,371,154 in Books ( See Top 100 in Books ) #86 in Functional Software Programming #2,907 in Software Design, Testing & Engineering (Books) #3,076 in Programming Languages (Books) | | Customer Reviews | 4.7 4.7 out of 5 stars (52) | | Dimensions | 6.69 x 0.81 x 9.61 inches | | Edition | 1st | | ISBN-10 | 1107452643 | | ISBN-13 | 978-1107452640 | | Item Weight | 1.42 pounds | | Language | English | | Print length | 358 pages | | Publication date | October 9, 2014 | | Publisher | Cambridge University Press | ## Images ![Thinking Functionally with Haskell - Image 1](https://m.media-amazon.com/images/I/71AtAdtjH5L.jpg) ## Customer Reviews ### ⭐⭐⭐⭐⭐ equational reasoning: realizing the dream of algebraic-like manipulation of code *by A***K on February 17, 2015* This book is an important landmark in the evolution of Haskell and functional programming. When we speak of “functional” programming, we’re talking about mutation free computation: you can create all the new state you want; but you can’t mutate any existing state. This has a number of advantages that don’t fall on deaf ears these days: one is that mutation free computations are automagically thread safe; which is music to the ears of anyone that’s had to grapple with threading, concurrency, or parallel programming issues. However, another (perhaps more important consideration) is that when we don’t have mutation to worry about, we are free to do substitutions, and manipulate functions (a.k.a. “code”) in algebraic-like ways; and that is the focus of this book. Richard Bird is one of the pioneers of using equational reasoning to refactor existing code and to prove that one code expression is equivalent (or not equivalent) to a different code expression (wherein we are perhaps interested in reliability or improving performance without sacrificing semantic meaning). Or, to prove what a code expression really means; and to thereby be able to generalize it or otherwise reason about it. If you are new to seeing code manipulated in algebraic-like ways, it can seem like black magic until one gets acclimated to thinking about code in a purely functional way; and Haskell, as a programming language, is uniquely suited to that task. This book claims to be a replacement for other works, but it does not cover some material that was covered in past books which I consider very worthwhile. In the way of disclosure I want to mention that I read this book cover to cover (including the index); but did not do any of the exercises (other than to read through them). I also read the following cover to cover: “Introduction to Functional Programming using Haskell second edition” (Bird) and “Algebra of Programming” (Bird, De Moor); both of which I thought were outstanding. One criticism I have of this book is that in the last chapter’s concluding remarks, a pure functional style is recommended over monadic programming (especially when there is no concern about interacting with the outside world). That left me wanting more elaboration: there are many uses of monads; one being to “lift” partial functions to more sophisticated total counterparts (i.e. Maybe). Is there a “purely” functional equivalent for such purposes that is preferable to monads; or is that use of monads perfectly reasonable? (I presume the latter, but would have liked more discussion on the matter.) Also I would have liked to see more examples of how monadic programming can cause difficulties for equational reasoning that can be removed by refactoring to a more purely functional style. A past book did grapple with some negative aspects of monads (like the way they can cause problems when trying to compose them and enforce a coherent order in how things get evaluated). More material on the “sin bin” nature of monads and their potential overuse would be nice. Another comment: I missed the material on bignums; albeit I think the approach taken in a prior publication was flawed because it didn’t “normalize” numbers from least significant (in head position) to most significant (which makes everything much harder, IMO). I hope to see a sequel to this book as the author’s understanding (and the topic itself) evolve. ### ⭐⭐⭐⭐⭐ Book *by P***O on January 8, 2026* Great ### ⭐⭐⭐⭐⭐ Great! Nice to read! *by M***O on April 1, 2019* I really enjoyed the reading! I am reading again and redoing the exercises. ## Frequently Bought Together - Thinking Functionally with Haskell - Algorithm Design with Haskell - Programming in Haskell --- ## Why Shop on Desertcart? - 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016 - 🌍 **Shop Globally** — Access 737+ million products across 21 categories - 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price - 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members) - 🔒 **Secure Payments** — Trusted payment options with buyer protection - ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews **Shop now:** [https://www.desertcart.com.sa/products/10340706-thinking-functionally-with-haskell](https://www.desertcart.com.sa/products/10340706-thinking-functionally-with-haskell) --- *Product available on Desertcart Saudi Arabia* *Store origin: SA* *Last updated: 2026-04-24*