why types matter
play

Why Types Matter Zheng Gao CREST, UCL Russells Paradox Let R be - PowerPoint PPT Presentation

Why Types Matter Zheng Gao CREST, UCL Russells 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


  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. 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 ?

  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 ? • If the barber does not shave himself, according to the rule he must shave himself.

  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. • If he does shave himself, according to the rule he will not 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 ? 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.

  7. 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.

  8. 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

  9. The Evolution of Types t

  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. 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

  16. Static & Dynamic Type Checking Source Compilation Executable Execution Code

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

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

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

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

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

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

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

  24. 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.

  25. Java’s Static Type Checking Suppose we have:

  26. Java’s Static Type Checking

  27. Java’s Static Type Checking Illegal. Compiler thinks new B().me() returns an object of class A, but at run- time, this returns an objects of class B.

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

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

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

  31. 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.

  32. 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)

  33. Step One someFunc (x) + myFunc (x)

  34. Step One someFunc (x) + myFunc (x) x : α

  35. Step Two someFunc (x) + myFunc (x) ADT ⟶ int x : α

  36. Step Two someFunc (x) + myFunc (x) ADT ⟶ int x : α α = ADT

  37. Step Two someFunc (x) + myFunc (x) ADT ⟶ int x : α α = ADT x : ADT

  38. Step Three someFunc (x) + myFunc (x) ADT ⟶ int x : ADT

  39. Step Three someFunc (x) + myFunc (x) ADT ⟶ int x : ADT +: int ⟶ int ⟶ int

  40. Step Three someFunc (x) + myFunc (x) ADT ⟶ int x : ADT +: int ⟶ int ⟶ int someFunc : ADT ⟶ int

  41. Polymorphism The provision of a single interface to entities of different types

  42. Parametric Polymorphism Ad Hoc Inclusion

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

  44. Ad Hoc Polymorphism Function overloading in programming languages

  45. Inclusion Polymorphism Inheritance creates inclusion polymorphism (subtyping)

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

Download Presentation
Download Policy: The content available on the website is offered to you 'AS IS' for your personal information and use only. It cannot be commercialized, licensed, or distributed on other websites without prior consent from the author. To download a presentation, simply click this link. If you encounter any difficulties during the download process, it's possible that the publisher has removed the file from their server.

Recommend


More recommend