1. David Evans http://www.cs.virginia.edu/~evans CS655: Programming Languages University of Virginia Computer Science Lecture 6: Types of Types “It would appear that we have reached the limits of what it is possible to achieve with computer technology, although one should be careful with such statements, as they tend to sound pretty silly in five years.” John Von Neumann, 1949

2. 1 Feb 2000University of Virginia CS 6552 Menu PS 1 Results (John) Latent Types, Dynamic Checking Algol60 Group Report Manifest Types, Dynamic Checking Manifest Types, Static Checking

3. 1 Feb 2000University of Virginia CS 6553 Types integers in [0, …)Strings Beatle’s Song Titles pointers that points to integer that is prime number Colors secret information pointers that points to pointer that points to storage shared by some other pointer programs that halt Type is any set of values Next week’s definition will be different

4. 1 Feb 2000University of Virginia CS 6554 Why have types? Overloading operators + vs. FADD – compiler needs types to figure out what “+” means Detecting program errors –Better to notice error than report incorrect result Make programs easier to read, understand and maintain –Better than comments if they are checked and can be trusted Security –Can use types to constrain the behavior of programs (we’ll see Proof-Carrying Code later…)

5. 1 Feb 2000University of Virginia CS 6555 Taxonomy Latent vs. Manifest –Are types visible in the program text? Checked statically vs. checked dynamically –Do you have to run the program to know if it has type errors? Checked weakly vs. strongly –How strict are the rules for using types? All combinations are (theoretically) possible –Language that is manifest + static + weak? –Language that is latent + dynamic + strong?

6. 1 Feb 2000University of Virginia CS 6556 Labrador: BARK with Latent Types Instruction ::= STORE Loc Literal | HALT | ERROR (Same as BARK) | ADD Loc 1 Loc 2 Loc 1 gets the value of Loc 1 + Loc 2. Loc 1 and Loc 2 must be the same type, result has same type. | MUL Loc 1 Loc 2 Loc 1 gets the value of Loc 1 * Loc 2. Loc 1 and Loc 2 must be the same type. | IF Loc 1 THEN Loc 1 If value in Loc 1 is non-zero, jump to instruction corresponding to value in Loc 2. Loc 1 and Loc 2 must contain integers. Literal ::= IntLiteral | RealLiteral IntLiteral ::= [ - ] ? [ 0 - 9 ][ 0 - 9 ]*Has type integer. RealLiteral ::= [-] ? [ 0 - 9 ][ 0 - 9 ]*.[ 0 - 9 ]*Has type real. As companions Labradors are kindly, patient,intelligent and always keen to please. They make perfect family dogs being especially good with children. Walter & Shackles Guide to Dogs

