Lambdas: Myths and Mistakes

Lambdas:
Myths and
Mistakes
by Richard Warburton

Learning FP is so much more than just
knowing what map/fold/filter/etc. do. It's
more like getting good at Portal :)
@copumpkin

Who am I?
Currently work at jClarity
Focus on performance diagnostics and
static analysis
Adopt a JSR (Date and Time + Lambdas)
Writing a book for O'Reilly Media on
Lambda Expressions in Java 8.

Talk Structure
Background and Motivation
Introduction to Lambda Expressions
Beyond the Myths
Functional Thinking

Lambda Expressions are
coming in Java 8!

Adopt-a-JSR?
Community driven standards feedback
Hackdays
Serve on Expert Groups
Initiated by Martijn Verburg

Some discussion
unimportant
Concrete Examples focus discussion

Introduction
to Lambda
Expressions

Overview of Lambdas
Goal: Better Libraries
Example: Data Parallelism
Approach: Allow Code as Data

Action Listener
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("button clicked");
}
});

Code as Data
button.addActionListener(
?
);

Need a parameter
button.addActionListener(event
);

Lambda Example
button.addActionListener(event ->
System.out.println("button clicked")
);

No parameters
Runnable helloWorld =
() -> System.out.println("Hello World");

Variable Capture
String name = getUserName();
button.addActionListener(event ->
System.out.println("hi " + name)
);

Functional Interfaces
Everything in Java has a type
Problem: Need types to represent
Functions
Solution: Use interfaces

public interface ActionListener extends EventListener {
public void actionPerformed(ActionEvent event);
}

Want to support automated Data
Parallelism
Construct for building computation
pipelines
Iterator with inversion of control

External Iteration
int count = 0;
for (Artist artist : artists) {
if (artist.isFrom("London")) {
count++;
}
}

Internal Iteration
artists.stream()
.filter(artist -> artist.isFrom("London"));

map
List<String> collected = Stream.of("a", "b", "hello")
.map(string -> string.toUpperCase())
.collect(toList());
assertEquals(asList("A", "B", "HELLO"),collected);

reduce
int count = Stream.of(1, 2, 3)
.reduce(0, (acc, x) -> acc + 1);
assertEquals(3, count);

filter
List<String> beginningWithNumbers =
Stream.of("a", "1abc", "abc1")
.filter(value -> isDigit(value.charAt(0)))
.collect(toList());
assertEquals(asList("1abc"), beginningWithNumbers);

Putting it all together
for a given an album, find the nationality of every band
playing on that album

Putting it all together (2)
1. transform an album into its artists
2. figure out which artists are bands
3. find the nationalities of each band

Putting it all together (3)
List<String> origins =
album.getMusicians()
.filter(artist -> artist.getName().startsWith("The"))
.map(artist -> artist.getNationality())
.collect(toList());

Method References
str -> str.length
String::length
x -> foo.bar(x)
foo::bar
str -> new Name(str)
Name::new

Claim: Syntax is the most
important thing about
Lambda Expressions

Yeah, I liked the # syntax proposal better,
too. One less character to type! :)

Have you considered 'default null'? It will
save a keyword

How about a single punctuation mark,
currently unused, as syntax sugar for "()-
>".

(_, _) -> _ + _
This is starting to look like risque ASCII art
:)

// Originally invalid
Stream.of(1, 2, 3)
.forEach(x -> System.out.println(x));
// Required extra ;
Stream.of(1, 2, 3)
.forEach(x -> System.out.println(x););

Difference between
expectations
Many language features stolen! adapted
Missing Features
Stronger Type System
Tuples
List construction syntax

Framing Effect
Different reactions depending on whether something is
presented as a loss or a gain.

Recall our earlier example
List<String> origins =
.collect(toList());

Eager vs Lazy (2)

Eager vs Lazy (3)
.collect(toList());

Very little TDD
Only a couple of developers used TDD or
unit tests
Maybe a reflection on general TDD
Maybe unfamiliarity with testing
functional code

How do I test this?
list.stream()
.map(x -> 1.0 / Math.ceil(1 + Math.pow(x) + Math.atan2(0, x)))
.collect(toList());

