Simon Peyton Jones Microsoft Research. August 2012

Transcription

1 Simon Peyton Jones Microsoft Research August 2012

2 Typecheck Desugar Source language Intermediate language Haskell Massive language Hundreds of pages of user manual Syntax has dozens of data types 100+ constructors Core 3 types, 15 constructors Rest of GHC

3 data Expr = Var Var Lit Literal App Expr Expr Lam Var Expr Let Bind Expr Case Expr Var Type [(AltCon, [Var], Expr)] Cast Expr Coercion Type Type Coercion Coercion Tick Note Expr data Bind = NonRec Var Expr Rec [(Var,Expr)] data AltCon = DEFAULT LitAlt Lit DataAlt DataCon 22 years old and still only 10 constructors. Bravo Girard!

4 Small IL is FANTASTIC because analysis, optimisation, and code generation, handle only a small language. BUT Type checking after desugaring bad error messages Desugaring/optimisations/code generation might screw up... seg fault in type-correct program.

5 Haskell Implicitly typed Binders typically un-annotated \x.x && y Type inference (complex, slow) Complicated to specify just which programs will type-check Ad-hoc restrictions to make inference feasible System FC Explicitly typed Every binder is type-annotated \(x:bool). x && y Type checking (simple, fast) Very simple to specify just which programs are type-correct Very expressive indeed; simple, uniform Core type checker is called Core Lint Very powerful internal consistency check on most of the compiler

6 Core type checker is called Core Lint Very powerful internal consistency check on most of the compiler Desugarer must produce well-typed Core Optimisation passes must transform well-typed Core to well-typed Core And a powerful sanity check on crazy typesystem extensions to source language. (If you can desugar it into Core, it must be sound; if not, think again.)

7 Core type checker is called Core Lint Very powerful internal consistency check on most of the compiler And a powerful sanity check on crazy typesystem extensions to source language. (If you can desugar it into Core, it must be sound; if not, think again.)

8 Start with lambda calculus. From Lambda the Ultimate X papers we know that lambda is super-powerful. But we need a TYPED lambda calculus

9 e ::= x k e 1 e 2 \(x: ).e e (a: ).e let bind in e case e of { alt 1.. alt n } e bind ::= x: =e rec { x 1 : 1 =e 1.. x n : n =e n } alt := C (x 1 : 1 ).. (x n : n ) DEFAULT

10 Haskell f :: Bool > Bool f x = not (not x) Core f:bool->bool = \(x:bool).not x fst :: (a,b) -> a fst (x,y) = x fst: ab. (a,b) -> a = (a:*). (b:*).\(x:(a,b)). case x of (,) (p:a) (q:b) -> p fst (True, x ) (,) :: ab. a -> b -> (a,b) fst Bool Char ((,) Bool Char True x )

11 x is a term variable (of type (a,b)) Type abstraction a,b are type variables (of kind *), bound by big lambda fst: ab. (a,b) -> a = (a:*). (b:*).\(x:(a,b)). case x of (,) (p:a) (q:b) -> p Type application fst has a type, so it must be applied to types, Bool, Char (,) :: ab. a -> b -> (a,b) fst Bool Char ((,) Bool Char True x )

