Why Types Matter. Zheng Gao CREST, UCL

Transcription

1 Why Types Matter Zheng Gao CREST, UCL

2 Russell s Paradox Let R be the set of all sets that are not members of themselves. Is R a member of itself? If so, this contradicts with R s definition If not, by definition, R should contain itself Formalism in naïve set theory: Let R = {x x x}, then R R R R

3

4 The Barber Paradox There is a town with a male barber who shaves all and only those men who do not shave themselves. Who shaves the barber?

5 The Barber Paradox There is a town with a male barber who shaves all and only those men who do not shave themselves. Who shaves the barber? If the barber does not shave himself, according to the rule he must shave himself.

6 The Barber Paradox There is a town with a male barber who shaves all and only those men who do not shave themselves. Who shaves the barber? If the barber does not shave himself, according to the rule he must shave himself. If he does shave himself, according to the rule he will not shave himself.

7 The Barber Paradox There is a town with a male barber who shaves all and only those men who do not shave themselves. Who shaves the barber? Naïve set theory If the barber does not shave himself, according to the contains contradiction rule he must shave himself. If he does shave himself, according to the rule he will not shave himself.

8 Types to the Rescue Constructs a hierarchy of types. Any object is built only from those of higher types, which prevents circular referencing. 1) a barber as a citizen of the town, who shaves himself and 2) a barber as a professional, who shaves others are of different types.

9 Type Theory An alternative to set theory as a foundation for mathematics, in which each term has a type Simply typed λ-calculus is one of the many forms of type theory, which consists of Base types Only one type constructor,, used to model the type of functions

10 The Evolution of Types t

11 The Evolution of Types t

12 The Evolution of Types t

13 The Evolution of Types t

14 The Evolution of Types t

15 The Evolution of Types t

16 Type System A tractable method that assigns types to syntactic phrases that compose a program, and automatically checks whether the usage of these phrases comply with their types An over-approximation of the run-time behaviour of program terms

17 Static & Dynamic Type Checking Source Code Compilation Executable Execution

18 Static & Dynamic Type Checking Static type checking Source Code Compilation Executable Execution

19 Static & Dynamic Type Checking Static type checking Early error detection Source Code Compilation Executable Execution

20 Static & Dynamic Type Checking Early error detection Static type checking Increased run-time efficiency Source Code Compilation Executable Execution

21 Static & Dynamic Type Checking Early error detection Static type checking Increased run-time efficiency Better documentation Source Code Compilation Executable Execution

22 Static & Dynamic Type Checking Early error detection Static type checking Increased run-time efficiency Dynamic type checking Better documentation Source Code Compilation Executable Execution

23 Static & Dynamic Type Checking Static type checking Early error detection Increased run-time efficiency Better documentation Dynamic type checking Reduced implementation overhead Source Code Compilation Executable Execution

24 Static & Dynamic Type Checking Static type checking Early error detection Increased run-time efficiency Better documentation Dynamic type checking Reduced implementation overhead Better expressibility Source Code Compilation Executable Execution

25 Why We Care Generally, almost all real-world programming languages have type systems which offers multiple benefits. Specifically for GI/GP, type systems have the promise to guide the search and avoid the construction of invalid individuals.

26 Java s Static Type Checking Suppose we have:

27 Java s Static Type Checking

28 Java s Static Type Checking Illegal. Compiler thinks new B().me() returns an object of class A, but at runtime, this returns an objects of class B.

29 Java s Static Type Checking Illegal. Compiler thinks new B().me() returns an object of class A, but at runtime, this returns an objects of class B. Legal.

30 Java s Static Type Checking Illegal. Compiler thinks new B().me() returns an object of class A, but at runtime, this returns an objects of class B. Legal. Legal.

31 Java s Static Type Checking Illegal. Compiler thinks new B().me() returns an object of class A, but at runtime, this returns an objects of class B. Legal. Legal. Legal. But throws cast exception at run-time.

32 Hindley Milner s Type System One of the most famous type systems for the typed λ- calculus with parametric polymorphism: A fast (nearly linear time) algorithm that automatically infer types of the constructs from their usage A set of typing rules, e.g.

33 HM Example Let us assume that we have a function myfunc of type: myfunc : ADT int And we want to infer the type of a function somefunc somefunc (x) + myfunc (x)

