Browse Books

Reviewer: Mirjana K. Ivanovic´

Many books on data structures assume imperative languages. This book is important because it presents data structures from the point of view of functional languages. The intended purposes of the book are threefold: it is a handy reference for professional functional programers, it can be used as a tutorial, and a wide range of computer science readers can use it for self-study. Unfortunately, the book is not appropriate for novices in programming and data structures. Some basic knowledge of abstract data types, such as stacks, queues, heaps, and finite maps, and of algorithm analysis is required. Okasaki presents many data structures, algorithms, and techniques using two important functional languages: Standard ML and Haskell. The book includes both classical data structures, such as red-black trees and binomial queues, and many new data structures developed exclusively for functional languages. Most of the programs can easily be adapted to other functional languages. Even C and Java programmers should find implementing these data structures a relatively straightforward process, although C's lack of automatic garbage collection can sometimes prove painful. The book is structured in three parts and consists of 11 chapters, an appendix, a list of references, and an index. The first chapter is an introduction and presents terminology that will be used in the rest of the book. The first part contains chapter 2, “Persistence,” and chapter 3, “Some Familiar Data Structures in a Functional Setting.” It introduces functional data structures and describes how they achieve persistence. The author then examines three well-known data structures—leftist heaps, binomial heaps, and red-black trees—and their implementation in Standard ML. The second part consists of four chapters: “Lazy Evaluation,” “Fundamentals of Amortization,” “Amortization and Persistence via Lazy Evaluation,” and “Eliminating Amortization.” These chapters are concerned with the relationship between lazy evaluation and amortization. The third part of the book contains chapters 8 through 11: “Lazy Rebuilding,” “Numerical Representations,” “Data-Structural Bootstrapping,” and “Implicit Recursive Slowdown.” It explores a handful of general techniques for designing functional data structures. This interesting new material is the most significant part of the book. The book is concise, and material is presented systematically. For readers without adequate preparation, it is rather difficult to follow and will require careful concentration. Depending on the reader's background, this approach can be either an advantage or a disadvantage. An appendix includes Haskell translations of the code presented in the text. The bibliography lists more than 120 closely related references. Every chapter ends with notes, giving pointers to additional literature on some important and interesting terms and notions presented in the chapter. The data structures, algorithms, and techniques presented are illustrated by many implemented examples, so programmers can develop their own functional data structures. Programs are physically well structured and readable, and are displayed in boxes. Okasaki has produced a valuable book about functional programming, exploring a wide range of data structures. Since there are not many books concerning these topics, the book is a significant contribution to the computer science literature. Everyone whose fields of interest are programming languages, data structures and algorithms, and especially declarative programming languages must have this book. It is also good additional material for computer science students.