<<<<<<< HEAD name: inverse layout: true class: taylor msoe --- class: center, middle .title[ # Functional Programming ] ??? Toggle speaker view by pressing P Pressing C clones the slideshow view, which is the view to put on the projector if you're using speaker view. Press ? to toggle keyboard commands help. --- # OO versus Functional * Object-oriented: **group** data with operations -- * Functional: treat operations **as** data ??? ## OO * modular and encapsulated * Code reuse through inheritance and composition * Functionality and data tightly coupled ## Functional * Can define functionality and pass it as a parameter * Well suited for concurrent and event driven --- class: animated slideInUp center, middle # Java 8 ## Added many functional features --- # Functional Characteristics * Function call can be replace by the result -- * Functions are not allowed to have side effects -- * Compiler is allowed to rearrange function invocations -- ... or run on different threads -- * Program flow driven by data dependencies, not order of instructions ??? * Data must be immutable * If changed, new copy is created --- # First-Class Functions Functions can be * Assigned to variables -- * Passed as arguments to other functions -- * Returned by other functions --- class: animated fadeIn # Lambda Functions ``` Button button = new Button("Run"); button.setOnAction(`event -> run(event)`); ``` -- * `run(event)` is a function that is passed to a method -- * Under the hood it is really the implementation of an interface -- ``` Button button = new Button("Run"); button.setOnAction(`new EventHandler<ActionEvent>() {` `@Override` `private void handle(ActionEvent event) {` ` run(event);` `}}`); ``` --- # Functional Interface ``` @FunctionalInterface public interface EventHandler<T> { void handle(T event); } ``` * An interface with only one method -- * Annotated as a `@FunctionalInterface` -- * Can use lambda expression -- ``` EventHandler<ActionEvent> handler = event -> run(event); ``` --- # `Collection` and `Stream` Interfaces * `Collection` - Efficient management of and access to their elements -- * `Stream` - A sequence of elements supporting sequential and parallel aggregate operations -- - A declarative description of their source and computational operations which will be performed in aggregate on that source --- # `Stream` Methods * `count()` - returns the number of elements in the stream * `distinct()` - returns a stream with duplicates removed * `limit(long maxSize)` - returns a stream with no more than `maxSize` elements * `skip(long count)` - returns a stream without the first `count` elements * `sorted()` - returns a stream in sorted order --- # Example - `count()` and `distinct()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); long count = words.stream() .count(); long numberUnique = words.stream() .distinct() .count(); System.out.println("Count: " + count + " Unique: " + numberUnique); ``` -- #### Output: ```diff Count: 6 Unique: 4 ``` --- # Higher-Order Functions * Accept other functions as argument(s) * Return a function as a result -- * E.g., `setOnAction(EventHandler<ActionEvent> e)` --- # Higher-Order Functions in `Stream` * `allMatch(Predicate<? super T> predicate)` * `anyMatch(Predicate<? super T> predicate)` * `noneMatch(Predicate<? super T> predicate)` * `filter(Predicate<? super T> predicate)` --- # `Predicate` Interface ``` @FunctionalInterface public interface Predicate<T> { boolean test(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Higher-Order Functions in `Stream` ... again * `allMatch(Predicate<? super T> predicate)` * `anyMatch(Predicate<? super T> predicate)` * `noneMatch(Predicate<? super T> predicate)` * `filter(Predicate<? super T> predicate)` --- # Example - `filter()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); Predicate<String> isShort = (word -> word!=null && word.length()<5); Object[] shortWords = words.stream() .filter(isShort) .toArray(); for(Object word : shortWords) { System.out.print(word + " "); } System.out.println(); ``` -- #### Output: ```diff a that a ``` --- # More Higher-Order Functions in `Stream` * `map(Function<? super T, ? extends R> mapper)` * `mapToDouble(Function<? super T> mapper)` * `mapToInt(Function<? super T> mapper)` --- # `Function` Interface ``` @FunctionalInterface public interface Function<T, R> { R apply(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Example - `map()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); List<String> lengths = words.stream() .map(word -> word + ": " + word.length()) .collect(Collectors.toList()); System.out.println(lengths); ``` -- #### Alternative: ``` Function<String, String> toLength = (word -> word + ": " + word.length()); words.stream().map(toLength); ``` -- #### Output: ```diff [a: 1, function: 8, that: 4, returns: 7, a: 1, function: 8] ``` --- # Numeric Streams .center[`IntStream`, `DoubleStream`, and `LongStream`] * `sum()` * `max()` * `min()` * `average()` * `summaryStatistics()` * `reduce()` --- # Example - `mapToInt()` ``` int sum = words.stream() .mapToInt(w -> w.length()); .sum(); ``` -- #### Output: ```diff Sum of lengths of all strings: 29 ``` --- # `Consumer` Interface ``` @FunctionalInterface public interface Consumer<T> { void accept(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Example - `forEach()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); words.stream() .forEach(w -> System.out.println(w + ": " + w.length())); ``` -- #### Output: ```diff a: 1 function: 8 that: 4 returns: 7 a: 1 function: 8 ``` Note: we can do `forEach()` directly on a `List`: ``` words.forEach(w -> System.out.println(w + ": " + w.length())); ``` --- # Extract Even Numbers ``` Stream<Integer> numbers = Stream.of(3, 8, 7, 2, 1, 9, 8); List<Integer> evens = numbers.filter(i -> i%2==0) .collect(Collectors.toList()); System.out.println(evens); ``` -- #### Output: ``` [8, 2, 8] ``` --- # Extract Based on Suffix ``` System.out.println(Stream.of("happy", "discussion" /* ... */, "locomotion") .filter(word -> word.endsWith("tion")) .count()); ``` -- #### Output: ``` 1 ``` --- # Extract Circles ``` Stream<Shape> shapes = Stream.of(new Circle(0, 0), new Square(0, 0, 4), new Circle(0, 0), new Triangle(0, 0, 1, 5)); List<Circle> circles = shapes.filter(shape -> shape instanceof Circle) .map(shape -> (Circle)shape) .collect(Collectors.toList()); ``` --- # Sum ``` double totalArea = shapes.mapToDouble(shape -> shape.getArea()) .sum(); System.out.println("Total area: " + totalArea); ``` -- #### Output: ``` Total area: 38.239208802178716 ``` --- # Average ``` OptionalDouble averageArea = shapes.mapToDouble(Shape::getArea) .average(); if(averageArea.isPresent()) { System.out.println("Average area: " + averageArea.getAsDouble()); } ``` -- #### Output: ``` Average area: 9.559802200544679 ``` --- # Summary Statistics ``` DoubleSummaryStatistics areaStats = shapes.mapToDouble(Shape::getArea) .summaryStatistics(); System.out.println("Number of shapes: " + areaStats.getCount()); System.out.println("Total area: " + areaStats.getSum()); System.out.println("Average area: " + areaStats.getAverage()); System.out.println("Maximum area: " + areaStats.getMax()); System.out.println("Minimum area: " + areaStats.getMin()); ``` -- #### Output: ``` Number of shapes: 4 Total area: 38.239208802178716 Average area: 9.559802200544679 Maximum area: 16.0 Minimum area: 2.5 ``` --- # Average with `reduce()` ``` double area = shapes.map(Shape::getArea) .reduce(0.0, (a, b) -> a+b); System.out.println("Total area: " + area); ``` -- #### Output: ``` Total area: 38.239208802178716 ``` ||||||| 2b08b56 ======= name: inverse layout: true class: taylor msoe --- class: center, middle .title[ # Functional Programming ] ??? Toggle speaker view by pressing P Pressing C clones the slideshow view, which is the view to put on the projector if you're using speaker view. Press ? to toggle keyboard commands help. --- # OO versus Functional * Object-oriented: **group** data with operations -- * Functional: treat operations **as** data ??? ## OO * modular and encapsulated * Code reuse through inheritance and composition * Functionality and data tightly coupled ## Functional * Can define functionality and pass it as a parameter * Well suited for concurrent and event driven --- class: animated slideInUp center, middle # Java 8 ## Added many functional features --- # Functional Characteristics * Function call can be replace by the result -- * Functions are not allowed to have side effects -- * Compiler is allowed to rearrange function invocations -- ... or run on different threads -- * Program flow driven by data dependencies, not order of instructions ??? * Data must be immutable * If changed, new copy is created --- # First-Class Functions Functions can be * Assigned to variables -- * Passed as arguments to other functions -- * Returned by other functions --- class: animated fadeIn # Lambda Functions ``` Button button = new Button("Run"); button.setOnAction(`event -> run(event)`); ``` -- * `run(event)` is a function that is passed to a method -- * Under the hood it is really the implementation of an interface -- ``` Button button = new Button("Run"); button.setOnAction(`new EventHandler<ActionEvent>() {` `@Override` `private void handle(ActionEvent event) {` ` run(event);` `}}`); ``` --- # Functional Interface ``` @FunctionalInterface public interface EventHandler<T> { void handle(T event); } ``` * An interface with only one method -- * Annotated as a `@FunctionalInterface` -- * Can use lambda expression -- ``` EventHandler<ActionEvent> handler = event -> run(event); ``` --- # `Collection` and `Stream` Interfaces * `Collection` - Efficient management of and access to their elements -- * `Stream` - A sequence of elements supporting sequential and parallel aggregate operations -- - A declarative description of their source and computational operations which will be performed in aggregate on that source --- # `Stream` Methods * `count()` - returns the number of elements in the stream * `distinct()` - returns a stream with duplicates removed * `limit(long maxSize)` - returns a stream with no more than `maxSize` elements * `skip(long count)` - returns a stream without the first `count` elements * `sorted()` - returns a stream in sorted order --- # Example - `count()` and `distinct()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); long count = words.stream() .count(); long numberUnique = words.stream() .distinct() .count(); System.out.println("Count: " + count + " Unique: " + numberUnique); ``` -- #### Output: ```diff Count: 6 Unique: 4 ``` --- # Higher-Order Functions * Accept other functions as argument(s) * Return a function as a result -- * E.g., `setOnAction(EventHandler<ActionEvent> e)` --- # Higher-Order Functions in `Stream` * `allMatch(Predicate<? super T> predicate)` * `anyMatch(Predicate<? super T> predicate)` * `noneMatch(Predicate<? super T> predicate)` * `filter(Predicate<? super T> predicate)` --- # `Predicate` Interface ``` @FunctionalInterface public interface Predicate<T> { boolean test(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Higher-Order Functions in `Stream` ... again * `allMatch(Predicate<? super T> predicate)` * `anyMatch(Predicate<? super T> predicate)` * `noneMatch(Predicate<? super T> predicate)` * `filter(Predicate<? super T> predicate)` --- # Example - `filter()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); Predicate<String> isShort = (word -> word!=null && word.length()<5); Object[] shortWords = words.stream() .filter(isShort) .toArray(); for(Object word : shortWords) { System.out.print(word + " "); } System.out.println(); ``` -- #### Output: ```diff a that a ``` --- # More Higher-Order Functions in `Stream` * `map(Function<? super T, ? extends R> mapper)` * `mapToDouble(Function<? super T> mapper)` * `mapToInt(Function<? super T> mapper)` --- # `Function` Interface ``` @FunctionalInterface public interface Function<T, R> { R apply(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Example - `map()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); List<String> lengths = words.stream() .map(word -> word + ": " + word.length()) .collect(Collectors.toList()); System.out.println(lengths); ``` -- #### Alternative: ``` Function<String, String> toLength = (word -> word + ": " + word.length()); words.stream().map(toLength); ``` -- #### Output: ```diff [a: 1, function: 8, that: 4, returns: 7, a: 1, function: 8] ``` --- # Numeric Streams .center[`IntStream`, `DoubleStream`, and `LongStream`] * `sum()` * `max()` * `min()` * `average()` * `summaryStatistics()` * `reduce()` --- # Example - `mapToInt()` ``` int sum = words.stream() .mapToInt(w -> w.length()); .sum(); ``` -- #### Output: ```diff Sum of lengths of all strings: 29 ``` --- # `Consumer` Interface ``` @FunctionalInterface public interface Consumer<T> { void accept(T t); } ``` .right[$ ^* $Not showing `default` methods] --- # Example - `forEach()` ``` List<String> words = Arrays.asList("a", "function", "that", "returns", "a", "function"); words.stream() .forEach(w -> System.out.println(w + ": " + w.length())); ``` -- #### Output: ```diff a: 1 function: 8 that: 4 returns: 7 a: 1 function: 8 ``` Note: we can do `forEach()` directly on a `List`: ``` words.forEach(w -> System.out.println(w + ": " + w.length())); ``` --- # Extract Even Numbers ``` Stream<Integer> numbers = Stream.of(3, 8, 7, 2, 1, 9, 8); List<Integer> evens = numbers.filter(i -> i%2==0) .collect(Collectors.toList()); System.out.println(evens); ``` -- #### Output: ``` [8, 2, 8] ``` --- # Extract Based on Suffix ``` System.out.println(Stream.of("happy", "discussion" /* ... */, "locomotion") .filter(word -> word.endsWith("tion")) .count()); ``` -- #### Output: ``` 1 ``` --- # Extract Circles ``` Stream<Shape> shapes = Stream.of(new Circle(0, 0), new Square(0, 0, 4), new Circle(0, 0), new Triangle(0, 0, 1, 5)); List<Circle> circles = shapes.filter(shape -> shape instanceof Circle) .map(shape -> (Circle)shape) .collect(Collectors.toList()); ``` --- # Sum ``` double totalArea = shapes.mapToDouble(shape -> shape.getArea()) .sum(); System.out.println("Total area: " + totalArea); ``` -- #### Output: ``` Total area: 38.239208802178716 ``` --- # Average ``` OptionalDouble averageArea = shapes.mapToDouble(Shape::getArea) .average(); if(averageArea.isPresent()) { System.out.println("Average area: " + averageArea.getAsDouble()); } ``` -- #### Output: ``` Average area: 9.559802200544679 ``` --- # Summary Statistics ``` DoubleSummaryStatistics areaStats = shapes.mapToDouble(Shape::getArea) .summaryStatistics(); System.out.println("Number of shapes: " + areaStats.getCount()); System.out.println("Total area: " + areaStats.getSum()); System.out.println("Average area: " + areaStats.getAverage()); System.out.println("Maximum area: " + areaStats.getMax()); System.out.println("Minimum area: " + areaStats.getMin()); ``` -- #### Output: ``` Number of shapes: 4 Total area: 38.239208802178716 Average area: 9.559802200544679 Maximum area: 16.0 Minimum area: 2.5 ``` --- # Average with `reduce()` ``` double area = shapes.map(Shape::getArea) .reduce(0.0, (a, b) -> a+b); System.out.println("Total area: " + area); ``` -- #### Output: ``` Total area: 38.239208802178716 ``` >>>>>>> 5a2374cc46accf21756e718121137c85127c07b9