Inf3110/4110

Types, Polymorphism and

Overloading

INF 3110/4110 - 2005

Gerardo Schneider
Department of Informatics – University of Oslo

Based on John C. Mitchell’s slides

1
Before starting... Some clarifications

‹Mandatory exercises must be done individually

‹Side-effect: a property of a function that modifies

INF 3110/4110 - 2005

some state other than its return value
• E.g., a function might modify a global variable or one
of its arguments; write a result in the screen or in a
file.

2
ML lectures
1. 05.09: A quick introduction to ML
2. 12.09: The Algol Family and more on ML
(Mitchell’s Chapter 5 + more)

INF 3110/4110 - 2005

3. Today: Types, Polymorphism and
Overloading (Mitchell’s Chapter 6)
4. 17.10: Exceptions and Continuations (Mitchell’s
Chapter 8)
5. 24.10: Revision (!?)

3
Outline
‹Types in programming

‹Type safety

INF 3110/4110 - 2005

‹Polymorphisms

‹Type inference

‹Type declaration
4
Type
A type is a collection of computational entities
sharing some common property

INF 3110/4110 - 2005

‹Examples ‹“Non-examples”
• Integers • {3, true, 5.0}
• [1 .. 100] • Even integers
• Strings • {f:int → int | if x>3
• int → bool then f(x) > x*(x+1)}
• (int → int) →bool

Distinction between types and non-types is language

dependent.
5
Uses for types
‹Program organization and documentation
• Separate types for separate concepts
– E.g., customer and accounts (banking program)

INF 3110/4110 - 2005

• Types can be checked, unlike program comments
‹Identify and prevent errors
• Compile-time or run-time checking can prevent
meaningless computations such as 3 + true - “Bill”
‹Support optimization
• Short integers require fewer bits
• Access record component by known offset

6
Type errors
‹Hardware error
• Function call x() (where x is not a function) may
cause jump to instruction that does not contain a

INF 3110/4110 - 2005

legal op code

‹Unintended semantics
• int_add(3, 4.5): Not a hardware error, since bit
pattern of float 4.5 can be interpreted as an integer

7
General definition of type error
‹A type error occurs when execution of program
is not faithful to the intended semantics
‹Type errors depend on the concepts defined in

INF 3110/4110 - 2005

the language; not on how the program is
executed on the underlying software
‹All values are stored as sequences of bits
• Store 4.5 in memory as a floating-point number
– Location contains a particular bit pattern
• To interpret bit pattern, we need to know the type
• If we pass bit pattern to integer addition function,
the pattern will be interpreted as an integer pattern
– Type error if the pattern was intended to represent 4.5
8
Subtyping
‹Subtyping is a relation on types allowing values
of one type to be used in place of values of
another

INF 3110/4110 - 2005

• Substitutivity: If A is a subtype of B (A<:B), then
any expression of type A may be used without type
error in any context where B may be used
‹In general, if f: A -> B, then f may be applied to
x if x: A
• Type checker: If f: A -> B and x: C, then C = A
‹In languages with subtyping
• Type checker: If f: A -> B and x: C, then C <: A
Remark: No subtypes in ML!
9
Monomorphism vs. Polymorphism
‹ Monomorphic means ”having only one form”, as
opposed to Polymorphic
‹ A type system is monomorphic if each constant,
variable, etc. has unique type

INF 3110/4110 - 2005

‹ Variables, expressions, functions, etc. are polymorphic if
they ”allow” more than one type

Example. In ML, the identity function fn x => x is

polymorphic: it has infinitely many types!
- fn x => x

Warning! The term ”polymorphism” is used with different

specific technical meanings (more on that later)
10
Outline
‹Types in programming

‹Type safety

INF 3110/4110 - 2005

‹Polymorphisms

‹Type inference

‹Type declaration
11
Type safety
‹A Prog. Lang. is type safe if no program can
violate its type distinction (e.g. functions and integer)
‹Examples of not type safe language features:

INF 3110/4110 - 2005

• Type casts (a value of one type used as another type)
– Use integers as functions (jump to a non-instruction or
access memory not allocated to the program)
• Pointer arithmetic
– *(p) has type A if p has type A*
– x = *(p+i) what is the type of x?
• Explicit deallocation and dangling pointers
– Allocate a pointer p to an integer, deallocate the memory
referenced by p, then later use the value pointed to by p

12
Relative type-safety of languages
‹Not safe: BCPL family, including C and C++
• Casts; pointer arithmetic

INF 3110/4110 - 2005

