The Ins and Outs of Gradual Type Inference

1. The Ins and Outs of Gradual Type Inference Aseem Rastogi Stony Brook University Avik Chaudhuri Basil Hosmer Adobe Systems

2. Gradually Typed Code e.g., a Flash application in ActionScript Statically Typed Code fully annotated with static types Dynamically Typed Code missing annotations = dynamic types type casts

3. Evolution of Scripts to Programs in our experience, a fantasy Statically Typed “Program” Gradual Typing missing annotations = dynamic types by default, rather than as fallback incrementally adding annotations for performance Dynamically Typed “Script”

4. Annoying Trade-Off Can this trade-off be eliminated? Annotation Burden Performance Penalty

5. Our Vision of Evolution Process • Type Inference: Key Ingredient for Evolution Infer Types Partially Typed “Script” Partially Untyped “Program” Annotate / Restructure

6. Gradual Type Inference • Type Inference Algorithm for Gradually Typed Languages Our Contributions • Practical Motivation • Improve Performance of • Flash Applications programs should not break, even when run in arbitrary environments • Goal • Backward Compatibility must admit reasoning outside the static type system • Non Goal • Increase Safety / Eliminate Errors … by eliminating as many type casts as possible

7. Gradual Type Inference

8. A Gradually Typed Program function foo(n:Number) { var s = 0; var i = s; while(i < n) { s = s + i; i = i + 1; } return s; }

9. Gradual Typing: No Type Inference function foo(n:Number):* { var s:* = 0; var i:* = s; while(i < n) { s = s + i; i = i + 1; } return s; } Missing Type = Dynamic Type

10. Gradual Typing: No Type Inference function foo(n:Number):* { var s:* = ⟨Number ▷ *⟩ 0; var i:* = s; while(i < n) { s = s + i; i = i + 1; } return s; } < : (Number, Number) Boolean + : (Number, Number) Number Type Casts Missing Type = Dynamic Type

11. Gradual Typing: No Type Inference function foo(n:Number):* { var s:* = ⟨Number ▷ *⟩ 0; var i:* = s; while(⟨* ▷ Number⟩i < n) { s = s + i; i = i + 1; } return s; } < : (Number, Number) Boolean + : (Number, Number) Number Missing Type = Dynamic Type

12. Gradual Typing: No Type Inference function foo(n:Number):* { var s:* = ⟨Number ▷ *⟩ 0; var i:* = s; while(⟨* ▷ Number⟩i < n) { s = ⟨Number ▷ *⟩ (⟨* ▷ Number⟩ s+ ⟨* ▷ Number⟩ i); i = i + 1; } return s; } < : (Number, Number) Boolean + : (Number, Number) Number Missing Type = Dynamic Type

13. Gradual Typing: No Type Inference function foo(n:Number):* { var s:* = ⟨Number ▷ *⟩ 0; var i:* = s; while(⟨* ▷ Number⟩i < n) { s = ⟨Number ▷ *⟩ (⟨* ▷ Number⟩ s+ ⟨* ▷ Number⟩ i); i = ⟨Number ▷ *⟩ (⟨* ▷ Number⟩ i + 1); } return s; } < : (Number, Number) Boolean + : (Number, Number) Number Missing Type = Dynamic Type

14. Gradual Typing: No Type Inference Performance Penalty function foo(n:Number):* { var s:* = ⟨Number ▷ *⟩ 0; var i:* = s; while(⟨* ▷ Number⟩i < n) { s = ⟨Number ▷ *⟩ (⟨* ▷ Number⟩ s+ ⟨* ▷ Number⟩ i); i = ⟨Number ▷ *⟩ (⟨* ▷ Number⟩ i + 1); } return s; } Missing Type = Dynamic Type

15. Gradual Typing: Type Inference function foo(n:Number):Foo! { var s:S = 0; var i:I = s; while(i < n) { s = s + i; i = i + 1; } return s; } Unknown types represented as type variables, solved to static typeswhere possible, dynamic typeas fallback Missing Type = Unknown Type Missing Type = Dynamic Type

16. Architecture of Type Inference Program Annotated With Type Variables Compilation Program With Coercions Closure Computation Solutions of Type Variables as Types Flow Relation Over Types Solution Derivation

17. Coercions • … are of the form T1 ▷ T2 • “term of type T1flows into context of type T2” • T ▷ X is an inflow for type variable X • X ▷ T is an outflowfor type variable X

18. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = s; while(i < n) { s = s + i; i = i + 1; } return s; } Number ▷ S

19. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩s; while(i < n) { s = s + i; i = i + 1; } return s; } Number ▷ S S ▷ I

20. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩i < n) { s = s + i; i = i + 1; } return s; } Number ▷ S S ▷ I I ▷ Number

21. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S> (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = i + 1; } return s; } Number ▷ S S ▷ I I ▷ Number S ▷ Number

22. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩i + 1); } return s; } Number ▷ S S ▷ I I ▷ Number S ▷ Number Number ▷ I

23. Generating Coercions function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩ i + 1); } return ⟨S ▷ Foo!⟩ s; } Number ▷ S S ▷ I I ▷ Number S ▷ Number Number ▷ I S ▷ Foo!

24. Solving for Type Variables X Inflows Outflows

