Design Pattern Reloaded (Devoxx BE 2015 )

How to implement a dozen of design patterns using Java 8 lambdas ?

Transcript

1. @YourTwitterHandle #DV14 #YourTag @this_is_not_a_twitter_handle #Devoxx #DP_RELOADED Design Pattern Reloaded Rémi Forax - University Paris East Marne la Vallée https://github.com/forax/design-pattern-reloaded
2. Me, Myself and I Father of 3 Assistant Prof at University of Paris East Expert for: JSR 292: invokedynamic JSR 335: lambda JSR 376: java module Open source dev: OpenJDK, ASM, JsJs, etc
3. Lies, damned lies, and wildcards ! Warning the following slides contain an awful amount of codes And most of the signature of the methods shown are wrong ! I have removed the wilcards (? extends, ? super)
4. Functional Interface A function type in Java is represented by a functional interface @FunctionalInterface interface BinOp { int apply(int val1, int val2); } a functional interface has only one abstract method
5. 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;
6. Predefined Functional interfaces in java.util.function signature interface method () → void Runnable run () → T Supplier get () -> int IntSupplier getAsInt T → void Consumer accept int → void IntConsumer accept T → boolean Predicate test int → boolean IntPredicate test T → R Function<T,R> apply int → R IntFunction<R> apply T → int ToIntFunction applyAsInt
7. Method Reference The operator :: allows to reference an existing method (static or not) :: on a type BinOp add = Integer::sum; ToIntFunction<String> fun = String::length; :: on an instance String hello = "hello"; IntSupplier supplier= hello::length;
8. Live Coding using jshell !
9. 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
10. Live Coding in jshell (2/3) -> List<String> list = Arrays.asList("hello", "devoxx"); | Added variable list of type List<String> with initial value [hello, devoxx] -> list.forEach(item -> System.out.println(item)); hello devoxx -> 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 devoxx -> Files.list(Paths.get(".")).forEach(printer); ./jimage-extracted ./.project ...
11. 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 devoxx -> Files.list(Paths.get(".")).forEach(printer); ./jimage-extracted ./.project ...
12. All I'm offering is the truth. Nothing more
13. 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
14. 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
15. 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
16. 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); }
17. 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); }
18. GoF Template Method :( public abstract classes public abstract classes are harmful ! are harmful !
19. 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); } } }
20. 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() { public void log(String message) { if (filter.accept(message)) { logger.log(message); } } }; } Local variable values are captured !
21. Higher Order Function 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")); Garbage class
22. 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); } }; } } Logger logger = msg - > System.out.println(msg); Logger filterLogger = logger.filter(msg -> msg.startsWith("foo")); g.filter(f)
23. 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); }
24. Summary public abstract classes are harmful => behaviors are encoded in the inheritance tree Use function composition instead !
25. GoF kind of patterns Structural Creational Behavioral
26. Structural Patterns Adapter Decorator Proxy logger.filter()
27. 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 ??
28. Partial Application Set the value of some parameters of a function (can also be done by 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);
29. Partial Application Logger <=> Logger2 + a fixed level public interface Logger { void log(String message); } public interface Logger2 { void log(Level level, String message); default Logger level(Level level) { ... } }
30. 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 !");
31. Partial Application & Method Ref. The operator :: also allows to do partial application on the receiver ToIntFunction<String> fun = String::length; IntSupplier supplier= "hello"::length; type instance
32. Summary partial application allows to set some arguments and let the others parameters to be set later a partially applied function can be shared !
33. Creational Patterns Static Factory Factory method Singleton Factory Kit Builder Same problem as template method Who want a global ?
34. 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 ?
35. 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);
36. 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);
37. 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); List<Vehicle> blueMotos =create5(blueMotoFactory);
38. Partial application on constructors (1/2) 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 ... } List<Vehicle> redCars = create5(partial(Car::new, RED))); List<Vehicle> blueMotos = create5(partial(Moto::new, BLUE))); Method reference on new + constructor
39. Partial application on constructors (2/2) 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); } List<Vehicle> redCars = create5(partial(Car::new, RED))); List<Vehicle> blueMotos = create5(partial(Moto::new, BLUE)));
40. Summary factories are just a way to do partial application in order to create class instance
41. Static Factory public interface Vehicle { public static Vehicle create(String name) { switch(name) { case "car": return new Car(); case "moto": return new Moto(); default: throw ... } } } Quite ugly isn't it ?
42. Factory Kit 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);
43. Factory Kit 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 :(
44. Factory Kit 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);
45. 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 ?
46. 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);
47. 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 ?
48. 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");
49. Lambda Builder ! public interface Builder { void register(String name, Supplier<Vehicle> supplier); } public interface VehicleFactory { Vehicle create(String name); static VehicleFactory factory(Consumer<Builder> consumer) { … } } VehicleFactory factory = VehicleFactory.factory(builder - > { builder.register("car", Car::new); builder.register("moto", Moto::new); }); Vehicle vehicle = factory.create("car");
50. Lambda Builder impl public interface Builder { void register(String name, Supplier<Vehicle> supplier); } public interface VehicleFactory { Vehicle create(String name); static VehicleFactory factory(Consumer<Builder> consumer) { HashMap<String, Supplier<Vehicle>> map = new HashMap<>(); consumer.accept(map::put); return name -> map.getOrDefault(name, () -> { throw new ...; }) .get(); } }
51. More “generic” with Java8 interfaces a Builder is a BiConsumer<String, Supplier<Vehicle>> a VehicleFactory is like a Function<String, Supplier<Vehicle>> static <K, T> Function<K, T> factoryKit( Consumer<BiConsumer<K, T>> consumer, Function<K, T> ifAbsent) { HashMap<K, T> map = new HashMap<>(); consumer.accept(map::put); return key -> map.computeIfAbsent(key, ifAbsent); } Function<String, Supplier<Vehicle>> factory = factoryKit(builder - > { builder.accept("car", Car::new); builder.accept("moto", Moto::new); }, name -> { throw new IAE("unknown vehicle " + name); }); Vehicle vehicle = factory.apply("car").get();
52. Summary A factory kit is a map of factories A builder allow to separate the mutable part and the immutable part
53. Behavioral Patterns Callback/Observer Chain of Responsibility State Monad Visitor
54. Sum all 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(); } } }
55. Using method references 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
56. Callback / 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, ...); } }
57. If the parser exists 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 … { class Adder { int sum; } Adder adder = new Adder(); CSVParser.parse(path, value -> adder.sum += value); return adder.sum; } }
58. 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)); } } }
59. 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
60. 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
61. Summary functional interface to functional interface conversion is a partial application using instance method reference
62. A hierarchy of Expression public interface Expr { public static class Variable public static Expr parse(Iterator<String> it) { implements Expr { ... private final String name; } ... } } public static class BinaryOp public static class Value implements Expr { implements Expr { private final Operator operator; private final double value; private final Expr left, right; ... public enum Operator { } ADD("+"), SUB("-"), MUL("*"); final String symbol; private static final Map<String, Operator> MAP = Arrays.stream(values()).collect(toMap(op -> op.symbol, op -> op)); public static Optional<Operator> parse(String token) { return Optional.ofNullable(MAP.get(token)); } }
63. Parsing a reverse Polish notation public interface Expr { public static Expr parse(Iterator<String> it) { String token = it.next(); Optional<Operator> operator = Operator.parse(token); if (operator.isPresent()) { Expr left = parse(it); Expr right = parse(it); return new BinaryOp(operator.get(), left, right); } try { return new Value(Double.parseDouble(token)); } catch(NumberFormatException e) { return new Variable(token); } } } public static void main(String[] args) { Expr expr = parse(Arrays.asList("+ 2 * a 3".split(" ")).iterator()); } The parsing code suppose that all subtypes are known
64. Extract the behaviors public static Optional<Expr> parseBinaryOp(String token, Supplier<Expr> supplier) { return Operator.parse(token) .map(op -> new BinaryOp(op, supplier.get(), supplier.get())); } public static Optional<Expr> parseValue(String token) { try { return Optional.of(new Value(Double.parseDouble(token))); } catch(NumberFormatException e) { return Optional.empty(); } } public static Optional<Expr> parseVariable(String token) { return Optional.of(new Variable(token)); }
65. Add a factory public static Optional<Expr> parseBinaryOp(String token, Supplier<Expr> supplier) { return ... } public static Optional<Expr> parseValue(String token) { return ... } public static Optional<Expr> parseVariable(String token) { return .. } public static Expr parse(Iterator<String> it, Function<String, Optional<Expr>> factory) { String token = it.next(); return factory.apply(token).orElseThrow(() -> new IAE("illegal token...)); }
66. Chain Of Responsibility The main can now specify how the parsing is done class Main { private static Expr create(Iterator<String> it) { return parse(it, token -> parseBinaryOp(token, () -> create(it)) .or(() -> parseValue(token)) .or(() -> parseVariable(token)))); } public static void main(String[] args) { Expr expr = create(Arrays.asList("+ 2 * a 3".split(" ")).iterator()); } }
67. Summary Lambdas allow to delay computation
68. State Yet another another logger ! Chatty Quiet chatty() chatty() quiet() quiet() error(msg) warning(msg) Consumer<String> error(msg) warning(msg)
69. State interface public interface Logger { void error(String message); void warning(String message); Logger quiet(); Logger chatty(); static Logger logger(Consumer<String> printer) { return new ChattyLogger(printer); } } Logger logger = Loggers.logger(System.out::println); logger.warning("WARNING"); Logger quiet = logger.quiet(); quiet.warning("WARNING"); Logger ChattyLogger QuietLogger
70. 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); } } } } But use inheritance instead of composition :(
71. Destructuring State (strategy) public class Logger { private final Consumer<String> error, 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, ??, ??); } } Use delegation instead !
72. 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(...));
73. 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));
74. 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(B::new);
75. Destructuring State impl public class Logger { private final Consumer<String> error, warning; private final Logger quiet, 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
76. Summary Lambdas allow to delay computation Can be used in constructor to solve circular initialization issues
77. Validation ? How to validate a user ? 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"); } public class User { private final String name; private final int age; ... }
78. 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; } validate User User Exception
79. Monad Represent 2 (or more) states has a unified value in order to compose transformations User | Exception validate1 User | Exception validate2 User | Exception User of User get Exception
80. 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();
81. Monad impl public class Validator<T> { private final T t; private final IllegalStateException error; private Validator(T t, IllegalStateException 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; } }
82. Separate field extraction 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();
83. 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), "age is ...") .get();
84. 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) {} }
85. 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>
86. 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; } }
87. Summary A monad represents several states as a unified value Monads allow to do function composition on function that have several return values
88. Visitor ? Given a hierarchy public interface Vehicle { … } public class Car implements Vehicle { … } public class Moto implements Vehicle { … } want to close it but also add new operations and new subtypes Let try to solve the expression problem !
89. Visitor – Double dispatch (GoF) 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);
90. 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.accept(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) {} }
91. Destructured Visitor public class Visitor<R> { public <T> Visitor<R> when( Class<T> type, Function<T, R> fun) { … } public R accept(Object receiver) { … } } Visitor<String> visitor = new Visitor<>(); visitor.when(Car.class, car -> "car") .when(Moto.class, moto -> "moto"); Vehicle vehicle = ... String text = visitor.accept(vehicle);
92. 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; } public R accept(Object receiver) { return map.getOrDefault(receiver.getClass(), r -> { throw new ISE(...); }) .apply(receiver); } } Doesn't compile !
93. 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 accept(Object receiver) { return map.getOrDefault(receiver.getClass(), r -> { throw … }) .apply(receiver); } } Doesn't compile !
94. 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<>(); @SuppressWarnings("unchecked") public <T> Visitor<R> when(Class<T> type, Function<T, R> f) { map.put(type, object -> f.apply((T)object)); return this; } public R accept(Object receiver) { return map.getOrDefault(receiver.getClass(), r -> { throw … }) .apply(receiver); } }
95. Destructured Visitor :) 'type' already knows the class at runtime 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 accept(Object receiver) { return map.getOrDefault(receiver.getClass(), r -> { throw … }) .apply(receiver); } }
96. Destructured Visitor :) 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 accept(Object receiver) { return map.getOrDefault(receiver.getClass(), r -> { throw … }) .apply(receiver); } }
97. Summary Function composition allows to decompose behavior into simpler one Gof Visitor, safe but no unknown subclasses Destructured Visitor, unsafe but you can add subclasses Expression problem not solved :(
98. TLDR; Functional interface bridge between OOP and FP Enable several FP techniques Higher order function, function composition, partial application UML class diagrams are dead ! No public abstract classes anymore !
99. @YourTwitterHandle #DV14 #YourTag @this_is_not_a_twitter_handle #Devoxx #DP_RELOADED