Type inference in the generic type system of Java 5pl/talks/Type_Inference_Generics.pdf · Type...

IntroductionSubtyping

The AlgorithmConclusion

Type inference in the generic type system of Java 5.0

Martin Plumicke

University of Cooperative EducationStuttgart/Horb

12. Januar 2007

Martin Plumicke Type inference in the generic type system of Java 5.0

Overview

IntroductionProblemRelated work

Subtyping

The AlgorithmType unificationType–inference–algorithmPrincipal typeTool demonstration

Conclusion

ProblemRelated work

Problem

Extensions of the Java 5.0 type–systemI parametrized types, type variables, type terms, wildcards

Vector<? extends AbstractList<? super Integer>>

Complex typingsI Often it is not obvious, which are the best types for methods and

variables

I Sometimes principal types in Java 5.0 are intersection types, whichare not expressible (contradictive of writing re-usable code)

=⇒ Developing a type–inference–system, which determines principal types

ProblemRelated work

Problem

variables

ProblemRelated work

Problem

variables

ProblemRelated work

Example: Multiplication of matrices

class Matrix extends Vector<Vector<Integer>> {Matrix mul(Matrix m) {

Matrix ret = new Matrix();

int i = 0;

while(i <size()) {Vector<Integer> v1 = this.elementAt(i);

Vector<Integer> v2 = new Vector<Integer>();

int j = 0;

while(j < v1.size()) {int erg = 0;

int k = 0;

while(k < v1.size()) {erg = erg + v1.elementAt(k)

* m.elementAt(k).elementAt(j); k++; }v2.addElement(new Integer(erg)); j++; }

ret.addElement(v2); i++; }return ret; }}

ProblemRelated work

Alternative Typing

