Is it...

• First-class functions?
• Not having side effects?
• (Referential transparency?)

— our own Kalani Thielen

FP as a Modality

not a family

Transformations

Not iterations

Constrained state

Local over global

How does this work?

foo = [1,2,3,4,5]
for i in (0...foo.size)
    foo[i] = foo[i] * 2
end

foo
# => [2,4,6,8,10]

foo = [1,2,3,4,5]
bar = []
for element in foo
    bar << element * 2
end

foo
# => [1,2,3,4,5]

bar
# => [2,4,6,8,10]

foo = [1,2,3,4,5]
foo.map {|x| x * 2}
# => [2,4,6,8,10]

Why do this?

foo = [1,2,3,4,5]
foo.map {|x| x * 2}

foo = some_dataset
foo.map {|x| costly_operation(x)}.reduce {|m, o| aggregation(m, o)}

I get it but...

We work in Java

Mixed bag from an FP standpoint

• Constrained state: encapsulation
• First-class functions: anonymous inner classes

element.addListener(new NotARealClosure() {
    public void someCallback(Event e)
    {
        // ugh.
    }
});

For all Java's flaws

FP can make ours better

Exhibit A:

Functional languages

love Option

scala> val x = List((1,2)).toMap
x: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2)

scala> x.get(1)
res2: Option[Int] = Some(2)

scala> x.get(3)
res3: Option[Int] = None

scala> x.getOrElse(4, 5)
res4: Option[Int] = 5

What does null mean?

HashMap<Integer, Integer> someHashMap = new HashMap<>();
someHashMap.put(1, 2);
Optional<Integer> foo = Optional.fromNullable(someHashMap.get(1));
Optional<Integer> bar = Optional.fromNullable(someHashMap.get(3));

if (foo.isPresent()) foo.get(); // 2
bar.isPresent(); // false
bar.get(); // IllegalStateException
bar.or(5); // 5

Why is this handy?

• No NullPointerExceptions. Ever.
• You're required to handle every case.

Exhibit B:

Functional languages

love Immutability