Javaslang

Vavr - Functional Java Done Right

Grzegorz Piwowarek

gpiwowarek@gmail.com

Me

pivovarit@

Twitter

GitHub

...everywhere else

Java 8

"Functional" Java8:

• Lambda Expressions
• Optional, Stream, CompletableFuture
• ...

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())
• ...

List<String> transform(List<String> list) {
    if (this.state.isEmpty() || list.isEmpty()) {
        throw new IllegalStateException("Ouch...");
    }

    list.add(this.state.get(0));
    list.add(SOME_CONSTANT);

    if (MOON.getLunarPhase() == FULL) list.remove(7); 

    this.moreState.addAll(list);
    OtherClass.mutableStaticField = list;

    return list;
}

Potential inputs:

• declared params
• instance state
• global state

Potential outputs:

• declared returned value
• mutable instance state
• mutable global state
• mutable params
• exceptions

Potential inputs:

• declared params

Potential outputs:

• declared returned value

Functional programming is not about lambdas.

"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

Immutability

Referential Transparency

Java Collections API:

• add()
• remove()
• clear()
• ...

Date date = new Date();

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

dates.contains(date); //false

λ

Tuple

Value

λ

Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;

• composition
• lifting
• currying
• memoization

Lifting

Function2<Integer, Integer, Integer> divideBy = (a, b) -> a / b;

Currying

Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;

Memoization

Function2<Integer, Integer, Integer> sum = (a, b) -> a + b;

Function0<Double> mem = Function0.of(Math::random).memoized();

Tuple

Tuple2<String, Integer> java8 = Tuple.of("Java", 8); 

Value

• Option
• Try
• Lazy
• Either
• Future
• Validation
• Collections API

Option

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

List<Optional<Integer>> list = ...
        
list.stream()
  .filter(Optional::isPresent)
  .map(Optional::get)
  .collect(toList());

Java 8

Try

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

Lazy

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

Functional Data Structures

Functional Data Structures:

• Persistent
• Immutable
• with Referential Transparent methods

"Functional Data Structures in Java" - Oleg Šelajev

Seq

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

Pattern Matching

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/

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

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

vavr.io

Thank you!

• gpiwowarek@gmail.com
• pivovarit@twitter (slides are here!)
• pivovarit@github