Java 8's lambdas empower us to create wonderful APIs. Javaslang lets us dive deeper into the world of functional programming by providing us with persistent data types, immutable collections and functional control structures. The results are beautiful and do just work. During this presentation we will recall Java8's downsides and explore how Javaslang's Scala-inspired features fill-in the gaps.

1. Javaslang - Functional Java
Done Right
Grzegorz Piwowarek
gpiwowarek@gmail.com
1

2. Me
Dev@TouK
Yoyo Player
Musician
2

3. pivovarit@
Twitter
GitHub
...everywhere else
3

4. pivovarit#2152
4

5. Java 8
5

6. "Functional" Java8:
Lambda Expressions
Optional, Stream, CompletableFuture
...
6

7. 7

8. Java 8 issues:
Only 3 functional control structures
No memoization
No lifting
No pattern matching
No tuples
Optional not Serializable/Iterable
Lack of Stream/Optional in APIs
Checked exceptions in functions
"Type pollution"
list.stream().map(...).collect(toList())
...
8

9. List<String> foo(List<String> list);
9

10. List<String> foo(List<String> list) {
if (this.state.isEmpty() || list.isEmpty()) {
throw new IllegalStateException("Ouch...");
}
list.add(this.state.get(0));
list.add(CONSTANT);
this.moreState.addAll(list);
OtherClass.mutableStaticField = list;
return list;
}
10

11. Potential inputs:
declared params
instance state
global state
Potential outputs:
declared returned value
mutable instance state
mutable global state
mutable params
exceptions
11

12. Potential inputs:
declared params
Potential outputs:
declared returned value
12

13. Functional programming is not
about lambdas.
13

14. "Functional programming is about writing pure functions,
about removing hidden inputs and outputs as far as we can,
so that as much of our code as possible
just describes a relationship between inputs and outputs."
http://blog.jenkster.com/2015/12/what-is-functional-programming.html
14

15. Immutability
Referential
Transparency
15

16. 16

17. 17

18. Java Collections API:
add()
remove()
clear()
...
18

19. Date date = new Date();
Set<Date> dates = new HashSet<>();
dates.add(date);
date.setTime(42);
dates.contains(date); //false
19

20. 20

21. λ
Tuple
Value
21

22. λ
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
CheckedFunction2<Integer, Integer, Integer> sum = (a, b) -> a + b;
composition
lifting
currying
memoization
22

23. Lifting
Function2<Integer, Integer, Integer> divideBy = (a, b) -> a / b;
Function2<Integer, Integer, Option<Integer>> lift = lift(divideBy);
23

24. Currying
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
Function1<Int, Function1<Int, Int>> curried = sum.curried();
Function1<Integer, Integer> add2 = curried.apply(2);
24

25. Memoization
Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;
Function2<Integer, Integer, Integer> memoizedSum = sum.memoized();
25

26. Function0<Double> mem = Function0.of(Math::random).memoized();
double randomValue1 = memoizedRand.apply();
double randomValue2 = memoizedRand.apply();
then(randomValue1).isEqualTo(randomValue2);
26

27. Tuple
Tuple2<String, Integer> java8 = Tuple.of("Java", 8);
Tuple2<String, Integer> that = java8.map(
s -> s + "slang",
i -> i / 4);
String transform = java8.transform((s, i) -> s + i);
Iterable<?> objects = java8.toSeq()
27

28. Value
Option
Try
Lazy
Either
Future
Validation
Collections API
public interface Value<T> extends Iterable<T>
28

29. Option
29

30. final String result = Option.of(somethingNullable)
.map(Object::toString)
.map(String::toLowerCase)
.getOrElse(() -> "DEFAULT VALUE");
30

31. List<Optional<Integer>> list = ...
list.stream()
.filter(Optional::isPresent)
.map(Optional::get)
.collect(toList());
List<Option<Integer>> list = ...
list.flatMap(o -> o);
Java 8
Javaslang
31

32. Try
32

33. Try.of(() -> new URI("bebebe"))
.map(URI::getScheme)
.getOrElse(() -> "UNKNOWN");
33

34. Lazy
34

35. Lazy<String> lazy = Lazy.of(this::veryLongComputation)
.map(Object::toString)
.map(String::toUpperCase);
lazy.get();
35

36. Functional Data
Structures
36

37. Functional Data Structures:
Persistent
Immutable
with Referential Transparent methods
37

38. Seq
38

39. 39

40. public static Stream<Integer> fibonacci() {
return Stream.of(1, 1)
.appendSelf(self -> self.zip(self.tail())
.map(t -> t._1 + t._2));
}
40

41. Pattern Matching
41

42. String on = Match(i).of(
Case(x -> x % 2 == 0, "Even"),
Case(x -> x % 2 == 1, "Odd"),
Case($(), "?"));
Option<String> on = Match(i).option(
Case(x -> x % 2 == 0, "Even"),
Case(x -> x % 2 == 1, "Odd"));
42

43. String on = Match(i).of(
Case($(1), "One"),
Case($(2), "Two"),
Case($(), "Something else"));
43

44. Match(localDate).of(
Case(LocalDate(2016, 2, 13), () -> "2016-02-13"),
Case(LocalDate(2016, $(), $_), m -> "month " + m + " in 2016"),
Case(LocalDate($(2016), $(), $_), (y, m) -> "my" + m + y),
Case($_, () -> "(catch all)")
);
44

45. String actual = Match(opt).of(
Case(Some($()), String::valueOf),
Case(None(), "no value"));
45

46. Match(i).of(
Case(is(1), "1"),
Case(isIn(2, 3), "2 or 3"),
Case(anyOf(is(4), noneOf(is(5), is(6))), "4 or not (5 or 6)"),
Case(instanceOf(String.class), "String content"),
Case($(), "?")
);
http://koziolekweb.pl/2016/06/18/pattern-matching-w-javie-z-javaslang-ii/
46

47. Match(param).of(
Case(isIn("-h", "--help"), o -> run(outerWorld::displayHelp)),
Case(isIn("-v", "--version"), o -> run(outerWorld::displayVersion)),
Case($(), o -> {}));
47

48. Try.of(this::doSomething)
.recover(x -> Match(x).of(
Case(instanceOf(Exception_1.class), ...),
Case(instanceOf(Exception_2.class), ...),
Case(instanceOf(Exception_n.class), ...)
))
.getOrElse(other);
48

49. www.javaslang.io
49

50. Thank you!
gpiwowarek@gmail.com
pivovarit@twitter (slides are here!)
pivovarit@github
50