Type Systems

Typing

Michal P´se (CTU in Prague)
ıˇ Object Programming Lect. 1: Type Systems September 21, 2010 2 / 30

The Purpose of Typing

”Well-typed programs never go wrong.”


What Does ”Go Wrong” Entail?

Execution errors.
Program crash.
Divergence.
...


The Purpose of Typing (II)

As a side eﬀect, typed programs are also more likely to actually do what
they are supposed to do.


Two Kinds of Typing

Static typing.
Dynamic typing (more precisely: dynamic checking).


Why Do They Both Exist?

It is provenly impossible to create a type system that rejects all
incorrect programs (written in a real-world programming language)
and accepts all correct ones.


Why Do They Both Exist?

It is provenly impossible to create a type system that rejects all
incorrect programs (written in a real-world programming language)
and accepts all correct ones.
Beneﬁts vs. costs trade-oﬀ: static typing rejects at least some
incorrect programs at the expense of not accepting certain correct
ones.


Example

class Foo { public void urgh() { ...} }
class Bar { public void urgh() { ...} }

void main() {
Object var;
if ( something()) var = new Foo();
else var = new Bar();
var.urgh();
}


Example

class Foo { public void urgh() { ...} }
class Bar { public void urgh() { ...} }

void main() {
Object var;
if ( something()) var = new Foo();
else var = new Bar();
var.urgh();
}

It is obvious that an object pointed at by var has method urgh, however,
many type systems don’t provide any way of expressing it without
modifying (and recompiling) deﬁnitions of Foo and Bar.


Which Is Better?

Debating which is better may (and probably will) get you into a
violent ﬂamewar.
The real question is whether there will ever be a type system that does
not stand in programmers’ way and rejects all incorrect programs.


Relaxed Notions of Typing

Untrapped errors vs. trapped errors, forbidden errors.
Safe languages disallow untrapped errors (usually by a mixture of
static and runtime checks).
Strongly typed languages disallow forbidden errors (ditto).
Weakly typed languages allow even for untrapped errors.


Type Algebra


Function Type

A→B


Product Type

A×B


Intersection Type

A∩B


Union Type

A∪B


Type System


Two Components of Type Control

Type system—a speciﬁcation.
Type checking algorithm—an algorithm.
There may be zero or more than one distinct type checking
algorithms for a particular type system.
Type systems described in a formal language have lower
probability of ambiguities, unconsidered corner cases etc.


Example

begin
string s;
s = "abc";
string t;
t = s + "def";
end


Grammar

P → begin CL end program
CL → C ; CL sequential composition

C→T I declaration
I =E assignment
T → string types
int
E→I identiﬁer
N numeral
S string literal
E1 + E2 sum of two subexpressions


Key Components of a Type System Speciﬁcation

Judgements.
Type rules.
Environment.


Type System

Empty Environment

∅ ◦


Type System (II)

Variable Creation
I : string ∈ Γ I : int ∈ Γ Γ ◦
Γ ∪ {I : string } ◦ Γ ∪ {I : int} ◦


Type System (III)

Literals
Γ ◦ Γ ◦
Γ S : string Γ N : int


Type System (IV)

Variables in Environment
I : string ∈ Γ I : int ∈ Γ
Γ I : string Γ I : int


Type System (V)

Sum
Γ E : string Γ F : string Γ E : int Γ F : int
Γ E + F : string Γ E + F : int


Type System (VI)

Assignment
Γ I : string Γ E : string Γ I : int Γ E : int
Γ I =E : Γ I =E :


Type System (VII)

Sequential Composition
Γ ◦
Γ :
Γ ∪ {I : string } ◦ Γ ∪ {I : string } C:
Γ string I ; C :
Γ ∪ {I : int} ◦ Γ ∪ {I : int} C:
Γ int I ; C :
Γ C: Γ CL :
Γ C ; CL :


Type System (VIII)

Program
∅ CL :
begin CL end :


Other Uses of Type Information

Semantics.
Optimization.
Static analysis.
...


See

Luca Cardelli. Type Systems. ACM Computing Surveys 28, 1 (March
1996), 263-264. http://doi.acm.org/10.1145/234313.234418


Type Systems

More Related Content

Viewers also liked

Similar to Type Systems

More from Michal Píše

Recently uploaded

Type Systems