David B. MacQueen

Standard ML of New Jersey

The Standard ML of New Jersey compiler has been under development for five years now. We have developed a robust and complete environment for Standard ML that supports the implementation of large software systems and generates efficient code. The compiler has also served as a laboratory for developing novel implementation techniques for a sophisticated type and module system, continuation based code generation, efficient pattern matching, and concurrent programming features.

Modules for standard ML

The functional programming language ML has been undergoing a thorough redesign during the past year, and the module facility described here has been proposed as part of the revised language, now called Standard ML. The design has three main goals: (1) to facilitate the structuring of large ML programs; (2) to support separate compilation and generic library units; and (3) to employ new ideas in the semantics of data types to extend the power of MLs polymorphic type system. It is based on concepts inherent in the structure of ML, primarily the notions of a declaration, its type signature, and the environment that it denotes.

A standard ML compiler

Standard ML is a major revision of earlier dialects of the functional language ML. We describe the first compiler written for Standard ML in Standard ML. The compiler incorporates a number of novel features and techniques, and is probably the largest system written to date in Standard ML.

Typing first-class continuations in ML

Abstract : First-class continuations are a powerful tool for implementing sophisticated control constructs like co-routines, processes, backtracking, and asynchronous signals. Until now they have been studied and employed in the context of dynamically type languages like Scheme. We have been pleasantly surprised to discover that first-class continuations can also be accommodated in a polymorphically typed language like ML simply by adding a new primitive type with a couple of associated operations. In fact, the added discipline of the ML type and verifying the metaproperties of soundness and observational soundness, but it is clear that extensive work is required to integrate continuations fully into the definition of Standard ML.

A semantic model of types for applicative languages

If integer constants are added to the syntax of the pure lambda calculus, then primitive integer values have to be added to the underlying domain V of values. Unlike functions, primitive values should not be applied; we want a run-time error to occur if an attempt is made to apply them as functions. Expressions that might lead to run-time errors are separated out by imposing a “type” structure on expressions. A systematic model of types is developed, in which types are formalized as “ideals” (sets with a certain structure). Polymorphic functions are handled by introducing a quantifier for taking conjunctions of types. Operations for constructing new types from old lead to the consideration of higher-order or meta types, which are called “kinds” to avoid confusion with types. Finally, the semantic model of types is applied to show the soundness of a proof system for inferring the types of expressions.

A Semantics for Higher-Order Functors

Standard ML has a module system that allows one to define parametric modules, called functors. Functors are “first-order,” meaning that functors themselves cannot be passed as parameters or returned as results of functor applications. This paper presents a semantics for a higher-order module system which generalizes the module system of Standard ML. The higher-order functors described here are implemented in the current version of Standard ML of New Jersey and have proved useful in programming practice.

Separate compilation for Standard ML

Languages that support abstraction and modular structure, such as Standard ML, Modula, Ada, and (more or less) C++, may have deeply nested dependency hierarchies among source files. In ML the problem is particularly severe because MLs powerful parameterized module (functor) facility entails dependencies among implementation modules, not just among interfaces. To efficiently compile individual modules in such languages, it is useful (in ML, necessary) to infer, digest, and cache the static environment resulting from the compilation of each module. Our system provides a simple model of compilation and linkage that supports incremental recompilation (a restricted form of separate compilation) with type-safe linkage. This model is made available to user programs in the form of a set of internal compiler modules, a feature that we call the “visible compiler”. The chief client of this interface is the IRM incremental recompilation manager from CMU.

Completeness of Proof Systems for Equational Specifications

Contrary to popular belief, equational logic with induction is not complete for initial models of equational specifications. Indeed, under some regimes (the Clear specification language and most other algebraic specification languages) no proof system exists which is complete even with respect to ground equations. A collection of known results is presented along with some new observations.

An implementation of standard ML modules

Standard ML includes a set of module constructs that support programming in the large. These constructs extend MLs basic polymorphic type system by introducing the dependent types of Martin Löfs Intuitionistic Type Theory. This paper discusses the problems involved in implementing Standard MLs modules and describes a practical, efficient solution to these problems. The representations and algorithms of this implementation were inspired by a detailed formal semantics of Standard ML developed by Milner, Tofte, and Harper. The implementation is part of a new Standard ML compiler that is written in Standard ML using the module system.

Persistence and type abstraction

Abstract types are a familiar and effective way of structuring programs. The basic idea of information hiding must, however, be reconciled with the need to store data for long periods of time and make it accessible to different activities. In particular, this requires that a type checker be able to recognize occurrences of the same abstract type during different activations of a program, while at the same time enforcing the privacy of data representations.