‹Almost safe: Algol family, Pascal, Ada.
• Explicit deallocation; dangling pointers
– No language with explicit deallocation of memory is fully
type-safe

‹Safe: Lisp, ML, Smalltalk, Java

• Lisp, Smalltalk: dynamically typed
• ML, Java: statically typed
13
Compile-time vs. run-time checking
‹Lisp uses run-time type checking
(car x) check first to make sure x is list
‹ML uses compile-time type checking

INF 3110/4110 - 2005

f(x) must have f : A → B and x : A
‹Basic tradeoff
• Both prevent type errors
• Run-time checking slows down execution (compiled ML
code, up-to 4 times faster than Lisp code)
• Compile-time checking restricts program flexibility
Lisp list: elements can have different types
ML list: all elements must have same type
14
Compile-time type checking
‹Sound type checker: no program with error is
considered correct
‹Conservative type checker: some programs

INF 3110/4110 - 2005

without errors are considered to have errors
‹Static typing always conservative
if (possible-infinite-run-expression)
then (expression-with-type-error)
else (expression-with-type-error)
Cannot decide at compile time if run-time error will occur
(from the undecidability of the Turing machine’s halting problem)

15
Outline
‹Types in programming

‹Type safety

INF 3110/4110 - 2005

‹Polymorphisms

‹Type inference

‹Type declaration
16
Polymorphism: three forms
‹Parametric polymorphism
• Single function may be given (infinitely) many types
• The type expression involves type variables

INF 3110/4110 - 2005

Example: in ML the identity function is polymorphic
- fn x => x; This pattern is called type scheme

val it = fn : 'a -> 'a

Type variable may be replaced by any type

An instance of the type scheme may give:

int→int, bool→bool, char→char,
int*string*int→int*string*int, (int→real)→(int→real), ...
17
Polymorphism: three forms (cont.)

‹Ad-hoc polymorphism (or Overloading)

• A single symbol has two (or more) meaning (it refers to
more than one algorithm)

INF 3110/4110 - 2005

• Each algorithm may have different type
• Choice of algorithm determined by type context
• Types of symbol may be arbitrarily different

Example: In ML, + has 2 different associated

implementations: it can have types int*int→int
and real*real→real, no others
18
Polymorphism: three forms (cont.)

‹Subtype polymorphism
• The subtype relation allows an expression to have
many possible types

INF 3110/4110 - 2005

• Polymorphism not through type parameters, but
through subtyping:
– If method m accept any argument of type t then m may also
be applied to any argument from any subtype of t

REMARK 1: In OO, the term “polymorphism” is usually used

to denote subtype polymorphism (ex. Java, OCAML, etc)

REMARK 2: ML does not support subtype polymorphism!

19
Parametric polymorphism
‹Explicit: The program contains type variables
• Often involves explicit instantiation to indicate how
type variables are replaced with specific types

INF 3110/4110 - 2005

• Example: C++ templates

‹Implicit: Programs do not need to contain types

• The type inference algorithm determines when a
function is polymorphic and instantiate the type
variables as needed
• Example: ML polymorphism

20
Parametric Polymorphism: ML vs. C++

‹C++ function template

• Declaration gives type of funct. arguments and result
• Place inside template to define type variables

INF 3110/4110 - 2005

• Function application: type checker does instantiation
‹ML polymorphic function
• Declaration has no type information
• Type inference algorithm
– Produce type expression with variables
– Substitute for variables as needed

ML also has module system with explicit type parameters

21
Example: swap two values
‹C++
template <typename T>
void swap (int& x, int& y){ void swap(T& , T& y){

INF 3110/4110 - 2005

int tmp=x; x=y; y=tmp; T tmp=x; x=y; y=tmp;
} }

‹Instantiations:
• int i,j; … swap(i,j); //use swap with T replaced with int
• float a,b;… swap(a,b); //use swap with T replaced with
float
• string s,t;… swap(s,t); //use swap with T replaced with
string

22
Example: swap two values

‹ML
- fun swap(x,y) =

INF 3110/4110 - 2005

let val z = !x in x := !y; y := z end;
val swap = fn : 'a ref * 'a ref -> unit

Remark: Declarations look similar in ML and C++,

but compile code is very different!

23
Parametric Polymorphism: Implementation

‹C++
• Templates are instantiated at program link time
• Swap template may be stored in one file and the

INF 3110/4110 - 2005

program(s) calling swap in another
• Linker duplicates code for each type of use
‹ML
• Swap is compiled into one function (no need for
different copies!)
• Typechecker determines how function can be used