7. 1 Feb 2000University of Virginia CS 6557 Labrador Program [0] STORE R0 3.14159 [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1.

8. 1 Feb 2000University of Virginia CS 6558 Operational Semantics: ADD Instructions[PC] = ADD Loc 1 Loc 2  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 RegisterFile[Loc 1 ] + RegisterFile[Loc 2 ] BARK rule: What does this mean?

9. 1 Feb 2000University of Virginia CS 6559 Typed Register File C = Instructions x PC x RegisterFile RegisterFile[i] = for all integers i type = integer | real value = an integer if type if integer, a real if type is real Assume functions typeof(RegisterFile[i]), valueof(RegisterFile[i])

10. 1 Feb 2000University of Virginia CS 65510 Operational Semantics: ADD integer Instructions[PC] = ADD Loc 1 Loc 2,  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 <integer, valueof(RegisterFile[Loc 1 ]) + integer valueof(RegisterFile[Loc 2 ])> typeof(RegisterFile[Loc 1 ]) = integer, typeof(RegisterFile[Loc 2 ]) = integer

11. 1 Feb 2000University of Virginia CS 65511 Operational Semantics: ADD real Instructions[PC] = ADD Loc 1 Loc 2, typeof(RegisterFile[Loc 1 ]) = real, typeof(RegisterFile[Loc 2 ]) = real  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc 1 <real, valueof(RegisterFile[Loc 1 ]) + real valueof(RegisterFile[Loc 2 ])>

12. 1 Feb 2000University of Virginia CS 65512 Strong vs. Weak Typing What do we have? –Latent, dynamic, strongly typed language To get: latent, dynamic, weakly typed language: –Allow ADD and MUL to work on mixed types, result is real, allow IF predicate to be real –Add transition rules for Instructions[PC] = ADD Loc 1 Loc 2, typeof(RegisterFile[Loc 1 ]) = real, typeof(RegisterFile[Loc 2 ]) = integer etc.

13. 1 Feb 2000University of Virginia CS 65513 Is Dynamic Type Checking Useful?

14. 1 Feb 2000University of Virginia CS 65514 Manifest Types Often, however, explicit (manifest) types make programs easier for compilers to read, not easier for humans to read; and explicit (manifest) types are generally cumbersome for the program writer as well. Implicitly (latently) typed programming languages thus have clear advantages in terms of readability and writability. Turbak & Gifford

15. 1 Feb 2000University of Virginia CS 65515 Mastiff: BARK with Manifest Types Program ::= Declaration* Instruction* Declaration ::= TYPE Loc INTEGER Loc will hold integral values. | TYPE Loc REAL Loc will hold real values. Instruction ::= STORE Loc Literal Loc gets the value of Literal. Loc must have been declared with the same type as Literal. … (same as Labrador) Mastiff: An excellent guard dog, yet gentle and affectionate to its family. Walter & Shackles Guide to Dogs

16. 1 Feb 2000University of Virginia CS 65516 Mastiff Program [D0]TYPE R0 REAL [D1]TYPE R1 INTEGER [0] STORE R0 3.14159 [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1

17. 1 Feb 2000University of Virginia CS 65517 Input Function: I : Program  C C = Instructions x PC x RegisterFile where Instructions = same as before, PC = 0 RegisterFile[n] = if TYPE Rn INTEGER is in Declarations RegisterFile[n] = if TYPE Rn REAL is in Declarations RegisterFile[n] = for all other integers n RegisterFile[n] = if (TYPE Rn INTEGER and TYPE Rn REAL are in Declarations)

18. 1 Feb 2000University of Virginia CS 65518 STORE Loc IntLiteral Instructions[PC] = STORE Loc IntLiteral, typeof(RegisterFile[Loc]) = integer  where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = if n  Loc

19. 1 Feb 2000University of Virginia CS 65519 Static Semantics Static checking = at compile-time –Dynamic checking = at run (simulate)-time Know a whole program is type-correct without running it Can make claims about all possible executions Drawbacks: –May limit expressiveness of types (not everything can be checked statically) –Some type-correct programs may not pass static checking

20. 1 Feb 2000University of Virginia CS 65520 Premise;...; Premise Conclusion Conclusions are type judgments: A E : T Read: A proves E has type T. Use type okay to mean it type-checks, but has no type. Type environment: A Type bindings: [I 1 :T 1,..., I n :T n ] I n (Loc) has type T n Typing Rules

21. 1 Feb 2000University of Virginia CS 65521 Mastiff Typing Rules A IntLiteral : integer[int-literal] RealLiteral : real[real-literal] A contains [Loc:T] Loc : T[location] true

22. 1 Feb 2000University of Virginia CS 65522 Typing ADD A Loc 1 : integer, A Loc2 2 : integer A ADD Loc 1 Loc 2 : okay [add-integers] A Loc 1 : real, A Loc2 2 : real A ADD Loc 1 Loc 2 : okay [add-reals]

23. 1 Feb 2000University of Virginia CS 65523 Typing MUL A Loc 1 : integer, A Loc2 2 : integer A MUL Loc 1 Loc 2 : okay [mul-integers] A Loc 1 : real, A Loc 2 : integer A MUL Loc 1 Loc 2 : okay [mul-weak]

24. 1 Feb 2000University of Virginia CS 65524 Typing IF A Loc 1 : integer, A Loc 2 : integer A IF Loc 1 THEN Loc 2 : okay [if] A Loc 1 : real, A Loc 2 : integer A IF Loc 1 THEN Loc 2 : okay [if-weak]

25. 1 Feb 2000University of Virginia CS 65525 Type Checking Statement is well-typed if and only if it has a provable type judgment: –Construct a proof tree, where the root is the type judgment for this statement, and leaves are the axioms Declarations provide the axioms: Declarations = TYPE Loc i0 T i0 ; TYPE Loc i1 T i1,...  A = [Loc i0 : T i0, Loc i1 : T i1,... ]

26. 1 Feb 2000University of Virginia CS 65526 Type Checking Example Check instruction 3: MUL R0 R1 [D0]TYPE R0 REAL [D1]TYPE R1 INTEGER [0] STORE R0 3.14159 [1] STORE R1 4 [2] MUL R1 R1 [3] MUL R0 R1 A R0 : real, A R1 : integer A MUL R0 R1 : okay [mul-weak] A contains [ R0 : real] R0 : real same for R1 : integer A = [ R0 : real; R1 : integer] from Declarations

27. 1 Feb 2000University of Virginia CS 65527 Mastiff with Expressions Program ::= Declaration* Instruction* Instruction ::= STORE Loc Expression Expression must match declared type of Loc | GOTO Expression Expression must be integer | IF Expression p THEN Expression j Expression j must be integer Expression ::= MUL Expression Expression | ADD Expression Expression | Loc | Literal | ( Expression )

28. 1 Feb 2000University of Virginia CS 65528 Type checking Example [D0] TYPE R0 REAL [0] STORE R0 (MUL 3.14159 (MUL 4 4)) [store-real] A R0 : real, A (MUL …) : real A STORE R0 (MUL …) : okay A 3.14 : real, A (MUL 4 4) : integer A MUL 3.14 (MUL 4 4) : okay [mul-weak] …[mul-int] …[real-literal]

29. 1 Feb 2000University of Virginia CS 65529 Summary Statically Checked Dynamically Checked Manifest TypesMastiff-SMastiff-D Latent TypesLabrador CLU, Pascal ML, FL Scheme, Smalltalk

30. 1 Feb 2000University of Virginia CS 65530 Charge Continue working on your projects! Tuesday: Data Abstraction –CLU: language designed to support methodology based on data abstraction –Reasoning (informally) about data abstractions Next: Object-Oriented Languages Later: (after Spring Break) –How to do static checking with latent types (type reconstruction, type inference) –How to use types for security Today at 4:00, Jordan Hall: Mark S. Boguski, Natl Institutes of Health Interface between computation and biology