closures for java

2007 JavaOneSM Conference | Session TS-2294 |

TS-2294

Closures for Java

Neal Gafter

Google

YOUR LOGOHERE

2007 JavaOneSM Conference | Session TS-2294 | 2

Why add Closures?

"In another thirty years people will laugh at anyone who tries to invent a language without closures, just as they'll laugh now at anyone who tries to invent a language without recursion." -Mark Jason Dominus


Outline

Goals, DefinitionsExisting solutionsRequirementsSpecificationExamplesNew APIs


Outline



Goals

• Concise “function” literals• without the pain of anonymous instances

• Interoperate with existing APIs• Enable control APIs• Functional and Aggregate Operations• Simple but powerful


Definition: Closure

A closure is a function that refers to free variables in its lexical context.

A function is a block of code with parameters. It may produce a result value.

A free variable is an identifier used but not defined by the closure.


Definition: Control API

• API-specific statement forms

• “special” methods, invocations

• On par with built-in statements


Outline



Example: For-EachUsing anonymous instances

interface OneArg<A> {

void invoke(A arg);

}

<T> void forEach(Collection<T> c, OneArg<T> block) {

for (Iterator<T> it = c.iterator();

c.hasNext();) {

block.invoke(it.next());

}

}


Example: For-Eachdesired

for (String s : strings) doThing(s);

actual

forEach(strings, new OneArg<String>() {

public void invoke(String s) {

doThing(s);

}

});



String toString(Thing t) { … }

for (Thing t : things) println(toString(t));

actual

forEach(things, new OneArg<Thing>() {

public void invoke(Thing t) {

println(toString(t)); // error!

}

});



for (String s : strings)

if (…) throw new MyException();

actual



if (…) throw new MyException(); // error!

}

});



for (String s : strings)

if (…) return computeResult(s);

actual



if (…) return computeResult(s); // error!

}

});



String found = null;

for (String s : strings) if (…) found = s;

actual



if (…) found = s; // error!

}

});


Anonymous Instances

• Verbose, extra wordy, clumsy, redundant• Closures are concise

• Incomplete capture of lexical context• this, toString, etc.• return, break, continue• non-final local variables

• Force irrelevant refactoring

• Control APIs not possible• can’t wrap an arbitrary block of code


Outline



interface Candidate { Set<Qualification> qualifications();}interface CandidatePool extends Collection<Candidate> { Object lock();}Candidate recruit(CandidatePool candidates, Set<Qualification> requirements) { synchronized (candidates.lock()) { for (Candidate c : candidates) { if (c.qualifications() .containsAll(requirements)) { candidates.remove(c); return c; } } } return recruitForeign(requirements);}

Program to be refactored


interface Candidate { Set<Qualification> qualifications();}interface CandidatePool extends Collection<Candidate> { Lock lock();}Candidate recruit(CandidatePool candidates, Set<Qualification> requirements) { withLock (candidates.lock()) { for (Candidate c : candidates) { if (c.qualifications() .containsAll(requirements)) { candidates.remove(c); return c; } } } return recruitForeign(requirements);}

Program refactored


An app-specific example: time

long t0 = System.nanoTime();boolean success = false;try { doSomething(); success = true;} finally { recordTime(“doSomething”, success, System.nanoTime() – t0);}


An app-specific example: time

time(“doSomething”) { doSomething();}


Requirements for Closures

• Simplify vs anonymous instances• Interoperate with existing APIs• Concise• Wrapped code not changed• Support Control APIs

• API-specific control statements• On par with built-in statement forms


Outline



Closures Specification

• Syntax and Semantics• closure expressions• function types• control statements

• Transparency• local variables• exceptions• control transfers• completion (reachable)


Syntax: Closure Expressions

{int x => x+1}

{int x, int y => x+y}

{String x => Integer.parseInt(x)}

{=> System.out.println(“hello”);}


Syntax: Closure Expressions

Primary:Closure