24
Parametric Polymorphism: Implementation

‹Why the difference?

• C++ arguments passed by reference (pointer), but
local variables (e.g. tmp, of type T) are on stack

INF 3110/4110 - 2005

– Compiled code for swap depends on the size of type T =>
Need to know the size for proper addressing
• ML uses pointers in parameter passing (uniform data
representation)
– It can access all necessary data in the same way, regardless
of its type
‹Efficiency
• C++: more effort at link time and bigger code
• ML: run more slowly
25
ML overloading
‹Some predefined operators are overloaded
• + has types int*int→int and real*real→real
‹User-defined functions must have unique type

INF 3110/4110 - 2005

• fun plus(x,y) = x+y; (compiled to int or real function, not
both)
In SML/NJ:
- fun plus(x,y) = x+y;
val plus = fn : int * int -> int
If you want to have plus = fn : real * real -> real you
must provide the type:
- fun plus(x:real,y:real) = x+y;
26
ML overloading (cont.)

‹Why is a unique type needed?

• Need to compile code implies need to know which +

INF 3110/4110 - 2005

(different algorithm for distinct types)

• Efficiency of type inference

• Overloading is resolved at compile time

– Choosing one algorithm among all the possible ones
– Automatic conversion is possible (not in ML!)

27
Outline
‹Types in programming

‹Type safety

INF 3110/4110 - 2005

‹Polymorphisms

‹Type inference

‹Type declaration
28
Type checking and type inference
‹Type checking: The process of checking
whether the types declared by the programmer
“agrees” with the language constraints/

INF 3110/4110 - 2005

requirement
‹Type inference: The process of determining the
type of an expression based on information
given by (some of) its symbols/sub-expressions

ML is designed to make type inference tractable

(one of the reason for not having subtypes in ML!)
29
Type checking and type inference
‹Standard type checking
int f(int x) { return x+1; };
int g(int y) { return f(y+1)*2;};

INF 3110/4110 - 2005

• Look at body of each function and use declared types
of identifies to check agreement.
‹Type inference
int f(int x) { return x+1; };
int g(int y) { return f(y+1)*2;};
• Look at code without type information and figure out
what types could have been declared.

30
Type inference algorithm: some history

‹Usually known as Milner-Hindley algorithm

‹1958: Type inference algorithm given by H.B.
Curry and R. Feys for the typed lambda calculus

INF 3110/4110 - 2005

‹1969: R. Hindley extended the algorithm and
proved it gives the most general type
‹1978: R. Milner -independently of Hindley-
provided an equivalent algorithm (for ML)
‹1985: L. Damas proved its completeness and
extended it with polymorphism

31
ML Type Inference
‹Example
- fun f(x) = 2+x;
val f = fn : int → int

INF 3110/4110 - 2005

‹How does this work?
• + has two types: int*int → int, real*real→real
• 2 : int, has only one type
• This implies + : int*int → int
• From context, need x: int
• Therefore f(x:int) = 2+x has type int → int

Overloaded + is unusual. Most ML symbols have unique type.

In many cases, unique type may be polymorphic. 32
Another presentation
f(x) = 2+x equiv f = λx. (2+x) equiv f = λx. ((plus 2) x)
‹Example
- fun f(x) = 2+x; Graph for λx. ((plus 2) x)
val f = fn : int → int

INF 3110/4110 - 2005

λ t→int = int→int
‹How does this work?
1. Assign types to leaves @ int (t = int)

2.Propagate to internal @ int→int x : t

nodes and generate + 2 : int
constraints int → int → int
real → real→real
3. Solve by substitution
33
Application and Abstraction

@ : r (s = t→ r) λ : s →t

f :s x :t x :s e :t

INF 3110/4110 - 2005

‹ Application ‹ Function expression
• f(x) • λx.e (fn x => e)
• f must have function type • Type is function type
domain→ range domain→ range
• domain of f must be type • Domain is type of variable x
of argument x • Range is type of function
• result type is range of f body e

34
Types with type variables
‹Example ’a is syntax for “type variable” (t in the graph)
Graph for λg. (g 2)
- fun f(g) = g(2);
val f = fn : (int→’a)→’a

INF 3110/4110 - 2005

s→t = (int→t)→t
‹How does this work? λ
t (s= int→t)
1. Assign types to leaves @

2.Propagate to internal g: s 2 : int

nodes and generate
constraints

3. Solve by substitution
35
Use of Polymorphic Function
‹Function
- fun f(g) = g(2);
val f = fn : (int→’a)→’a

