Lambdas and Generics (Intro)

Transcription

1

2 Lambdas and Generics (Intro) Dan S. Wallach and Mack Joiner, Rice University Copyright 2016 Dan S. Wallach, All Rights Reserved

3 New this week in Subversion! week02-lists (check it out!) edu/rice/week2lists/glist.java This week s project: adding several functions to GList This week s lab: writing lambda filter functions

4 Piazza / Subversion updates If you re not enrolled, you re no longer in Piazza The you originally registered under might be different. If you can t get in, check your for another invitation. Subversion as well Changes should kick in by the end of the day.

5 Thinking generically Last week, we built functional lists But everything is in terms of Object. This has problems. // // Functional lists // interface ObjectList { ObjectList add(object o); boolean contains(object o); Object head(); ObjectList tail(); boolean empty(); } ObjectList ol = ObjectList.makeEmpty().add("Hello").add("Rice").add("Owls"); System.out.println(ol.head()); // Owls System.out.println(ol.tail().head()); // Rice System.out.println(ol.tail().tail().head()); // Hello

6 Thinking generically When all the world s an Object You have to explicitly typecast. How can we require that ObjectList ol = ObjectList.makeEmpty().add("Hello").add("Rice").add("Owls"); String foo = (String) ol.head(); everything is the same type? We want to declare this to be a List of String. Require inputs to be String Guarantee outputs to be String Never need to typecast

7 Making a generic list Java allows us to have type parameters We re defining GList of T Static methods as well The makeempty() method takes a type parameter so it can return an empty list of the proper type. Static method type parameters show up to the left of the method name. And they re often not necessary! // // Generic functional lists // interface GList<T> { public T add(t o); public boolean contains(t o); public T head(); public GList<T> tail(); public boolean empty(); public static <T> GList<T> makeempty() {... } } GList<String> list = GList.<String>makeEmpty().add("Hello").add("Rice").add( Owls ); String s = list.head(); // no typecasting! Rule of thumb: try it with and without.

8 Shirt<T>

9 Shirt<T>

10 Vocabulary alert! Generics = Parametric Polymorphism (Type) Parameter = Type arguments in the brackets (<T>, etc.) Polymorphism = Same code can operate over different types Remember Zen Coding Rule #1: Don t Repeat Yourself. Generics help.