25. Solving in a Static Type System Precision L.U.B. G.L.B. Safety Solution(X) X Inflows Outflows

26. Solving in a Gradual Type System Precision L.U.B. Solution(X) X Inflows

27. Solving in a Gradual Type System Precision L.U.B. Solution(X) Recall: eliminating errors is a non-goal X Inflows

28. Solving for Type Variables function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩ i + 1); } return ⟨S ▷ Foo!⟩ s; } Number ▷ S S = Number S ▷ I I ▷ Number S ▷ Number Number ▷ I S ▷ Foo!

29. Solving for Type Variables function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩ i + 1); } return ⟨S ▷ Foo!⟩ s; } Number ▷ S S = Number S ▷ I I = Number ⨆ S = Number I ▷ Number S ▷ Number Number ▷ I S ▷ Foo!

30. Solving for Type Variables function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩ i + 1); } return ⟨S ▷ Foo!⟩ s; } Number ▷ S S = Number S ▷ I I = Number ⨆ S = Number I ▷ Number S ▷ Number Number ▷ I S ▷ Foo! Foo! = S = Number

31. Solving for Type Variables function foo(n:Number):Foo! { var s:S = ⟨Number ▷ S⟩ 0; var i:I = ⟨S ▷ I⟩ s; while(⟨I ▷ Number⟩ i < n) { s = ⟨Number ▷ S⟩ (⟨S ▷ Number⟩ s + ⟨I ▷ Number⟩ i); i = ⟨Number ▷ I⟩ (⟨I ▷ Number⟩ i + 1); } return ⟨S ▷ Foo!⟩ s; } Number ▷ S S = Number S ▷ I I = Number ⨆ S = Number Outflows ignored I ▷ Number S ▷ Number Number ▷ I S ▷ Foo! Foo! = S = Number

32. Annotated Program function foo(n:Number):Number { var s:Number = ⟨Number ▷ Number⟩ 0; var i:Number = ⟨Number ▷ Number⟩s; while(⟨Number ▷ Number⟩i < n) { s = ⟨Number ▷ Number⟩ (⟨Number ▷ Number⟩ s + ⟨Number▷ Number⟩i); i = ⟨Number ▷ Number⟩ (⟨Number ▷ Number⟩i + 1); } return ⟨Number ▷ Number⟩ s; }

33. Annotated Program: No Casts function foo(n:Number):Number { var s:Number = 0; var i:Number = s; while(i < n) { s = s + i; i = i + 1; } return s; }

34. Summarizing… Key Idea (1) Consider Only Inflows to Solve Type Variables

35. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); }

36. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } Boolean Number ▷ X Number Number ▷ X

37. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } Boolean Number ▷ X Number Number ▷ X X = ⊥ Number

38. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } Boolean Number ▷ X Number Number ▷ X X = ⊥ Number Unsound

39. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } Boolean Number ▷ X Number Number ▷ X X = * Number

40. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } Boolean Number ▷ X Number Number ▷ X Imprecise X = * Number

41. Type Inference for Higher Order Types var x:X = function(y:Number):Number { … }; If(b) { x = function(y:Boolean):Number { … }; x(true); } X = Boolean Number Boolean Number ▷ X Number Number ▷ X

42. Higher Order Types: Kinds

43. Higher Order Types: Kinds Suppose that solution of X is of the form _ _ function type

44. Higher Order Types: Kinds Suppose that solution of X is of the form _ _ The kind of X under this structure isX? X!

45. Higher Order Types: Kinds Suppose that solution of X is of the form _ _ The kind of X under this structure isX? X! Infer X? and X! based on their inflows function applications of X

46. Higher Order Types: Kinds Suppose that solution of X is of the form _ _ “a kind for every type constructor” all parts of a higher-order type solved based on inflows ≈ naïve subtyping The kind of X under this structure isX? X! Infer X? and X! based on their Inflows

47. Type Inference for Higher Order Types Boolean Number ▷ X var x:X = function(y:Number):Number { … }; if(b) { x = function(y:Boolean):Number { … }; x(true); } Number Number ▷ X Number Number ▷ X? X! Boolean Number ▷ X? X! X?X! ▷ X

48. Type Inference for Higher Order Types Boolean Number ▷ X var x:X = function(y:Number):Number { … }; if(b) { x = function(y:Boolean):Number { … }; x(true); } Number Number ▷ X Boolean Number ▷ X? X! Number Number ▷ X? X! X?X! ▷ X Boolean ▷ X?

49. Type Inference for Higher Order Types Boolean Number ▷ X var x:X = function(y:Number):Number { … }; if(b) { x = function(y:Boolean):Number { … }; x(true); } Number Number ▷ X Boolean Number ▷ X? X! Number Number ▷ X? X! X?X! ▷ X Boolean ▷ X? X? ▷ Boolean Number ▷ X!

50. Type Inference for Higher Order Types Boolean Number ▷ X var x:X = function(y:Number):Number { … }; if(b) { x = function(y:Boolean):Number { … }; x(true); } Number Number ▷ X Number Number ▷ X? X! Boolean Number ▷ X? X! X?X! ▷ X Boolean ▷ X? X? ▷ Boolean Number ▷ X! X? ▷ Number