class Matrix extends Vector<Vector<Integer>> {Matrix/Vector<Vector<Integer>> mul(Matrix/Vector<Vector<Integer>> m) {

Matrix/Vector<Vector<Integer>> ret = new Matrix();

int i = 0;

while(i <size()) {Vector<Integer> v1 = this.elementAt(i);

Vector<Integer> v2 = new Vector<Integer>();

int j = 0;

while(j < v1.size()) {int erg = 0;

int k = 0;

ProblemRelated work

Purpose: Typless

class Matrix extends Vector<Vector<Integer>> {mul(m) {

ret = new Matrix();

i = 0;

while(i <size()) {v1 = this.elementAt(i);

v2 = new Vector<Integer>();

j = 0;

while(j < v1.size()) {erg = 0;

k = 0;

ProblemRelated work

System determines the principle typing(s)

mul: Matrix → Matrix &Matrix→ Vector<Vector<Integer>>& . . .&Vector<? extends Vector<? extends Integer>>

→ Vector<? super Vector<Integer>>

ProblemRelated work

Related work

over type expressions)

recursive typeF−bounded polymorphismus

(Cartesian product algorithm

(Data polymorpic Cartesian product algorithm in Java)

type system

S−unification)

[Plevyak, Chien 94]

(Precise concrete TI in OO data polymorphism function polymorphism no principal type)

(inclusion constraints)

[Hindley/Milner et. al.]

[Aiken, Wimmer 93]

[Eifrig, Smith, Trifonov 95a/b][Agesen 95/96]

no data polymorphism) [Agesen, Palsberg, Schwartzbach 93]

[Palsberg, Schwartzbach 91]

(TI in OO−Languages)

(Inheritance)

[Wang, Smith 01]

(Type parameter inference, Generic Libraries

(Type parameter inference, Generic Libraries Extension of [Palsberg, Schwartzbach 94] to parametrized types)

[Fuhrer, Tip Kiezun, Dolby, Keller 05]

[Donovan,Kiezun, Tschantz, Ernst 04]

(copying classes)

diiferentiation of declaration and allocation side

[Oxhoj, Palsberg, Schwartzbach 92]

ProblemRelated work

Related work

recursive typeF−bounded polymorphismus

type system

S−unification)

[Plevyak, Chien 94]

[Aiken, Wimmer 93]

[Eifrig, Smith, Trifonov 95a/b][Agesen 95/96]

no data polymorphism) [Agesen, Palsberg, Schwartzbach 93]

(Inheritance)

[Wang, Smith 01]

(copying classes)

precise typesno principle type

Extension of [Palsberg, Schwartzbach 94] to parametrized types)

ProblemRelated work

Related work

recursive type

F−bounded polymorphismus

type system

S−unification)

precise types

(Type parameter inference, Generic Libraries Extension of [Palsberg, Schwartzbach 94] to parametrized types)

(copying classes)

[Agesen, Palsberg, Schwartzbach 93]

(Inheritance)

[Wang, Smith 01]

[Aiken, Wimmer 93]

[Eifrig, Smith, Trifonov 95a/b]

[Plevyak, Chien 94]

no principle type

[Agesen 95/96]

no data polymorphism)

λ− Terms

ProblemRelated work

Our approach

[Hindley/Milner et al]

– function type constructor → (no higher–order functions)

+ function template (ty1 × . . .× tyn) → ty0

(first–order functions)

+ data and function polymorphism (overloading)

ProblemRelated work

Our approach

ProblemRelated work

Our approach

ProblemRelated work

Abbreviation for wildcard–types

Instead of A<? extends B> we write

and instead of C<? super D> we write

C<?D>.

Subtyping ordering ≤∗

Reflexive and transitiv closure of

I if θ extends θ′ then θ≤∗ θ′.I if θ1≤∗ θ2 then σ1( θ1 )≤∗ σ2( θ2 ), where for each type variable a ofθ2 holds σ1( a ) = σ2( a ) (soundness condition).

I a≤∗ θ′ for a ∈ BTV (θ1&...&θn) where ∃θi : θi ≤∗ θ′.I It holds C<θ1, . . . , θn>≤∗ C<θ′1, . . . , θ

′n> if for θi and θ′i either

I θi = ?θi , θ′i = ?θ

′i and θi ≤∗ θ

′i or

I θi = ?θi , θ′i = ?θ

′i and θ

′i ≤∗ θi or

I θi , θ′i are no wildcard arguments and θi = θ′i or

I θ′i = ?θi orI θ′i = ?θi

I It holds C<θ1, . . . , θn>≤∗ C<θ′1, . . . , θ′n> if it holds

C<θ1, . . . , θn>≤∗ C<θ′1, . . . , θ′n> and C<θ1, . . . , θn> is the capture

conversions of C<θ1, . . . , θn>.

Capture conversion

The capture conversions C<θ1, . . . , θn> of a type C<θ1, . . . , θn> isdefined as:

I for all θi = ? there is a fresh type variable bi |ui [ai=bi | 16i6n] suchthat θi = bi .

I for all θi = ?θ′i there is a fresh type variable bi |θ

′i & ui [ai=bi | 16i6n],

such that θi = bi .

I for all θi = ?θ′i there is a fresh type variable θ′|bi |ui [ai=bi | 16i6n] ,such that θi = bi .

I otherwise θi = θi

Example: Matrix<a>≤∗ Vector<Vector<a>>

Vector<Vector<Integer>>

Matrix<Integer>

|IntegerX

Vector< Vector< >>

Matrix< >

Integer

Vector< Vector<Integer>>

Vector< Vector< >>

Matrix< > Integer |IntegerX

|Integer

Matrix< >

Vector<Vector< >>

Integer

Matrix< > Integer

Matrix<Integer>

|IntegerX

Vector< Vector< >>

Matrix< >

Integer

Vector< Vector< >>

|Integer

Matrix< >

Vector<Vector< >>

Integer

Matrix< > Integer

Matrix<Integer>

|IntegerX

Vector< Vector< >>

Matrix< >

Integer

Vector< Vector< >>

Matrix< > Integer

|IntegerX

|Integer

Matrix< >

Vector<Vector< >>

Integer

Matrix< > Integer

Matrix<Integer>

|IntegerX

Vector< Vector< >>

Matrix< >

Integer

Vector< Vector< >>

|Integer

Matrix< >

Vector<Vector< >>

Integer

Matrix< > Integer

Type unificationType–inference–algorithmPrincipal typeTool demonstration

The algorithm

Type unification

Subtyping relation for type terms: ≤∗

Type Unification problem:

For two type terms θ1 and θ2 a substitution σ is demandedsuch that:

σ( θ1 )≤∗ σ( θ2 ).

Base of Hindley/Milner approach:(Type) unification algorithm [Martelli, Montanari 1982]

(reduce)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ

′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(erase)Eq ∪ { θ .

= θ′ }Eq

θ = θ′

(swap)Eq ∪ { θ .

= a }Eq ∪ { a

.= θ } a ∈ TV

(subst)Eq ∪ { a

.= θ }

Eq[a 7→ θ] ∪ { a.= θ } a occurs in Eq but not in θ

Type unification algorithm for Java 5.0 type terms withoutwildcards [Plumicke 2004, Unif’04, Cork]

(adapt)Eq ∪ {D<θ1, . . . , θn> l D′<θ′1, . . . , θ′m> }Eq ∪ {D′<θ

′1, . . . , θ

′m>[ai 7→ θi | 16 i 6n] l D′<θ′1, . . . , θ′m> }

where there are θ′1, . . . , θ

′m with

I (D<a1, . . . , an>≤∗ D′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(reduce1)Eq ∪ {C<θ1, . . . , θn> l D<θ′1, . . . , θ′n> }Eq ∪ { θπ( 1 )

.= θ′1, . . . , θπ( n )

.= θ′n }

I C<a1, . . . , an>≤∗ D<aπ( 1 ), . . . , aπ( n )>

I { a1, . . . , an } ⊆ TV

I π is a permutation

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(erase)Eq ∪ { θ

.= θ′ }

Eqθ = θ′

(swap)Eq ∪ { θ

.= a }

Eq ∪ { a.= θ } a ∈ TV

(subst)Eq ∪ { a

.= θ }

Eq[a 7→ θ] ∪ { a.= θ }

I a occurs in Eqbut not in θ

′1, . . . , θ

′m>[ai 7→ θi | 16 i 6n] l D′<θ′1, . . . , θ′m> }

′m with

I (D<a1, . . . , an>≤∗ D′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

.= θ′1, . . . , θπ( n )

.= θ′n }

I C<a1, . . . , an>≤∗ D<aπ( 1 ), . . . , aπ( n )>

I { a1, . . . , an } ⊆ TV

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(erase)Eq ∪ { θ

.= θ′ }

Eqθ = θ′

(swap)Eq ∪ { θ

.= a }

Eq ∪ { a.= θ } a ∈ TV

(subst)Eq ∪ { a

.= θ }

Eq[a 7→ θ] ∪ { a.= θ }

′1, . . . , θ

′m>[ai 7→ θi | 16 i 6n] l D′<θ′1, . . . , θ′m> }

′m with

I (D<a1, . . . , an>≤∗ D′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

.= θ′1, . . . , θπ( n )

.= θ′n }

I C<a1, . . . , an>≤∗ D<aπ( 1 ), . . . , aπ( n )>

I { a1, . . . , an } ⊆ TV

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(erase)Eq ∪ { θ

.= θ′ }

Eqθ = θ′

(swap)Eq ∪ { θ

.= a }

Eq ∪ { a.= θ } a ∈ TV

(subst)Eq ∪ { a

.= θ }

Eq[a 7→ θ] ∪ { a.= θ }

Type unification algorithm with wildcards

(redUp)Eq ∪ { θ l ?θ′ }Eq ∪ { θ l θ′ } (redUpLow)

Eq ∪ { ?θ l ?θ′ }Eq ∪ { θ l θ′ } (redLow)

Eq ∪ { ?θ l θ′ }Eq ∪ { θ l θ′ }

Wildcards in outermost position

(red1)Eq ∪ {C<θ1, . . . , θn> l D<θ′1, . . . , θ

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

Reduce rule for outermosttype symbol

where– C<a1, . . . , an>≤∗ D<aπ( 1 ), . . . , aπ( n )>

– { a1, . . . , an } ⊆ BTV

– π is a permutation

(redExt)Eq ∪ {X<θ1, . . . , θn>l? ?Y <θ′1, . . . , θ

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

Reduce rule forextends wildcards

where– ?Y <aπ( 1 ), . . . , aπ( n )> ∈ gr(X<a1, . . . , an> )– { a1, . . . , an } ⊆ BTV

Eq ∪ { ?θ l θ′ }Eq ∪ { θ l θ′ }

(red1)Eq ∪ {C<θ1, . . . , θn> l D<θ′1, . . . , θ

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

– { a1, . . . , an } ⊆ BTV

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

Eq ∪ { ?θ l θ′ }Eq ∪ { θ l θ′ }

(red1)Eq ∪ {C<θ1, . . . , θn> l D<θ′1, . . . , θ

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

– { a1, . . . , an } ⊆ BTV

′n> }

Eq ∪ { θπ( 1 ) l? θ′1, . . . , θπ( n ) l? θ

′n }

(redSup)Eq ∪ {X<θ1, . . . , θn>l?

?Y <θ′1, . . . , θ′n> }

Eq ∪ { θ′1 l? θπ( 1 ), . . . , θ′n l? θπ( n ) }

Reduce rule forsuper wildcards

– ?Y <aπ( 1 ), . . . , aπ( n )> ∈ gr(X<a1, . . . , an> )– { a1, . . . , an } ⊆ BTV

(redEq)Eq ∪ {X<θ1, . . . , θn>l? X<θ′1, . . . , θ

′n> }

Eq ∪ { θπ( 1 ).= θ′1, . . . , θπ( n )

.= θ′n }

Reduce rule forequal type symbols

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ

′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

Original reduce rule

(redSup)Eq ∪ {X<θ1, . . . , θn>l?

?Y <θ′1, . . . , θ′n> }

Eq ∪ { θ′1 l? θπ( 1 ), . . . , θ′n l? θπ( n ) }

′n> }

Eq ∪ { θπ( 1 ).= θ′1, . . . , θπ( n )

.= θ′n }

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ

′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(redSup)Eq ∪ {X<θ1, . . . , θn>l?

?Y <θ′1, . . . , θ′n> }

Eq ∪ { θ′1 l? θπ( 1 ), . . . , θ′n l? θπ( n ) }

′n> }

Eq ∪ { θπ( 1 ).= θ′1, . . . , θπ( n )

.= θ′n }

(reduce2)Eq ∪ {C<θ1, . . . , θn>

.= C<θ′1, . . . , θ

′n> }

Eq ∪ { θ1.= θ′1, . . . , θn

.= θ′n }

(adapt)Eq ∪ {D<θ1, . . . , θn> l D ′<θ′1, . . . , θ

′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l D ′<θ′1, . . . , θ

′m> }

′m with outermost adapt rule

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(adaptExt)Eq ∪ {D<θ1, . . . , θn>l? ?D

′<θ′1, . . . , θ′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

′m with adapt rule: extends wildcard

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(adaptSup)Eq ∪ {D ′<θ′1, . . . , θ

′m>l?

?D<θ1, . . . , θn> }Eq ∪ {D ′<θ

′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

′m with adapt rule: super wildcard

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l D ′<θ′1, . . . , θ

′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

′<θ′1, . . . , θ′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(adaptSup)Eq ∪ {D ′<θ′1, . . . , θ

′m>l?

?D<θ1, . . . , θn> }Eq ∪ {D ′<θ

′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l D ′<θ′1, . . . , θ

′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

′<θ′1, . . . , θ′m> }

Eq ∪ {D ′<θ′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(adaptSup)Eq ∪ {D ′<θ′1, . . . , θ

′m>l?

?D<θ1, . . . , θn> }Eq ∪ {D ′<θ

′1, . . . , θ

′m>[ai 7→ CC( θi ) | 16 i 6n] l? ?D

′<θ′1, . . . , θ′m> }

I (D<a1, . . . , an>≤∗ D ′<θ′1, . . . , θ

′m>) ∈ FC( ≤ )

(erase1)Eq ∪ { θ l θ′ }Eq

θ≤∗ θ′

(erase2)Eq ∪ { θl? θ

′ }Eq

θ′ ∈ gr( θ )

(erase3)Eq ∪ { θ .

= θ′ }Eq

θ = θ′

(swap)Eq ∪ { θ .

= a }Eq ∪ { a

.= θ } θ 6∈ BTV , a ∈ BTV

(subst)Eq′ ∪ { a

.= θ }

Eq′[a 7→ θ] ∪ { a.= θ } a occurs in Eq′ but not in θ

(erase1)Eq ∪ { θ l θ′ }Eq

θ≤∗ θ′

(erase2)Eq ∪ { θl? θ

′ }Eq

θ′ ∈ gr( θ )

(erase3)Eq ∪ { θ .

= θ′ }Eq

θ = θ′

(swap)Eq ∪ { θ .

= a }Eq ∪ { a

.= θ } θ 6∈ BTV , a ∈ BTV

(subst)Eq′ ∪ { a

.= θ }

Eq′[a 7→ θ] ∪ { a.= θ } a occurs in Eq′ but not in θ

Example

Subtyping relation: Matrix<a>≤∗ Vector<Vector<a>>Vector<a>≤∗ AbstractList<a>≤∗ List<a>

Application of the algorithm:{ Matrix<b> l Vector<Vector<?AbstractList<Object>>>, a

.= b }

(adapt)=⇒ { Vector<Vector<CC( b )>>

lVector<Vector<?AbstractList<Object>>>,a.= b }

(red1,redEq)=⇒ {CC( b )

.= ?AbstractList<Object>,

a.= b }

=⇒ fail

Example cont.

{ Matrix<b> l Vector<?Vector<?AbstractList<Object>>>,a.= b }

adapt=⇒ { Vector<Vector<CC( b )>>

lVector<?Vector<?AbstractList<Object>>>,a.= b }

red1,redExt=⇒ {CC( b ) l? ?AbstractList<Object>,

a.= b }

newsets,subst=⇒ {{ b .

= AbstractList<Object>, a.= AbstractList<Object> },

{ b .= ?AbstractList<Object>, a

.= ?AbstractList<Object> },

{ b .= Vector<Object>, a

.= Vector<Object> },

{ b .= ?Vector<Object>, a

.= ?Vector<Object> } }

Type–inference–algorithm

Type assumptions: For each absent type in the program atype-placeholder (fresh type variable) is assumed.

Run over the abstract syntax tree: During the run over abstract syntaxtree of the coresponding java class the types are calculatedgradually by type unification.

Multiplying the assumptions: If the result of a type unification containsmore than one result or if there is data polymorphism, the set oftype assumptions is multiplied.

Erase type assumptions: If the type unification fails, the correspondingset of type assumptions is erased.

New method type parameters: At the end remained type-placeholdersare replaced by new introduced method type parameters.

Intersection types: At the end each remained set of type assumptionsforms one element of the result’s intersection type.

Type–inference rules

(O, τ, τ ′) BExpr e1 : θ′, (O, τ, τ ′) BExpr e2 : θ[Assign]

(O, τ, τ ′) BExpr Assign( e1, e2 ) : θ′θ≤∗ θ′

(O, τ, τ ′) BExpr re : θ∀16 i 6n : (O, τ, τ ′) BExpr ei : θi ,

(θ′1 . . . θ′n, θ) = lub( θ, f , (θ1, . . . , θn) )

[Method-Call

](O, τ, τ ′) BExpr MethodCall( re, f ( e1, . . . , en ) ) : θ

(O, τ, τ ′) BExpr e : θ[Return]

(O, τ, τ ′) BStmt Return( e ) : θ

(θ′1 . . . θ′n, θ) = lub( θ, f , (θ1, . . . , θn) )

[Method-Call

(θ′1 . . . θ′n, θ) = lub( θ, f , (θ1, . . . , θn) )

[Method-Call

Example: Multiplication of matrices: Type assumptions

class Matrix extends Vector<Vector<Integer>> {{α } mul({β } m) {

{ γ } ret = new Matrix();

int i = 0;

while(i <size()) {{ ι } v1 = this.elementAt(i);

{κ } v2 = new Vector<Integer>();

int j = 0;

while(j < v1.size()) {{χ } erg = 0;

int k = 0;

while(k < v1.size()) {erg = erg + ({ ξ }({ ι } v1).elementAt(k))

* ({ψ }({φ } ({β } m).elementAt(k)).elementAt(j)); k++;}v2.addElement({χ } erg); j++; }

ret.addElement({µ } v2); i++; }return ret; }}

ret = new Matrix ()

{α } mul({β } m) {{ γ } ret = { Matrix } new Matrix();. . .return { γ } ret;

Unification: Matrix l γ

⇒γ = Matrixγ = Vector<Vector<Integer>>γ = Vector<?Vector<Integer>>γ = Vector<?Vector<?Integer>>γ = Vector<?Vector<

?Integer>>γ = Vector<?Vector<Integer>>

Type assumptions after the first unification

class Matrix extends Vector<Vector<Integer>> {{α, α, α, α, α, α } mul({β, β, β, β, β, β } m) {

{ Matrix, Vector<Vector<Integer>>, Vector<?Vector<Integer>>,Vector<?Vector<?Integer>>, Vector<?Vector<

?Integer>>,Vector<?Vector<Integer>> } ret = new Matrix();

int i = 0; while(i <size()) {{ ι, ι, ι, ι, ι, ι } v1 = this.elementAt(i);

{κ, κ, κ, κ, κ, κ } v2 = new Vector<Integer>();

int j = 0; while(j < v1.size()) {{χ, χ, χ, χ, χ, χ } erg = 0;

int k = 0; while(k < v1.size()) {erg = erg +({ ξ, ξ, ξ, ξ, ξ, ξ }({ ι, ι, ι, ι, ι, ι } v1).elementAt(k))

* ({ψ,ψ, ψ, ψ, ψ, ψ }({φ, φ, φ, φ, φ, φ }({β, β, β, β, β, β } m).elementAt(k)).elementAt(j)); k++;}

v2.addElement({χ, χ, χ, χ, χ, χ } erg); j++; }ret.addElement({µ, µ, µ, µ, µ, µ } v2); i++; }

return ret; }}Martin Plumicke Type inference in the generic type system of Java 5.0

v1 = this.elementAt(i);

{α } mul({β } m) {. . .{ ι } v1 = ({ Matrix } this).elementAt(i);. . .

Unification: Matrix l Vector<ι>

ι = Vector<Integer>ι = Vector<?Integer>ι = Vector<?Integer>

v2 = new Vector<Integer> ();

{α } mul({β } m) {. . .{κ } v2 = { Vector<Integer> } new Vector<Integer>();. . .

Unification: Vector<Integer> l κ

κ = Vector<Integer>κ = Vector<?Integer>κ = Vector<?Integer>

erg = erg + v1.elementAt(k)

* m.elementAt(k)).elementAt(j)); (I)

{α } mul({β } m) {. . .

{χ } erg = {χ } erg + ({ ξ }({ ι }v1).elementAt(k))* ({ψ }({φ } ({β } m).elementAt(k)).elementAt(j)); k++;}

. . .}

({β } m).elementAt(k): Unification: β l Vector<φ>β = Vector<φ>β = Matrix ⇒ φ = Vector<Integer> or

φ = ?Vector<Integer> orφ = ?Vector<?Integer> orφ = ?Vector<Integer>

* m.elementAt(k)).elementAt(j)); (II)

({φ }({β }m).elementAt(k)).elementAt(j):

Unification: φl Vector<ψ>

β = Vector<φ> ⇒ φ = Vector<ψ> orφ = ?Vector<ψ> orφ = Matrix

β = Matrix⇒ φ = Vector<Integer>⇒ OKφ = . . .

* m.elementAt(k)).elementAt(j)); (III)

({ ξ }({ ι }v1).elementAt(k))*({ψ }({φ }({β }m).elementAt(k)).elementAt(j)):β = Vector<φ> :

From * : (int, int) → int follows

Unification: ψ l Integer

φ = Vector<ψ> ⇒ ψ = Integer⇒ OK⇒ ψ = ?Integer⇒ OK

φ = ?Vector<ψ> ⇒ ψ = Integer⇒ OK⇒ ψ = ?Integer⇒ OK

φ = Matrix⇒ (ψ =)Vector<Integer> l Integer⇒ fail⇒ assumption is erased

* m.elementAt(k)).elementAt(j)); (IV)

{α } mul({β } m) {. . .

Result for β:

β = Vector<Vector<Integer>>β = Vector<Vector<?Integer>>β = Vector<?Vector<Integer>>β = Vector<?Vector<?Integer>>β = Matrix

* m.elementAt(k)).elementAt(j)); (V)

