More About Closures

• Type inference
• Short forms of functions
• Control abstractions

Type Inference

• Scala is strongly typed. Any value has a type guarantee.
• Just like Java:

  String greeting = "Hello";
  greeting = 42; // Error

• But without having to declare types:

  var greeting = "Hello" // String is inferred
  greeting = 42 // Error

• Contrast with scripting languages such as JavaScript

  var greeting = 'Hello' // This is JavaScript
  greeting = 42 // Ok
  alert(greeting.length) // Runtime error: 42 doesn't have a length member

Type Inference 2

• Can override inferred type (only to a supertype, of course)

  var greeting : Any = "Hello"
  greeting = 42 // Ok

• Parameter types must be specified (because they are not initialized when they are declared)

  def mystery(x) = 42 * x // Error
  def mystery(x : Int) = 42 * x // Ok

• Function return type is inferred
  • If x is Int, then 42 * x is also Int
• Exception: Recursive function

  def fac(x : Int) = if (x == 0) 1 else x * fac(x - 1)

  • Can't get type of right hand side without knowing type of fac
  • Limitation of Scala: Other languages (e.g. Haskell) can infer recursive types through “unification”

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).filter((x) => x % 2 == 0)

  • List[A].filter (p : (A) => Boolean) : List[A]
  • A is Int since List(1, 2, 3) is a List[Int]
  • f must be (Int)=>Boolean
  • x must be Int

Parameter Simplifications

• Ok to omit () around a single inferred parameter

  List(1, 2, 3).filter(x => x % 2 == 0)
  List(1, 2, 3).sort((x, y) => x > y)
    // need () with 2 or more parameters

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

  List(1, 2, 3).filter(_ % 2 == 0)
  List(1, 2, 3).sort(_ > _)

Control Abstractions

• Methods such as map and filter have as argument a function (i.e. code)
• A while loop has two arguments: a condition (code) and a body (code)
• Could we implement while in Scala?

  Sure:

   def While(cond: () => Boolean, body: () => Unit) { 
    if (cond()) { 
      body(); While(cond, body) 
    } 
  }

• But calling is a bit ugly:

  var x = 1
  While (() => x < 10, 
    () => { println(x); x+= 1 })

By-Name Parameters

• Control abstraction = User or library function that looks to programmers like a language mechanism
• Want nice syntax, e.g. {} for blocks without () =>
• Use “by-name” parameters

  def While(cond: => Boolean, body: => Unit) { // Not () =>
    if (cond) { // NOTE: No () in call
      body; While(cond, body) 
    } 
  }

• Now the unsightly () => are gone from the call:

   While ({ x < 10 }, 
     { x += 1; println(x) })

• Still unhappy about unsightly ( , ) in call.

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 mul(x : Int, y : Int) = x * y
  mul(3, 4) is 12
  def mul2(x : Int)(y : Int) = x * y
  mul2(3)(4) is 12

• What is mul2(3)?
• A function that is capable of eating 4, thus yielding 12
• y : Int => 3 * y

The While Control Abstraction

• def While(cond: => Boolean)(body: => Unit) { 
    if (cond) { 
      body; While(cond)(body) 
    } 
  }

  While (x < 20) { x += 1; println(x) }

• Trick #1: By-name parameters
• Trick #2: Currying
• Somewhat weirdly, While {x < 20} also works

A Useful Control Abstraction

• Writing a file in Java is a pain

  PrintWriter writer = new PrintWriter("foo.txt");
  try {
    writer.println(line1);
    writer.println(line2);
    ...
  } finally {
    writer.close(); // Make sure this happens for any exception
  }

• We want a control abstraction

  DoWrite(new PrintWriter("foo.txt")) { writer => 
    writer.println(line1);
    writer.println(line2);
    ...
  }

• Note that this control abstraction has a parameter in the block.
• Note that the type of the parameter is inferred!
• See Lab for solution

Lab

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

1. What is the shortest command you can use to
   • Remove all strings of length > 5 from a list
   • Sort a list of strings by increasing length
   • Find the longest string in a list (using /:)(Hard--may be easier after step 2)

   For each of these, first store the list in a variable lst

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

Step 2: 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.head /: lst.tail)((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 we'll make this generic. Don't worry—it won't hurt a bit:

   def max[T](lst : List[T], less : (T, T) => Boolean) =
     (lst.head /: lst.tail)((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 mul2 above. What is the code for your revised function? What happens when you call max2(lst)(_ < _)?

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

Step 3: Implement DoWrite

1. Implement the DoWrite control abstraction from the lecture. The While example isn't a perfect model to follow:
   • While took two function parameters () => Boolean, () => Unit
   • DoWrite has one parameter of type PrintWriter and one parameter that is a function

   What is the type of that function?

2. Using Currying, define DoWrite(writer : PrintWriter)(body: the type you deduced in step 1). Make a try/finally block. In the inside of the try, simply call body.
3. Call

   DoWrite(new PrintWriter("abc.txt")) { writer => 
     writer.println("Alpha")
     writer.println("Bravo")
     writer.println("Charlie")
   }

   Where is the file abc.txt located, and what is its contents?

Step 4: Checking DoWrite

1. We want to see that the DoWrite abstraction does its job. Call

   def test() {
     val writer = new PrintWriter("def.txt")
     writer.println("Delta")
     writer.println("Echo")
     throw new NullPointerException()
     writer.println("Foxtrot")
   }

   What happens?

2. What is in def.txt? What did you expect to be in it?
3. Now call

   DoWrite(new PrintWriter("def.txt")) { writer => 
     writer.println("Delta");
     throw new NullPointerException()
     writer.println("Foxtrot");
   }

   What is in def.txt? What does that prove?