12 fst: ab. (a,b) -> a = (a:*). (b:*).\(x:(a,b)). case x of (,) (p:a) (q:b) -> p fst Bool Char ((,) Bool Char True x ) ( (a:*). (b:*).\(x:(a,b)). case x of (,) (p:a) (q:b) -> p) Bool Char ((,) Bool Char True x ) (substitute [Bool/a, Char/b] Binder from impl of fst (\(x:(bool,char). gets correct type case x of (,) (p:bool) (q:char) -> p) ((,) Bool Char True x )

13 fst Bool Char ((,) Bool Char True x ) (inline fst) ( (a:*). (b:*).\(x:(a,b)). case x of (,) (p:a) (q:b) -> p) Bool Char ((,) Bool Char True x ) (beta-reduce, substitute [Bool/a, Char/b] (\(x:(bool,char). case x of (,) (p:bool) (q:char) -> p) ((,) Bool Char True x ) (beta-reduce, substitute for x) case (,) Bool Char True x of (,) (p:bool) (q:char) -> p (case of constructor, substitute [True/p, x /q] True

14 Type abstraction and application Term abstraction and application

15 data Expr = Var Var Lit Literal App Expr Expr Lam Var Expr -- Both term and type lambda Let Bind Expr Case Expr Var Type [(AltCon, [Var], Expr)] Cast Expr Coercion Type Type Coercion Coercion Tick Note Expr data Var = Id Name Type -- Term variable TyVar Name Kind -- Type variable...

16 Robust to transformations (ie if the term is well typed, then the transformed term is well typed): beta reduction inlining floating lets outward or inward case simplification Simple, pure exprtype :: Expr -> Type Type checking (Lint) is easy and fast

17 data T a where T1 :: a. b. b -> (b -> a) -> T a f :: T a -> a b is not mentioned in f = a. \(x:t a). T1 s result type case x of T1 (b:*) (y:b) (g:b->a) -> g y Pattern-matching on T1 binds the type variable b as well as the term variables y and g We say that b is an existential variable of T1 T1 :: ab. b -> (b -> a) -> T a a. ( b.(b, b->a)) -> T a

18 data T a where T1 :: Bool -> T Bool T2 :: T a f :: T a -> a -> Bool f = a. \(x:t a) (y:a). case x of T1 (z:bool) -> let (v:bool) = not y in v && z T2 -> False f :: T a -> a -> Bool f = a. \(x:t a) (y:a). let (v:bool) = not y in case x of T1 (z:bool) -> v && z T2 -> False Problem 1 not :: Bool -> Bool but y::a Problem 2 Floating the let seems well-scoped, but gives a bogus program

19 data T a where T1 :: Bool -> T Bool T2 :: T a Pattern matching on T1 brings into scope some EVIDENCE that (a=bool) f :: T a -> a -> Bool f = a. \(x:t a) (y:a). case x of T1 (c:a~bool) (z:bool) -> let (v:bool) = not (y c) in v && z T2 -> False c is an EVIDENCE VARIABLE We can USE the evidence to convert (y::a) to type Bool If e: and c: ~, then (e c) : T1 :: a. (a~bool) -> Bool -> T a

20 T1 :: a. (a~bool) -> Bool -> T a Then any application of T1 must supply evidence T1 e1 e2 where e1 : ( ~Bool ), e2 : Bool Here e1 is a value that denotes evidence that =Bool And any pattern match on T1 gives access to evidence case s of { T1 (x: ~Bool ) (y:bool) ->... } where s : T

21 But what terms e have type ~Bool? Answer: coercion terms e ::= x k e 1 e 2 \(x: ).e e (a: ).e let bind in e case e of { alt 1.. alt n } e Coercion terms

22 T1 :: a. (a~bool) -> Bool -> T a Consider the call: T1 Bool <Bool> True : T Bool Here <Bool> : Bool ~ Bool ::= < >... Can I call T1 Char e True : T Char? No: that would need (e : Char ~ Bool) and there are no such terms e

23 data T a where T1 :: Bool -> T Bool T2 :: T a g :: T a -> Maybe a g = a. \(x:t a). case x of T1 (c:a~bool) (z:bool) -> Just a (z sym c) T2 -> Nothing ::= < > sym... If : ~ then sym : ~ Have evidence c:a~bool Need evidence sym c : Bool~a

24 data T a where T1 :: Bool -> T Bool T2 :: T a Have evidence c:a~bool Need evidence Maybe (sym c) : Maybe Bool ~ Maybe a g :: T a -> Maybe a g = a. \(x:t a). case x of T1 (c:a~bool) (z:bool) -> (Just a z) Maybe (sym c) T2 -> Nothing ::= < > sym T 1... n... If i : i ~ i then T 1... n : T 1... n ~ T 1... n

25

26 Just like type abstraction/application, evidence abstraction/application provides a simple, elegant, consistent way to express programs that use local type equalities in a way that is fully robust to program transformation and can be typechecked in an absolutely straightforward way Only new term forms are e ::=... e