{χ } erg = {χ } erg + ({ ξ }({ ι }v1).elementAt(k))*({ψ }({φ }({β }m).elementAt(k)).elementAt(j)):

From +, * : (int, int) → intwith

ξ = Integer l Integerξ = ?Integer l Integer

andψ = Integer l Integerψ = ?Integer l Integer

followsχ = Integer

v2.addElement(erg);

{α } mul({β } m) {. . .{κ } v2 = new Vector<Integer>();. . .v2.addElement({χ } erg);. . .

χ = Integer, κ = Vector<Integer>⇒ Integer l Integer⇒ OK

χ = Integer, κ = Vector<?Integer>⇒ Integer l ?Integer⇒ fail⇒ assumption is erased

χ = Integer, κ = Vector<?Integer>⇒ Integer l ?Integer⇒ OK

ret.addElement(v2); (I)

{ γ } ret = new Matrix(); . . . ; ret.addElement({κ } v2);

κ = Vector<Integer>, γ = Matrix⇒ Vector<Integer> l Vector<Integer>⇒ OK

κ = Vector<Integer>, γ = Vector<Vector<Integer>>⇒ Vector<Integer> l Vector<Integer>⇒ OK

κ = Vector<Integer>, γ = Vector<?Vector<Integer>>⇒ Vector<Integer> l ?Vector<Integer>⇒ fail

κ = Vector<Integer>, γ = Vector<?Vector<?Integer>>⇒ Vector<Integer> l ?Vector<?Integer>⇒ fail

κ = Vector<Integer>, γ = Vector<?Vector<?Integer>>

⇒ Vector<Integer> l ?Vector<?Integer>⇒ fail

κ = Vector<Integer>, γ = Vector<?Vector<Integer>>⇒ Vector<Integer> l ?Vector<Integer>⇒ OK

ret.addElement(v2); (II)

{ γ } ret = new Matrix(); . . . ; ret.addElement({κ } v2);

With κ = Vector<?Integer> for all assumptions of γ type unificationfails.

Result:γ = Matrixγ = Vector<Vector<Integer>>γ = Vector<?Vector<Integer>>

return ret;

{α } mul({β } m) {. . .return { γ } ret;

}Unification: γ l α forγ = Matrixγ = Vector<Vector<Integer>>γ = Vector<?Vector<Integer>>

Result: α = Matrixα = Vector<Vector<Integer>>α = Vector<?Vector<Integer>>α = Vector<?Vector<Integer>>α = Vector<?Vector<?Integer>>α = Vector<?Vector<

?Integer>>Martin Plumicke Type inference in the generic type system of Java 5.0

Result:

mul: &α,β(α→β),

α≤∗ Vector<?Vector<?Integer>>,Matrix≤∗ β

Principal type

Definition [Damas, Milner 1982]:

“A type-scheme for a declaration is a principal type-scheme, if any othertype-scheme for the declaration is a generic instance of it.”

Generalization to the Java 5.0 type system

“An intersection type-scheme for a declaration is a principal type-scheme,if any other type-scheme for the declaration is a generic instance of oneelement of the intersection type-scheme.”

Principal type

Definition [Damas, Milner 1982]:

“A type-scheme for a declaration is a principal type-scheme, if any othertype-scheme for the declaration is a generic instance of it.”

Generalization to the Java 5.0 type system

“An intersection type-scheme for a declaration is a principal type-scheme,if any other type-scheme for the declaration is a generic instance of oneelement of the intersection type-scheme.”

Principal type

DefinitionAn intersection type of a method m in a class C

m : (θ1,1 × . . .× θ1,n → θ1)& . . .&(θm,1 × . . .× θm,n,→ θm)

is called principal if for any correct type annotated method declaration

rty m(ty1 a1 , . . . , tyn an) { . . . }

there is an element (θi ,1 × . . .× θi ,n,→ θi ) of the intersection type andthere is a substitution σ, such that

σ( θi )≤∗ rty , ty1 ≤∗ σ( θi ,1 ), . . . , tyn ≤∗ σ( θi ,n )Martin Plumicke Type inference in the generic type system of Java 5.0

Reduced principal type:

The inferred type of the example

where α≤∗ Vector<?Vector<?Integer>> and Matrix≤∗ β.

is a principle type.

But there is also a reduced principle type:

mul: Vector<?Vector<?Integer>>→ Matrix

Reduced principal type:

The inferred type of the example

where α≤∗ Vector<?Vector<?Integer>> and Matrix≤∗ β.

is a principle type.

But there is also a reduced principle type:

mul: Vector<?Vector<?Integer>>→ Matrix

Principle type property

TheoremThe type inference algorithm calculates a principle type.

Tool demonstration

I Matrix–Example

I Overloading–Example

Conclusion and future work

ConclusionI Type-inference-algorithm for Java 5.0

I Type unification

I Principle type property

Future workI Reduce the number of calculated typings.

I Handling of interesection types (adaption of byte-code generation)

Conclusion and future work

ConclusionI Type-inference-algorithm for Java 5.0

I Type unification

I Principle type property

Future workI Reduce the number of calculated typings.

I Handling of interesection types (adaption of byte-code generation)

Type inference in the generic type system of Java 5pl/talks/Type_Inference_Generics.pdf · Type...

Documents

Transcript of Type inference in the generic type system of Java 5pl/talks/Type_Inference_Generics.pdf · Type...

Type Inference II David Walker COS 441. Type Inference Goal: Given unannotated program, find its type or report it does not type check Overview: generate.

A Semantics for Static Type Inference

Types, Type Inference and Unification

Generalizing Hindley-Milner Type Inference Algorithmssoft.vub.ac.be/~cfscholl/Capita-Selecta-2015/papers/2002 Heeren.pdf · Generalizing Hindley-Milner Type Inference Algorithms Bastiaan

Superfast Type Inference Engine

Type Inference: CIS Seminar, 11/3/2009 Type inference: Inside the Type Checker. A presentation by: Daniel Tuck.

Chapter 1: Type Inference

Type Inference - Princeton University Computer Science...Language Design for Type Inference We call this type the principle type (scheme) for map. Any other ML-style type you can give

Towards Type Inference for JavaScript - SLURP Home Pageslurp.doc.ic.ac.uk/pubs/typeinferenceforjavascript-ecoop05.pdf · Towards Type Inference for JavaScript? Christopher Anderson

GENERIC MACHINE LEARNING INFERENCE ON HETEROGENOUS ...

Types and Type Inference

Mocha: Type Inference for Java

Sugeno-Type Fuzzy Inference - Strona główna AGHhome.agh.edu.pl/~mrzyglod/iw/iw_pliki/FLToolbox_Estratto2.pdf · Sugeno-Type Fuzzy Inference The fuzzy inference process we’ve been

Hindley Milner Type Inference

Lecture #22: Type Inference and Unification

Polymorphism and Type Inference in Database Programmingohori/research/tods96.pdf · Polymorphism and Type Inference in Database Programming ... no type checking is done during compilation,

Domain Type TLD Manager .aaa generic American Automobile … · 2019. 8. 29. · Domain Type TLD Manager.aaa generic American Automobile Association, Inc..aarp generic AARP.abarth

Variance Reduction in Black-box Variational Inference by Adaptive … · 2018. 7. 4. · Black-box variational inference (BBVI)[Ranganathet al., 2014] is a generic approximate inference

Type Checking and Type Inference

Type Inference for a Modal Type System€¦ · Homotopy type theory... Yiluo Wei ANU Type Inference for a Modal Type System May 24, 2019 6 / 22. Introduction and MotivationMy WorkPerformance