1. Doaitse Swierstra Atze Dijkstra Doaitse Swierstra Atze Dijkstra Type Systems

2. 2 lectures from the book “Types and Programming Languages”, Benjamin Pierce study the type inferencer/checker of the Utrecht Haskell Compiler (UHC) project small exercises Components

3. 3 Grammars and Parsing Implementation of Programming Languages fluency in Haskell programming Prerequisites

4. 4 should be relatively easy to follow, but it will take time (500 pages) well written, with extensive set of exercises both theory and practice uses ML as a demonstration and implementation language written at an easy pace Book

5. 5 “extension” of IPT compiler data types multiparameter type classes forall and existential quantifiers polymorphic kinds UHC

6. 6 1. Modules 2. Extendible Records 3. Functional Dependencies 4. Typed AG 5. XMLambda 6. Unifying Kind and Type Inference 7. Kind Inferencing in Helium 8. Haskell Type System 9. Uniqueness Types 10. Implicit Arguments Projects

7. 7 import and export types keep safety class issues parallel imports typed annotations ML functors 1 Modules

8. 8 allow cartesian products with labelled fields subtype relation use class sytem to express constraints many different proposals exits 2 Extendible Records

9. 9 allow parameters in instance definitions to have a functional relationship very useful in multi-parameter type classes implemented in Hugs and GHC 3 Functional Dep’cies

10. 10 add elements of Haskell to AG system delicate choice of features has to be made useful work, as you will all recognise Typed AG

11. 11 yet another approach to extendible records moves further away from Haskell has nice applications XMLambda

12. 12 type inference and kind inference are very similar make the code look just as similar can this be extended to even more levels? Unifying Type and Kind Inference

13. 13 Helium: light weight Haskell for first year students excellent error messages tranport kind inference to helium contraint based type inferencer Kind Inference in Helium

14. 14 study the full haskell type system document missing features from UHC add some of the still missing elements Haskell Type System

15. 15 the type system keep tracks of the number of references to a value (1 or >1) replacement for IO monad invented and implemented in Clean makes efficient implementation possible avoids dynamic garbage collection Uniqueness Types

16. 16 generalise the class parameters extend haskell so you can make classes into first class citizens Implicit Arguments

17. 17 if you want a specific partner then choose a partner decide on your preferences ranking 1-5 for your top 5 preferred projects mail to doaitse@cs.uu.nl before tomorrow 17.00 What to do now?

18. 18 motivation mathematical preliminaries untyped arithmetic expressions the untyped lambda calculus nameless representation of terms Chapter 1-10

19. 19 ML implementation Typed arithmetic expressions Simply typed lanbda calculus ML implementation 1-10 continued

20. 20 nothing in these chapters should come as a surpsise and you should just browse/read ML is used: somewhat baroque notation!! strict evaluation!! the theory treated at some points relies on this!, so keep this in mind Observations

21. 21 originally: data organistation, layout of data in memory: PIC (99) overloading, nice notation: 3+5.0 programs should not go wrong elementary operations are applied to bit patterns that represent the kind of data they expect programs do terminate Why types?

22. 22 assist in organisation of program code dependent types => total correctness a type system constrains the number of legal programs is some useful way Why Types?

23. 23 dynamic typing (LISP, Java coercions) static typing (as you know it) Higher Order Logic, Automath integration with theorem provers the type system can express every property of a program Kind of Typing Systems

24. operational semantics big step semantics small step semantics denotational semantics axiomatic semantics Proving program properties Our preference here

25. 25 we can express every possible computation in the untyped lambda calculus Lambda calculus

26. 26 Booleans t ::= true | false | if t then t else t v ::= true | false if true then t1 else t2 => t1 if false then t1 else t2 => t2

27. 27 Booleans (strict evaluation) t1 -> t1’ if t1 then t2 else t3 => if t1’ then t2 else t3 note that the condition is evaluated before the expressions themselves are

28. 28 evaluation is deterministic (i.e. always exactly one rule applies) evaluation always terminates normal forms are unique Observe

29. 29 Arithmetic Expressions t ::= 0 | succ t | pred t | iszero t nv :: = 0 | succ nv t1 => t2 succ t1 => succ t2

30. 30 Booleans tru = \t.\f.t fls = \t.\f.f if = \c.\t.\e. c t e if tru 2 3 => (\c.\t.\e. c t e) tru 2 3 => ( \t.\e. tru t e) 2 3 => ( \e. tru 2 e) 3 => tru 2 3 => (\t.\f.t) 2 3 => ( \f.2) 3 => ( 2)

31. 31 Integers c0 = \s.\z. z c1 = \s.\z. s z c2 = \s.\z.s (s z) c3 = \s.\z.s (s (s z))

32. 32 Recursion!! omega = (\x. x x)(\x. x x) ?? fix = \f.(\x. f(x x)) (\x. f(x x)) fix g => (\x. g(x x))(\x. g(x x)) => g((\x. g(x x))(\x. g(x x))) => g (fix g)

33. 33 Recursion (cont.) note that fix generates copies of g if necessary and passes the generater on to this g so that g can generate new copies is necessary

34. 34 try to find a type for fix if you cannot find one, try to explain why you cannot Exercise

35. 35 Untyped lambda calculus t ::= x | \x.t | t t v :: = \x.t

36. 36 De Bruijn Indices represent lambda terms without using identifiers an identifier is replaced by a number indicating how far the argument is removed from the top of the stack

37. 37 Example is represented by

38. 38 Terms

39. 39 Exercise define a Haskell data type for the untyped lambda calculus with variables define a Haskell data type for representing de Bruijn terms define a translation from the first to the second write a small interpreter for the latter

40. 40 Chapter 6: de Bruijn numbers Chapter 7: an interpreter in ML Hint