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

https://flic.kr/p/acFwxG


Mutable Collections are Evil

Returning void == Side-Effect!

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

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

FCKt2


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

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

F95 /

FCK

t

t2

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

Value

Iterable


Optional or Option?

Option

Some None

Value

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("");


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("")


Lifting and Try-ing reduce exception handling clutter

and side-effects


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

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


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)

.map

.filter

.flatMap


Wrapping upSlick, stable, consistent API

Object-functional

Complex(?)

Version 3 in 2017


.iohttp://

Do you want to know more?


Thank You!<[email protected]>

javaslang @ devoxx

Engineering