Closures

Functions as Parameters
Capturing the Enclosing Environment
Application: Event Handling

Functions as Parameters

Consider the map function from lab 2

val triple = (x : Int) => 3 * x
(1 to 10).map(triple)
// yields 3 6 9 12 ... 30

Let's implement such a function. For simplicity, we only use sets and functions of Int
Two parameters: List[Int], function (Int) => Int, returns List[Int]
```
def map(lst : List[Int], fun: (Int) => Int) : List[Int] = 
```
Map of empty list is Nil, otherwise apply fun to lst.head and use recursion:
```
if (lst.isEmpty) 
  Nil else
  fun(lst.head) :: map(lst.tail, fun)
```
Sample call:
```
map(List(1, 2, 3), (x : Int) => 3 * x)
```
A function describes a piece of behavior, such as

What should map do with each element in lst?

Capturing the Enclosing Environment

Consider this function:

val n = 3
val fun = (x : Int) => n * x
// What is fun(2)?

n is not defined in the scope of fun, but that is ok. In the body of a function, you can use any variable from the enclosing scope.
Doesn't seem a big deal—n is immutable, so it will always be 3. But consider this:
```
def mulBy(n : Int) = (x : Int) => n * x
```

Huh? Let's call it:

val quadruple = mulBy(4) // the function (x : Int) => 4 * x

And let's call that:
```
quadruple(5) // yields 20
```
Each call to mulBy yields a different function.
Each function has a different value of n
Closure = function + binding of its free variables (i.e the variables that are not defined locally in the function)

Application: Event Handling

val textArea = new JTextArea(20, 50)
val button1 = new JButton("Click Me!")
  
button1.addActionListener((e : ActionEvent) => { 
  textArea.append("I was clicked\n") 
})

Closure captures textArea
Full code here (if you are interested)

Tedious in Java; requires inner class

final JTextArea textArea = new JTextArea(20, 50);
button1.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent event) {
      textArea.append("Hello\n");
   }
};

Lab

Format of classes: approx. 20 minutes lecture, 45 minutes lab, 10 minute wrap-up
Use your laptop (with JDK 1.6 and Scala installed)
Work with a buddy
One of you fusses with the code, the other types up answers
Switch roles each time
Submit lab work to eCampus.

Step 1: Filters

What does the following function do? If in doubt, call it with a few values.
```
val isEven = (x : Int) => x % 2 == 0
```
Type (1 to 10).filter(isEven). As always, don't type the period, but type ENTER. What do you get?

HINT: These “What do you get” exercises are a lot more effective when you and your buddy first discuss whar you think you'll get. “Form a hypothesis” is an essential part of the learning path.
Describe what filter does.

Step 2: A Random Number List

The random number generator in Scala is similar to that in Java. What output do you get from
```
val gen = new Random
gen.nextInt(10)
gen.nextInt(10)
```
What is the significance of the 10?
We want to define a function randList(len : Int, n : Int) : List[Int] that makes a list of length len of random integers between 0 and n - 1. For example, randList(5, 10) might yield a list of numbers 5 1 2 0 9. Define randList as a recursive function. What is the code of your function?
Hint: If len is 0, the result is nil. Otherwise, it is gen.nextInt(n) :: something. What is your definition?

Note: You need not define gen. You already defined it in part 1. Just use it.
What do you get for randList(5, 1000)? For randList(1000, 5)?
Why is randList a closure?

Step 3: Filtering Large Numbers

Write a function greaterThan100(lst : List[Int]) that returns only those integers in lst that are greater than 100. Don't use recursion; simply call filter with an appropriate function:
```
def greaterThan100(lst : List[Int]) = {
  val fun = ... // your work 
  lst.filter(fun) // NOTE: The last expression in a { ... } is its value
}
```
What is your function's code?
What is the value of greaterThan100(randList(10, 200))? Why does that give you confidence that you implemented everything correctly?
Of course, having a hard-wired bound of 100 is intensely ugly. Let's generalize:
```
def greaterThan(n : Int, lst : List[Int]) = {
  val fun = ... // your work 
  lst.filter(fun) 
}
```
For example, greaterThan(50, nums) yields all values of nums > 50.

What is the code of your greaterThan function?
What is the value of greaterThan(100, randList(10, 200))?
Why is the fun inside greaterThan a closure?

Step 4: Listeners (Optional)

Do this if you have extra time.

Run the listener example code, by pasting the instructions from action.scala into your Scala interpreter. (This is probably an exercise in frustration if you use the Windows shell. Remedy: rxvt in Bash or emacs.) What happens if you click each of the buttons?
Fix the Exit button so that it calls frame.setVisible(false). How did you do that?