Types

1. Types

2. Overview Categorizing what a statement is intended to accomplish is difficult. Categorizing what a data structure is intended to mean (at least in part) is much easier. Types permit this categorization, and enforce rules that the data structures are used in a meaningful way.

3. Limited Objectives • To allow overloading. E.g. “x+y” can be • IntAdd(x,y) if int x,y. • FloatAdd(IntToFloat(x),y) if int x, float y. • StringCat(x,IntToString(y)) if string x, int y etc.

4. Grand Objective:Eliminating nonsense • Using the same bit string with two different interpretations: as an integer and a float etc. • Mixing apples and oranges. E.g. assigning a month (represented as an integer) to be a font (ditto). Multiplying a font by 7. • Dereferencing. E.g. dereferencing a pointer to a “customer ” record and reading it as if it were a “item for sale” record. • Calling a function with inappropriate arguments.

5. Further constraints • Composite types (records, arrays, lists etc.) • User-defined types with constraints • Types have properties. • Functions have types • Polymorphic functions (e.g. list operations) • Not overburden user with type theory. • If possible, find errors at compile time. • Low runtime burden. • Allow user to do transgressive things if that’s really what they intend to do. Tension between nanny PL and permissive PL.

6. Dynamic vs. Static Typing • Dynamic typing: Type of a variable is not known until run time. Variables must be allocated on heap and tagged with type. (LISP, other interpreted PLs) • Static typing: Type of a variable can be determined at compile time. • Declarations (most PL’s): user declares type. • Inferred (ML): compiler infers type.

7. Static typing allows efficient compilation • Allocate memory • Disambiguate overloading

8. Translating between types Type conversion (also called type casting): explicitly translating one type to another. int I; float X; char C; I = int(X); X = float(I); C = char(I);

9. Type coercion Compiler automatically translates one type to another. i=x;  i = fix(x) x=i;  x = float(i) x=2  x = 2.0

10. Non-converting type coercion Reading a bit string of one type as if it were another type. E.g. using the bit string for floating point as if it were an integer. Rarely what you actually want. Highly implementation dependent. Therefore, the PL should make it impossible to do this accidentally.

11. Overloading An operator or function is overloaded if it has multiple definitions, depending on the types of the arguments. E.g. int i; float x; string s; i+i  intAdd(i,i) x+x  floatAdd(x,x) s+s  stringAppend(s,s)

12. Overloading functions function exponent (N,P : Integer) return Integer; function exponent(N: Float; P: Integer) return Float; function exponent(N,P; Float) return Float; (Ada)

13. Terminology Type checking: Ensure that a program obeys the language’s type rules. Type clash: Violation of the rules. Strongly typed: The implementation catches all type clashes.

14. The rules depend on the language An operation can be a type clash in one language but not in another. E.g. int i, a[32]; i := 100; a[i] := 5; In PASCAL this is a type clash because “array of integer of size 32” is a type. In Ada it’s just a semantic error, because the type is “array of integer”. If you want your language to be statically typed, you have to define types so that this isn’t a type clash. Not that it makes any difference to what the compiler or the run-time executor does.

15. Viewpoints on types Denotational: A type is a set of values. Constructive: Complex types are built up from primitive types Abstract: A type consists of a set of operations that combine according to specified rules.

16. Basic types • Numeric: Integer, floating point, long/short integer, double precision … • Character: short (ASCII), long (Unicode) • Boolean

17. Enumerated types PASCAL type weekday = (sun, mon, tue, wed, thu, fri, sat) for today := mon to fri do begin … var sales : array[day] of real; Implemented as integers, but incompatible. weekday D; D := 5 /* Type error */

18. Subrange types Ada: type testScore is new Integer range 0 … 100; // Derived type subtype workday is weekday range mon … fri; // Constrained subtype

19. Compatibility: Derived type S : testScore; Count : Integer; S := 95; // OK. “95” has type // “Universal_Integer” S := Count; // Not OK. Type clash. S := testScore(Count); // OK // Casting from Integer to testScore

20. Compatibility: Subtype D : weekday; E : workday; E = D; // OK. No cast needed. D = sat; E= D; // Range error but not a type error.

21. Arrays A one-dimensional array M[L..U] of type T is a mapping from the integers between L and U to values of type T. Assume all values of type T are the same size. The standard implementation of M places all U+1-L values in a consecutive block of memory of size (U+1-L)*|T|, starting at address A0. The starting address of M[I] is A0+(I-L)*|T|