INF 3110/4110 - 2005

‹Possible applications

g may be the function: g may be the function:

- fun add(x) = 2+x; - fun isEven(x) = ...;
val add = fn : int → int val it = fn : int → bool
Then: Then:
- f(add); - f(isEven);
val it = 4 : int val it = true : bool
36
Recognizing type errors

‹Function
- fun f(g) = g(2);
val f = fn : (int→’a)→’a

INF 3110/4110 - 2005

‹Incorrect use
- fun not(x) = if x then false else true;
val not = fn : bool → bool
- f(not);
Why?
Type error: cannot make bool → bool = int → ’a

37
Another type inference example
‹Function Definition
Graph for λ〈g,x〉. g(g x)
- fun f(g,x) = g(g(x));
val f = fn : (’a→’a)*’a → ’a

INF 3110/4110 - 2005

‹Type Inference s*t→v = (v→v)*v→v
λ
Assign types to leaves
v (s = u→v)
@
Propagate to internal
nodes and generate g: s u (s = t→u)
constraints @
g :s x:t
Solve by substitution
38
Polymorphic datatypes
‹Datatype with type variable
- datatype ’a list = nil | cons of ’a*(’a list);
nil : ’a list

INF 3110/4110 - 2005

cons : ’a*(’a list) → ’a list
‹ Polymorphic function
- fun length nil = 0
| length (cons(x,rest)) = 1 + length(rest);
length : ’a list → int
‹Type inference
• Infer separate type for each clause
• Combine by making two types equal (if necessary) 39
Main points about type inference
‹Compute type of expression
• Does not require type declarations for variables
• Find most general type by solving constraints

INF 3110/4110 - 2005

• Leads to polymorphism
‹Static type checking without type specifications
‹May lead to better error detection than ordinary
type checking
• Type may indicate a programming error even if there
is no type error (example following slide).

40
Information from type inference
‹An interesting function on lists
fun reverse (nil) = nil
| reverse (x::lst) = reverse(lst);

INF 3110/4110 - 2005

‹Most general type
reverse : ’a list → ’b list
‹What does this mean?
Since reversing a list does not change its type,
there must be an error in the definition

x is not used in “reverse(lst)”!

41
Outline
‹Types in programming

‹Type safety

INF 3110/4110 - 2005

‹Polymorphisms

‹Type inference

‹Type declaration
42
Type declaration
‹Transparent: alternative name to a type that
can be expressed without this name

INF 3110/4110 - 2005

‹Opaque: new type introduced into the program,
different to any other

ML has both forms of type declaration

43
Type declaration: Examples
‹Transparent (”type” declaration)

- type Celsius = real;

- fun toCelsius(x) = ((x-32.0)*0.5556);

INF 3110/4110 - 2005

- type Fahrenheit = real;
val toCelsius = fn : real → real
More information:
- fun toCelsius(x: Fahrenheit) = ((x-32.0)*0.5556): Celsius;
val toCelsius = fn : Fahrenheit → Celsius

• Since Fahrenheit and Celsius are synonyms for real,

the function may be applied to a real:

- toCelsius(60.4);
val it = 15.77904 : Celsius
44
Type declaration: Examples
‹Opaque (”datatype” declaration)
- datatype A = C of int;
- datatype B = C of int;

INF 3110/4110 - 2005

• A and B are different types
• Since B declaration follows A decl.: C has type int→B
Hence:
- fun f(x:A) = x: B;
Error: expression doesn't match constraint [tycon mismatch]
expression: A constraint: B
in expression: x: B
• Abstract types are also opaque (Mitchell’s chapter 9)
45
Equality on Types
Two forms of type equality:

‹Name type equality: Two type names are equal

INF 3110/4110 - 2005

in type checking only if they are the same name

‹Structural type equality: Two type names are

equal if the types they name are the same

Example: Celsius and Fahrenheit are structurally

equal although their names are different
46
Remarks – Further reading
‹More on subtype polymorphism (Java):
Mitchell’s Section 13.3.5

INF 3110/4110 - 2005

47
ML lectures
1. 05.09: A quick introduction to ML
2. 12.09: The Algol Family and more on ML
(Mitchell’s Chapter 5 + more)

INF 3110/4110 - 2005

3. Today: Types, Polymorphism and Overloading
(Mitchell’s Chapter 6)
4. 17.10: Exceptions and Continuations
(Mitchell’s Chapter 8)
5. 24.10: Revision (!?)

48