Introducing Scala-like function types into Java-TX

Size: px

Start display at page:

Download "Introducing Scala-like function types into Java-TX"

Brent Horn
5 years ago
Views:

1 Introducing Scala-like function types into Java-TX ManLang 2017 Martin Plümicke Andreas Stadelmeier

2 Overview 1 Type of lambda expressions in Java-8 2 Introducing real function types 3 Java TX The type inference algorithm 4 Conclusion and Outlook Seite 2

3 Lambda Expressions in Java 8 has no explicite type. (x) -> x; Lambda expressions get functional interfaces as compatible target types from the environment. Type of lambda expressions in Java-8 Seite 3

4 Functional Interface Interfaces with a single abstract method. E.g. 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(); } Major benefit of target typing: Possibility of implementing callback functions in existing libraries by lambda expressions. Until Java 7 that callback functions has often been implemented by anonymous inner classes. Type of lambda expressions in Java-8 Seite 4

5 Simulating function types In the package: java.util.function there are public interface Function<T,R> { R apply(t t); } public interface BiFunction<T,U,R> { R apply(t t, U u); } Type of lambda expressions in Java-8 Seite 5

6 Properties of function types 1 Subtyping 2 Less reasonable subtyping in Java 8 3 Direct application of lambda expressions Type of lambda expressions in Java-8 Seite 6

