Review

• Closure = snippet of code + bindings of free variables
• Useful any time that you need to pass code to some other function
• Comparators, delayed execution (event handlers, threads), resource control

Warm-up exercise: What is mystery?

val lst = List("Mary", "had", "a", "little", "lamb")
val mystery = lst.filter(_.length > 3)

http://ActiveLecture.org

Closures in Java

• Several competing proposals (as well as the “do nothing” option)
• Tricky to add in an existing language: interacts with generics, exception handling, even return and this
• BGGA (Bracha, Gafter, Gosling, Ahe): Do everything
• CICE/ARM (Lee, Lea, Bloch): Do the simplest thing that works
• There are other proposals, but these are at the opposite ends of the spectrum
• Case study of the challenges of language evolution

BGGA Syntax

• Closure syntax similar to Scala

  { Type1 arg1, Type2 arg2, ... => stat1, stat2, ..., expr } 

• Example

  { String a, String b => a.length() - b.length() }

• Closure type { String, String => int }
• Use invoke to call closure

  void sort(String[] a, { String, String => int } comp) {
     ... if (comp.invoke(a[i], a[j]) < 0) ...
  }

Closure Conversion

• Closure -> anonymous object of anonymous class implementing interface with single method

  button1.addActionListener({ ActionEvent event => textField.setText(...); })

• Converts { ActionEvent => void } closure to

  new ActionListener() {
     public void actionPerformed(ActionEvent event) { // single method
        closure.invoke(event);
     }
  }

• Useful glue between closures and traditional Java APIs

Control Invocation Syntax

• Makes closure syntax nicer for resource control syntax
• Without control invocation syntax

  doRead(new FileInputStream("foo.dat"), { InputStream in => 
     ... 
     in.read(); 
     ... 
  });

• With control invocation syntax

  doRead(InputStream in : new FileInputStream("foo.dat")) { // looks like a regular block
     ...
     in.read();
     ...
  }

• Just syntactic sugar:

  methodCall(Type1 param1, ... Typen paramn : expr1, ... exprm) block

  is rewritten to

  methodCall(expr1, ... exprm, { Type1 param1, ... Typen paramn => block })

What Does This Program Do?

import java.util.*;

public class Puzzler {
   public static void main(String[] args) {
      String[] foo = new String[] { "Mary", "had", "a", "little", "lamb" };
      Arrays.sort(foo, { String a, String b => return a.length() - b.length() });
      System.out.println(Arrays.toString(foo));
   }
}

1. It prints [a, had, Mary, lamb, little]
2. It compiles but it doesn't print anything
3. It doesn't compile

And This?

import java.io.*;
public class Puzzle {
   public static void doRead(InputStream in, {InputStream ==> void throws IOException } body) throws IOException {
      try { body.invoke(in); } finally { in.close(); }
   }
   public static void main(String[] args) throws IOException {
      doRead(InputStream in : new FileInputStream("Puzzle.java")) {
         int c = 0;
         while ((c = in.read()) != -1) {
            if (c == '*') return;
         }
         System.out.println("No asterisk");
      }
      System.out.println("Done");
   }
}

1. It prints Done
2. It prints No asterisk, then Done
3. It prints nothing

What Does return Mean?

• Return a value from the closure?
  • Natural for closures that compute a value
• Return from the enclosing block?
  • Natural for closures in control invocations
• Current implementation has two kinds of closures
  • Restricted closures can't have return
  • Unrestricted closures can have return; returns from enclosing block
  • Unrestricted closures written with ==> instead of =>

CICE

• Concise Instance Creation Expression

  button1.addActionListener(ActionListener(ActionEvent event) { ... });

• Ok to drop the new and the name of the single method
• Variables in the enclosing scope need not be declared final
• Mutated variables in the enclosing scope must be declared public
• That's it

ARM

• Automatic Resource Management

  try (InputStream in = new FileInputStream()) {
     . . .
  }

• Implicit finally { in.close(); }
• Requires that in implements Disposable
• Particularly powerful with multiple resources
• Like using in C#
• Proposed for JDK 7, adoption seems likely

Lab

• Lab instructions in schedule
• Submit to Google group