Type inference in Java 8

Size: px

Start display at page:

Download "Type inference in Java 8"

Oswin Wilkerson
6 years ago
Views:

1 Type inference in Java 8 Martin Plümicke Baden-Wuerttemberg Cooperative State University Stuttgart/Horb 10. Januar 2013

2 Overview Introduction The function TYPE The sub-function TYPEExpr The sub-function TYPEStmt The function SOLVE The whole algorithm TI

3 Martin Pluemicke s research on type inference for Java with generics and lambda expressions (version 5 8) UNIF 04: Type unification in Generic Java Type unification for generic java types without wildcards PPPJ 2006: Typeless programming in Java 5.0 Type inference for generic java types without wildcards WLP2007/INAP2007: Java type unification with wildcards Type unification for generic java types with wildcards PPPJ 2007: Typeless programming in Java 5.0 with wildcards Type inference for generic java types with wildcards PPPJ 2011: Well typings for Java λ λ expressions, but no methods Function types as types of λ expressions Adaption of the type inference algorithm of Fuh and Mishra 88 results: well typings (condtional types) PPPJ 2008: Imtersection types in java Resolving the intersection types for code generation 2014 (to publish): More type inference in java 8 Functional interfaces as types of λ expressions Type inference for λ expressions result: set of type results with some constraints 2014 (to publish): Functional interfaces vs. function types in Java with lambdas function types as types of λ expressions Additional functional interfaces as target types of lambda expressions KPS 2013: Implementierung eines Typinferenzalgorithmus für Java 8 Work in progress/to DO: Eclipse PlugIn Resolving the intersection types for code generation

4 History of Java type system Version 1: Subtyping on classes (without parameters) Ex.: Integer Object

5 History of Java type system Version 1: Version 5: Subtyping on classes (without parameters) Ex.: Integer Object Parametrized classes (type constructors) Ex.: Vector<X> Subtyping extension Ex.: Matrix Vector<Vector<Integer>> Wildcards (with lower and upper bounds) Ex.: Vector<? extends Integer>

6 History of Java type system Version 1: Version 5: Subtyping on classes (without parameters) Ex.: Integer Object Parametrized classes (type constructors) Ex.: Vector<X> Subtyping extension Ex.: Matrix Vector<Vector<Integer>> Wildcards (with lower and upper bounds) Ex.: Vector<? extends Integer> Version 8: Functional interfaces, but no function types

7 Motivating Example: External Iteration public class Student { String name; int graduationyear; double score; }

8 Motivating Example: External Iteration public class Student { String name; int graduationyear; double score; } List<Student> students =... double highestscore = 0.0; for (Student s : students) { if (s.gradyear == 2013) { if (s.score > highestscore) { highestscore = s.score; } } }

9 Motivating Example: External Iteration public class Student { String name; int graduationyear; double score; } List<Student> students =... double highestscore = 0.0; for (Student s : students) { if (s.gradyear == 2013) { if (s.score > highestscore) { highestscore = s.score; } } } external iteration serial iteration not thread-safe

10 Motivating Example: Inner classes public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(new Predicate<Student>() { public boolean op(student s) { return s.getgradyear() == 2013; } })

11 Motivating Example: Inner classes public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(new Predicate<Student>() { public boolean op(student s) { return s.getgradyear() == 2013; } }).map(new Mapper<Student,Double>() { public Double extract(student s) { return s.getscore(); } })

12 Motivating Example: Inner classes public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(new Predicate<Student>() { public boolean op(student s) { return s.getgradyear() == 2013; } }).map(new Mapper<Student,Double>() { public Double extract(student s) { return s.getscore(); } }).max();

13 Motivating Example: Inner classes public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(new Predicate<Student>() { public boolean op(student s) { return s.getgradyear() == 2013; } }).map(new Mapper<Student,Double>() { public Double extract(student s) { return s.getscore(); } }).max(); internal iteration by inner classes traversal may be done in parallel but ugly syntax

