functional programming in java 8

FP in JAVA 8

sponsored by !Ignasi Marimon-Clos (@ignasi35)

JUG Barcelona

@ignasi35

thanks!

@ignasi35

about you

@ignasi35

about me

@ignasi35

1) problem solver, Garbage Collector, mostly scala, java 8, agile for tech teams

2) kayaker

3) under construction

4) all things JVM

@ignasi35

FP in Java 8

Pure Functions

no side effects

if not used, remove it

fixed in — fixed out

@ignasi35

FP in Java 8

(T, R) -> Q

@ignasi35

FP in Java 8

Supplier<T>

Function<T,R>

BiFunction<T,R,Q>

Predicate<T>

Consumer<T>

() -> T

(T) -> R

(T, R) -> Q

(T) -> boolean

(T) -> {}

@ignasi35

currying

(T, R) -> (Q) -> (S) -> J

BiArgumentedPrototipicalFactoryFactoryBean

@ignasi35

@ignasi35

thanks!

@ignasi35End of presentation

@ignasi35

@ignasi35

XXIst Century DateTime

@ignasi35


• Date is DEAD (my opinion) • Calendar is DEAD (my opinion)

!

!

• DEAD is 57005 (that’s a fact)

@ignasi35


• Clock • LocalDate • LocalDateTime • Duration vs Period • ZonedDateTime

!

• Enum.Month • Enum.DayOfWeek

@ignasi35

XXIst Century DateTimeEnum.Month !

• Not just JAN, FEB, MAR • Full arithmetic • plus(long months) • firstDayOfYear(boolean leapYear) • length(boolean leapYear) • …

@ignasi35


• Clock • replace your sys.currentTimeMillis • allows testing • Instant/now

• LocalDate • LocalDateTime • Duration vs Period • ZonedDateTime

@ignasi35

@ignasi35


• Clock • LocalDate • a date • no TimeZone • birth date, end of war, man on moon,…

• LocalDateTime • Duration vs Period • ZonedDateTime

@ignasi35

@ignasi35


• Clock • LocalDate • LocalDateTime • an hour of the day • noon • 9am

• Duration vs Period • ZonedDateTime

@ignasi35

@ignasi35


• Clock • LocalDate • LocalDateTime • Duration vs Period • Duration: 365*24*60*60*1000 • Period: 1 year (not exactly 365 days) • Duration (Time) vs Period (Date)

• ZonedDateTime

@ignasi35

@ignasi35


• Clock • LocalDate • LocalDateTime • Duration vs Period • ZonedDateTime (not an Instant!!) • Immutable • nanosecond detail • Normal, Gap, Overlap

@ignasi35

@ignasi35

Lists

a1 1 2 3Nil

List<Integer> nil = Lists.nil(); ! List<Integer> a3 = nil.prepend(3); List<Integer> a2 = a3.prepend(2); List<Integer> a1 = a2.prepend(1);

@ignasi35

Lists

a1 1 2 3Nil

head(); tail();

@ignasi35

public interface List<T> { T head(); List<T> tail(); boolean isEmpty(); void forEach(Consumer<? super T> f); default List<T> prepend(T t) { return new Cons<>(t, this); } }

Lists

@ignasi35

Listsa1

1 2 3Nil

List<Integer> a0 = a1.prepend(0); List<Integer> b = a1.prepend(4);

0

a0

4

b Cons

Cons

Cons Cons Cons

@ignasi35

class Cons<T> implements List<T> { private T head; private List<T> tail; Const(T head, List<T> tail) { this.head = head; this.tail = tail; } ! T head(){return this.head;} List<T> tail(){return this.tail;} boolean isEmpty(){return false;} ! void forEach(Consumer<? super T> f){ f.accept(head); tail.forEach(f); } }

Lists

@ignasi35

class Nil<T> implements List<T> { ! T head() { throw new NoSuchElementException(); } List<T> tail() { throw new NoSuchElementException(); } boolean isEmpty() { return true; } void forEach(Consumer<? super T> f){ } !}

Lists

@ignasi35

Listsa1

1 2 3Nil

0

a0

4

b Cons

Cons

Cons Cons Cons

Persistent Datastructures (not ephemeral, versioning) Immutable As efficient (consider amortised cost)

@ignasi35

@ignasi35