Approach 1: Test
surrounding function
Don't test the lambda
Test the method its surrounded by
Works well for simple lambdas

Approach 2: Extract
Method
double complexFunction(double x) {
return 1.0 / Math.ceil(1 + Math.pow(x) + Math.atan2(0, x));
}
list.stream()
.map(this::complexFunction)
.collect(toList());

Mistake: debugging
list.stream()
.filter(filteringFunction)
.map(mappingFunction)
.collect(toList());
List<Bar> bars = new ArrayList<>();
for (Foo element : list) {
if (filteringFunction(element) {
Bar result = mappingFunction(element);
bars.add(result);
}
}

peek
list.stream()
.filter(filteringFunction)
.peek(e -> System.out.println("Filtered value: " + e));
.map(mappingFunction)
.map(e -> e);
.collect(toList());

Comparators
Comparator<String> comparator = comparing(String::length);
Comparator<String> comparator = comparing(str -> str.length);

Compiler Error
java: reference to comparing is ambiguous both
method
<T>comparing(java.util.function.ToIntFunction< ? super T>)
in java.util.Comparator and method
<T,U>comparing(java.util.function.Function< ? super T,? extends U>)
in java.util.Comparator match

What happened?
// Generic object variant
public static <T, U extends Comparable< ? super U>>
Comparator<T>
comparing(Function< ? super T, ? extends U> keyExtractor)
// Specialised primitive variant
public static <T>
Comparator<T>
comparing(ToIntFunction< ? super T> keyExtractor)

Summary
Syntax important, but not in the way
people think
New approaches for debugging and
testing
Take care of overloads and compiler
error messages

Functional
Thinking?Thinking in terms of the input to output relationship and
not a sequence of steps

First code that people
write
List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.forEach(x -> {
System.out.println(x);
});

Non-idiomatic Proposals
Eg: capture non-final local variables

Example Problem
Count the number of instances of each word in a
document.

Ideal Solution
reader.lines()
.flatMap(s -> Stream.of(s.split(" ")))
.collect(groupingBy(s -> s, counting()));

Ideal Solution (then)
reader.lines()
.flatMap(s -> Stream.of(s.split(" ")))
.collect(groupingBy(s -> s, reducing(s -> 1, Integer::sum)));
// Map entries for "dad"
// [ "dad", "dad", "dad" ] => [1, 1, 1] => 3

Bad Solution (Part 1)
Map<string, list<string="">> initial
= br.lines()
.flatMap(s -> Arrays.stream(s.split(" ")))
.collect(groupingBy(s -> s));
Map<map.entry<string, integer="">, Integer> freq1 = initial
.entrySet().stream()
.map(entry -> new AbstractMap.SimpleImmutableEntry<string, integer="">(entry.ge
.collect(Collectors.toMap(entry -> entry.getValue()));
</string,></map.entry<string,></string,>

Bad Solution (Part 2)
Supplier<hashmap<string, integer="">> supplier = () -> new
HashMap<string, integer="">();
BiConsumer<hashmap<string, integer="">, Map.Entry<string, integer="">> accum =
(HashMap<string, integer=""> result, Map.Entry<string, integer="">
entry) -> result.put(entry.getKey(), entry.getValue());
BiConsumer<hashmap<string, integer="">, HashMap<string, integer="">>
merger = HashMap::putAll;
Map<string, integer=""> freq2 = initial.entrySet().stream()
.map(entry -> new AbstractMap.SimpleImmutableEntry<string, integer="">(entry.ge
.collect(supplier, accum, merger);
</string,></string,></string,></hashmap<string,></string,></str

Summary
Functional Thinking the most important
thing to learn
Not Java specific at all
Requires Practise

Conclusions
Gone through a bunch of examples of
specific issues
‘Functional Thinking’: Not necessary to
start learning.
Try before you buy

Questions?@RichardWarburto
http://insightfullogic.com
https://github.com/RichardWarburton/

Lambdas: Myths and Mistakes

Recommended

More Related Content

What's hot (19)

Similar to Lambdas: Myths and Mistakes (20)

More from RichardWarburton (20)

Recently uploaded (20)

Lambdas: Myths and Mistakes