javaslang @ devoxx

#Devoxx #Javaslang @koenighotze

JΛVΛSLΛNGFunctional Sugar For Java

Senacor Technologies Programmer!

That’s me coding Scala

David Schmitz / @koenighotzeSenacor Technologies

Programmer! That’s me coding Scala

What’s in it for you?Functional programming is hip

How Javaslang helped us

Examples, Code!

Functors, applicatives,

monads and friends stay home

Code that is easier to reason about

Side-effects are eviltry { int i = 1/0; } catch (Throwable t) { … }Exceptions are goto-statements

Referential TransparencyMath.random();

Math.max(1, 2);

Math.random();

Math.max(1, 2);

Pure functions are a Good ThingTm

Thinking in ValuesImmutability

Performance

Safety

In a nutshell, think about “what to code“

not “how to code”

Enter Java 8(a) -> a + 2

list.stream().filter…

Excitement…

“Try filtering all invalid users from a list of users”

Excitement?…untilusers.stream() .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}) .collect(Collectors.toList());

#Devoxx #Javaslang @koenighotzePainting by Gustav Courbet

import static javaslang.API.*;

What we’ll coverImmutable collections

Some functional sugar

Pattern matching

Before we get to the details… Let’s fix that ugly code

Fixing Things….users.stream() .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}) .collect(Collectors.toList());

Functional collectionsList.ofAll(users) .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}) .collect(Collectors.toList());

No need for CollectorsList.ofAll(users) .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}) .collect(Collectors.toList());

No need for CollectorsList.ofAll(users) .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}); .collect(Collectors.toList());

Wrapping ExceptionsList.ofAll(users) .filter(user -> { try { return user.validate(); } catch (Exception ex) { return false; }}); .collect(Collectors.toList());

