"Java 8, Lambda e la programmazione funzionale" by Theodor Dumitrescu

Copyright 2011 - 2018, ThinkOpen S.r.l.Copyright 2011 - 2018, ThinkOpen S.r.l.
Why java moved a step forward to functional
programming?

Copyright 2011 - 2018, ThinkOpen S.r.l.
2

3

FUNCTIONAL PROGRAMMING
=
LOGIC
+
CATEGORY THEORY
+
COMPUTER SCIENCE

Lambda calculus
λx.y
Alonzo Church

Haskell vs. Ada vs. C++ vs. Awk vs. …
by Paul Hudak and Mark P. Jones
6

7

8

3 BILLION DEVICES
9

3 BILLION DEVICES
12 BILLION CORES
10

3 BILLION DEVICES
12 BILLION CORES
24 BILLION THREADS
11

Some people, when confronted with a problem,
think, “I know, I’ll use multi-threading”
Nothhw tpe yawrve o oblems.
12

Semaphores
Thread pools
Callbacks
Synchronization
Locks
Atomic operations
Race condition
Functions
Functions
Functions
Functions
Functions
Functions
Functions

14

15

16

17

“Functional programming is
more a way of thinking than a
tool of set”
Neal Ford

19
Execution in the
Kingdom of Nouns
by
Steve Yegge

20

21
button.setOnAction( new EventHandler<ActionEvent>() {
@Override public void handle(ActionEvent e) {
//…
}
});

22
button.onAction( a -> /*...*/ );

When the verbs were slaves
Object foo(int x) {
//..
return null;
}

Object foo(int x) {
//..
return null;
}
IDLE

Object foo(int x) {
//..
return null;
}
Object foo(int x) {
//..
throw new RuntimeException();
//..
}
IDLE

Object foo(int x) {
//..
return null;
}
Object foo(int x) {
//..
//..
}
IDLE
LAIRS

Object foo(int x) {
//..
return null;
}
Object foo(int x) {
//..
//..
}
Object foo(int x) throws Exception{
//..
throw new Exception(...);
//..
}
IDLE
LAIRS

Object foo(int x) {
//..
return null;
}
Object foo(int x) {
//..
//..
}
Object foo(int x) throws Exception{
//..
throw new Exception(...);
//..
}
IDLE
LAIRS
CONFRONTATIONAL

Verbs in the kingdom of Java 8
var lambda = x -> x+1;

var f = t -> ...;
FIRST-CLASS CITIZEN

Optional<R> foo(T t) {
//….
}
FIRST-CLASS CITIZEN

Optional<R> foo(T t) {
//….
}
FIRST-CLASS CITIZEN
TRUSTY

var true = (x,y) -> x;
var false = (x,y) -> y;

var true = (x,y) -> x;
var false = (x,y) -> y;DATA

#1 Parametrize everything
35

36
public class NumericalList <T extends Number>
extends ArrayList<T> {
public double sum() {
double sum = 0;
for(Number n : this)
sum += n.doubleValue();
return sum;
}
public double product() {
double product = 0;
product *= n.doubleValue();
return product;
}
}

37
double sum = 0;
return sum;
}
double product = 0;
return product;
}
}

38
double sum = 0;
return sum;
}
double product = 0;
return product;
}
}

39
double sum = 0;
return sum;
}
double product = 0;
return product;
}
}

40
private double fetch(double start, Operation op) {
double tmp = start;
tmp = op.on(tmp, n.doubleValue());
return tmp;
}
return fetch(0, new Operation {
@Override
public double on(double arg0, double arg1) {
return arg0 + arg1;
}
});
}
}

41
double tmp = start;
return tmp;
}
return fetch(0, (arg0, arg1) -> arg0 + arg1);
}
interface Operation {
double op(double arg0, arg1);
}
}

42
double tmp = start;
return tmp;
}
return fetch(0, (arg0, arg1) -> arg0 + arg1);
}
public double sumOnlyEven() {
return fetch(0, (arg0, arg1) -> arg1 % 2 == 0 ? arg0 + arg1 : arg0);
}
}

43
boolean areValid(double arg0, arg1);
}
double tmp = start;
if(op.areValid(tmp, arg1))
return tmp;
}

44
@Override
return arg0 + arg1;
}
@Override
public boolean areValid(double arg0, double arg1) {
return true;
}
});
}
public double multiply() {
@Override
return arg0 * arg1;
}
@Override
return true;
}
});
}

45
default boolean areValid(double arg0, double arg1) {
return true;
}
}
double tmp = 0;
if(op.areValid(tmp, arg1))
return tmp;
}

46
public double sumOnlyEven() {
@Override
return arg0 + arg1;
}
@Override
return (arg0 + arg1) % 2 == 0;
}
});
}
public double multiplyOnlyEven() {
@Override
return arg0 * arg1;
}
@Override
return (arg0 + arg1) % 2 == 0;
}
});
}

#2 Functions types are interfaces
47

