Types

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.

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.

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.

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.

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.

Static typing allows efficient compilation

• Allocate memory

• Disambiguate overloading

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);

Type coercion

Compiler automatically translates one type to another.

i=x; i = fix(x)

x=i; x = float(i)

x=2 x = 2.0

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.

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)

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)

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.

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.

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.

Basic types

• Numeric: Integer, floating point, long/short integer, double precision …

• Character: short (ASCII), long (Unicode)

• Boolean

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 */

Subrange types

Ada:

type testScore is new Integer range 0 … 100; // Derived type

subtype workday is weekday range mon … fri; // Constrained subtype

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

Compatibility: Subtype

D : weekday;

E : workday;

E = D; // OK. No cast needed.

D = sat;

E= D; // Range error but not a type error.

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|

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.

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

Allocation of arrays: cntd

• Lifetime survives function that creates it: allocated on heap

• Dynamic size: Allocated on heap.

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.

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

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.

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.

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|

Efficient array access

for (I=0; I++; I<N) for (J=0; J++; J<N) M[I][J] = I+J;may work much faster thanfor (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.

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

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.

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.

What are pointers allowed to point to?

• Only heap objects (Pascal, Ada-83, Java)

• Stack objects (C, C++, Ada-95)

Dangling pointer

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

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

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.

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.

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.

Union/variants

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

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 */

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 caseend record

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