22. Dope vector Features of the array that are not known at compile time must be saved in a data structure known as a dope vector. The location of the dope vector and the significance of its fields is known at compile time.

23. Allocation of arrays Global lifetime, static shape: Allocated at fixed address. Local lifetime, static shape: Allocated in activation record Local lifetime, shape bound at elaboration time: Allocated in activation record using indirection and dope vector

24. Allocation of arrays: cntd • Lifetime survives function that creates it: allocated on heap • Dynamic size: Allocated on heap.

25. Array bounds checking In principle, at every reference to A[I], you have to check that I is within the bounds of A. In implementations that don’t do this (C, FORTRAN) this is by far the most common source of unsafeness and bizarre bugs. An optimizing compiler can often eliminate many of these checks as redundant.

26. Bizarre bugs Bugs whose manifestation is not explainable in terms of the language model. Chief source: Out of bounds array, pointer arithmetic, dangling pointer, erroneous deallocation

27. Bizarre bugs (cntd) May appear or disappear when • Add or delete unused variable declaration • Add or delete print statements. • Reorder variable declarations • Upgrade compiler May appear in executing routines far from the actual bug. May be intermittent.

28. Magic success Code that shouldn’t really work that does because of some unsafe operation. E.g. a variable is properly initialized because some array is written past its bounds.

29. Multidimensional arrays An array M of dimension A x B of type T is allocated as a block of size AxBx|T|. Row-major order (almost universal): M[0,0], M[0,1], … M[0,B-1], M[1,0], M[1,1] … M[1,B] … M[A-1,0] … M[A-1,B-1]. M[I,J] at M[0,0] + (B*I+J)*|T|

30. Efficient array access for (I=0; I++; I<N) for (J=0; J++; J<N) M[I][J] = I+J; may work much faster than for (J=0; J++; J<N) for (I=0; I++; I< N) M[I][J] = I+J; • Cache hit rate • (In large arrays) Page fault rate.

31. Ragged arrays Multidimensional array allocated as a array of pointers to rows. Either record the length of each row or terminate with a flag value (e.g. null character). Advantages: • Sometimes faster (trade indirection for multiplication). • Sometimes space efficient (trade pointer for null values).

32. Records As compared with arrays: • Heterogeneous type, while arrays are homogeneous. • Named fields rather than integer index. Offset of field from record is known at compile time.

33. Pointers • Really only two operations: Creating a pointer to an object, and following a pointer. • C allows arithmetic on pointers within same array to achieve optimization. Bad idea.

34. What are pointers allowed to point to? • Only heap objects (Pascal, Ada-83, Java) • Stack objects (C, C++, Ada-95)

35. Dangling pointer double *p; void a() { double x; p = &x; } void b() { int i = 1; *p = 2.0; print(i); } main() { a(); b(); }.

36. Ada 95 has restrictions on pointers to stack objects that prevent this, but that’s complicated.

37. Advantages to allowing pointers to stack objects If you want to create a data structure with pointers whose lifetime is equal to the function that creates it, that’s easy to do allocating it on the stack, and a pain to do allocating it on the heap. Note: during the lifetime of the data structure, the same code will work whether it’s on the stack or on the heap.

38. Other advantage to allowing pointers to stack objects function A lexically contains functions B and C. A has a collection of large structures (e.g. arrays). Declare a pointer local to B and C and use the pointer to pass references to the structure.

39. Unions/Variants Example: A bibliography records: • Books. Fields: Author, title, date, publisher. • Articles. Fields: Author, title, journal title, date, volume, pages. • Manuscripts: Fields: Author, title, library, ms number. You want all these to be the same type, because you want to create arrays of such records. You don’t want 9 different fields, of which at least 3 will always be null.

40. Union/variants These are generally more trouble than they’re worth, so unless you’re actually tight for space, don’t bother.

41. Unions in C: The wrong way union datum { int i; double d; } /* u.d and u.i share the same storage */ union datum u; u.d = 2.0; /* storage is set as floating point */ j = u.i; /* and accessed as integer */

42. Ada variant parts: the right way type ItemCat is (Book, Article, MS) type BibRecord(Category: ItemCat) record Author, Title: string; case Category is when Book => year: Integer; publisher: string; when Article => year, vol, pStart, pEnd: Integer; jnl: string end case end record

43. Ada variant parts Can only access pStart field if Category is set to “Article” (runtime check). If fields have been set and Category is changed, then fields are reset to “Unbound”.