7 Subtyping (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i Type of lambda expressions in Java-8 Seite 7

8 Subtyping (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i Function<T 1, T 0 > Function<T 1, T 0>, for T i T i Type of lambda expressions in Java-8 Seite 7

9 Subtyping (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i Function<T 1, T 0 > Function<T 1, T 0>, for T i T i Example: For Integer Number Object holds: Number Number Integer Object Type of lambda expressions in Java-8 Seite 7

10 Subtyping (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i Function<T 1, T 0 > Function<T 1, T 0>, for T i T i Example: For Integer Number Object holds: but Number Number Integer Object Function<Number, Number> f_numnum =... Function<Integer, Object> f_intobj = f_numnum is wrong!, as Function<Number, Number> Function<Integer, Object> Type of lambda expressions in Java-8 Seite 7

11 Subtyping with wildcards (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i Function<T 1, T 0 > Function<T 1, T 0>, for T i T i Type of lambda expressions in Java-8 Seite 8

12 Subtyping with wildcards (T 1,..., T N) T 0 (T 1,..., T N ) T 0, iff T i T i but Function<T 1, T 0 > Function<T 1, T 0>, for T i T i Function<T 1, T 0> Function<? super T 1,? extends T 0 >, for T i T i Type of lambda expressions in Java-8 Seite 8

13 Large example for function types //A -> (B -> (((A, B) -> C) -> C))) g = x -> y -> f -> f.apply(x,y); Type of lambda expressions in Java-8 Seite 9

14 Large example for function types //A -> (B -> (((A, B) -> C) -> C))) Func.<? super A,? extends Func.<? super B,? extends Func.<? super BiFunc.<? super A,? super B,? ext. C>>,? extends C>>> g = x -> y -> f -> f.apply(x,y); Type of lambda expressions in Java-8 Seite 10

15 Large example for function types //A -> (B -> (((A, B) -> C) -> C))) Func.<? super A,? extends Func.<? super B,? extends Func.<? super BiFunc.<? super A,? super B,? ext. C>>,? extends C>>> g = x -> y -> f -> f.apply(x,y); Ugly syntax! Type of lambda expressions in Java-8 Seite 10

16 Less reasonable subtyping in Java 8 I class Sub extends Super { void m() { Function<Sub, Sub> f = x -> x; //common subtyping Function<? super Sub,? extends Super> g1; g1 = f; Super sup = g1.apply(new Sub()); } } Type of lambda expressions in Java-8 Seite 11

17 Less reasonable subtyping in Java 8 I class Sub extends Super { void m() { Function<Sub, Sub> f = x -> x; } } //exchanging the wildcard bounds Function<? extends Super,? super Sub> g2; g2 = f; //g2.apply(new Sub()); //incorrect g2.apply(null); //sup = g2.apply(null); //incorrect Object o = g2.apply(null); Type of lambda expressions in Java-8 Seite 12

18 Direct application of lambda expressions In the λ-calculus β-conversion (direct application of a lambda expression to its arguments) is possible: (λ x.e)arg = E[x/arg]. In Java 8 this lambda term would have the following form: (x -> h(x)).apply(arg); Such expressions are not permitted, as the lambda expression has no type. Type of lambda expressions in Java-8 Seite 13

19 Direct application of lambda expressions In the λ-calculus β-conversion (direct application of a lambda expression to its arguments) is possible: (λ x.e)arg = E[x/arg]. In Java 8 this lambda term would have the following form: (x -> h(x)).apply(arg); Such expressions are not permitted, as the lambda expression has no type. ((Function<T,R>)x -> h(x)).apply(arg); is ok!, as there is cast expression. Type of lambda expressions in Java-8 Seite 13

20 Currying f : T 1 (T 2 (... (T N T 0 )...)) x1 -> x2 ->...-> xn -> h(x1,...,xn)).apply(a1).apply(a2)...apply(an) Type of lambda expressions in Java-8 Seite 14

21 Currying f : T 1 T 2... T N T 0 x1 -> x2 ->...-> xn -> h(x1,...,xn)).apply(a1).apply(a2)...apply(an) Type of lambda expressions in Java-8 Seite 15

22 Currying f : T 1 T 2... T N T 0 ((Function<T1, Function<T2,... Function<TN, T0>>> ) x1 -> x2 ->...-> xn -> h(x1,...,xn)).apply(a1).apply(a2)...apply(an) Type of lambda expressions in Java-8 Seite 16

23 Summary: Solving drawbacks: Loss of function types Introducing Bi/Function Interfaces Subtyping problem Using wildcards Impossibility of direct application of lambda expressions Using type-casts All problems are solvable, but not pretty!!! Type of lambda expressions in Java-8 Seite 17

24 Summary: Solving drawbacks: Loss of function types Introducing Bi/Function Interfaces Subtyping problem Using wildcards Impossibility of direct application of lambda expressions Using type-casts All problems are solvable, but not pretty!!! Introducing real function types Type of lambda expressions in Java-8 Seite 17

25 View to Scala Scala supports variance annotations of type parameters of generic classes. In contrast to Java, variance annotations may be added when a class abstraction is defined, whereas in Java, variance annotations are given by clients when a class abstraction is used. [Scala Tutorial] Introducing real function types Seite 18

26 View to Scala Scala supports variance annotations of type parameters of generic classes. In contrast to Java, variance annotations may be added when a class abstraction is defined, whereas in Java, variance annotations are given by clients when a class abstraction is used. [Scala Tutorial] trait Function_n[-T1,..., -Tn, +R] { def apply(x1: T1,..., xn: Tn): R override def tostring = "<function>" } Introducing real function types Seite 18

27 Introduction of FunN* interface FunN*<-T1,..., -TN,+R> { R apply(t1 arg1,..., TN argn); } where FunN <T 1,..., T N,T 0 > FunN <T 1,..., T N,T 0> iff T i T i For FunN no wildcards are allowed. Introducing real function types Seite 19

28 Introduction of FunN* interface FunN*<-T1,..., -TN,+R> { R apply(t1 arg1,..., TN argn); } where FunN <T 1,..., T N,T 0 > FunN <T 1,..., T N,T 0> iff T i T i For FunN no wildcards are allowed. Lambda expressions are explicitly typed by FunN* types Introducing real function types Seite 19

29 Solved Problems Lambda expressions have types FunN types allows subtyping without wildcards Direct application of lambda expressions is possible without type-casts. Introducing real function types Seite 20

30 Preserving target typing Remember: Lambda-expressions implements callback functions. In Java 8 lambda-expressions could be compatible with a target type. Now any expression could be compatible with a target type. Example from JavaFX Button btn = new Button(); btn.settext("say Hello World "); btn.setonaction( event -> System.out.println("Hello World!")} ); Introducing real function types Seite 21

31 Preserving target typing Remember: Lambda-expressions implements callback functions. In Java 8 lambda-expressions could be compatible with a target type. Now any expression could be compatible with a target type. Example from JavaFX Fun1*<ActionEvent, String> helloworld = event -> System.out.println("Hello World!");} Button btn = new Button(); btn.settext("say Hello World "); btn.setonaction(helloworld); Introducing real function types Seite 22

32 Java-TX Core of Java 8 Real function types as presented Global type inference Java TX Seite 23

33 Java-TX Core of Java 8 Real function types as presented Global type inference Local type inference (e.g. Scala): val i = 1 It is not necessary to declare the type of i. but val fact = (x) => if (x <= 1) 1 else x * fact(x-1); //fact do not compile //the type of fact must be declared Global type inference infers also types of recursive functions. Java TX Seite 23

34 The type inference algorithm [Plümicke 14] TI: TypeAssumptions Class { (Constraints, TClass) } 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 } Java TX Seite 24

35 The type inference algorithm [Plümicke 14] TI: TypeAssumptions Class { (Constraints, TClass) } 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 } TYPE: Inserts type annotations, widely type variables as placeholders to any subexpression in the input class. Determines the set of type constraints (inequations of types). Java TX Seite 24

36 The type inference algorithm [Plümicke 14] TI: TypeAssumptions Class { (Constraints, TClass) } 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 } TYPE: Inserts type annotations, widely type variables as placeholders to any subexpression in the input class. Determines the set of type constraints (inequations of types). SOLVE: Solves the constraints set by type unification [Plümicke 07] Java TX Seite 24

37 class MathStruc<A> { A model; innerop = o -> ms -> new MathStruc<A>(o.apply(this.model, ms.model)); } MathStruc(A m) { model=m; } Java TX Seite 25

