Motivation At the very begining Ni won t be complete until it has static typing 1 Maintenance needs nipkgs: 1M sloc Errors hard to spot 1 Eelco Dolstr

Transcription

1 A type-system for Ni Théophane Hufschmitt October / 24

2 Motivation At the very begining Ni won t be complete until it has static typing 1 Maintenance needs nipkgs: 1M sloc Errors hard to spot 1 Eelco Dolstra 2 / 24

3 Why isn t it done yet l s t : l e t = head l s t ; y = elemat l s t 1 ; i n i f i s S t r i n g then y. ${} e l s e + y 3 / 24

4 Impossible to type everything 4 / 24

5 Requirements No compilation No synta etension Type as much code as possible The ill-typed code must still be accepted 5 / 24

6 Need for powerful types l e t f = : y : i f i s I n t then + y e l s e && y ; i n f Type of f? Int Int Int, but also Bool Bool Bool 6 / 24

7 Set-theory to the rescue A B 7 / 24

8 Set-theory to the rescue A B A B 7 / 24

9 We can do the same with types (more or less),, \,,, \, Singleton types 1, true, blah, 8 / 24

10 Back to our eample l e t f = : y : i f i s I n t then + y e l s e && y ; i n f f is of type (Int Int Int) (Bool Bool Bool) 9 / 24

11 Gradual type Let s introduce? Represents unknown types Used to type untypeable epressions l e t = getenv X ; i n {y = 1}. ${} 10 / 24

12 Inference alone not always enough : +1»? I n t : i f i s I n t then e l s e not»? ( Int Bool ) 11 / 24

13 Inference alone not always enough /*: Int */ : +1» Int Int : i f i s I n t then e l s e not»? ( Int Bool ) 11 / 24

14 Inference alone not always enough /*: Int */ : +1» Int Int /*: Int Bool*/ : i f i s I n t then e l s e not» Int Bool ( Int Bool ) 11 / 24

15 Type reconstruction Lambda Lambda y Apply Apply y (+) 12 / 24

16 Type reconstruction Lambda Lambda y Apply Apply y (+) Int Int Int 12 / 24

17 Type reconstruction Lambda Lambda y Apply Apply y (+) Int Int Int t 12 / 24

18 Type reconstruction Lambda Lambda t = Int y Apply Apply y (+) Int Int 12 / 24

19 Type reconstruction Lambda Lambda t = Int y Apply Apply (+) Int Int y t y 12 / 24

20 Type reconstruction Lambda Lambda t = Int t y = Int y Apply Apply y (+) Int 12 / 24

21 Type reconstruction Lambda Lambda t = Int y Apply Apply y (+) Int Int 12 / 24

22 Type reconstruction Lambda Lambda y Apply Apply y (+) Int Int Int 12 / 24

23 Type checking Lambda If-then-else Apply - not isint 13 / 24

24 Type checking Lambda If-then-else Apply - not isint (Int Int) (Bool Bool) 13 / 24

25 Type checking Lambda If-then-else Apply - not isint Int Int 13 / 24

26 Type checking Lambda If-then-else t = Int Apply - not isint Int 13 / 24

27 Type checking Lambda If-then-else t = Int Apply - not isint?? 13 / 24

28 Type checking Lambda If-then-else t = Int Apply - not isint (Int true) ( Int false) 13 / 24

29 Type checking Lambda If-then-else t = Int Apply - not isint Int 13 / 24

30 Type checking Lambda If-then-else t = Int Apply - not isint true 13 / 24

31 Type checking Lambda If-then-else t = Int Apply isint true - not Int 13 / 24

32 Type checking Lambda If-then-else t = Int Apply - not isint true 13 / 24

33 Type checking Lambda If-then-else Apply - not isint Bool Bool 13 / 24

34 Type checking Lambda If-then-else Apply - not isint 13 / 24

35 Checking to the rescue l e t f /* : ( Int I n t ) ( Bool Bool ) */ = : i f i s I n t then e l s e not ; i n f» ( I n t Int ) ( Bool Bool ) 14 / 24

36 More precision l e t f = /*: Int */ : ( ( y : y ) /*: Bool*/) ) ; i n f Pass 15 / 24

37 More precision l e t f /*: Int Bool */ = : ( ( y : y ) ) ) ; i n f Error 15 / 24

38 Summary of the features Types in comments in normal ni code (Hopefully) powerful enough type-system La by default and safe when needed : e /*:? */: e 16 / 24

39 Lists Regular epression lists [ 1 2 true ] /* : [ I n t * true bar # ] */ [ true bar ] /* : [ I n t * true bar # ] */ 17 / 24

40 Lists Regular epression lists [ 1 2 true ] /* : [ I n t * true bar # ] */ [ true bar ] /* : [ I n t * true bar # ] */ [ I n t Bool ] ( Int, Bool ) 17 / 24

41 Static attribute sets { = 1 ; y = f a l s e ; z = foo } 18 / 24

42 Static attribute sets { = 1 ; y = f a l s e ; z = foo }» { = 1 ; y = f a l s e ; z = foo } 18 / 24

43 More attribute sets { /* : I n t */, y /* : I n t */? 1,... } : + y 19 / 24

44 More attribute sets { /* : I n t */, y /* : I n t */? 1,... } : + y» { = Int, y =? Int,.. } I n t 19 / 24

45 Dynamic attribute sets l e t myfunction /* : I n t String */ = ; = getenv Foo ; i n { ${} = 1 ; ${myfunction 2} = true } 20 / 24

46 Dynamic attribute sets l e t myfunction /* : I n t String */ = ; = getenv Foo ; i n { ${} = 1 ; ${myfunction 2} = true }» { _ =? 1 true } 20 / 24

47 Gradual type sometimes unwanted (: ) is basically an unsafe cast We would sometimes like to have more guaranties Don t automatically add gradual types everywhere Or even disable the gradual type 21 / 24

48 Strict mode Gradual type ( ( : ) 1) /* : Bool */ Typechecks 22 / 24

49 Strict mode Gradual type ( ( : ) 1) /*# strict-mode */ /* : Bool */ Error 22 / 24

50 Strict mode Gradual type ( ( : ) 1) /*# strict-mode */ /* : Bool */ Error Records definition l e t = getenv FOO ; y = getenv BAR ; i n { ${} = 1 ; ${y} = 2 ; } Typechecks 22 / 24

51 Strict mode Gradual type ( ( : ) 1) /*# strict-mode */ /* : Bool */ Error Records definition l e t = getenv FOO ; y = getenv BAR ; i n { ${} = 1 ; ${y} = 2 ; } /*# strict-mode */ Error 22 / 24

52 Control of the gradual type l e t c a s t = : ; i n ( c a s t 1 ) /* : Bool */ Typechecks 23 / 24

53 Control of the gradual type l e t c a s t = : ; i n ( c a s t 1 ) /*# no-gradual */ /* : Bool */ Error 23 / 24

54 Control of the gradual type l e t c a s t = : ; i n (from_gradual ( c a s t (to_gradual 1))) /*# no-gradual */ /* : Bool */ Typechecks 23 / 24

55 And that s all for today POC implementation in OCaml (Very wip) rewrite in Haskell 24 / 24

56 And that s all for today POC implementation in OCaml (Very wip) rewrite in Haskell regnat regnat@freenode regnat@regnat.ovh 24 / 24