Sound and complete elimination of singleton kinds

Reviewer: R. Clayton

Pushing high-level information down to lower-level program representations enables manipulations such as link-time code improvement and runtime security analysis. However, high-level information carries costs not usually found at lower levels, potentially making manipulations expensive. Kinds can be thought of as types for types; singleton kinds are useful for identifying types that can be considered equivalent, a determination useful for languages with type-exporting modules. However, lower-level language representations usually don't deal with higher-order information such as kinds. This paper describes and proves a technique for translating kinds into information more amenable to lower-level language representations, or eliminating them altogether. Program types are modeled with singleton kinds via a calculus having 45 inference rules. One inference rule, the singleton elimination rule, is the key to the transformation: it asserts the equivalence of two types if one of the types is a kind of the other type. Applying the singleton elimination rule to a program model replaces claims about types and kinds with claims about equivalence between types. Over half of this paper consists of proofs of the transformation, its soundness, and its completeness. The proof page count is impressive, because the proof technique was adapted from Stone and Harper [1], allowing much of the proof's development to be farmed out. Much of what remains includes a fair amount of proof by case analysis. Although singleton-kind elimination has been implemented in a compiler, this paper, apart from a warning on exponential blow-up for naive implementations, is light on the practical aspects of this work. Online Computing Reviews Service