LX: A Language for Flexible Type Analysis

1. LX: A Language for Flexible Type Analysis Stephanie Weirich Cornell University joint work with Karl Crary (CMU)

2. Typed Compilation Terms Types Source IL Machine A series of translations between typed languages, propagating a set of invariants throughout the entire compilation process. Types are used for a variety of optimizations and provide safety assurances about the output of compiler.

3. Polymorphic Subscript Because any array may be passed to a polymorphic function, all arrays must look the same, no matter the type of their elements. A:array int B:array bool ICFP '98 sub = Fn a:Type => fn (A:array a,i:int) => wordsub(A,i) 06/08/99

4. Monomorphic subscript In languages such as C, the type of an array is always known at compilation. We can pack boolean values into integer arrays. int A[4] bool B[4] A[2] intsub(A,2) B[2] intsub(B,0)&(1<<2) <> 0 06/08/99

5. Type Analysis ( liML ) A:array int B:array bool type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a,i:int) => typecase a of int => wordsub(A,i) | bool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0 06/08/99

6. A Problem What if, during typed compilation, two source types map to the same target type? Source Language false true int bool term compilation type compilation Target Language 0 1 int

7. An initial attempt Target language contains both source language and target language types, and has a built-in type constructor interp to translate between them. sub = Fn a:S => fn (A:array (interp a),i:int) => typecase a of [int]S=> wordsub(A,i) | [bool]S => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

8. Issues in Compilation How do we preserve the meaning of typecase when the types themselves change? • type translation may not be injective • in TALx86,intint may be compiled into a variety of types depending on the calling convention, register allocation, etc • In closure conversion, a b converted to c. (a * c  b) * c • larger type takes longer to analyze • typecase is no longer exhaustive

9. Goal • Need a facility to describe the types of another language, and describe a translation of those types into the types of the current language. • Need a way to examine those representations the term level

10. Example datakind S=SInt|SBool interp :S -> Type interp = fn a:S => case a of SInt => int | SBool => int sub = Fn a:S => fn (A:array (interp a),i:int) => ccasea of SInt=> wordsub(A,i) | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

11. LX Language • Type analysis is just a programming idiom • System F augmented with building blocks for datakinds • tuples • sums • primitive recursion • Strongly Normalizing so that type checking is decidable • Term-level ccase

12. Another Example datakind M =Int |Prodof M * M |ArrowofM * M interp : M -> Type fun interp ( a:M) = case a of Int => int | Prod (c1,c2)) => interp(c1) * interp(c2) | Arrow (c1,c2)) => interp(c1)  interp(c2)

13. Example fun printf [a:M] (x:interp a) => ccase a of Int=> (* x is of type int *) print_int x Prod(b,c)=> print “<“; printf [b](fst x); print “,”; printf [c] (snd x); print “>” Arrow(b,c) => (* x is of type interp(b)interp(c) *) print “fun” (* x is of typeinterp(Prod(b,c))*) (* x is of typeinterp(b) * interp(c)*)

14. Type-Analyzing Languages analyze native types analyze constructed types type-passing semantics liML LX type-erasure semantics lR LXvcase

15. Type-Passing Semantics Types are necessary at run time Requires sophisticated machinery to describe low level languages Abstract kinds and translucent sums for polymorphic typed closure conversion [MMH 96] Type-Erasure Semantics Types may be erased prior to run time Standard type theory constructs suffice Simpler typed closure conversion [ MWCG 97][CWM 98]

16. Type Passing Example ( liML ) type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a,i:int) => typecase a of int => wordsub(A,i) | bool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

17. Type Erasure Example ( lR ) type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a, i:int, rx:R(a)) => typecase rxof Rint => wordsub(A,i) | Rbool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

18. Example datakind S=SInt|SBool interp :S  Type interp = fn a:S => case a of SInt => int | SBool => int datatype SRep = RInt | RBool

19. Example sub = Fn a:S => fn (A:array (interp a),i:int, rx:SRep) => case rxof RInt => ccase a of SInt => wordsub(A,i) | SBool => impossible | RBool => ccase a of SInt => impossible | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

20. Second Try datatype SRep [a:S ] = RInt of (case a of SInt => unit | SBool => void) | RBool of (case a of SInt => void | SBool => unit)

21. Second Try sub = Fn a:S => fn (A:array (interp a),i:int, rx:SRep(a)) => case rxof RInt y => vcasea of SInt => wordsub(A,i) | SBool => dead y | RBool y => vcasea of Sint => dead y | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

22. Related Work Inductive Types Mendler 87, Werner 94, Howard 92, 96, Gordon 94 Type Analysis Harper/Morrisett 95, Duggan 98, etc… Type Erasure Crary/Weirich/Morrisett 98 Typed Compilation TIL - FLINT - TAL - Church