2
Values and Types
Part 3
▪ Types of values.
▪ Primitive, composite, recursive types.
▪ Type systems: static vs dynamic typing, type completeness.
▪ Expressions.
▪ Implementation notes.
2-1
Recursive types
▪ A recursive type is one defined in terms of itself.
▪ Examples of recursive types:
• lists
• trees
2-2
Lists (1)
▪ A list is a sequence of 0 or more component values.
▪ The length of a list is its number of components. The
empty list has no components.
▪ A non-empty list consists of a head (its first component)
and a tail (all but its first component).
▪ A list is homogeneous if all its components are of the
same type. Otherwise it is heterogeneous.
2-3
Lists (2)
▪ Typical list operations:
• length
• emptiness test
• head selection
• tail selection
• concatenation.
2-4
Lists (3)
▪ For example, an integer-list may be defined recursively to
be either empty or a pair consisting of an integer (its head)
and a further integer-list (its tail):
Integer-List = nil Unit + cons(Integer Integer-List)
or Integer-List = { nil } { cons(i, l) | i Integer; l Integer-List }
where Unit is a type with only one (empty) value.
▪ Solution:
Integer-List = { nil }
{ cons(i, nil) | i Integer }
{ cons(i, cons(j, nil)) | i, j Integer }
{ cons(i, cons(j, cons(k, nil))) | i, j, k Integer }
…
2-5
Example: Java lists (1)
▪ Class declarations for integer-lists:
class IntList {
public int data;
public IntList tail; recursive
public IntList (int d, IntList t) {
data = d; tail = t;
}
}
▪ An integer-list construction:
new IntList(2,
new IntList(3,
new IntList(5,
new IntList(7, null)))));
2-6
Example: Java lists (2)
▪ Class declarations for object-lists:
class List {
public Object data;
public List tail;
public List (Object d, IntList t) {
data = d; tail = t;
}
}
▪ Note that List objects are heterogeneous lists (since
data can refer to an object of any class).
▪ By contrast, IntList objects are homogeneous lists.
2-7
Example: Haskell lists
▪ Type declaration for integer-lists:
data IntList = Nil | Cons Int IntList
recursive
▪ Some IntList constructions:
Nil
Cons 2 (Cons 3 (Cons 5 (Cons 7 Nil)))
▪ Actually, Haskell has built-in list types:
[Int] [String] [[Int]]
▪ Some list constructions:
[] [2,3,5,7] ["cat","dog"] [[1],[2,3]]
2-8
Example: Ada lists
▪ Type declarations for integer-lists:
type IntNode;
type IntList is access IntNode;
type IntNode is record
mutually
data: Integer;
recursive
tail: IntList;
end record;
▪ An IntList construction:
new IntNode'(2,
new IntNode'(3,
new IntNode'(5,
new IntNode'(7, null)))
2-9
Strings
▪ A string is a sequence of 0 or more characters.
▪ Some PLs (ML, Python) treat strings as primitive.
▪ Haskell treats strings as lists of characters. Strings are thus
equipped with general list operations (length, head
selection, tail selection, concatenation, …).
▪ Ada treats strings as arrays of characters. Strings are thus
equipped with general array operations (length, indexing,
slicing, concatenation, …).
▪ Java treats strings as objects, of class String.
2-10
Static vs dynamic typing (1)
▪ Before any operation is performed, its operands must be
type-checked to prevent a type error. E.g.:
• mod operation: check that both operands are integers
• and operation: check that both operands are booleans
• indexing operation: check that the left operand is an array, and that
the right operand is a value of the array’s index type.
2-11
Static vs dynamic typing (2)
▪ In a statically typed PL:
• all variables and expressions have fixed types
(either stated by the programmer or inferred by the compiler)
• all operands are type-checked at compile-time.
▪ Most PLs are statically typed, including Ada, C, C++, Java,
Haskell.
2-12
Static vs dynamic typing (3)
▪ In a dynamically typed PL:
• values have fixed types, but variables and expressions do not
• operands must be type-checked when they are computed at run-
time.
▪ Some PLs and many scripting languages are dynamically
typed, including Smalltalk, Lisp, Prolog, Perl, Python.
2-13
Example: Python dynamic typing (1)
▪ Python function definition: The type of n is unknown.
def even (n): So the “%” (mod) operation
return (n % 2 == 0) must be protected by a run-
time type check.
▪ The types of variables and parameters are not declared, and
cannot be inferred by the Python compiler. So run-time
type checks are needed to detect type errors.
2-14
Example: Python dynamic typing (2)
▪ Python function definition:
def respond (prompt):
# Print prompt and return the user’s response,
# as an integer if possible, otherwise as a string.
try:
response = raw_input(prompt) yields a string
return int(response)
except ValueError: converts the string to an
return response integer, or throws
ValueError if impossible
▪ Application code:
m = respond("Month? ")
if m == "Jan": m = 1
elif m == "Feb": m = 2
2-15
Example: Ada static typing
▪ Ada function definition:
The compiler doesn’t
function is_even (n: Integer) know the value of n.
return Boolean is But, knowing that n’s
begin type is Integer, it infers
return (n mod 2 = 0); that the type of “n mod
end; 2 = 0” will be Boolean.
▪ Call: The compiler doesn’t know the
p: Integer; value of p. But, knowing that p’s
… type is Integer, it infers that the
if is_even(p+1) … type of “p+1” will be Integer.
▪ Even without knowing the values of variables and
parameters, the Ada compiler can guarantee that no type
errors will happen at run-time.
2-16
Static vs dynamic typing (4)
▪ Advantages and disadvantages of static and dynamic typing:
• Static typing is more efficient.
– Dynamic typing requires run-time type checks (which make
the program run slower), and forces all values to be tagged
(to make the type checks possible).
– Static typing requires only compile-time type checks, and
does not force values to be tagged.
• Static typing is more secure: the compiler can guarantee
that the object program contains no type errors. Dynamic
typing provides no such security.
• Dynamic typing is more flexible. This is needed by some
applications where the types of the data are not known in
2-17
advance.
Type completeness (1)
▪ In principle, a value of any type can be:
• assigned
• composed with other values (as components of composite values)
• passed as an argument (to a procedure or function)
• returned as a function result.
▪ But some (mainly older) PLs restrict which of these
operations are applicable to certain types of values.
2-18
Example: type completeness (1)
▪ Ada function and application code:
type Complex is
record x, y: Float; end record;
function sum (c1, c2: Complex)
return Complex is
begin
return (c1.x+c2.x, c1.y+c2.y);
end;
-- Print the complex sum of p, q, and r:
put(sum(sum(p, q), r));
2-19
Example: type completeness (2)
▪ What if Ada function results were restricted to primitive
values?
procedure add (c1, c2: in Complex;
c3: out Complex) is
begin
c3 := (c1.x+c2.x, c1.y+c2.y);
end;
-- Print the complex sum of p, q, and r:
declare
t1, t2: Complex;
begin
add(p, q, t1);
add(t1, r, t2);
put(t2);
end;
2-20
