Algorithm design with Haskell is sectioned into six major parts, covering a multitude of topics and algorithms. There are too many individual topics to highlight in this review; however, as a programming lecturer, these few were of particular interest to me: timing, sorting, graphs, searching, and recursion.
The authors have chosen to use the Haskell programming language to demonstrate the various algorithms. The Haskell wiki defines the language:
Haskell is an advanced purely-functional programming language. In particular, it is a polymorphically statically typed, lazy, purely functional language, quite different from most other programming languages. 
This is a very important point for anyone wishing to read this work, as the language is central to the concepts discussed. Therefore, the book in not for the layperson; it is tailored for university students, academics, and professional programmers with advanced skills and knowledge of Haskell or functional languages.
The book covers problems that are outside of standard imperative programming, for example, the problem of managing the currency levels in two bank accounts. The rules associated with the transactions between the accounts form the problem, which the book solves by finding the shortest partition of a list of positive and negative integers into a list of safe segments.
The book’s complexity and its coverage of advanced algorithms can be overwhelming. The preface explains that this book is the companion to an earlier work, Thinking functionally with Haskell . This earlier publication should be read before attempting to understand Algorithm design with Haskell. While I am not an expert in functional languages, I was able to enjoy reading selected chapters and gaining an understanding of the various algorithms. I found the topics flowed easily, although highly technical, and there are both new and well-known algorithms. Of particular importance are the included exercises and related answers, which offer practical opportunities to use the language within the context of the topics. I can envisage this book as a valuable text within higher education, because the objective was not to teach the language but to use Haskell to explore well-established programming principles like greedy algorithms, divide and conquer, and thinning.
Both authors are interested in computer programming languages and have academic experience, which is reflected in the writing style of a textbook. While this is a valuable resource within the field of functional programming, I would suggest the readership is limited to professional programmers and students studying functional languages.