1. Type Systems CSE 340 – Principles of Programming Languages Fall 2016
Adam Doupé
Arizona State University

2. Type Systems
Informally, a type in a programming language specifies a set of values and operations that can be applied on those values
A type can be associated with a variables or a constant
Values are not necessarily numeric values, for example we can specify function types
A type system consists of
Basic types
Type constructors
Type inference
Type compatibility

3. Type Declaration Programming language will typically include
Basic types
Included in the programming language and available to any program written in that language
Type constructors
Way for a programmer to define new types

4. Type Constructors Pointer to T, where T is a type
struct { a1: T1; a2 : T2; …, ak: Tk; }
Where ai is a field name and Ti is a previously defined type
array range of T
Where range can be single or multi dimensional
function of T1, T2, ..., Tk returns T
Type is a function, the types of the parameters are T1 ... Tk and the return type is T

5. Using Type Constructors
Declaring Types
Type cm : integer;
Type RGBA : array [0..4] of int;
Type png : array [0..256] of RGBA;
Anonymous Types
array [0..4] of int x;
struct {
int a;
char b;
} y;

6. Type Compatibility Which assignments are allowed by the type system?
a = b;?
int a; float b;
float a; int b;

7. Type Inference
Types of expressions or other constructs as a function of subexpression types
a + b
a int; b float
Returns a float in C
Error in ML
a * b
a string; b int
Error in most languages
Returns a string in Python

8. Type Compatibility Principally about type equivalence
How to determine if two types are equal?
Type cm : integer;
Type inch : integer;
cm x;
inch y;
x = y?

9. Name Equivalence Types must have the exact same name to be equivalent
Type cm : integer;
Type inch : integer;
cm x;
inch y;
x = y?
// ERROR

10. Name Equivalence a: array [0..4] of int; b: array [0..4] of int;
a = b?
Not allowed under name equivalence

11. Name Equivalence a, b: array [0..4] of int; a = b?
Not allowed because array [0..4] of int is not named

12. Name Equivalence Type A: array [0..4] of int; a: A; b: A; a = b?
Allowed, because both a and b have the same name

13. Internal Name Equivalence
If the program interpreter gives the same internal name to two different variables, then they share the same type
a, b: array [0..4] of int;
c: array [0..4] of int;
a = b?
Yes, because interpreter/compiler gives the same internal name to a and b
a = c?
No, because interpreter/compiler gives different internal name to c than to a and b

14. Structural Equivalence
Same built-in types
Pointers to structurally equivalent types
Type cm : integer;
Type inch : integer;
cm x;
inch y;
x = y?
// Allowed!

15. Structural Equivalence
int* a;
float* b;
a = b?
Not structurally equivalent, because int and float are not structurally equivalent

16. Structural Equivalence
Determining struct structural equivalence
Two structures
st1 { x1: W1, x2: W2, …, xk: Wk }
st2 { y1: Q1, y2: Q2, ..., yk: Qk }
st1 and st2 are structurally equivalent iff
W1 structurally equivalent to Q1
W2 structurally equivalent to Q2
...
Wk structurally equivalent to Qk

17. Structural Equivalence
struct A { a: int, b: float }
struct B { b: int, a: float }
A foo;
B bar;
foo = bar?

18. Structural Equivalence
struct A { a: int, b: float }
struct B { b: float, a: int }
A foo;
B bar;
foo = bar?

19. Structural Equivalence
Determining array structural equivalence
Two Arrays
T1 = array range1 of t1
T2 = array range2 of t2
T1 and T2 are structurally equivalent iff:
range1 and range2 have (1) the same number of dimensions and (2) the same number of entries in each dimension
t1 and t2 are structurally equivalent

20. Structural Equivalence
Determining function structural equivalence
Two functions
T1 = function of (t1, t2, t3, …, tk) returns t
T2 = function of (v1, v2, v3, ..., vk) returns v
T1 and T2 are structurally equivalent iff:
For all i from 1 to k, ti is structurally equivalent to vi
t is structurally equivalent to v

21. Determining Structural Equivalence
The goal is to determine, for every pair of types in the program, if they are structurally equivalent
Seems fairly simple, just keep applying the previous 5 rules until the base case 1 is reached
How to handle the following case:
T1 = struct { a: int; p: pointer to T2; }
T2 = struct { a: int; p: pointer to T1; }
Applying the rules states that T1 is structurally equivalent to T2 iff pointer to T1 is structurally equivalent to pointer to T2, which is true iff T1 is structurally equivalent to T2 …

22. Structural Equivalence Algorithm
The way to break the stalemate is to assume that T1 and T2 are structurally equivalent because no rule contradicts them being structurally equivalent
Our goal is to create an n X n table, where n is the number of types in the program, and each entry in the table is true if the types are structurally equivalent and false otherwise

23. Structural Equivalence Algorithm
To support cyclical definitions, we first initialize all entries in the table to true
We assume that types are structurally equivalent unless we have proof otherwise
Algorithm is fairly simple
Set the n X n table to have each entry as true
While table has not changed
Check each entry i, j in the table, and if Ti and Tj are not structurally equivalent, then set the entry i, j in the table to false
Note that Ti and Tj are the ith and jth types in the program

24. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true

25. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true

26. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true

27. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

28. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

29. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

30. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

31. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

32. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

33. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

34. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false

35. T1 = struct { a: int, p: pointer to T2 } T2 = struct { c: int, q: pointer to T3 } T3 = struct { a: float, p: pointer to T1 } T1 T2 T3
true
false