CS 152 - Lecture 4

Cover page image

Functions as Parameters

Consider the map function:

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 multiplyBy(n : Int) = (x : Int) => n * x
```

Huh? Let's call it:

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

And let's call that:
```
quadruple(5) // yields 20
```
Each call to multiplyBy 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)

Parameter Inference From Context

When a function parameter type is known, you can supply an anonymous function without specifying its parameter types
```
def twice(f: (Int) => Int, x : Int) = f(f(x))
twice((x) => 42 * x, 3) 
  // Ok, x : Int is inferred from context
```
Very useful when calling library functions
```
 List(1, 2, 3).map((x) => x * x)
```
- List[A].map(f : (A) => B) : List[B]
- A is Int since List(1, 2, 3) is a List[Int]
- f must be (Int)=> . . .
- x must be Int

Parameter Simplifications

Ok to omit () around a single inferred parameter

List(1, 2, 3).map(x => x * 0.5)
List(1, 2, 3).sortWith((x, y) => x > y)
  // need () with 2 or more parameters, or with 0 parameters

Use _ for a parameter that only occurs once in the body

List(1, 2, 3).map(_ * 0.5)
List(1, 2, 3).sortWith(_ > _)

The _ can't be in an expression that is passed to another function.

List(1, 2, 3).map(math.sqrt(_ + 1)) // Error—Can't pass _ + 1 to math.sqrt
List(1, 2, 3).map(math.sqrt(_) + 1) // Ok

Reductions

map produces a list of values.
What if we want a single value?
In the previous lecture, we wrote
```
def sum(List[Int] lst): Int
```
What about product? Max? Min?

The combining function should be an argument:

def reduce(lst: List[Int], op: (Int, Int) => Int): Int

Call as

val result = reduce(lst, (x, y) => x + y)

Or with anonymous variables:
```
val result = reduce(lst, _ + _)
```

Implementation:

def reduce(lst: List[Int], op: (Int, Int) => Int): Int =
  if (lst.tail.isEmpty) lst.head else
  op(lst.head, reduce(lst.tail, op))

Lab

You work with a buddy
One of you writes the code (coder), the other types up answers (scribe)
When you get stuck, ask your buddy first!
Switch roles each lab. The previous scribe is the coder for this lab.
The scribe submits lab work in lab3/report.txt inside the Git repo. Include the coder's name in the report!
If the coder wants to submit something, that's cool too. Do whatever is easy.

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?
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 scala.util.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: Reduce

What is reduce(List(1,2,3,4,5), (x, y) => x - y)?
Scala has two forms of reduce called reduceLeft and reduceRight. Try
```
(1 to 5).reduceLeft(_ - _)
(1 to 5).reduceRight(_ - _)
```
What do each of them do?
Given a list of digits, pick one of the two forms of reduce to compute the decimal value. For example, List(1, 7, 2, 9) should turn into 1729. Hint: (x, y) => 10 * x + y.

We have implemented one of the forms of reduce in the lecture. Which one? Implement the other. Here is an outline:

def otherReduce(lst: List[Int], op: (Int, Int) => Int) = {
  def otherReduceHelper(lst: List[Int], op: (Int, Int) => Int, partialResult: Int): Int =
    if (lst.isEmpty) ... else
    otherReduceHelper(..., op, op(..., ...))
  otherReduceHelper(..., op, ...)
}