CS 152 - Lecture 5

Cay S. Horstmann

Higher Order Functions

• A higher order function consumes or produces another function.
• Example of consumption: map

  (1 to 10).map(x => x * x)
  

• Why would you want to produce a function?
• And how?

Producing Functions

• We can define a function

  def triple(x: Int) = 3 * x

• Then we can use it:

  (1 to 10).map(triple)

• Here is another:

  def quadruple(x: Int) = 4 * x
  (1 to 10).map(quadruple)
  

• What about a generic “multiply by n” function so that I can write:

(1 to 10).map(multiplyBy(5))

Producing Functions

• multiplyBy(5) needs to produce a function...
• of type Int => Int:

  def multiplyBy(n: Int) : Int => Int = ...
  

• It needs to produce a function that consumes an integer:

  ... = (x: Int) => ...
  

• and the result is n * x.
• Now all together:

  def multiplyBy(n: Int) : Int => Int = (x: Int) => n * x
  

• The return type is inferred:

  def multiplyBy(n: Int) = (x: Int) => n * x
  

Comparators

• Comparators used for sorting:

  List(1, 2, 3).sortWith(_ > _)
  

• Want to turn a discriminator function into a comparator:

  strings.sortWith(comparingBy(s => s.length())
  

• What does comparingBy produce?
  • A function (String, String) => Boolean
• What does comparingBy consume?
  • A function String => Integer

• def comparingBy(f: String => Integer) =
     (x: String, y: String) => ... // A Boolean
  

• The rest is simple:

  ... => f(x) < f(y)

Composing Comparators

• Preparation: Make comparingBy generic.

  def comparingBy[T, R : Ordering](f: T => R) = { // Don't worry about the details
    import scala.Ordered.orderingToOrdered
    (x: T, y: T) => f(x) < f(y)
  } 

• Now it works for a map Person => String:

  case class Person(first: String, last: String)
  val people = List(Person("Fred", "Flintstone"), Person("Fred", "Brooks"), Person("Barney", "Rubble"))
  people.sortWith(comparingBy(_.first))
  

• Now we want to compare by first name, using the last name to break ties:

  people.sortWith(breakingTies(comparingBy(_.first), comparingBy(_.last)))
  

Composing Comparators

• What does breakingTies produce?
• A function (Person, Person) => Boolean
• What does breakingTies consume?
• Two functions (Person, Person) => Boolean

• def breakingTies(c1: (Person, Person) => Boolean, c2: (Person, Person) => Boolean) =
     (x: Person, y: Person) => ... // A Boolean

• => if (c1(x, y)) true else
    if (c1(y, x)) false else
    c2(x, y)

Currying

• Currying = Turning a function that takes two arguments into a function that takes one argument. That function returns a function that consumes the second argument. (Named after the logician Haskell Brooks Curry)
• Huh?
• Simple example:

  def multiply(x : Int, y : Int) = x * y
  multiply(3, 4) is 12

• Now let's do this a little different:

  def multiply(x : Int)(y : Int) = x * y
  multiply(3)(4) is 12

• What is multiply(3)?
• A function that is capable of eating 4, thus yielding 12:

  def multiply(x: Int) = (y: Int) => x * y // That's our multiplyBy
  

• Can make higher-order functions easier on the eye:

  def comparingBy(f: String => Integer) = (x: String, y: String) => f(x) < f(y)
  def comparingBy(f: String => Integer)(x: String, y: String) = f(x) < f(y)      

• Similar to the rewrite of a val to a def:

  val triple = (x: Int) => 3 * x
  def triple(x: Int) = 3 * x
  

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 lab4/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: Short Function Notation

Define a variable lst as

val lst = List("Alpha", "Bravo", "Charlie", "Delta", "Echo", "Foxtrot", "Golf")

What is the shortest command you can use to

1. Yield all short strings (of length < 5) from lst
2. Yield the words sorted by increasing length
3. Find the longest string (using reduce)

Step 2: Currying

• Write a function makeMin that consumes a comparator (a function (String, String) => Boolean) and produces a function (a: String, b: String) => String that computes the smaller of the two inputs, as measured by the comparator.
• Did you use Currying? If so, pat yourself on the back. Now do it the other way around. Or if you did it the other way around, do it with currying.
• Make your function generic. Just replace String with T and stick a [T] right after the function name. Don't worry—it won't hurt a bit.

Step 3: More Currying

1. Here is a function of computing the “maximum” string in a list that works for any ordering.

   def max(lst : List[String], less : (String, String) => Boolean) =
     lst.reduce((x, y) => if (less(x, y)) y else x)

   Make a call to max that yields the longest string in a list lst. Use _ for the string parameters in your less function.

2. Now make this generic. Don't worry—it won't hurt a bit:

   def max[T](lst : List[T], less : (T, T) => Boolean) =
     lst.reduce((x, y) => if (less(x, y)) y else x)

   What happens when you call max(lst, _ < _)?

3. Ok, that didn't work so well. Currying to the rescue. Curry the max[T] function, exactly like multiply above. What is the code for your revised function? What happens when you call max(lst)(_ < _)?

   (Why does this work? Now the Scala type inferencer knows that T must be String after processing max(lst).)