Functional Programming in JAVA 8

FP in JAVA 8
sponsored by !
Ignasi Marimon-Clos (@ignasi35)
JUG Barcelona

@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
End of presentation

@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
Enum.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
• ZonedDateTime

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

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

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

@ignasi35
• Clock
• LocalDate
• LocalDateTime
• ZonedDateTime (not an Instant!!)
• Immutable
• nanosecond detail
• Normal, Gap, Overlap

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

@ignasi35
Lists
a1 1 2 3
Nil
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
Lists
a1
1 2 3
Nil
0
a0
b Cons
Cons Cons Cons
4
Cons
List<Integer> b = a1.prepend(4);

@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
Lists
a1
1 2 3
Nil
0
a0
b Cons
Cons Cons Cons
4
Cons
Persistent Datastructures (not ephemeral, versioning)
Immutable
As efficient (consider amortised cost)

@ignasi35
filter
//…
List<T> filter(Predicate<? super T> p) {
return this;
}
}
!
//…
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
//…
<R> List<R> map(Function<T, R> f) {
return (List<R>) this;
}
}
!
//…
return new Const<>(f.apply(head), tail.map(f));
}
}

@ignasi35
fold
<Z> Z reduce(Z z, BiFunction<Z, T, Z> f) {
return z;
}
}
!
<Z> Z reduce(Z z, BiFunction<Z, T, Z> f) {
return tail.reduce(f.apply(z,head), f);
}
}

!
@Test
void testMapList() {
List<List<String>> actual = Lists
@ignasi35
.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
flatMap
!
//…
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
recap
filter
!
map
!
fold
!
flatMap

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

@ignasi35
Maybe (aka Optional)
replaces null completely

@ignasi35
forever

@ignasi35
forever
and ever

@ignasi35
forever
and ever
and ever

@ignasi35
forever
and ever
and ever
and ever

@ignasi35
forever
and ever
and ever
and ever
and ever

@ignasi35
forever
and ever
and ever
and ever
and ever
and 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
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
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
recap
!
Maybe simulates nullable
Future will eventually happen
!
Exceptions still fuck up your day

@ignasi35
Try
Simulates a computation that:
!
succeeded
or
threw exception

@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
Moar resources
https://github.com/rocketscience-projects/javaslang
by https://twitter.com/danieldietrich
thanks @thomasdarimont for the tip
!
https://github.com/functionaljava/functionaljava
by http://www.functionaljava.org/ (runs in Java7)

Functional Programming in JAVA 8

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (20)

Similar to Functional Programming in JAVA 8

Similar to Functional Programming in JAVA 8 (20)

More from Ignasi Marimon-Clos i Sunyol

More from Ignasi Marimon-Clos i Sunyol (10)

Recently uploaded

Recently uploaded (20)

Functional Programming in JAVA 8