11 What about the singleton empty-list? Beforehand: one instance of the empty-list (SINGLETON) interface ObjectList { public static ObjectList makeempty() { return Empty.SINGLETON; } class Empty implements ObjectList { private static final ObjectList SINGLETON = new Empty(); // Constructor isn't for public use. private Empty() { }

12 What about the singleton empty-list? Afterward: still one instance of the empty-list But we re doing some weird stuff to pull this off. <> : type inference <?> : type wildcard interface GList<T> { /** * Create a new empty list of the given parameter type. */ public static <T> GList<T> makeempty() GList<T> castsingleton = (GList<T>) SINGLETON; return castsingleton; } class Empty<T> implements GList<T> { private Empty() { } private static final GList<?> SINGLETON = new Empty<>();

13 Under the hood: type erasure Rule #1: there s only ever one real class (GList, etc.) Java does type erasure, so GList<String> and GList<Foo> compile down to just GList Implications At runtime, inside GList<T>, we don t know what T actually is Forbidden: T t = new T(); We ll work around this later; other PL s have reified generics which fix this. There s only ever one static method / member of a given name private static final GList<?> SINGLETON = new Empty<>(); // original code private static final GList SINGLETON = new Empty (); // runtime implementation, after type erasure

14 Under the hood: type erasure Rule #1: there s only ever one real class (GList, etc.) Java does type erasure, so GList<String> and GList<Foo> compile down to just GList Implications At runtime, inside GList<T>, we don t know what T actually is Forbidden: T t = new T(); Our empty-list never returns a T, so we ll get away with our cheating. public T head() { throw new NoSuchElementException("can't take head() of an empty list"); } But there s no problem with returning GList<T>, since we get those from the main GList class. We ll work around this later; other PL s have reified generics which fix this. There s only ever one static public method GList<T> / member add(t of val) a given { name return new Cons<>(val, this); private static final GList<?> SINGLETON = new Empty<>(); // original code private static final GList SINGLETON = new Empty (); // runtime implementation, after type erasure }

15 Your friend: type inference Q: Why don t we need to declare the type parameter of the Cons<>? interface GList<T> { default GList<T> add(t val) { } return new Cons<>(val, this); A: Java figures it out from context. IntelliJ will yell at you if it can t make an inference. You must declare type parameters for variable declarations, return types, argument types. You often use a diamond <> for a constructor s type parameter. You often leave out the type parameter (no diamond) for method calls.

16 More type inference This code works: GList<Integer> numbers = GList.<Integer>makeEmpty().add(1).add(2).add(3); This code also works: GList<Integer> emptylist = GList.makeEmpty(); GList<Integer> numbers = emptylist.add(1).add(2).add(3); This code won t compile: GList<Integer> numbers = GList.<>makeEmpty().add(1).add(2).add(3); This code won t compile, either: GList<Integer> numbers = GList.makeEmpty().add(1).add(2).add(3);

17 More type inference This code works: GList<Integer> numbers = When in doubt, make yourself a separate empty-list of the correct type. GList.<Integer>makeEmpty().add(1).add(2).add(3); This code also works: GList<Integer> emptylist = GList.makeEmpty(); GList<Integer> numbers = emptylist.add(1).add(2).add(3); This code won t compile: GList<Integer> numbers = GList.<>makeEmpty().add(1).add(2).add(3); This code won t compile, either: GList<Integer> numbers = GList.makeEmpty().add(1).add(2).add(3);

18 More on generics coming Wednesday Instead, let s talk about lambdas.

19 Operating on a list Let s say we have a List of integers and we want the even numbers. Old-school, ugly, mutation style: List<Integer> originallist =... List<Integer> resultlist = new LinkedList<>(); for (int i : originallist) { if (i % 2 == 0) { resultlist.add(i); } }

20 No mutation!

21 Operating on a list New-school, beautiful, functional style: static GList<Integer> evens(glist<integer> input) { } return input.filter(i -> i % 2 == 0); lambda expression another operation on GList (just like add())

22 What s a lambda? A lambda is a function without a name i -> i % 2 == 0 This lambda takes one argument (i) and returns a boolean Note that there are no type declarations! How? Type inference. Java figures it out from context. We re operating on GList<Integer> so i must also be an integer

23 Using lambdas: the GList filter function public GList<T> filter(predicate<t> predicate) { if (predicate.test(headval)) { return tailval.filter(predicate).add(headval); } else { return tailval.filter(predicate); } }

24 Using lambdas: the GList filter function An instance of the Predicate interface (a lambda returning boolean) public GList<T> filter(predicate<t> predicate) { if (predicate.test(headval)) { return tailval.filter(predicate).add(headval); } else { return tailval.filter(predicate); } }

25 Using lambdas: the GList filter function public GList<T> filter(predicate<t> predicate) { if (predicate.test(headval)) { return tailval.filter(predicate).add(headval); } else { return tailval.filter(predicate); } } Applying the function

26 Functional programming vocabulary Predicate: a function that returns a boolean Operator: a function returning the same type unary operator: one argument (e.g., trig functions) binary operator: two arguments (e.g., addition, subtraction) Function: arguments and results can be different types Supplier: produces data (e.g., reading lines of text from a file) Consumer: eats data, has side effect, returns nothing (e.g., printing)

27 Various forms of lambda syntax These are all equivalent: public class Foo { // "inline" lambdas Function<Integer,Integer> oneplus1 = x -> x + 1; Function<Integer,Integer> oneplus2 = (x) -> { return x + 1; }; Function<Integer,Integer> oneplus3 = (Integer x) -> (x + 1); static int oneplusx(int x) { } return x + 1; } // "method reference" lambda (works for static and instance methods) Function<Integer,Integer> oneplus4 = Foo::oneplusx;

28 Common FP list operators list.map(function) list Apply the function to every element of the list, return a new list list.filter(predicate) list Compute a new list: every element where the predicate is true list.sort(comparator) list Return a new list sorted by a function that says which is bigger More coming on Wednesday!

29 Mapping Replace each element in a list with the function applied to it GList<Integer> originals =... ; GList<Integer> squares = originals.map(i -> i * i); GList<String> strings =...; GList<String> lowercases = strings.map(x -> x.tolowercase()); GList<Integer> strlengths = strings.map(string::length); Function return type can be different (e.g., String::length)

30 Your lab this week Writing lots of lambdas that filter lists! Don t start working on it until you arrive at your lab.

31 Live coding demo Implement GList.reverse() Walk through, demonstrate GList.map() Another type parameter!