Doaitse SwierstraAtze Dijkstra

Doaitse SwierstraAtze Dijkstra

Type SystemsType Systems

2

lectures from the book “Types and Programming Languages”, Benjamin Piercestudy the type inferencer/checker of the Utrecht Haskell Compiler (UHC)projectsmall exercises

Components

3

Grammars and ParsingImplementation of Programming Languagesfluency in Haskell programming

Prerequisites

4

should be relatively easy to follow, but it will take time (500 pages)well written, with extensive set of exercisesboth theory and practiceuses ML as a demonstration and implementation languagewritten at an easy pace

Book

5

“extension” of IPT compilerdata typesmultiparameter type classesforall and existential quantifierspolymorphic kinds

UHC

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

import and export typeskeep safetyclass issuesparallel importstyped annotationsML functors

1 Modules

8

allow cartesian products with labelled fieldssubtype relationuse class sytem to express constraintsmany different proposals exits

2 Extendible Records

9

allow parameters in instance definitions to have a functional relationshipvery useful in multi-parameter type classesimplemented in Hugs and GHC

3 Functional Dep’cies

10

add elements of Haskell to AG systemdelicate choice of features has to be madeuseful work, as you will all recognise

Typed AG

11

yet another approach to extendible recordsmoves further away from Haskellhas nice applications

XMLambda

12

type inference and kind inference are very similarmake the code look just as similarcan this be extended to even more levels?

Unifying Type and Kind Inference

13

Helium: light weight Haskell for first year studentsexcellent error messagestranport kind inference to heliumcontraint based type inferencer

Kind Inference in Helium

14

study the full haskell type systemdocument missing features from UHCadd some of the still missing elements

Haskell Type System

15

the type system keep tracks of the number of references to a value (1 or >1)replacement for IO monadinvented and implemented in Cleanmakes efficient implementation possibleavoids dynamic garbage collection

Uniqueness Types

16

generalise the class parametersextend haskell so you can make classes into first class citizens

Implicit Arguments

17

if you want a specific partner then choose a partnerdecide on your preferences ranking 1-5 for your top 5 preferred projectsmail to doaitse@cs.uu.nl before tomorrow 17.00

What to do now?

18

motivationmathematical preliminariesuntyped arithmetic expressionsthe untyped lambda calculusnameless representation of terms

Chapter 1-10

19

ML implementationTyped arithmetic expressionsSimply typed lanbda calculusML implementation

1-10 continued

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

originally: data organistation, layout of data in memory: PIC (99)overloading, nice notation: 3+5.0programs 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

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

dynamic typing (LISP, Java coercions)static typing (as you know it)Higher Order Logic, Automath

integration with theorem proversthe type system can express every property of a program

Kind of Typing Systems

operational semanticsbig step semanticssmall step semantics

denotational semanticsaxiomatic semantics

Proving program properties

Our preference here

25

we can express every possible computation in the untyped lambda calculus

Lambda calculus

26

Booleans t ::= true | false | if t then t else t

v ::= true | false

if true then t1 else t2 => t1if false then t1 else t2 => t2

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

evaluation is deterministic (i.e. always exactly one rule applies)evaluation always terminatesnormal forms are unique

Observe

29

Arithmetic Expressions

t ::= 0 | succ t | pred t | iszero t

nv :: = 0 | succ nv

t1 => t2succ t1 => succ t2

30

Booleans tru = \t.\f.tfls = \t.\f.fif = \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

Integersc0 = \s.\z. zc1 = \s.\z. s zc2 = \s.\z.s (s z)c3 = \s.\z.s (s (s z))

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

Recursion (cont.)

note that fix generates copies of g if necessaryand passes the generater on to this gso that g can generate new copies is necessary

34

try to find a type for fixif you cannot find one, try to explain why you cannot

Exercise

35

Untyped lambda calculus

t ::= x | \x.t | t t

v :: = \x.t

36

De Bruijn Indices

represent lambda terms without using identifiersan identifier is replaced by a number indicating how far the argument is removed from the top of the stack

37

Example

is represented by

38

Terms

39

Exercise

define a Haskell data type for the untyped lambda calculus with variablesdefine a Haskell data type for representing de Bruijn termsdefine a translation from the first to the secondwrite a small interpreter for the latter

40

Chapter 6: de Bruijn numbersChapter 7: an interpreter in ML

Hint