14 Motivating Example: Inner classes public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(new Predicate<Student>() { public boolean op(student s) { return s.getgradyear() == 2013; } }).map(new Mapper<Student,Double>() { public Double extract(student s) { return s.getscore(); } }).max(); Idea: internal iteration by inner classes traversal may be done in parallel but ugly syntax

15 Lambda expression Well-known from functional programming languages. Example: Identity function \x -> x -- HASKELL fn x => x (lambda (x) x) -- SML -- SCHEME

16 Lambda expression Well-known from functional programming languages. Example: Identity function \x -> x -- HASKELL fn x => x (lambda (x) x) -- SML -- SCHEME Application: (\x -> x) 1 = 1

17 Lambda expression Well-known from functional programming languages. Example: Identity function \x -> x -- HASKELL fn x => x (lambda (x) x) -- SML -- SCHEME Application: (\x -> x) 1 = 1 Function-types: (\x -> x) :: a -> a

18 Motivating Example: public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(student s -> s.getgradyear() == 2013).map(Student s -> s.getscore()).max();

19 Motivating Example: public class Student { String name; int graduationyear; double score; } SomeCoolList<Student> students =... double highestscore = students.filter(student s -> s.getgradyear() == 2013).map(Student s -> s.getscore()).max(); Lambda expressions more readable

20 functional interfaces restricted type inference method references default methods

21 Functional interfaces (SAM Types) An interface with one method Example: interface Operation { public int op (int x, int y); } int doop(operation o, int a, int b) { return o.op(a, b); }...

22 Functional interfaces (SAM Types) An interface with one method Example: interface Operation { public int op (int x, int y); } int doop(operation o, int a, int b) { return o.op(a, b); }... doop((int x, int y) -> x + y, 5, 7);

23 Functional interfaces in the Java library interface Comparator<T> { int compare(t x, T y); } interface FileFilter { boolean accept(file x); } interface DirectoryStream.Filter<T> { boolean accept(t x); } interface Runnable { void run(); } interface ActionListener { void actionperformed(...); } interface Callable<T> { T call(); }

24 Target types lambda expressions have no explicit type a target type is deduced from the context

25 Target types lambda expressions have no explicit type a target type is deduced from the context Example: Operation op = (int x, int y) -> x + y Target type: Operation Runnable op = (int x, int y) -> x + y Target type: Runnable

26 Target types lambda expressions have no explicit type a target type is deduced from the context Example: Operation op = (int x, int y) -> x + y Target type: Operation Runnable op = (int x, int y) -> x + y Target type: Runnable Which is a correct target type?

27 Functional interfaces as compatible target types A lambda expression is compatible with a type T, if T is a functional interface type The lambda expression has the same number of parameters as T s method, and those parameters types are the same Each expression returned by the lambda body is compatible with T s method s return type Each exception thrown by the lambda body is allowed by T s method s throws clause

28 Functional interfaces as compatible target types A lambda expression is compatible with a type T, if T is a functional interface type The lambda expression has the same number of parameters as T s method, and those parameters types are the same Each expression returned by the lambda body is compatible with T s method s return type Each exception thrown by the lambda body is allowed by T s method s throws clause Lemma: There is an equivalence class of compatible target types for a lambda expression.

29 Canonical representative For the equivalence class of the compatible target types of a lambda expression, there is a canonical representative with FunN <R, T 1,..., T N> interface FunN <R,T1,..., TN > { R apply(t1 arg1,..., TN argn ); } if the type of the single method of a compatible target type is (T 1,..., T N) R

