It's Java Jim, But Not As We Know It!

© Copyright Azul Systems 2017
@speakjava
It’s Java, Jim, But Not
As We Know It!
Simon Ritter
Deputy CTO, Azul Systems
1

Agenda
 Java Lambda expressions
 Lambda expression performance
 How far can we take lambdas?
 Summary
2

Java Lambda Expressions

JDK 8 Lambda Expressions
 Simplified representation of behaviour in Java
– Anonymous inner class is clunky
 Assign to variable, pass as parameter
 Use wherever the type is a Functional Interface
– Much simpler than adding a function type to Java
– Single abstract method
– Not necessarily single method
 default and static methods don’t count
4

Lambda Expression Syntax
 Like a method
– But not associated with a class
– Typed parameters, body, return type, exceptions
 Closure over values, not types
– Only capture effectively-final variables
5
(parameters) -> body
Lambda operator

Capturing Lambdas
6
class DataProcessor {
private int currentValue;
public void process() {
DataSet myData = myFactory.getDataSet();
dataSet.forEach(d -> d.use(currentValue++));
}
}

Capturing Lambdas
7
class DataProcessor {
private int currentValue;
public void process() {
DataSet myData = myFactory.getDataSet();
dataSet.forEach(d -> d.use(this.currentValue++));
}
}
Reference to this inserted
by compiler

Method References
 Method references let us reuse a method as a lambda
expression
FileFilter x = File f -> f.canRead();
FileFilter x = File::canRead;

Method References
 Format: target_reference::method_name
 Three kinds of method reference
– Static method
– Instance method of an arbitrary type
– Instance method of an existing object
9

Method References
10
Lambda
Method Ref
Lambda
Method Ref
Lambda
Method Ref
(args) -> ClassName.staticMethod(args)
(arg0, rest) -> arg0.instanceMethod(rest)
(args) -> expr.instanceMethod(args)
ClassName::staticMethod
ClassName::instanceMethod
expr::instanceMethod
Rules For Construction

Method References
(String s) -> Integer.parseInt(s);
(String s, int i) -> s.substring(i)
Axis a -> getLength(a)
Integer::parseInt
String::substring
this::getLength
Lambda
Method Ref
Lambda
Method Ref
Lambda
Method Ref
Examples

Lambda Expression
Performance

Lambdas & Anonymous Inner Classes
 Functionally equivalent
13
myList.forEach(w -> System.out.println(w));
myList.forEach(new Consumer<String>() {
@Override
public void accept(String w) {
System.out.println(w);
}
});
myList.forEach(System.out::println);

Anonymous Inner Classes
 As the name suggests, we are dealing with classes
– Compiler generates class with name like Foo$1
– Type pollution
 The class must be loaded at run time
 Instantiated like any other class
 Lambda expressions could be implemented this way
– Originally they were
– Forces an inner class where you didn’t ask for it
 You wanted a function
14

Lambda Implementation
 A better answer: invokedynamic
– Introduced in Java SE 7 to improve performance of
dynamically typed languages running on the JVM
– Defers implementation of the Lambda to runtime
 Lambda compilation
– Generate invokedynamic call (lambda factory)
 java.lang.LambdaMetaFactory
 Return instance of (lambda) functional interface type
– Convert body of lambda to method
 Not necessary for method references
15

Lambda Implementation
 Non-capturing Lambda
– Simple conversion to static method in the class where the
lambda is used
 Capturing Lambdas
– Static method with captured variables prepended as
parameters
– Synthetic instance method of class using Lambda
 Lambda invokes a class method
16

Implementation Differences
 Lambdas
– Linkage (CallSite)
– Capture
– Invocation
17
 Anonymous inner classes
– Class loading
– Instantiation
– Invocation
 Non-capturing lambdas automatically optimise
 Method references are slightly more optimal
 -XX:+TieredCompilation gives better Lambda results
– Advice is don’t use -XX:-TieredCompilation

How Far Can We Take
Lambdas?
With inspiration from Jarek Ratajski

© Copyright Azul Systems 2017 19
Alonso Church
The λ Calculus (1936)
What does this have to do with Java?

Exploding Head Lambdas
 Java programmers are typically imperative programmers
 Functional programming is not imperative
