Type Inference

Arvind

Computer Science and Artificial Intelligence Laboratory M.I.T.

September 26, 2006 http://www.csg.csail.mit.edu/6.827

Type Inference

September 26, 2006

L06-2

Type Inference

• Type inference is typically presented in two different forms:

– Type inference rules: Rules define the type of each expression

• Clean and concise; needed to study the semantic properties, i.e., soundeness, of the type system – Type inference algorithm: Needed by the compiler

writer to deduce the type of each subexpression or to deduce that the expression is ill typed.

• Often it is nontrivial to derive an inference

algorithm for a given set of rules. There can be

many different algorithms for a set of typing rules.

L06-3

first ...

A Simple Type System

(no polymorphism)

L06-4

-calculus with Constants & Letrec

E ::= x | x.E | E E

| Cond (E, E, E)

| PF

(E

,...,E

)

| CN

| CN

(E

,...,E

) | CN

(SE

,...,SE

)

| let S in E

PF

::= negate | not | ... | Prj

| Prj

| ...

PF

::= + | ...

CN

::= Number | Boolean CN

::= cons | ...

Statements

S ::=  | x = E | S; S

not in initial terms

There are no types in the syntax of the language!

L06-5

A Simple Type System

Types

::=  base types

| t type variables

| 

-> 

Function types

Type Environments

TE ::= Identifiers  Types

int, bool, ...

L06-6

Simple Type Inference Rules

Typing: TE ├ ^{e : }

(App) TE ├ ^e

:  -> 

TE ├ ^e

: 

 TE ├ ^(e

e

) : 

(Abs)

TE ├ x.e : -> 

(Var)

TE ├ ^{x : }

(Const)

TE ├ ^{c : }

(Let)

TE ├ (let x = e

in e

) : 

TE + {x : } ├ ^{e : }

(x : )TE

typeof(c) = 

TE+{x : } ├ ^e

: TE+{x : } ├ ^e

: 

L06-7

Simple Type Inference Rules ^cont

(Cond)

TE ├ ^Cond(e

, e

, e

) :  (PF)

TE ├ ^(e

+ e

) : int (CN)

TE ├ ^CN(e

, e

) : CN(





(Pro)

TE ├ ^Prj

(e) : 

TE ├ ^e

: bool TE ├ ^e

: TE ├ ^e

: 

TE ├ ^e

: int TE ├ ^e

: int

TE ├ ^e

: 

TE ├ ^e

: 

TE ├ ^{e : CN(}



)

one such

rule for

each PF

one set

of such

rules for

each data

structure

type

L06-8

Simple Inference Algorithm

W(TE, e) returns (S,) such that S (TE) ├ e : 

The type environment TE records the most general type of each identifier while the substitution S

records the changes in the type variables

Def W(TE, e) = Case e of

x = ...

x.e = ...

(e

e

) = ...

let x = e

in e

= ...

L06-9

Simple Inference Algorithm ^(cont-1)

Def W(TE, e) = Case e of

c = ({}, Typeof(c))

x = if (x  Dom(TE))  then Fail else let = TE(x);

in ({},  )

x.e = let (S

, 

) = W(TE + { x : u }, e);

in (S

, S

(u) -> 

) (e

e

) =

let x = e

in e

=

u’s

represent new type variables

let (S

, 

) = W(TE, e

);

(S

, 

) = W(S

(TE), e

);

S

= Unify(S

(

), 

-> u);

in (S

S

S

, S

(u))

let (S

, 

) = W(TE + {x : u}, e

);

S

= Unify(S

(u), 

);

(S

, 

) = W(S

S

(TE) + {x : 

}, e

);

in (S

S

S

, 

)

September 26, 2006 http://www.csg.csail.mit.edu/6.827 L06-10

Simple Inference Algorithm ^(cont-1)

Cond(e

,e

, e

) =

(e

+ e

) =

CN(e

, e

) =

Prj

(e) =

let (S

, 

) = W(TE, e

);

(S

, 

) = W(S

(TE), e

);

S

= Unify(

, int); S

= Unify(

, int);

in (S

S

S

S

, int)

let (S

, 

) = W(TE, e

);

(S

, 

) = W(S

(TE), e

);

in (S

S

, CN(

, 

)) let (S, ) = W(TE, e);

S

= Unify(, CN(u1,u2)));

