L.1 A functor is an object that encapsulates a function. Its apply() method takes one parameter, applies an algorithm and returns a value. It is defined as a 'functional' interface:

interface Functor { // apply(p) runs some computation on param of type T and returns a value of type R public R apply(T param); }

a) Write a class implementing the Functor interface, called LengthFun. Its apply() function returns the length (Integer) of a String parameter.

Write a LengthFun.main() function that: o illustrates how the class is used to print the length of a string. o instantiates a lambda expression of type Functor that does the same thing as LengthFun.apply(), and uses it to print the length of a string.

b) Define a subclass of LinkedList, called MyList, that has an additional generic function that "maps" the elements from the list to a new MyList object through a functor object.

The signature of the MyList.map() method is:

public MyList map(Functor fo) { // write here the code for the map() function. }

For an object mylist the mylist.map(fo) creates a new MyList object, iterates over the elements of mylist and appends values fo.apply(current list element) to the new list. At the end map() returns the new list.

For instance, consider a TimesTwoFun functor whose Integer apply(Integer param) function returns 2*param.intValue(). Define a variable tt = new TimesTwoFun(); Now, suppose the elements of a MyList object lst are (-2,1,0,4). Then , the new MyList object returned by the lst.map(tt) will have elements (-4,2,0,8). That is, the lst.map(fo) function creates a new MyList object with elements equal to fo.apply(x), for each element x from the lst list.

Write the TimesTwoFun class.

Write the MyList class that extends LinkedList, with the only custom method being map() (all others are inherited from LinkedList).

Write a main() function in MyList.java that: o implements the example defined above with the TimesTwoFun class. o repeats the same thing using a lambda expression insted of the TimesTwoFun object.

c) A Functor2 interface describes a function with 2 variables of types T1, and T2, respectively, and returning a value of type R. The apply function takes one parameter of type T1, one parameter of type T2, and returns type R.

interface Functor2 { R apply(T1 param1, T2 param2); }

Add a reduce() function to the MyList class that takes as parameters a Functor2 object, and an initial value of type T.

public R reduce(Functor2 fo2, T2 initialValue) { // write code here }

reduce(fo2, initVal) returns the sucessive "cummulative" application of the Functor2 apply() function to all elements of the list, beginning with the initial value and the first element of the list. For instance, assume the list elements are (a,b,c,d) and that a Functor2 object fo2 is defined. Then the reduce(fo2, v) call returns fo2.apply(fo2.apply(fo2.apply(fo2.apply(v, a), b), c), d) As a second example, a class called Summer implements the Functor2 interface. Summer.apply(x,y) returns x + y. Declare the summer ref. variable to be a reference to a Summer object. Assume the elements in the list are (3, -1, 1, 4). Then lst.reduce(summer, 0) should return ((((3+0)+(-1))+1)+4) == 7, i.e. the sum of all elements in the list.

To do: o Write the generic reduce() function in the MyList class defined first at point b). Make sure the function's parameter/return types are defined correctly. o Write the Summer class that implements the Functor2 interface, as described above. o Write a test driver class called SummerTest with a main() function that: i) implements the example above with the Summer object and the list with numbers. ii) implements the example above with a lambda expression instead of a Summer object. Make sure the code works.

d) The map and reduce functions are part of the functional programming paradigm and are widely used in non-functional languages as well. To understand the power of the map/reduce combination, use the code written in parts a)-c)) to implement the following in a the main() function of class MRExample:

- create a MyList object ls with several nonempty String objects added to it - use function ls.map() to return the list of Integer objects representing the length of each string in ls. Use the LengthFun functor class. Call the returned list a variable li. - Use li.reduce() with a Summer object to compute the total number of characters in all strings in the ls list.

e) Write in the main() function of a new class MRExampleWithLambdas the same logic as in part d) ***using lambda expressions*** and chain the map() and reduce() calls in one expression: ls.map(...).reduce(....).