filterclass Nil<T> implements List<T> { //… List<T> filter(Predicate<? super T> p) { return this; } } !class Cons<T> implements List<T> { //… List<T> filter(Predicate<? super T> p) { if (p.test(head)) return new Const<>(head, tail.filter(p)); else return tail.filter(p); } }

@ignasi35

map

@ignasi35

map

f

@ignasi35

mapclass Nil<T> implements List<T> { //… <R> List<R> map(Function<T, R> f) { return (List<R>) this; } } !class Cons<T> implements List<T> { //… <R> List<R> map(Function<T, R> f) { return new Const<>(f.apply(head), tail.map(f)); } }

@ignasi35

@ignasi35

fold

f

f

f

@ignasi35

fold

class Nil<T> implements List<T> { <Z> Z reduce(Z z, BiFunction<Z, T, Z> f) { return z; } } !class Cons<T> implements List<T> { <Z> Z reduce(Z z, BiFunction<Z, T, Z> f) { return tail.reduce(f.apply(z,head), f); } }

@ignasi35

fold

aka reduce

@ignasi35

map revisited

f

@ignasi35

f

map revisited

@ignasi35

! @Test void testMapList() { List<List<String>> actual = Lists .of(“hello world”, “This is sparta”, “asdf asdf”) .map(s -> Lists.of(s.split(“ ”))); ! List<String> expected = Lists.of(“hello”, “world”, “This”, “is”, “sparta”, “asdf”, “asdf”); ! assertEquals(expected, actual); }

map revisited

@ignasi35

@ignasi35

map

f

@ignasi35

flatMap

f

@ignasi35

flatMap

!class Cons<T> implements List<T> { //… <R> List<R> map(Function<T, R> f) { return new Const<>(f.apply(head), tail.map(f)); } ! <R> List<R> flatMap(Function<T, List<R> f) { return f.apply(head).append(tail.flatMap(f)); } !}

@ignasi35

@ignasi35

recap

filter !

map !

fold !

flatMap

@ignasi35

@ignasi35

class MyFoo { ! //@param surname may be null Person someFunc(String name, String surname) { … } !}

@ignasi35

Maybe (aka Optional)

replaces null completely

@ignasi35


replaces null completelyforever

@ignasi35


replaces null completelyforeverand ever

@ignasi35


replaces null completelyforeverand everand ever

@ignasi35


replaces null completelyforeverand everand everand ever

@ignasi35


replaces null completelyforeverand everand everand everand ever

@ignasi35


replaces null completelyforeverand everand everand everand everand ever

@ignasi35


!class MyFoo { Person someFunc(String name, Optional<String> surname) { … } ! … !}

@ignasi35


!class MyFoo { Optional<Person> someFunc(Name x, Optional<Surname> y) { … } ! … !}

@ignasi35


Some/Just/Algo !

!

None/Nothing/Nada

ADT

@ignasi35

@ignasi35


filter: applies predicate and Returns input or None map: converts content fold: returns Some(content) or Some(default) flatMap: see list

get: returns content or throws Exception getOrElse: returns content or defaultValue

@ignasi35

recap

filter !

map !

fold !

flatMap

ADT !

Functor

@ignasi35

@ignasi35

Future (aka CompletableFuture)

@ignasi35

Future (aka CF, aka CompletableFuture)

!

[FAIL] Does not use map, flatMap, filter. !

[PASS] CF implemented ADT !

[FAIL] Because Supplier, Consumer, Function, Bifuction, … CF’s API sucks.

@ignasi35

Future

filter: creates new future applying Predicate map: converts content if success. New Future fold: n/a flatMap: see list

andThen: chains this Future’s content into a Consumer onSuccess/onFailure: callbacks recover: equivalent to map() but applied only on Fail

@ignasi35

recap

filter !map !fold !flatMap !andThen

ADT !Functor

@ignasi35

!

Maybe simulates nullable Future will eventually happen

!

Exceptions still fuck up your day

recap

@ignasi35

@ignasi35

Try

Simulates a computation that: !

succeeded or

threw exception

@ignasi35

@ignasi35

Try in action

@ignasi35

@ignasi35

Try in action

@ignasi35

@ignasi35

!class PersonRepository { Try<Person> loadBy(Name x, Optional<Surname> y) { … } ! … !}

Conclusions

@ignasi35

class SafeDatabase { <T> T withTransaction(Function<Connection, T> block) { … } } !class AnyAOP { <T> T envolve(Supplier<T> block) { … } }

Conclusions

@ignasi35

@ignasi35

Moar resources

https://github.com/rocketscience-projects/javaslang

by https://twitter.com/danieldietrich

!

https://github.com/functionaljava/functionaljava

by http://www.functionaljava.org/ (runs in Java7)

thanks @thomasdarimont for the tip

https://github.com/rocketscience-projects/javaslang

https://twitter.com/danieldietrich

https://github.com/functionaljava/functionaljava

http://www.functionaljava.org/

@ignasi35

@ignasi35

Namaste

@ignasi35

Questions

@ignasi35End of presentation

functional programming in java 8

Technology