34 Step One somefunc (x) + myfunc (x)

35 Step One somefunc (x) + myfunc (x) x : α

36 Step Two somefunc (x) + myfunc (x) x : α ADT int

37 Step Two somefunc (x) + myfunc (x) x : α ADT int α = ADT

38 Step Two somefunc (x) + myfunc (x) x : α ADT int α = ADT x : ADT

39 Step Three somefunc (x) + myfunc (x) x : ADT ADT int

40 Step Three somefunc (x) + myfunc (x) x : ADT ADT int +: int int int

41 Step Three somefunc (x) + myfunc (x) x : ADT ADT int +: int int int somefunc : ADT int

42 Polymorphism The provision of a single interface to entities of different types

43 Parametric Polymorphism Ad Hoc Inclusion

44 Parametric Polymorphism Generic programming in programming languages Rank-N polymorphic function is a function whose parameters are Rank-(N-1) polymorphic

45 Ad Hoc Polymorphism Function overloading in programming languages

46 Inclusion Polymorphism Inheritance creates inclusion polymorphism (subtyping)

47 Inclusion Polymorphism Inheritance creates inclusion polymorphism (subtyping) Cat < Animal Dog < Animal

48 HM Limitations Limited to rank 1 parametric polymorphism Does not support ad hoc polymorphism No notion of subtyping

49 Limitation Example One Suppose we have subtyping B < A, any function that takes arguments of type A is expected to takes arguments of type B as well. somefunc (x) + myfunc (x) x : α ADT int α = ADT??? x : ADT???

50 Limitation Example One Suppose we have subtyping B < A, any function that takes arguments of type A is expected to takes arguments of type B as well. somefunc (x) + myfunc (x) x : α ADT int α = ADT??? x : ADT???

51 Limitation Example Two In HM, an assumption set may contain at most one typing assumption for an construct The operator <, for example, has types: char char bool int int bool But it does not have the type: α.α α bool So any single typing is either too narrow or too wide

52 Intersection Types Allow a term to have multiple types by introducing a type constructor, a universal type ω used for untypable constructs, and the following typing rules: In practice, intersection types enable function overloading.

53 Union Types The dual notion of intersection types, which introduces a type constructor and similar typing rules. In C / C++, union types are the construct union

54 Example Consider the following code snippet in C++: The type of function foo would be: ((int ADT) int void) ((int ADT) float void)

55 Example Consider the following code snippet in C++: The type of function foo would be: ((int ADT) int void) ((int ADT) float void)

56 Example Consider the following code snippet in C++: The type of function foo would be: ((int ADT) int void) ((int ADT) float void)

57 Example Consider the following code snippet in C++: The type of function foo would be: ((int ADT) int void) ((int ADT) float void)

58 Example Consider the following code snippet in C++: The type of function foo would be: ((int ADT) int void) ((int ADT) float void)

59 Retype A general tool that automatically replaces certain types, together with the corresponding operations if necessary, of a program with new ones.

60 Potential Applications Reducing energy consumption Precision tracking and improvement for FP programs New mutation operators in GI/GP Taint analysis Symbolic execution Auto-transplantation

61 Intersection Types in Retype We use intersection types to cleanly model function overloading, because Retype may generate new overloads of an existing operator. Consider the following code snippet: Assumption: an external function ext_func of type int int Objective: retype int to ADT

62 Intersection Types in Retype We use intersection types to cleanly model function overloading, because Retype may generate new overloads of an existing operator. Consider the following code snippet: Before retyping Assumption: an external function ext_func of type int int Objective: retype int to ADT

63 Intersection Types in Retype We use intersection types to cleanly model function overloading, because Retype may generate new overloads of an existing operator. Consider the following code snippet: Before retyping +: int int int Assumption: an external function ext_func of type int int Objective: retype int to ADT

64 Intersection Types in Retype We use intersection types to cleanly model function overloading, because Retype may generate new overloads of an existing operator. Consider the following code snippet: Before retyping +: int int int +: int int int Assumption: an external function ext_func of type int int Objective: retype int to ADT

65 Intersection Types in Retype We use intersection types to cleanly model function overloading, because Retype may generate new overloads of an existing operator. Consider the following code snippet: After retyping +: ADT ADT ADT +: ADT int ADT Assumption: an external function ext_func of type int int Objective: retype int to ADT