Incremental polymorphic type checking with update

Abstract

We describe a variant of Milner's ML type inference algorithm which can be used to perform incremental type checking of programs with partially unspecified functions (or predicates in Prolog). This supports modification (e.g. for correction) of procedures defined previously and provides for a convenient treatment of top-level mutual recursion including Prolog-style incremental clausal definition.

The system allows us to: define a function of, say, type α→α a, use it in suceeding functions and then modify its definition to a type instance, such as list(β x int) → list(β x int), provided that, in the meantime, it has not been used by other functions at an incompatible instance. Undefined procedures can be treated as having type α (or α → β corresponding to the function λx.fail).

This is useful for the case of languages (like HOPE, Miranda, Haskell and Prolog) which require that all top-level procedures are defined mutually recursively — forward references can then be treated as if defined by λx.fail which is then updated when the proper definition is seen. Such languages generally require either top-level mutually recursive phrases to be textually partitioned or require all procedures to have their type declared before their definition or first use — this is because Milner's type inference for recursive definitions is decidable but too weak and because Mycroft's ML+ generalisation is semantically stronger but undecidable in the absence of advance type declarations.

The algorithm presented here allows mutually recursive functions to be type-checked one-by-one (online) with or without type declarations and always gives a type at least as general as the offline algorithm for recursive definitions in ML (or its strongly-connected dependency component variant used in Miranda). With type declarations preceding all forward references it exhibits the decidable type system in HOPE and Prolog.