48
double op(double arg0, double arg1);
boolean areValid(double arg0, double arg1);
}
Single Responsibility Principle
+
Interface Segregation Principle
@FunctionalInterface
interface Validator {
boolean areValid(double arg0,
double arg1);
}
double op(double arg0,
double arg1);
}

49
double arg1);
}
+
boolean isValid(double arg0);
}

50
double arg1);
}
+
interface …..{
boolean …..(double arg0);
}

#3 Monoids
building complexity starting from simplicity
51

52
#3 Monoids building complexity starting from simplicity
class Sum implements Operation {
double op(double arg0, double arg1) { return arg0 + arg1; }
}

53
}
abstract class OperationDecorator implements Operation {
protected Operation operationToBeDecorated; // the Operation being decorated
public OperationDecorator (Operation operationToBeDecorated) {
this.operationToBeDecorated = operationToBeDecorated;
}
@Override
public double op(double arg0, double arg1) {
return operationToBeDecorated.op(arg0, arg1); //Delegation
}
}

54
}
}
@Override
}
}
class DoubleAgumentsDecorator extends OperationDecorator {
public DoubleAgumentsDecorator (Operation opToBeDecorated) {
super(opToBeDecorated);
}
@Override
return super.op(arg0*2, arg1*2);
}
}

55
}
}
@Override
}
}
}
@Override
}
}
new CeilResultDecorator(new DoubleAgumentsDecorator(new Sum()))

56
}
}
@Override
}
}
}
@Override
}
}
new CeilResultDecorator(new DoubleAgumentsDecorator(new Sum()))

57
}
}
@Override
}
}
}
@Override
}
}
new BlahDecorator(new BlahBlahDecorator(new Sum()))

58
var doubles = (double arg) -> arg * 2;
var round = Math::ciel;
var add10 = (double arg) -> arg + 10;
var roundAdd10 = add10.andThen(round);
var veryComplexFunction = fstStep
.andThen(sndStep)
.andThen(Math::sin)
.andThen(...)
….
.andThen(...);
var veryVeryComplexFunction = fstVeryComplexFunction
.andThen(sndveryComplexFunction)
….

double -> double
59
doubles
double -> double
round
double -> double
add10
double -> double
double -> double
doubles
double -> double
add10
double -> double
double -> double
double
double -> double
add10
double -> double op
double -> double

double -> double
60
double -> int int -> String String -> double byte[] -> doubledouble -> byte[]

61
Composition pattern only works for functions
that have only one parameter

62
High order functions are not just function
that can be moved around but also functions
that returns functions

#4 Partial applications and Closure
63

64
let product a b = a * b;

65
product :: Num a => a -> a -> a

66
product :: Num a => a -> (a -> a)

67
Function<Double, Function<Double,Double>>

68
product = a -> (b -> a * b);

69
product = a -> (b -> a * b);
var doubles = product(2);
var tenTimes = product(10);
double ten = tenTimes(1);

70
Foo newFoo(....) {
class Bar implements Foo { }
Bar b = new Bar();
//….
return b;
}

71
Function<T,R> foo(....) {
//….
var privateObj = ….;
return t -> {
//here I can use privateObj
return ret;
}
}

#5 Monads and map
72

73
#5 Monads and map
if (a != null ) {
//…
if(b != null) {
//...
if(c != null) {
//…
if(...) {
//...
} else { return null; }

74
#5 Monads and map
if (optionalA.isPresent()) {
var a = optionalA.get();
//…
if (optionalB.isPresent()) {
var b = optionalB.get();
//...
if (optionalC.isPresent()) {
var c = optionalC.get();
//…
if(...) {
//...
} else { return Optional<T>.empty(); }

75
#5 Monads and map
var ifSomeDo = f -> obj -> notNull(obj) ? f(obj) : null;
var sample = arg -> doSomething
.andThen(ifSomeDo(somethingElse)
.andThen(ifSomeDo(somethingElse2)
.andThen(ifSomeDo( a -> map(a))
.apply(arg);

76
Optional’s univers
Values’ universe
#5 Monads and map

77
Values’ universe
#5 Monads and map

78
Values’ universe
#5 Monads and map

79
Values’ universe
T -> R
Optional<T> -> Optional<R>
Optional.map
#5 Monads and map

80
Optional<Optional<Optional<Optional<Optional<O
ptional<Optional<Optional<Optional<Optional<Op
tional<Optional<Optional<Value>>>>>>>>>>>>>
#5 Monads and map

81
Optional.flatMap
#5 Monads and map

82
#5 Monads and map

83
#5 Monads and map

84
#5 Monads and map

85
#5 Monads and map

86
#5 Monads and map

87
#5 Monads and map

88
#5 Monads and map

89

"Java 8, Lambda e la programmazione funzionale" by Theodor Dumitrescu

More Related Content

What's hot (20)

Similar to "Java 8, Lambda e la programmazione funzionale" by Theodor Dumitrescu (20)

More from ThinkOpen (20)

Recently uploaded (20)

"Java 8, Lambda e la programmazione funzionale" by Theodor Dumitrescu