Browse Books

Reviewer: Daniel Joseph Dougherty

ML (for meta-language) was developed in the early 1970s as a language in which to express proofs in the formal system Edinburgh LCF. This initial application led to a language that had higher-order functions and a secure type system, but included imperative features and a mechanism to handle exceptions—in other words, to a novel functional programming language appropriate for general applications. The language has evolved in several ways, the most notable extension being a parametrized module system. This mature product has been christened Standard ML, and this book is the official definition of its syntax and semantics. Standard ML is most celebrated for its type system (Milner's extension of some key ideas from typing in combinatory logic). The language is strongly and statically typed, so each program phrase has a unique type that is known before program execution. Furthermore, functions can apply to arguments with a variety of types, and the programmer's code does not indicate the types of expressions. The language achieves these competing benefits by automatically inferring most general polymorphic types for expressions as part of the compile-time analysis of a program. Standard ML's approach to programming in the large, embodied by its module facility (inspired by ideas from the languages HOPE and CLEAR), is as significant as its type system. Roughly speaking, modules comprise named environments, called structures, and mappings between the structures. The key point is that structures are typed, obeying the same discipline as smaller program units; the types of structures, called signatures, are inferred by the type system. Program execution is thus naturally divided into a static type inference phase, viewed as abstract evaluation, and a dynamic phase, in which a concrete value is determined. This division, and the organization of the language into the Core level and the higher Module level, have given the language definition its structure as a text. The main part of the book consists of six sections: a section each on parsing, type inference, and run-time semantics for the Core and for the Modules. Essentially, the text presents the formal development of a mathematical theory: the definition of the legal expressions and the assignment of meanings to these expressions. The specification of the syntax is standard. The specification of the static semantics and the dynamic semantics is in terms of rules of inference for deriving assertions of the form a gainst the background B, the phrase P evaluates to the meaning M. In the static phase M is usually a type, while in the dynamic phase it is usually a value—this uniform treatment reiterates the type-inference-as-abstract-evaluation point of view. This book is not an introduction to Standard ML but, as suggested in the preface, it will be useful as background for readers of expository texts. The preface briefly describes the design philosophy and the origins of ML and the authors' conception of programming language definition. The appendix gives an account of the language's development and records the contributions of the people principally involved. Both are very well written. This definition was preceded by three earlier versions, circulated as technical reports, and reflects a handful of minor changes to these, which are outlined in the Preface. The typography is impeccable, and the index is generous. Standard ML has been an inspiration in the theory and practice of recent programming language design. This book is a model of clarity and rigor; I hope that it will be as influential as the language it defines.