Wrapping ExceptionsList.ofAll(users) .filter(user ->

Try.of(user::validateAddress) .getOrElse(false) ); } catch (IllegalStateException ex) { return ); .collect(Collectors.toList();

List.ofAll(users) List.filter(user -> Try.of(user::validateAddress) .getOrElse(false));

“Try filtering all invalid users from a list of users”

Immutable Collections Image by Douglas Muth, https://flic.kr/p/acFwxG

Mutable Collections are Evil

Returning void == Side-Effect!

interface Collection<E> { … void clear(); }

Easy solution? Collections

Collections .unmodifiableList(list); .add("BUMM");

Easy solution? Collections

Collections .unmodifiableList(list) .add("BUMM");

Javaslang CollectionsList<~> t = List.of(“F95”);

List<~> t2 = t.append(withName(“FCK”));

F95 /t

ImmutableList<~> t = List.of(“F95”);

List<~> t2 = t.prepend(“FCK”);

F95 /t

List<~> t = List.of(“F95”);

List<~> t2 = t.prepend(“FCK”);

Persistent and Efficient

Streams are glorified IteratorsStream<String> jdk = Stream.of("a", “B");

jdk.map(String::toUpperCase); jdk.map(String::toLowerCase);

java.lang.IllegalStateException: stream has already been operated upon or closed at java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203) at java.util.stream.ReferencePipeline.<init>(ReferencePipeline.java:94) at java.util.stream.ReferencePipeline$StatelessOp.<init>(ReferencePipeline.java:618) at java.util.stream.ReferencePipeline$3.<init>(ReferencePipeline.java:187) at java.util.stream.ReferencePipeline.map(ReferencePipeline.java:186)

Javaslang StreamsStream<String> slang = Stream.of("a", "B"); slang.map(String::toUpperCase); // “A”,“B” slang.map(String::toLowerCase); // “a”,“b”

Javaslang StreamsStream<String> slang = Stream.of("a", "B"); slang.map(String::toUpperCase) .take(2); slang.map(String::toLowerCase) .take(2);

Javaslang StreamsStream<String> slang = Stream.of("a", "B"); slang.map(String::toUpperCase) .take(2);// “A”,“B” slang.map(String::toLowerCase) .take(2);// “a”,“b”

Functional data structures improve performance and

reduce the chance of unexpected behaviour

Functional Sugar

“Find a user and, if an address is available, fetch

the user’s street”

Cascading Pile of ShameUser user = repo.findOne("id"); if (user != null) { Address address = user.getAddress(); if (null != address) {

return address.getStreet(); } }

We’ve got java.util.Optional

Optional<User> opt = Optional.ofNullable(user);

if (optional.isPresent()) { … }

Please stop usingOptional#isPresent()

An Option is like a Gift Box

NoneSome

Map opens the Gift Box

MapSome Some

Nothing from Nothing( )->

MapNone None

Optional or Option?

Optional

Optional or Option?

Option

Some None

Optional or Option?

Option

Some None

Iterable

Optional or Option?

Option

Some None

Iterable

Optional or Option?

Option

Some None

Iterable

Serializable

Fixing the Pile of ShameUser user = repo.findOne("id"); if (user != null) { Address address = user.getAddress(); if (null != address) {

Option all the ThingsUser user = repo.findOne("id"); if (user != null) { Address address = user.getAddress(); if (null != address) {

Option all the ThingsOption<User> user = repo.findOne("id"); if (user != null) { Address address = user.getAddress(); if (null != address) {

Option all the ThingsOption<User> user = repo.findOne("id"); user.flatMap(User::getAddress) Address address = user.getAddress(); if (null != address) {

Option<User> user = repo.findOne("id"); user.flatMap(User::getAddress) Address address = user.getAddress(); if (null != address) {

return address.getStreet(); } } Option<Address> getAddress()

Option all the ThingsOption<User> user = repo.findOne("id"); user.flatMap(User::getAddress) Address address = user.getAddress(); if (null != address) {

Option all the ThingsOption<User> user = repo.findOne("id"); user.flatMap(User::getAddress) Address address = user.getAddress(); .map(Address::getStreet)

repo.findOne("id") .flatMap(User::getAddress) .map(Address::getStreet) .getOrElse("");

“Find a user and, if an address is available, fetch the user’s street”

Option and map transform nested code into an

understandable story

Working with legacy codePainting by Eero Järnefelt

Nice Validation Codepublic static String check(String iban){ if (validationMagic(iban)) { return iban; }

throw new IllegalArgumentException(“Peng”); }

Awesome WTF Code String iban; try { iban = check("AL47"); } catch (IllegalArgumentException ex) { iban = ""; }

From Exceptions to Options

String iban = lift(Iban::check) .apply("AL47...") .getOrElse("");

From Exceptions to Options

String iban = lift(Iban::check) .apply("AL47...") .getOrElse("");

Wrapping Exceptions with Try

Try.of(() -> stuffToDo())

Wrapping Exceptions with Try

FailureException

SuccessResult

Try.of(() -> stuffToDo())

Exceptions to Options with Try

Try.of(() -> check("AL..")) .getOrElse("")

Exceptions to Options with Try

Try.of(() -> check("AL..")) .getOrElse("")

Lifting and Try-ing reduce exception handling clutter

and side-effects

Structural DecompositionImage by Arend, https://flic.kr/p/pkBe4g

Classic HTTP Handlingif (OK.equals(res.getStatusCode())) { return res.getBody(); }

return emptyList();

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

Pattern Matching Basics

Match(expression) .of(cases)

Cases map functions to patterns

Case(pattern, function)

Example Patterns

$() wildcard pattern $(“foo”) equals pattern isIn(“a”, “b”) conditional pattern

HTTP Handling Fixed

*Note: some type details missing

Match(res.getStatusCode()) .of( Case($(OK), res.getBody()), Case($(), emptyList()) );

HTTP Handling Fixed

OK or anything else

HTTP Handling Fixed

HTTP Handling FixedMatch(res.getStatusCode()) .of( Case($(OK), res.getBody()), Case($(), emptyList()) );

Matching a Try

public Try<…> fetchFromUrl(…) { … }

Matching a TryMatch(fetchFromUrl(“…”)) .of( Case(Success($()), identity()), Case(Failure($()), emptyList()) );

Presto!Match(fetchFromUrl(“…”)) .of( Case(Success($()), identity()), Case(Failure($()), emptyList()) );

Pattern matching replaces complex if-then-else sequences

with clear expressions

HashMap.of("Foo", "Bar", "Qux", "Baz") .bimap(String::toLowerCase, String::toUpperCase) .get("qux"); // BAZ

Javaslang offers much more

Javaslang offers much moreTuple.of("Foo", 1) .map((s, i) -> Tuple.of(s + "Bar", i + 5)) // “FooBar”, 6

Javaslang offers much more

So, is this is the mother of all free lunches?

What are the drawbacks?

What are the drawbacks?count(Collection-libs)

count(Logging-libs)

What are the drawbacks?Option.of(foo)

.filter

.flatMap

Wrapping upSlick, stable, consistent API

Object-functional

Complex(?)

Version 3 in 2017

.iohttp://

Do you want to know more?

Thank You!<david.schmitz@senacor.com>

javaslang @ devoxx

Engineering

goto devoxx

spring actionscript at devoxx

devoxx 2013 io t

technical archaeology devoxx

devoxx 2013 - hazelcast

izpack at devoxx 2010

synyx - devoxx for kids bedcon15 - devoxx for... · 2016....

devoxx 2013 summary/keynotes

greach 2017 - javaslang & groovy: the best of both worlds

devoxx activiti in action

devoxx uk bof session

devoxx 2012 hibernate envers

devoxx enterprise scale angular

devoxx 2014 monitoring

devoxx 2014 michael_neale

cassandra devoxx 2010

kotlin @ devoxx 2011

lescastcodeurs devoxx france 2015

vaadin roadmap-devoxx-2013

apache camel devoxx 2010