Closure:{ FormalParameterDeclsopt => BlockStatementsopt Expressionopt }


Semantics: Closure Expressions

• Creates an object that represents

• code of the body

• lexical context

• Few restrictions

• May access locals, this

• May return from enclosing method


Semantics: Closure Expressions

• The closure conversion turns a closure into an instance of some interface

• Provides interoperability with existing APIs.

• You can restrict the closure’s operations

• If no target type,use the natural function type


Syntax: Function Types

{int => int}

{int, int => int}

{String => int throws NumberFormatException}

{ => void}

{T => U}


Syntax: Function Types

Type:{TypeListopt => Type FunctionThrowsopt }


Semantics: Function Types

{String => int throws NumberFormatException}

is shorthand for

java.lang.function.IO<String,NumberFormatException>

where

package java.lang.function;

public interface IO<A, X extends Exception> {

int invoke(A a0) throws X;

}


Semantics: Function Types

• “Ordinary” interface types• with an invoke method

• You can extend, implement them• Declare variables, parameters, return types, etc.• Covariant results, etc.• (No special type rules)


Syntax: Control Statements

withLock(lock, {=> doSomething();});



withLock(lock) { doSomething();}



ControlStatement:

foropt Primary ( Formals : ExpressionListopt ) Statement

foropt Primary ( ExpressionListopt ) Statement

Is translated to

Primary( ExpressionList, { Formals => Statement });


Outline



Perform some operation while holding a java.util.concurrent.Lock (today)

Example: Control APIs

void incrementBalance(int deposit) {

myLock.lock();

try {

balance += deposit;

} finally {

myLock.unlock();

}

}


Using a proposed new closure-based APIExample: Control APIs


Locks.withLock(myLock,

{ => balance += deposit; });

}


Using the control statement syntaxExample: Control APIs


Locks.withLock(myLock) {

balance += deposit;

}

}


Make a new list by applying a function to each element of an existing list

Example: Aggregate Operations

List<Integer> parseInts(List<String> strings)

throws NumberFormatException {

return Collections.map(

strings, {String s => Integer.decode(s)});

}


Launch a task using an Executor (today)Example: Interaction w/ Existing APIs

void launch(Executor ex) {

ex.execute(new Runnable() {

public void run() {

doSomething();

}

});

}


Launch a task using an Executor (closure)Example: Interaction w/ Existing APIs


ex.execute({ =>

doSomething();

});

}


Or, using the control statement syntaxExample: Interaction w/ Existing APIs


ex.execute() {

doSomething();

}

}


Add a swing listener (today)Example: Interaction w/ Existing APIs

void addListener(final ItemSelectable is) {

is.addItemListener(

new ItemListener() {

public void itemStateChanged(ItemEvent e)

{ doSomething(e, is); }

}

);

}


Add a swing listener (closure)Example: Interaction w/ Existing APIs


is.addItemListener(

{ ItemEvent e => doSomething(e, is); }

);

}


Or, using the control statement syntaxExample: Interaction w/ Existing APIs


is.addItemListener(ItemEvent e :) {

doSomething(e, is);

}

}


Outline



New APIs

• API-specific control constructs• Collections• Concurrency• Closables

• Aggregate operations• Functional Primitives


Map-specific iteration

Map<Key,Value> map = …;

for eachEntry(Key k, Value v : map) {

// operate with k, v here

}


Locking

Lock lock = …;

withLock(lock) {

// lock held here

}


Closing Streams

with(InputStream s: expr) { // operate on stream}

• The stream is closed on completion


Aggregate Operations

List<Integer> list = …;

Integer sum = Collections.reduce( list, {Integer x, Integer y => x+y});


More complex APIs

• Fork-Join Concurrency (Doug Lea)• Functional and Higher-order Utilities

• AOP?• Continuations?• Multiple dispatch?


For More Information

• Closures in Java BOF• http://www.javac.info/• http://gafter.blogspot.com/


Questions?

closures for java

Documents