in (S S, S (u1))

These should probably be type

constants let (S

, 

) = W(TE, e

);

(S

, 

) = W(S

(TE), e

);

(S

, 

) = W(S

S

(TE), e

);

S

= Unify(

, bool); S

= Unify(

,

);

in (S

S

S

S

S

, S

S



)

L06-11

Type Inference : Example

let f = n.cond ((eq0 n), 1, n*(f (pred n)) in f

W(  , A) =

W({f : u

}, n.B) =

( [Int / u

] , Bool ) W({f : u

, n : u

}, (eq0 n) ) =

W({f : u

, n : u

}, B) = ( [ ] , Int -> Int )

Unify(u

, Int) =

A B

[ Int / u

]

W({f : u

, n : Int}, 1) = ( [ ] , Int) W({f : u

, n : Int}, n*(f (pred n))) =

W({f : u

, n : Int}, n) = ( [ ] , Int)

( [Int -> Int / u

] , Int)

W({f : Int -> Int}, f ) = ( [ ] , Int -> Int)

([Int -> Int / u

, Int / u

] , Int) ([Int -> Int / u

] , Int -> Int)

W({f : u

, n : Int}, f (pred n)) = ( [Int -> u

/ u

] , u

) Unify(u

, Int -> u

) = [ Int -> u

/ u

]

Unify(Int -> Int -> Int , Int -> u

-> Int) = [ Int / u

]

L06-12

Soundness

• The proposed type system is said to be sound if e :  then e indeed evaluates to a value in 

• A method of proving soundness:

– The semantics of the language is defined in terms of a value space that has integer

values, Boolean values etc. as subspaces.

– Any expression that may evaluate to a special value “wrong” will not type check.

– There is no type expression that denotes the subspace “wrong”.

Such proofs tend to be difficult ...

L06-13

Some observations

• A type system restricts the class of programs that are considered “legal”

• It is possible a term in the untyped –

calculus may not cause any errors but may not be typeable in a particular type system

let

id = x. x

in ... (id True) ... (id 1) ...

This term is not typeable in the simple type

system we have discussed so far.

L06-14

Polymorphic Types

Constraints:

let

id = x. x

in ... (id True) ... (id 1) ...

id :: t

--> t

id :: Int --> t

id :: Bool --> t

Does not unify!!

id :: t

. t

--> t

Different uses of a generalized type variable may be instantiated differently

id

: Bool --> Bool id

: Int --> Int

Solution: Generalize the type variable

When can we

generalize?

L06-15

now...

The Hindley-Milner Type System

L06-16

A mini Language

to study Hindley-Milner Types

• There are no types in the syntax of the language!

• The type of each subexpression is derived by the Hindley-Milner type inference algorithm.

Expressions

E ::= c constant

| x variable

| x. E abstraction

| (E

E

) application

| let x = E

in E

let-block

L06-17

A Formal Type System

Note, all the ’s occur in the beginning of a type scheme, i.e., a type  cannot contain a type scheme 

Types

::=  base types

| t type variables

| 

-> 

Function types

Type Schemes

::= 

|t. 

Type Environments

TE ::= Identifiers  Type Schemes

L06-18

Instantiations

• Type scheme can be instantiated into a type ^’ by substituting types for the bound variables of , i.e.,

^’ = S  for some S s.t. Dom(S)  BV() - ^’ is said to be an instance of (>^’)

- ^’ is said to be a generic instance of when S maps variables to new variables.

=t

...t

. 

Example:

=t

. t

-> t

t

-> t

is a generic instance of

Int -> t

is a non generic instance of 

L06-19

Generalization aka Closing

• Generalization introduces polymorphism

• Quantify type variables that are free in  but not free in the type environment (TE)

• Captures the notion of new type variables of 

Gen(TE,) = t

...t

. 

where { t

...t

} = FV() - FV(TE)

L06-20

HM Type Inference Rules

Typing: TE ├ ^{e : }

(App) TE ├ ^e

:  -> 

TE ├ ^e

: 

 TE ├ ^(e

e

) : 

(Abs)

TE ├ x.e : -> 

(Var)

TE ├ ^{x : }

(Const)

TE ├ ^{c : }

(Let)

TE ├ (let x = e

in e

) : 

TE + {x : } ├ ^{e : }

(x : )TE   

typeof(c)  

TE+{x : } ├ ^e

: TE+{x:Gen(TE,)} ├ ^e

: 

L06-21

HM Inference Algorithm

Def W(TE, e) = Case e of

c = ({}, Typeof(c)) x =

x.e =

(e

e

) =

let x = e

in e

=

u’s

represent new type variables

let (S

, 

) = W(TE, e

);

(S

, 

) = W(S

(TE), e

);

S

= Unify(S

(

), 

-> u);

in (S

S

S

, S

(u))

if (x  Dom(TE))  then Fail else let t

...t

.= TE(x);

in ( { }, [u

/ t

] )

let (S

, 

) = W(TE + { x : u }, e);

in (S

, S

(u) -> 

)

let (S

, 

) = W(TE + {x : u}, e

);

S

= Unify(S

(u), 

);

 = Gen(S

S

(TE), S

(

) );

(S

, 

) = W(S

S

(TE) + {x : }, e

);

in (S

S

S

, 

)

L06-22

Hindley-Milner: Example

x. let f = y.x

in (f 1, f True)

W(  , A) =

W({x : u

}, B) =

( [ ] , u

) ( [ ] , u

-> u

)

u

.u

-> u

TE = {x : u

, f : u

.u

-> u

}

( [ ] , u

-> u

) W(TE, 1 ) = ( [ ] , Int )

[ Int / u

, u

/ u

] ( [ ] , u

)

( [ ] , (u

,u

) )

Unify(u

-> u

, Int -> u

) = W({x : u

, f : u

, y : u

}, x ) = W({x : u

, f : u

}, y.x ) =

Gen({x : u

}, u

-> u

) = W(TE, (f 1) ) =

( [ ] , u

-> (u

,u

) )

W(TE, f ) =

Unify(u

, u

-> u

) =

B A

[ (u

-> u

) / u

]

...

L06-23

Important Observations

• Do not generalize over type variables used elsewhere

• Let is the only way of defining polymorphic constructs

• Generalize the types of let-bound identifiers

only after processing their definitions

L06-24

Properties of HM Type Inference

• It is sound with respect to the type system.

An inferred type is verifiable.

• It generates most general types of expressions.

Any verifiable type is inferred.

• Complexity

PSPACE-Hard

DEXPTIME-Complete

Nested let blocks

L06-25

Extensions

• Type Declarations

Sanity check; can relax restrictions

• Incremental Type checking

The whole program is not given at the same time, sound inferencing when types of some functions are not known

• Typing references to mutable objects

Hindley-Milner system is unsound for a language with refs (mutable locations)

• Overloading Resolution

L06-26

HM Limitations:

-bound vs Let-bound Variables

Only let-bound identifiers can be instantiated differently.

let

twice f x = f (f x) in twice twice succ 4

vs.

let

twice f x = f (f x) foo g = (g g succ) 4 in foo twice

foo is not type correct !

Generic vs. Non-generic type variables

L06-27

Puzzle: Another set of Inference rules

(Gen) TE ├ e : t  FV(TE) TE ├ e : t.

(Spec) TE ├ e : t.

TE ├ e : [t’/t]

(Var) (x : )  TE TE ├ ^{x : }

(Let) TE+{x:} ├ ^e

: TE+{x:} ├ ^e

:

TE ├ (let x = e

in e

) : 

(App) and (Abs) rules remain unchanged.

Sound but no

inference

algorithm !

L06-28

next time --- Overloading