A Spectrum of Type Soundness and Performance. Ben Greenman & Matthias Felleisen Northeastern University

Transcription

1 A Spectrum of Type Soundness and Performance Ben Greenman & Matthias Felleisen Northeastern University

2 Is type soundness all-or-nothing? Can adding types slow down a program?

3 Migratory Typing

4

5

6

7 Typed/Untyped Languages

8 Typed/Untyped Languages Gradualtalk Typed Racket TPD StrongScript* mypy Pallene Grace Flow Hack Pyre Pytype rtc SafeTS* Strongtalk TypeScript Typed Clojure Typed Lua Pyret Thorn* Dart 1 Dart 2* Nom* Pycket Reticulated

9 Oldest by Date Newest Strongtalk Hack Typed Racket Grace Thorn* Gradualtalk Pallene Typed Lua Pyre Reticulated Dart 2* mypy StrongScript* TypeScript Flow Typed Clojure Pytype Dart 1 SafeTS* rtc TPD Pyret Nom* Pycket

10 Academia by Creator Industry Gradualtalk Typed Racket TPD StrongScript* Pallene Grace rtc SafeTS* Strongtalk Typed Clojure Typed Lua Pyret Thorn* Nom* Pycket Reticulated mypy Flow Hack Pyre Pytype TypeScript Dart 1 Dart 2*

11 Sound by Theory Unsound Gradualtalk Typed Racket TPD StrongScript* Pallene Grace SafeTS* Pyret Thorn* Dart 2* Nom* Pycket Reticulated mypy Flow Hack Pyre Pytype rtc Strongtalk TypeScript Typed Clojure Typed Lua Dart 1

12 Not Dead by Performance Dead Gradualtalk TPD StrongScript* mypy Pallene Grace Flow Hack Pyre Pytype rtc SafeTS* Strongtalk TypeScript Typed Clojure Typed Lua Pyret Thorn* Dart 1 Dart 2* Nom* Pycket Reticulated Typed Racket (the word 'dead' is used here in a technical sense)

13 Chaos!

14

15 H E 1

16 H higher-order semantics E erasure semantics 1 first-order semantics

17 Contributions (1/2) Model: - one mixed-typed language - one surface type system - three semantics H E 1

18 Contributions (2/2) H E 1

19 Contributions (2/2) H E 1 H E 1

20 Contributions (2/2) Implementation: - Racket syntax/types - three compilers - the first controlled performance experiment H E 1

21 Model

22 t = Nat Int t t t t Nat <: Int

23 t = Nat Int t t t t Nat <: Int v = n i v,v λ(x)e λ(x:t)e n i

24 t = Nat Int t t t t Nat <: Int v = n i v,v λ(x)e λ(x:t)e n i e =... dyn t e stat t e

25 t = Nat Int t t t t Nat <: Int v = n i v,v λ(x)e λ(x:t)e n i e =... dyn t e stat t e e dyn t e : t e : t stat t e

26 Γ = { fib : Nat Nat norm : Nat Nat Nat map : (Nat Nat) Nat Nat Nat Nat Γ fib (dyn Nat -1) : Nat Γ norm (dyn Nat Nat -1,-2 ) : Nat Γ map (dyn (Nat Nat) (λ(x)e)) y : Nat Nat

27 Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

28 H E 1

29 H E 1

30 higher-order H Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

31 H E 1

32 TPD Pycket Gradualtalk Typed Racket H E 1

33 TPD Pycket Gradualtalk Typed Racket H E 1

34 erasure E Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

35 TPD Pycket Gradualtalk Typed Racket H E 1

36 TPD Pycket Gradualtalk Typed Racket H 1 E mypy Flow Hack Pyre Pytype rtc Strongtalk TypeScript Typed Clojure Typed Lua Dart 1

37 TPD Pycket Gradualtalk Typed Racket H 1 E mypy Flow Hack Pyre Pytype rtc Strongtalk TypeScript Typed Clojure Typed Lua Dart 1

38 first-order 1 Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

39 TPD Pycket Gradualtalk Typed Racket H 1 E mypy Flow Hack Pyre Pytype rtc Strongtalk TypeScript Typed Clojure Typed Lua Dart 1

40 TPD Pycket Gradualtalk Typed Racket H Reticulated 1 E mypy Flow Hack Pyre Pytype rtc Strongtalk TypeScript Typed Clojure Typed Lua Dart 1

41 TPD mypy Pycket Gradualtalk Typed Racket H Flow Hack Pyre E Pytype rtc Strongtalk SafeTS* Dart 2* Reticulated Pallene 1 TypeScript Typed Clojure Nom* Grace Typed Lua Dart 1

42 TPD mypy Pycket Gradualtalk Typed Racket H StrongScript* Flow Hack Pyre Pyret E Pytype rtc Strongtalk SafeTS* Dart 2* Reticulated Pallene 1 Thorn* TypeScript Typed Clojure Nom* Grace Typed Lua Dart 1

43 Is type soundness all-or-nothing?

44 H E 1 Same type soundness?

45 Same type soundness? No! H E 1

46 - H e:t sound for H - E e sound for E H E 1-1 e:k(t) sound for 1 H e:t E e 1 e:k(t)

47 Implementation

48 H E 1 H E 1

49 H E 1

50 H E 1 expand typecheck enforce t optimize

51 H E 1 expand expand typecheck typecheck enforce t erase t optimize

52 H E 1 expand expand expand typecheck typecheck typecheck enforce t erase t enforce K(t) optimize

53 H E 1 expand expand expand typecheck typecheck typecheck enforce t erase t enforce K(t) optimize Optimize?

54 Experiment

55 - 10 benchmark programs - 2 to 10 modules each - 4 to 1024 configurations each - compare overhead to untyped docs.racket-lang.org/gtp-benchmarks

56 Results

57 Typical program Overhead vs. Untyped Num. Type Annotations

58 Typical program Overhead vs. Untyped H E 1 higher-order erasure first-order Num. Type Annotations

59

60 Implications

61 Theory Implications H progress + preserves types H 1 E E progress 1 progress + preserves type constructors

62 Theory Implications H progress + preserves types H 1 E E progress 1 progress + preserves type constructors - H refines 1-1 refines E

63 Performance Implications H add types to 'packages' E add types anywhere 1 add types sparingly Overhead vs. Untyped Num. Type Annotations

64

65 higher-order H Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

66 erasure E Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

67 first-order 1 Nat fib -1 Nat Nat norm -1,-2 Nat Nat map y λ(x)e

68 TPD mypy Pycket Gradualtalk Typed Racket H StrongScript* Flow Hack Pyre Pyret E Pytype rtc Strongtalk SafeTS* Dart 2* Reticulated Pallene 1 Thorn* TypeScript Typed Clojure Nom* Grace Typed Lua Dart 1

69

70 Is type soundness all-or-nothing? What invariants should the language guarantee? Can adding types slow down a program? Yes, through interaction with untyped code (or data)