On the type structure of standard ML

Reviewer: Pierre Weis

A framework for a formal description of the type checking and semantics of the core of the Standard ML purely functional language and its module system is presented in this research paper. The formalism is based on an explicitly typed second-order &lgr;-calculus, named XML, which is predicative since types and type schemes are clearly separated into two distinct universes. The type reconstruction algorithm of ML is then considered as a mere translation from implicitly typed terms in ML to explicitly typed XML expressions. Given the semantics of XML, the semantics of ML programs are simply obtained from the semantics of the corresponding XML expressions. Since XML includes general sums and products, ML modules can be expressed by XML expressions: structures and signatures map to general sums, and functors map to general products. Having precisely defined the XML language and the mapping from ML to XML, the authors are able to analyze the implications of extending ML by removing the distinction between monotypes and polytypes (to treat modules as ordinary ML values). They prove that removing this universe distinction while keeping strong sums and general products in the language implies the existence of a type of all types, which implies an undecidable type checking problem and the existence of programs without explicit recursion that do not terminate. The overall idea that implicitly typed ML programs can be considered shorthand for explicitly typed &lgr;-terms has been folklore in the ML community. The authors state this idea precisely for the purely applicative core of ML. Unfortunately, they give up nontrivial features of the ML core language, namely recursiveness, side effects, and exception handling. With these features omitted, ML programs are strongly normalizing, and call-by-value and call-by-name semantics coincide, escaping from the difficulties of the translation from ML polymorphism to second-order &lgr;-terms. Unfortunately, the extension of the formalism to the full ML core language is far from evident, and the paper does not hint at how to do so. Furthermore, the “strong sums” approach used here to modelize the ML module system has not been entirely successful, and other approaches have been proposed (see Leroy [1] or Harper and Lillibridge [2]). This paper presents a nice piece of theory that formalizes the relationship between implicitly typed ML programs and their explicitly typed counterparts. The formalism is powerful enough to take into account the module system (excluding sharing specifications), and it provides a uniform framework to express the semantics of ML. The extension of the formalism to the full ML language would confirm the adequacy of the approach, but this work remains to be done.