– As we’ll see
 Lambda Calculus and Turing Machines are equivalent
 But will give you a headache
– At least it did me!
 What can we do only using Lambda expressions?
– And one functional interface
20

Functional Interface
@FunctionalInterface
public interface Lambda {
Lambda apply(Lambda lambda);
}

Function Basics
 Identity [ λx.x ]
Lambda identity = x -> x;
Lambda identity = new Lambda {
Lambda apply(Lambda x) {
return x;
}
};

Function Basics (Booleans)
 Boolean false [ λf.λx.x ]
boolFalse = f -> (x -> x); // Always returns identity
boolFalse = new Lambda {
Lambda apply(Lambda f) {
return new Lambda {
return x;
}
}}};

Function Basics (Booleans)
 Boolean true [ λf.λx.f ]
boolTrue = f -> (x -> f); // Never returns identity
boolTrue = new Lambda {
Lambda apply(Lambda f) {
return new Lambda {
return f;
}
}}};

Church Numerals
 Zero [ λf.λx.x ]
• Identity for addition and subtraction (a ± 0 = a)
• The Lambda is the same as false
• The function is applied zero times to the argument
zero = f -> x -> x;
 One [ λf.λx.(f x) ]
one = f -> x -> f.apply(x);
 Two [ λf.λx.(f (f x)) ]
two = f -> x -> f.apply(f.apply(x));
25

Church Encoding
 Successor: n++ [ λn.λf.λx.f(n f x) ]
successor =
n -> f -> x -> f.apply(n.apply(f).apply(x));
26

Church Encoding
 Predecessor: n--
27
predecessor = n -> f -> x ->
n.apply(g -> h -> h.apply(g.apply(f)))
.apply(u -> x).apply(u -> u);
[ λn.λf.λx.n(λg.λh.h(g f))(λu.x)(λu.u) ]

Church Encoding
 Add: m + n [ λm.λn.λf.λx ((m f) ((n f) x)) ]
m -> n -> f -> x -> m.apply(f).apply(n.apply(f).apply(x))
 Subtract: m - n [ λm.λn.(n predecessor) m ]
m -> n -> m.apply(predecessor).apply(n)
28

Solving 2 + 2 With Lambdas
Lambda two = f -> x -> f.apply(f.apply(x));
Lambda plus = m -> n ->
f -> x -> m.apply(f).apply(n.apply(f).apply(x));
Lambda four = plus.apply(two).apply(two);
4 = + 2 2 (Polish notation)

n -> f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(n.apply(f).apply(x))

n -> f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(n.apply(f).apply(x))
f -> x -> f -> x -> f.apply(f.apply(x)).apply(f)
.apply(f -> x -> f.apply(f.apply(x).apply(f).apply(x))

f -> x ->
f -> x -> f.apply(f.apply(x)).apply(f)
.apply(f -> x -> f.apply(f.apply(x)).apply(f).apply(x))
f -> x ->
x -> f.apply(f.apply(x))

f -> x ->
f -> x -> f.apply(f.apply(x)).apply(f)
f -> x ->
f -> x ->
.apply(x -> f.apply(f.apply(x)).apply(x))

f -> x -> x -> f.apply(f.apply(x))
.apply(x -> f.apply(f.apply(x)).apply(x))
.apply(f.apply(f.apply(x)))
.apply(f.apply(f.apply(x)))
f -> x -> f.apply(f.apply(f.apply(f.apply(x))) = 4!

Summary

Lambda Expressions
 Very useful and powerful
– Succinct way to parameterise behaviour
 Better performance than anonymous inner class
– Invokedynamic implementation
 Can be used in weird and wonderful ways
– Not necessarily to be recommended!
36

More Information
 Dixin Yan’s blog
– weblogs.asp.net/dixin (C# based, but useful)
– October 2016
 Jarek’s presentation from Voxxed Zurich
– https://www.youtube.com/watch?v=Dun8ewSeX6c
37

@speakjava
It’s Java, Jim, But Not
As We Know It!
Simon Ritter
Deputy CTO, Azul Systems
38

It's Java Jim, But Not As We Know It!

More Related Content

What's hot

Viewers also liked

Similar to It's Java Jim, But Not As We Know It!

More from Simon Ritter

Recently uploaded

It's Java Jim, But Not As We Know It!

Editor's Notes