38 The TYPE function inserts the following types. innerop:α = (o:β -> (ms:γ -> (new MathStruc<A>(o.apply(this.model:A, ms.model:δ):ɛ) ):MathStruc<A>):Fun1*<γ,η> ):Fun1*<β,ζ>; and determines the following set of constraints: { Fun1 <β,ζ> α, Fun1 <γ,η> ζ, MathStruc<A> η, γ MathStruc<δ>, ɛ A, β. = Fun2 <ι, κ,ɛ>, A ι, δ κ }. Java TX Seite 26

39 Reslut of SOLVE: (, [α Fun1 <Fun2 <A, δ,a>, Fun1 <MathStruc<δ>,MathStruc<A>>>, ζ Fun1 <MathStruc<δ>,MathStruc<A>>, η MathStruc<A>, γ MathStruc<δ>, ɛ A, β Fun2 <A, δ,a>]) Java TX Seite 27

40 Reslut of SOLVE: (, [α Fun1 <Fun2 <A, δ,a>, Fun1 <MathStruc<δ>,MathStruc<A>>>, ζ Fun1 <MathStruc<δ>,MathStruc<A>>, η MathStruc<A>, γ MathStruc<δ>, ɛ A, β Fun2 <A, δ,a>]) class MathStruc<A,Delta> { A model; Fun1*<Fun2*<A,Delta,A>, Fun1*<MathStruc<Delta>,MathStruc<A>> innerop = (Fun2*<A,Delta,A> o -> (MathStruc<A, Delta> ms) -> new MathStruc<A,Delta>(o.apply(this.model, ms.model)); } Java TX Seite 27

41 Demo Java TX Seite 28

42 Brian Goetz s (Oracle) arguments against real function types It would add complexity to the type system and further mix structural and nominal types (Java is almost entirely nominally typed). It would lead to a divergence of library styles some libraries would continue to use callback interfaces, while others would use structural function types. The syntax could be unwieldy, especially when checked exceptions were included. It is unlikely that there would be a runtime representation for each distinct function type, meaning developers would be further exposed to and limited by erasure. For example, it would not be possible (perhaps surprisingly) to overload methods m(t->u) and m(x->y). Java TX Seite 29

43 Brian Goetz s (Oracle) arguments against real function types It would add complexity to the type system and further mix structural and nominal types (Java is almost entirely nominally typed). It would lead to a divergence of library styles some libraries would continue to use callback interfaces, while others would use structural function types. The syntax could be unwieldy, especially when checked exceptions were included. It is unlikely that there would be a runtime representation for each distinct function type, meaning developers would be further exposed to and limited by erasure. For example, it would not be possible (perhaps surprisingly) to overload methods m(t->u) and m(x->y). Java TX Seite 30

44 Brian Goetz s (Oracle) arguments against real function types It would add complexity to the type system and further mix structural and nominal types (Java is almost entirely nominally typed). It would lead to a divergence of library styles some libraries would continue to use callback interfaces, while others would use structural function types. The syntax could be unwieldy, especially when checked exceptions were included. It is unlikely that there would be a runtime representation for each distinct function type, meaning developers would be further exposed to and limited by erasure. For example, it would not be possible (perhaps surprisingly) to overload methods m(t->u) and m(x->y). Java TX Seite 31

45 Brian Goetz s (Oracle) arguments against real function types It would add complexity to the type system and further mix structural and nominal types (Java is almost entirely nominally typed). It would lead to a divergence of library styles some libraries would continue to use callback interfaces, while others would use structural function types. The syntax could be unwieldy, especially when checked exceptions were included. It is unlikely that there would be a runtime representation for each distinct function type, meaning developers would be further exposed to and limited by erasure. For example, it would not be possible (perhaps surprisingly) to overload methods m(t->u) and m(x->y). Java TX Seite 32

46 Conclusion and Outlook Conclusion Benefits and drawbacks of functional interfaces as target types of lambda expressions in Java 8. Simulating of function types by functional interfaces Function respectively BiFunction. Introduction of Scala-like functional interfaces into Java. Preserving traget typing to implement existing callback interfaces. Type inference algorithm with Scala-like functional interfaces. Conclusion and Outlook Seite 33

47 Conclusion and Outlook Conclusion Benefits and drawbacks of functional interfaces as target types of lambda expressions in Java 8. Simulating of function types by functional interfaces Function respectively BiFunction. Introduction of Scala-like functional interfaces into Java. Preserving traget typing to implement existing callback interfaces. Type inference algorithm with Scala-like functional interfaces. Outlook Complete implementation Bytecode without type-erasures Conclusion and Outlook Seite 33

Type inference in Java 8

Type inference in Java 8 Martin Plümicke Baden-Wuerttemberg Cooperative State University Stuttgart/Horb 10. Januar 2013 Overview Introduction The function TYPE The sub-function TYPEExpr The sub-function