Design Pattern Reloaded

Rmi Forax / ParisJUG / June 2015

https://github.com/forax/design-pattern-reloaded
 Me, Myself and I

Assistant Prof at Paris East University

Expert for JSR 292, 335 and 376
Open source dev: OpenJDK, ASM, JsJs, etc
Father of 3
 Apprenticeship !
Warning, this is an ad !

Ecole Suprieur d'Ingnieurs Paris Est

(Fillire Informatique)
http://esipe.u-pem.fr/

Universit Paris Est Marne La Valle

(Licence 3 / Master Informatique)
http://www.u-pem.fr/
 Foreword - Functional Interface
A function type is represented by a functional interface

@FunctionalInterface
interface BinOp {
int apply(int val1, int val2);
}

a functional interface has only one abstract method

 Foreword - Lambda
@FunctionalInterface
interface BinOp {
int apply(int val1, int val2);
}
a functional interface has only one abstract method

Conceptually equivalent to
typedef BinOp = (int, int) int

BinOp add = (x, y) -> x + y;

BinOp mul = (a, b) -> a * b;
Foreword - Predefined interfaces
Defined in package java.util.function
signature interface method
() void Runnable run
() T Supplier get

T void Consumer accept

int void IntConsumer accept

T boolean Predicate test

int boolean IntPredicate test

TR Function<T,R> apply
int R IntFunction<R> apply
T int ToIntFunction applyAsInt
 Foreword - Method Reference
The operator :: allows to reference an existing method
(static or not)

:: on a type
BinOp add = Integer::sum;

:: on a reference
ThreadLocalRandom r = ThreadLocalRandom.current();
BinOp randomValue = r::nextInt;
 Live Coding in jshell (1/3)
-> interface BinOp {
>> int apply(int v1, int v2);
>> }
| Added interface BinOp
-> BinOp add = (a, b) -> a + b;
| Added variable add of type BinOp with initial value
$Lambda$1/13648335@6bdf28bb
-> add.apply(2, 3);
| Expression value is: 5
| assigned to temporary variable $1 of type int
-> add = (x, y) -> x y;
| Variable add has been assigned the value $Lambda$2/968514068@511baa65
-> add.apply(2, 3);
| Expression value is: -1
| assigned to temporary variable $2 of type int
 Live Coding in jshell (2/3)
-> List<String> list = Arrays.asList("hello", "paris");
| Added variable list of type List<String> with initial value [hello, paris]
-> list.forEach(item -> System.out.println(item));
hello
paris
-> Consumer<Object> printer = item -> System.out.println(item);
| Added variable printer of type Consumer<Object> with initial value
$Lambda$4/2114889273@3d24753a
-> list.forEach(printer);
hello
paris
-> Files.list(Paths.get(".")).forEach(printer);
./jimage-extracted
./.project
...
 Live Coding in jshell (3/3)

-> IntStream.range(0, 10).reduce(0, (a, b) -> a + b);

| Expression value is: 45
| assigned to temporary variable $3 of type int
-> IntStream.range(0, 10).reduce(0, Integer::sum);
| Expression value is: 45
| assigned to temporary variable $4 of type int
-> Consumer<Object> printer = System.out::println;
| Modified variable printer of type Consumer<Object> with initial value
$Lambda$8/1419810764@36f6e879
-> list.forEach(printer);
hello
paris
-> Files.list(Paths.get(".")).forEach(printer);
./jimage-extracted
./.project
...
All I'm offering is the truth. Nothing more
 Design Pattern - 1994
Classes are not only for data !

Two big principles:

Program to an interface, not an implementation
Favor object composition over class inheritance

Side note:
Some GoF patterns do not respect these principles
 A simple Logger

public interface Logger {

void log(String message);

public static void main(String[] args) {

Logger logger = msg -> System.out.println(msg);
}
}

No parenthesis if one argument

 Filtering logs
public interface Logger {
void log(String message);
}
public interface Filter {
boolean accept(String message);
}

I want a Logger that only log messages that are

accepted by a filter
 GoF Template Method !