30 Matrices in Java 8 class Matrix extends Vector<Vector<Integer>> { //Matrix -> ((Matrix, Matrix) -> Matrix) -> Matrix Fun1<Fun1<Matrix, Fun2<Matrix, Matrix,Matrix>>, Matrix> op = (Matrix m) -> (Fun2<Matrix, Matrix,Matrix> f) -> f.apply(this, m);

31 Matrices in Java 8 class Matrix extends Vector<Vector<Integer>> { //Matrix -> ((Matrix, Matrix) -> Matrix) -> Matrix Fun1<Fun1<Matrix, Fun2<Matrix, Matrix,Matrix>>, Matrix> op = (Matrix m) -> (Fun2<Matrix, Matrix,Matrix> f) -> f.apply(this, m); //(Matrix, Matrix) -> Matrix Fun2<Matrix, Matrix,Matrix> mul = (Matrix m1, Matrix m2) -> { Matrix ret = new Matrix ();... //matrix multiplication return ret; }

32 Matrices in Java 8 class Matrix extends Vector<Vector<Integer>> { //Matrix -> ((Matrix, Matrix) -> Matrix) -> Matrix Fun1<Fun1<Matrix, Fun2<Matrix, Matrix,Matrix>>, Matrix> op = (Matrix m) -> (Fun2<Matrix, Matrix,Matrix> f) -> f.apply(this, m); //(Matrix, Matrix) -> Matrix Fun2<Matrix, Matrix,Matrix> mul = (Matrix m1, Matrix m2) -> { Matrix ret = new Matrix ();... //matrix multiplication return ret; } public static void main(string[] args) { Matrix m1 = new Matrix(...); Matrix m2 = new Matrix(...); (m1.op.apply(m2)).apply(m1.mul);} } }

33 Goal class Matrix extends Vector<Vector<Integer>> { op = (m) -> (f) -> f.apply(this, m); mul = (m1, m2) -> { ret = new Matrix ();... //matrix multiplication return ret; } public static void main(string[] args) { Matrix m1 = new Matrix(...); Matrix m2 = new Matrix(...); (m1.op.apply(m2)).apply(m1.mul);} } }

34 The language Source := class class := Class(stype, [ extends( stype ), ]FieldDecl ) FieldDecl := Field( [type, ]var[, expr] ) block := Block( stmt ) stmt := block Return( expr ) While( bexpr, block ) LocalVarDecl( var[, type] ) If( bexpr, block[, block] ) stmtexpr lambdaexpr := Lambda( ((var[, type])), (stmt expr) ) stmtexpr := Assign( var, expr ) New( stype, expr ) MethodCall( iexpr, apply, expr ) vexpr := LocalVar( var ) InstVar( iexpr, var ) iexpr = vexpr stmtexpr Cast( type, iexpr ) this super expr := lambdaexpr iexp bexp sexp

35 Type parameter instatiation (Java 5.0): id: a a id(1) : for a the type Integer is inferred. Diamond operator (Java 7): Vector <Integer> v = new Vector <> Parameter s type inference in (Java 8): (T1 x1,..., TN xn) h( x1,..., XN ) The types T1,..., TN can be inferred: (x1,..., xn) h( x1,..., XN ) is a correct Lambda expression in Java 8.

36 More type inference

37 Sketch of the algorithm TI The function TYPE The function SOLVE The whole algorithm TI TYPE: Introduces fresh type variables and collects the constraints SOLVE: Solves the constraints by type unification

38 Data-structures Introduction The function TYPE The function SOLVE The whole algorithm TI Set of type assumptions: v : θ: Assumptions for fields or local variables of the actual class. τ.v : θ: Assumptions for fields of the class τ.

39 Data-structures Introduction The function TYPE The function SOLVE The whole algorithm TI Set of type assumptions: v : θ: Assumptions for fields or local variables of the actual class. τ.v : θ: Assumptions for fields of the class τ. Set of constraints: { θ R θ R {,?,. = } }

40 The function TYPE The function SOLVE The whole algorithm TI TYPE: TypeAssumptions Class TClass ConstraintsSet

41 The function TYPE The function SOLVE The whole algorithm TI TYPE: TypeAssumptions Class TClass ConstraintsSet TYPE( Ass, Class( τ, extends( τ ), fdecls ) ) = let fdecls = [Field( f 1, lexpr 1 ),..., Field( f n, lexpr n )] ftypeass = { this.f i : a i a i fresh type variables } { this : τ, super : τ } { visible types of fields of τ } AssAll = Ass ftypeass

42 The function TYPE The function SOLVE The whole algorithm TI TYPE: TypeAssumptions Class TClass ConstraintsSet TYPE( Ass, Class( τ, extends( τ ), fdecls ) ) = let fdecls = [Field( f 1, lexpr 1 ),..., Field( f n, lexpr n )] ftypeass = { this.f i : a i a i fresh type variables } { this : τ, super : τ } { visible types of fields of τ } AssAll = Ass ftypeass Forall 1 i n (lexp it : rtyf i, ConSF i ) = TYPEExpr( AssAll, lexpr i )

43 The function TYPE The function SOLVE The whole algorithm TI TYPE: TypeAssumptions Class TClass ConstraintsSet TYPE( Ass, Class( τ, extends( τ ), fdecls ) ) = let fdecls = [Field( f 1, lexpr 1 ),..., Field( f n, lexpr n )] ftypeass = { this.f i : a i a i fresh type variables } { this : τ, super : τ } { visible types of fields of τ } AssAll = Ass ftypeass Forall 1 i n (lexp it : rtyf i, ConSF i ) = TYPEExpr( AssAll, lexpr i ) fdecls t = [Field( a 1, f 1, lexpr 1t : rtyf 1 ),..., Field( a n, f n, lexpr nt : rtyf nt )]

44 The function TYPE The function SOLVE The whole algorithm TI TYPE: TypeAssumptions Class TClass ConstraintsSet TYPE( Ass, Class( τ, extends( τ ), fdecls ) ) = let fdecls = [Field( f 1, lexpr 1 ),..., Field( f n, lexpr n )] ftypeass = { this.f i : a i a i fresh type variables } { this : τ, super : τ } { visible types of fields of τ } AssAll = Ass ftypeass Forall 1 i n (lexp it : rtyf i, ConSF i ) = TYPEExpr( AssAll, lexpr i ) fdecls t = [Field( a 1, f 1, lexpr 1t : rtyf 1 ),..., Field( a n, f n, lexpr nt : rtyf nt )] in (Class( τ, extends( τ ), fdecls t ), ( i ConSF i { (rtyf i a i ) 1 i n }))

45 The function TYPE The function SOLVE The whole algorithm TI TYPEExpr: TypeAssumptions Expr TExpr ConstraintsSet

46 The function TYPE The function SOLVE The whole algorithm TI TYPEExpr: TypeAssumptions Expr TExpr ConstraintsSet For Lambda: TYPEExpr( Ass, Lambda( (x 1,..., x N ), expr stmt ) ) = let AssArgs = { x i : a i a i fresh type variables } (expr t : rty, ConS) = TYPEExpr( Ass AssArgs, expr ) (stmt t : rty, ConS) = TYPEStmt( Ass AssArgs, stmt ) in (Lambda( (x 1 :a 1,..., x N :a N ), expr t :rty stmt t :rty ) : FunN <a, a 1,..., a N >, ConS { (rty a) }), where a is a fresh type variable

47 The function TYPE The function SOLVE The whole algorithm TI For MethodCall: TYPEExpr( Ass, MethodCall( re, apply( e 1,..., e n ) ) ) = let (re t : rty, ConS) = TYPEExpr( Ass, re ) (e it : rty i, ConS i ) = TYPEExpr( Ass, e i ), 1 i n in (MethodCall( re t : rty, apply( e 1t :rty 1,..., e nt :rty n ) ):a, (ConS i ConS i) { rty FunN <a, a 1,..., a N > } { rty i a i 1 i N } where a 1,..., a N and a are fresh type variables

48 The function TYPE The function SOLVE The whole algorithm TI TYPEStmt: TypeAssumptions Stmt TStmt ConstraintsSet

49 The function TYPE The function SOLVE The whole algorithm TI TYPEStmt: TypeAssumptions Stmt TStmt ConstraintsSet For Return: TYPEStmt( Ass, Return( e ) ) = let (e t : rty, ConS) = TYPEExpr( Ass, e ) in (Return( e t : rty ) : rty, ConS))

50 For Block: Introduction The function TYPE The function SOLVE The whole algorithm TI TYPEStmt( Ass, Block( s ) ) = let (s t : rty, ConS) = TYPEStmt( Ass, s ) in (Block( s t : rty ) : rty, ConS)

51 For Block: Introduction The function TYPE The function SOLVE The whole algorithm TI TYPEStmt( Ass, Block( s ) ) = let (s t : rty, ConS) = TYPEStmt( Ass, s ) in (Block( s t : rty ) : rty, ConS) TYPEStmt( Ass, Block( s 1,..., s n ) ) = let (s 1t : rty 1, ConS 1 ) = TYPEStmt( Ass, s 1 ) (Block( s 2t,..., s nt ) : rty 2, ConS 2 ) = TYPEStmt( Ass, Block( s 2,..., s n ) ) in (Block( s 1t : rty 1, s 2t,..., s nt ) : a, ConS 1 ConS 2 { (rty 1 a), (rty 2 a) }) where a is a fresh type variable

52 The function TYPE The function SOLVE The whole algorithm TI Example class Matrix extends Vector<Vector<Integer>> { op = (m) -> (f) -> f.apply(this, m); }

53 The function TYPE The function SOLVE The whole algorithm TI Example class Matrix extends Vector<Vector<Integer>> { op = (m) -> (f) -> f.apply(this, m); } The result contains: lexpr 1t = Lam( m : a m, Lam( f : a f, MCall( LoVar( f ) : a f, apply( this : Matrix, LoVar( m ) : a m ) ) : a 3 ) : Fun1<a app, a f > ) : Fun1<a λf, a m >

54 The function TYPE The function SOLVE The whole algorithm TI Example class Matrix extends Vector<Vector<Integer>> { op = (m) -> (f) -> f.apply(this, m); } The result contains: lexpr 1t = Lam( m : a m, Lam( f : a f, MCall( LoVar( f ) : a f, apply( this : Matrix, LoVar( m ) : a m ) ) : a 3 ) : Fun1<a app, a f > ) : Fun1<a λf, a m > and the set of constraint: { (Fun1<a λf, a m > a op ), (Fun1<a app, a f > a λf ), (a f Fun2<a 3, a 1, a 2 >), (Matrix a 1 ), (a m a 2 ), (a 3 a app ) }

55 The function TYPE The function SOLVE The whole algorithm TI SOLVE: ConstraintsSet Constraints SubstSet { fail } SOLVE( ConS ) = let subs = TUnify( ConS ) in if (there are σ subs in solved form) then { σ subs σ is in solved form } if (there are σ subs, which has the form { v R v v, v are type vars } { v. = θ v is a type vars }) then { v R v v, v are type vars } { v. = θ v is a type vars } else fail

56 The function TYPE The function SOLVE The whole algorithm TI The sub-function TUnify 1 TUnify: ConstraintsSet { ConstraintsSet } { fail } Input: { (θ 1 θ 1 ),..., (θ n θ n) } Output: { σ 1,..., σ m } Post-condition: j { (σ j ( θ 1 ) σ j ( θ 1 )),..., (σ j( θ n ) σ j ( θ n )) } where is the sub-typing relation 1 [Pluemicke 2009]: Java type unification with wildcards, INAP 07

57 The function TYPE The function SOLVE The whole algorithm TI TI: TypeAssumptions Class { (Constraints, TClass) } { fail }

58 The function TYPE The function SOLVE The whole algorithm TI TI: TypeAssumptions Class { (Constraints, TClass) } { fail } TI( Ass, Class( τ, extends( τ ), fdecls ) ) = let (Class( τ, extends( τ ), fdecls t ), ConS) = TYPE( Ass, Class( τ, extends( τ ), fdecls ) ) { (cs 1, σ 1 ),..., (cs n, σ n ) } = SOLVE( ConS ) in { (cs i, σ i ( Class( τ, extends( τ ), fdecls t ) )) 1 i n }

59 Example Introduction The function TYPE The function SOLVE The whole algorithm TI ConS = { (Fun1<a λf, a m > a op ), (Fun1<a app, a f > a λf ), (a f Fun2<a 3, a 1, a 2 >), (Matrix a 1 ), (a m a 2 ), (a 3 a app ) }

60 Example Introduction The function TYPE The function SOLVE The whole algorithm TI ConS = { (Fun1<a λf, a m > a op ), (Fun1<a app, a f > a λf ), (a f Fun2<a 3, a 1, a 2 >), (Matrix a 1 ), (a m a 2 ), (a 3 a app ) } The result of SOLVE (without wildcard-types): { ({ a m a 2, a 3 a app } { a op. = Fun1<Fun1<aapp, Fun2<a 3, Matrix, a 2 >>, a m >, a λf. = Fun1<aapp, Fun2<a 3, Matrix, a 2 >>, a f. = Fun2<a3, Matrix, a 2 >, a 1. = Matrix }) ({ a m a 2, a 3 a app } { a op. = Fun1<Fun1<aapp, Fun2<a 3, Vec<Vec<Int>>, a 2 >>, a m >, a λf. = Fun1<aapp, Fun2<a 3, Vec<Vec<Int>>, a 2 >>, a f. = Fun2<a3, Vec<Vec<Int>>, a 2 >, a 1. = Vec<Vec<Int>> }) }

61 The function TYPE The function SOLVE The whole algorithm TI Example cont. class Matrix<a 2, a m extends a 2, a app, a 3 extends a app> extends Vector<Vector<Integer>> { Fun1<Fun1<a app, Fun2<a 3, Matrix,a 2>>, a_m> op = (a m m) -> (Fun2<a 3, Matrix,a 2> f) -> f.apply(this, m); }

62 The function TYPE The function SOLVE The whole algorithm TI Example cont. class Matrix<a 2, a m extends a 2, a app, a 3 extends a app> extends Vector<Vector<Integer>> { Fun1<Fun1<a app, Fun2<a 3, Matrix,a 2>>, a_m> op = (a m m) -> (Fun2<a 3, Matrix,a 2> f) -> f.apply(this, m); } more principal than... class Matrix extends Vector<Vector<Integer>> { Fun1<Fun1<Matrix, Fun2<Matrix, Matrix,Matrix>>, Matrix> op = (Matrix m) -> (Fun2<Matrix, Matrix,Matrix> f) -> f.apply(this, m); }

63 The function TYPE The function SOLVE The whole algorithm TI Solution of multiple results 1. Select one correct type in an Eclipse-PlugIn. standard generation of byte-code 2. Extend Java type-system by a restricted form of intersection types. a changed generation of byte-code is necessary 2 2 [Pluemicke 2008],Intersection Types in Java, PPPJ 08]

64 Java 8: ThisTest TestLambda Matrix (TestFunN) Outlook: Methods TestMethodCall Java 7: Overloading OL

65 Summary Complete type inference for a core of Java 8. Prototypical implementation

66 Summary Complete type inference for a core of Java 8. Prototypical implementation Outlook Methods with overloading and overriding. Introduction of intersection types in the code generation

Ausblick auf Java 8. Martin Plümicke. 25. Mai Baden-Wuerttemberg Cooperative State University Stuttgart/Horb

Ausblick auf Java 8. Martin Plümicke. 25. Mai Baden-Wuerttemberg Cooperative State University Stuttgart/Horb Ausblick auf Java 8 Martin Plümicke Baden-Wuerttemberg Cooperative State University Stuttgart/Horb 25. Mai 2012 Overview Introduction Introduction Closures Java s motivation λ expressions Functional interfaces