public interface Logger {
void log(String message);
}
public interface Filter {
boolean accept(String message);
}
public abstract class FilterLogger implements Logger, Filter {
private final Logger logger;
public FilterLogger(Logger logger) {
this.logger = Objects.requireNonNull(logger);
}
public void log(String message) {
if (accept(message)) {
logger.log(message);
}
}
public abstract boolean accept(String message);
}
 GoF Template Method :(
public interface Logger {
void log(String message);
}
public interface Filter {
boolean accept(String message);
}
public abstract class FilterLogger implements Logger, Filter {
private final Logger logger;
public FilterLogger(Logger logger) {
this.logger = Objects.requireNonNull(logger);
}
public void log(String message) {
if (accept(message)) {
logger.log(message);
}
}
public abstract boolean accept(String message);
}
 GoF Template Method :(

public abstract classes

are harmful !
 Favor object composition !
public class FilterLogger implements Logger {
private final Logger logger;
private final Filter filter;
public FilterLogger(Logger logger, Filter filter) {
this.logger = Objects.requireNonNull(logger);
this.filter = Objects.requireNonNull(filter);
}
public void log(String message) {
if (filter.accept(message)) {
logger.log(message);
}
}
}
 With an anonymous class
FilterLogger has the same interface as Logger,
so it can be unamed !

public class Loggers {

public static Logger filterLogger(Logger logger, Filter filter) {
Objects.requireNonNull(logger);
Objects.requireNonNull(filter);
return new Logger() { Local variable values
public void log(String message) { are captured !
if (filter.accept(message)) {
logger.log(message);
}
}
};
}
}
 Higher order function
Garbage class
public class Loggers {
public static Logger filterLogger(Logger logger, Filter filter) {
Objects.requireNonNull(logger);
Objects.requireNonNull(filter);
return message -> {
if (filter.accept(message)) {
logger.log(message);
}
};
}
}
Logger logger = msg - > System.out.println(msg);
Logger filterLogger =
Loggers.filterLogger(logger, msg -> msg.startsWith("foo"));
 Function composition
using instance (default) method
public interface Logger {
void log(String message);
default Logger filter(Filter filter) {
Objects.requireNonNull(filter);
return message -> {
if (filter.accept(message)) {
log(message);
}
};
}
} g.filter(f)

Logger logger = msg - > System.out.println(msg);

Logger filterLogger =
logger.filter(msg -> msg.startsWith("foo"));
With Java 8 predefined interfaces
public interface Logger {
void log(String message);

default Logger filter(Predicate<String> filter) {

Objects.requireNonNull(filter);
return message -> {
if (filter.test(message)) {
log(message);
}
}; package java.util.function;
}
} @FunctionalInterface
public interface Predicate<T> {
public boolean test(T t);
}
 Summary
Public abstract classes are harmful because
behaviors are encoded in inheritance tree thus
can not be composed easily

Use function composition instead !

 FP vs OOP from 10 000 miles
FP
no class, no inheritance, only functions

FP can be seen through GoF Principles:

Program to an interface, not an implementation
function can be seen as interface with one abstract method
function doesn't expose their implementation detail
Favor object composition over class inheritance
function composition <=> object composition
 GoF kind of patterns

Structural

Behavioral

Creational
 Structural Patterns
Adapter,
Bridge,
Decorator,
Composite,
Proxy,
Flyweight, etc

most of them derive from

Favor object composition over class inheritance
 Yet Another Logger
public enum Level { WARNING, ERROR }
public interface Logger2 {
void log(Level level, String message);
}

Logger2 logger2 = (level, msg) ->

System.out.println(level + " " + msg);
logger2.log(ERROR, "abort abort !");

// how to adapt the two loggers ?

Logger logger = logger2 ??
 Partial Application
Set the value of some parameters of a function
(also called curryfication)

interface BinOp { int apply(int x, int y); }

interface UnOp { int apply(int x); }

BinOp add = (x, y) -> x + y;

UnOp add1 = x -> add.apply(x, 1);

BinOp mul = (a, b) - > a * b;

UnOp mulBy2 = a - > mul.apply(2, a);
 Partial Application
Logger.log == Logger2.log + a specific level

public interface Logger {

void log(String message);
}
public interface Logger2 {
void log(Level level, String message);

default Logger level(Level level) {

...
}
}
 Adapter
public interface Logger2 {
void log(Level level, String message);

default Logger level(Level level) {

return msg -> log(level, msg);
}
}

Logger2 logger2 = ...

Logger logger = logger2.level(ERROR);
logger.log("abort abort !");
 Partial Application & Method Ref.
The operator :: also allows to do partial
application on the receiver

BiConsumer<PrintStream, Object> consumer =

PrintStream::println;
type
PrintStream out = System.out;
Consumer<Object> consumer2 = out::println;
instance
package java.util.function;
public interface Consumer<T> { public interface BiConsumer<T, U> {
public void accept(T t); public void accept(T t, U u);
} }
 Summary
partial application allows to set some values
and let the others to be set later

a partially applied function can be shared !

 Behavioral Patterns
Command
Iterator Iteration
Observer
State
Visitor
 Command
A command is just a function

interface Command {
void perform();
}

Command command =
() - > System.out.println("hello command");
 Iteration
2 kinds
Internal iteration (push == Observer)
External iteration (pull == Iterator)

List<String> list =
Internal:
list.forEach(item -> System.out.println(item));

External:
for(String item: list) {
System.out.println(item);
}
External iteration is harder to write
forEach is easier to write than an Iterator
public class ArrayList<E> implements Iterable<E> {
private E[] elementData;
private int size;
public void forEach(Consumer<E> consumer) {
for(int i = 0; i < size; i++) {
consumer.accept(elementData[i]); internal
}
}
public Iterator<E> iterator() {
return new Iterator<E>() {
private int i;
public boolean hasNext() { return i < size; } external
public E next() { return elementData[i++]; }
};
}
}
Internal Iteration is less powerful
in Java
No side effect on local variables allowed !

List<Double> list =
Internal: sum is not effectively final
double sum = 0;
list.forEach(value -> sum += value);

External:
for(double value: list) {
sum += value;
}
 Sum values of a CSV ?

public class SumCSV {

public static double parseAndSum(Path path) throws {
try (Stream<String> lines = Files.lines(path)) {
return lines
.flatMap(line -> Arrays.stream(line.split(","))
.mapToDouble(token -> Double.parseDouble(token))
.sum();
}
}
}
 Sum values of a CSV ?
(using method reference)
public class SumCSV {
public static double parseAndSum(Path path) throws {
try (Stream<String> lines = Files.lines(path)) {
return lines
.flatMap(Pattern.compile(",")::splitAsStream)
.mapToDouble(Double::parseDouble)
.sum();
}
} Partial application
}
 Observer
Decouple work in order to close the CVSParser
(as in Open/Close Principle)

public interface Observer {

void data(double value);
}
public class CSVParser {
public static void parse(Path path, Observer observer) throws {
...
}
}
public class SumCSV {
public double parseAndSum(Path path) throws {
CSVParser.parse(path, ...);
...
}
}
 Observer side
public interface Observer {
void data(double value);
}
public class CSVParser {
public static void parse(Path path, Observer observer) throws {
...
}
} side effect
public class SumCSV {
private double sum;
public double parseAndSum(Path path) throws {
CSVParser.parse(path, value -> sum += value);
return sum;
}
}
 Observable side
The closed module

public interface Observer {

void data(double value);
}
public class CSVParser {
public static void parse(Path path, Observer observer) throws {
try (Stream<String> lines = Files.lines(path)) {
lines.flatMap(Pattern.compile(",")::splitAsStream)
.mapToDouble(Double::parseDouble)
.forEach(value -> observer.data(value));
}
}
}
 Functional Interfaces conversion
DoubleStream.forEach() takes a DoubleConsumer as
parameter

public interface Observer {

void data(double value);
}
public class CSVParser {
public static void parse(Path path, Observer observer) throws {
try (Stream<String> lines = Files.lines(path)) {
lines.flatMap(Pattern.compile(",")::splitAsStream)
.mapToDouble(Double::parseDouble)
.forEach(value -> observer.data(value));
}
}
} DoubleConsumer
 Functional Interfaces conversion
:: can be used to do interface to interface conversion

public interface Observer {

void data(double value);
}
public class CSVParser {
public static void parse(Path path, Observer observer) throws {
try (Stream<String> lines = Files.lines(path)) {
lines.flatMap(Pattern.compile(",")::splitAsStream)
.mapToDouble(Double::parseDouble)
.forEach(observer::data);
}
}
} DoubleConsumer
 Summary
function interface to functional interface
conversion is just a partial application using
instance method reference
 State
Yet another another logger !

chatty() quiet()
quiet()

Chatty Quiet

chatty()

error(msg) warning(msg) error(msg) warning(msg)

Consumer<String>
 State interface
Logger
public interface Logger {
enum Level { ERROR, WARNING }
void error(String message);
void warning(String message); ChattyLogger QuietLogger
Logger quiet();
Logger chatty();
static Logger logger(Consumer<String> printer) {
return new ChattyLogger(printer);
}
}

Logger logger = Loggers.logger(System.out::println);

logger.error("ERROR");
logger.warning("WARNING");
Logger quiet = logger.quiet();
quiet.error("ERROR");
quiet.warning("WARNING");
 State implementation
class ChattyLogger implements Logger { class QuietLogger implements Logger {
private final Consumer<String> printer; private final Consumer<String> printer;
ChattyLogger(Consumer<String> printer) { QuietLogger(Consumer<String> printer) {
this.printer = printer; this.printer = printer;
} }
public void error(String message) { public void error(String message) {
printer.accept(message); printer.accept(message);
} }
public void warning(String message) { public void warning(String message) {
printer.accept(message); // empty
} }
public Logger quiet() { public Logger quiet() {
return new QuietLogger(printer); return this;
} }
public Logger chatty() { public Logger chatty() {
return this; return new ChattyLogger(printer);
} }
} }

Use inheritance not composition :(

 Destructuring State
public class Logger { Use delegation instead
public enum Level { ERROR, WARNING }
private final Consumer<String> error;
private final Consumer<String> warning;
private Logger(Consumer<String> error, Consumer<String> warning,
?? quiet, ?? chatty) {
this.error = error;
this.warning = warning;
...
}
public void error(String message) { error.accept(message); }
public void warning(String message) { warning.accept(message); }
public Logger quiet() { return ??; }
public Logger chatty() { return ??; }
public static Logger logger(Consumer<String> consumer) {
Objects.requireNonNull(consumer);
return new Logger(consumer, consumer, ??, ??);
}
}
 Circular initialization ?
How to create an instance of A that depends on B
that depends on A ?

class A { class B {
B b; A a;

A(B b) { B(A a) {
this.b = b; this.a = a;
} }
} }

A a = new A(new B(...));

 Circular initialization
In the constructor, send this to a factory function
taken as parameter !

class A { class B {
B b; A a;

A(Function<A, B> fun) { B(A a) {

this.b = fun.apply(this); this.a = a;
} }
} }

A a = new A(a -> new B(a));

 Circular initialization
In the constructor, send this to a factory function
taken as parameter !

class A { class B {
B b; A a;

A(Function<A, B> fun) { B(A a) {

this.b = fun.apply(this); this.a = a;
} }
} }
Method reference on new + constructor
A a = new A(B::new);
 Destructuring State impl
public class Logger {
private final Logger quiet;
private final Logger normal;
private Logger(Consumer<String> error, Consumer<String> warning,
Function<Logger, Logger> quietFactory,
Function<Logger, Logger> chattyFactory) {
this.error = error;
this.warning = warning;
this.quiet = quietFactory.apply(this);
this.chatty = chattyFactory.apply(this);
}
public Logger quiet() { return quiet; }
public Logger chatty() { return chatty; }
public static Logger logger(Consumer<String> consumer) {
Objects.requireNonNull(consumer);
return new Logger(consumer, consumer,
chatty -> new Logger(consumer, msg -> { /*empty*/ }, identity(), it -> chatty),
identity());
}
}
import static java.util.function.Function.identity
 Summary
lambdas allow to delay computation

if used in constructor, can solve

circular initialization issues
 Visitor ?

Given a hierarchy

public interface Vehicle { }

public class Car implements Vehicle { }
public class Moto implements Vehicle { }

want to close it but

allow to add new operations and new subtypes
(let solve the expression problem :) )
 Visitor Double dispatch
public interface Vehicle {
<R> R accept(Visitor<R> v);
}
public class Car implements Vehicle {
<R> R accept(Visitor<R> v) { return v.visitCar(this); }
}
public class Moto implements Vehicle {
<R> R accept(Visitor<R> v) { return v.visitMoto(this); }
}
public class MyVisitor implements Visitor<String> {
public String visitCar(Car car) { return "car"; }
public String visitMoto(Moto moto) { return "moto"; }
}
Visitor<String> visitor = new MyVisitor();
Vehicle vehicle = ...
vehicle.accept(visitor);
 Destructured Visitor API
API first !

Visitor<String> visitor = new Visitor<>();

visitor.when(Car.class, car -> "car")
.when(Moto.class, moto -> "moto");

Vehicle vehicle = ...

String text = visitor.call(vehicle);

package java.util.function;
public interface Function<T, R> {
public R apply(T t);
public default <V> Function<V,R> compose(Function<V,T> f) {}
public default <V> Function<T,V> andThen(Function<R,V> f) {}
}
 Destructured Visitor
public class Visitor<R> {
public <T> Visitor<R> when(
Class<T> type, Function<T, R> fun) { }
public R call(Object receiver) { }
}

Visitor<String> visitor = new Visitor<>();

visitor.when(Car.class, car -> "car")
.when(Moto.class, moto -> "moto");

Vehicle vehicle = ...

String text = visitor.call(vehicle);
 Destructured Visitor :(
Java has no existential type :(

public class Visitor<R> {

private final HashMap<Class<?>, Function<Object, R>> map =
new HashMap<>();
public <T> Visitor<R> when(Class<T> type, Function<T, R> f) {
map.put(type, f);
return this;
} Doesn't compile !

public R call(Object receiver) {

return map.getOrDefault(receiver.getClass(),
r -> { throw new ISE(...); })
.apply(receiver);
}
}
 Destructured Visitor :(
Java has no existential type / maybe with a wildcard ?

public class Visitor<R> {

private final HashMap<Class<?>, Function<?, R>> map =
new HashMap<>();
public <T> Visitor<R> when(Class<T> type, Function<T, R> f) {
map.put(type, f);
return this;
}
public R call(Object receiver) {
return map.getOrDefault(receiver.getClass(), r -> { throw })
.apply(receiver);
}
} Doesn't compile !
 Destructured Visitor :)
All problems can be solved by another level of indirection :)

public class Visitor<R> {

private final HashMap<Class<?>, Function<Object, R>> map =
new HashMap<>();
public <T> Visitor<R> when(Class<T> type, Function<T, R> f) {
map.put(type, object -> f.apply(type.cast(object)));
return this;
}
public R call(Object receiver) {
return map.getOrDefault(receiver.getClass(), r -> { throw })
.apply(receiver);
}
}
 Destructured Visitor +
function composition
And using function composition

public class Visitor<R> {

private final HashMap<Class<?>, Function<Object, R>> map =
new HashMap<>();
public <T> Visitor<R> when(Class<T> type, Function<T, R> f) {
map.put(type, f.compose(type::cast));
return this;
}
public R call(Object receiver) {
return map.getOrDefault(receiver.getClass(), r -> { throw })
.apply(receiver);
}
}
 Summary
function composition allows to decompose
behavior into simpler one
 Creational Patterns

Static Factory
Factory method
Same problem as template method
Singleton
Abstract Factory Who want a global ?

Builder
Monad ?
 Instance Creation
public interface Vehicle { }
public class Car implements Vehicle {
public Car(Color color) { }
}
public class Moto implements Vehicle {
public Moto(Color color) { }
}
I want to create only either 5 red cars or 5 blue
motos ?
 Instance Factory ?
public interface VehicleFactory {
public Vehicle create();
}
public List<Vehicle> create5(VehicleFactory factory) {
return IntStream.range(0,5)
.mapToObj(i -> factory.create())
.collect(Collectors.toList());
}

VehicleFactory redCarFactory = ...

VehicleFactory blueMotoFactory = ...

List<Vehicle> redCars = create5(redCarFactory);

List<Vehicle> blueMotos = create5(blueMotoFactory);
 Instance Factory
public interface VehicleFactory {
public Vehicle create();
}
public List<Vehicle> create5(VehicleFactory factory) {
return IntStream.range(0,5)
.mapToObj(i -> factory.create())
.collect(Collectors.toList());
}

VehicleFactory redCarFactory = () -> new Car(RED);

VehicleFactory blueMotoFactory = () -> new Moto(BLUE);

List<Vehicle> redCars = create5(redCarFactory);

List<Vehicle> blueMotos = create5(blueMotoFactory);
 With Java 8 predefined interfaces
public List<Vehicle> create5(Supplier<Vehicle> factory) {
return IntStream.range(0,5)
.mapToObj(i -> factory.get())
.collect(Collectors.toList());
}

Supplier<Vehicle> redCarFactory = () -> new Car(RED);

Supplier<Vehicle> blueMotoFactory = () -> new Moto(BLUE);

List<Vehicle> redCars =
create5(redCarFactory); package java.util.function;
List<Vehicle> blueMotos =
@FunctionalInterface
create5(blueMotoFactory); public interface Supplier<T> {
public T get();
}
 Instance Factory ==
Partial application on constructors
public List<Vehicle> create5(Supplier<Vehicle> factory) {
return IntStream.range(0,5)
.mapToObj(i -> factory.get())
.collect(Collectors.toList());
}
public static <T, R> Supplier<R> partial(
Function<T, R> function, T value) {
return () -> function.apply(value);
}
Method reference on new + constructor

List<Vehicle> redCars =
create5(partial(Car::new, RED)));
List<Vehicle> blueMotos =
create5(partial(Moto::new, BLUE)));
 Static Factory
public interface Vehicle {
public static Vehicle create(String name) {
switch(name) {
case "car":
return new Car();
case "moto": Quite ugly isn't it ?
return new Moto();
default:
throw ...
}
}
}
 Abstract Factory
public class VehicleFactory {
public void register(String name,
Supplier<Vehicle> supplier) {
...
}
public Vehicle create(String name) {
...
}
}

VehicleFactory factory = new VehicleFactory();

factory.register("car", Car::new);
factory.register("moto", Moto::new);
 Abstract Factory impl
public class VehicleFactory {
private final HashMap<String, Supplier<Vehicle>> map =
new HashMap<>();
public void register(String name, Supplier<Vehicle> supplier) {
map.put(name, fun);
}
public Vehicle create(String name) {
Supplier<Vehicle> supplier = map.get(name);
if (supplier == null) {
throw new ;
}
return supplier.get();
}
} The pattern is encoded into several lines :(
 Abstract Factory impl
public class VehicleFactory {
private final HashMap<String, Supplier<Vehicle>> map =
new HashMap<>();
public void register(String name, Supplier<Vehicle> supplier) {
map.put(name, fun);
}
public Vehicle create(String name) {
return map.getOrDefault(name, () - > { throw new ...; })
.get();
}
}

VehicleFactory factory = new VehicleFactory();

factory.register("car", Car::new);
factory.register("moto", Moto::new);
 With a singleton-like ?

public class VehicleFactory {

public void register(String name, Supplier<Vehicle> supplier) {
...
}
public Vehicle create(String name) {
...
}
}

What if I want only one instance of Moto ?

 With a singleton-like
public class VehicleFactory {
public void register(String name, Supplier<Vehicle> supplier) {
...
}
public Vehicle create(String name) {
...
}
}

VehicleFactory factory = new VehicleFactory();

factory.register("car", Car::new);

Moto singleton = new Moto();

factory.register("moto", () -> singleton);
 From Factory to Builder
public class VehicleFactory {
public void register(String name, Supplier<Vehicle> supplier) {
...
}
public Vehicle create(String name) {
...
}
}

How to separate the registering step from the creation step ?

 Classical Builder
public class Builder {
public void register(String name, Supplier<Vehicle> supplier) { }
public VehicleFactory create() { }
}
public interface VehicleFactory {
Vehicle create(String name);
}

Builder builder = new Builder();

builder.register("car", Car::new);
builder.register("moto", Moto::new);
VehicleFactory factory = builder.create();
Vehicle vehicle = factory.create("car");
 Lambda Builder !

public interface Builder {

void register(String name, Supplier<Vehicle> supplier);
}
public interface VehicleFactory {
Vehicle create(String name);
static VehicleFactory create(Consumer<Builder> consumer) {

}
}

VehicleFactory factory = VehicleFactory.create(builder - > {

builder.register("car", Car::new);
builder.register("moto", Moto::new);
});
Vehicle vehicle = factory.create("car");
 Lambda Builder impl

public interface Builder {

void register(String name, Supplier<Vehicle> supplier);
}

public interface VehicleFactory {

Vehicle create(String name);

static VehicleFactory create(Consumer<Builder> consumer) {

HashMap<String, Supplier<Vehicle>> map = new HashMap<>();
consumer.accept(map::put);
return name -> map.getOrDefault(name, () -> { throw new ...; })
.get();
}
}
 Summary
factories are just a way to do partial application
in order to create class instance
 Validation ?
How to validate a user ? public class User {
private final String name;
private final int age;
...
}
User user = new User("bob", 12);
if (user.getName() == null) {
throw new IllegalStateException("name is null");
}
if (user.getName().isEmpty()) {
throw new IllegalStateException("name is empty");
}
if (!(user.getAge() > 0 && user.getAge() < 50)) {
throw new IllegalStateException("age isn't between 0 and 50");
}
 Monad
Represent 2 (or more) states has a unified
value in order to compose transformations

public static User validateName(User user) {

if (user.getName() == null) {
throw new IllegalStateException("...");
}
return user;
} User

User validate

Exception
 Monad
Represent 2 (or more) states
has a unified value in order to
compose transformations
User

of

User | Exception validate1 User | Exception validate2 User | Exception

get

User Exception
 Monad
public class Validator<T> {
public static <T> Validator<T> of(T t) {
...
}
public Validator<T> validate(Predicate<T> validation, String message) {
...
}
public T get() throws IllegalStateException {
...
}
}

User validatedUser = Validator.of(user)

.validate(u -> u.getName() != null, "name is null")
.validate(u -> !u.getName().isEmpty(), "name is empty")
.validate(u -> u.getAge() > 0 && u.getAge() < 50, "age isn't between ...")
.get();
 Monad impl
public class Validator<T> {
private final T t;
private final IllegalStateException error;
private Validator(T t, IllegalStateException error) {
this.t = t;
this.error = error;
}
public static <T> Validator<T> of(T t) {
return new Validator<>(Objects.requireNonNull(t), null);
}
public Validator<T> validate(Predicate<T> validation, String message) {
if (error == null && !validation.test(t)) {
return new Validator<>(t, new IllegalStateException(message));
}
return this;
}
public T get() throws IllegalStateException {
if (error == null) { return t; }
throw error;
}
}
 Separate attribute from validation
public class Validator<T> {
public Validator<T> validate(Predicate<T> validation,
String message) { }
public <U> Validator<T> validate(Function<T, U> projection,
Predicate<U> validation, String message) {
...
}
}

User validatedUser = Validator.of(user)

.validate(User::getName, Objects::nonNull, "name is null")
.validate(User::getName, name -> !name.isEmpty(), "name is ...")
.validate(User::getAge, age -> age > 0 && age < 50, "age is ...")
.get();
 Higher order function

public static Predicate<Integer> inBetween(int start, int end) {

return value -> value > start && value < end;
}

User validatedUser = Validator.of(user)

.validate(User::getName, Objects::nonNull, "name is null")
.validate(User::getName, name -> !name.isEmpty(), "...")
.validate(User::getAge, inBetween(0, 50), "...")
.get();
 Monad impl
public class Validator<T> {
public Validator<T> validate(Predicate<T> validation,
String message) {
...
}
public <U> Validator<T> validate(Function<T, U> projection,
Predicate<U> validation, String message) {
return validate(t -> validation.test(projection.apply(t)), message);
}
}

package java.util.function;
public interface Function<T, R> {
public R apply(T t);
public default <V> Function<V,R> compose(Function<V,T> f) {}
public default <V> Function<T,V> andThen(Function<R,V> f) {}
}
 Monad impl
public class Validator<T> {
public Validator<T> validate(Predicate<T> validation,
String message) {
...
}
public <U> Validator<T> validate(Function<T, U> projection,
Predicate<U> validation, String message) {
return validate(
projection.andThen(validation::test)::apply, message);
} Function<U,Boolean>
}
Predicate<T>
 Gather validation errors
public class Validator<T> {
private final T t;
private final ArrayList<Throwable> throwables = new ArrayList<>();
public Validator<T> validate(Predicate<T> validation, String message) {
if (!validation.test(t)) {
throwables.add(new IllegalStateException(message));
}
return this;
}
public T get() throws IllegalStateException {
if (throwables.isEmpty()) { return t; }
IllegalStateException e = new IllegalStateException();
throwables.forEach(e::addSuppressed);
throw e;
}
}
 Summary
A monad represents several states
as a unified value

Monads allow to do function

composition on function that have
several return values
 TLDR;
Functional interface
bridge between OOP and FP

Enable several FP techniques

Higher order function, function composition,
partial application

UML class diagram is dead !

public abstract classes are dead too !