Using foreach for control instead of Closures

Overview

While there is no doubt Closures are very powerful concept they are fairly complex to implement properly and efficiently.
However, one of the use cases, control block can be simulated using the for each loop without limiting functionality of the blocks involved.

The approach

This approach uses Java 5's for each loop and Iterable/Iterators in a novel way to provide the control functionality.

A single control structure.

In the following example, the lock is acquired the first time the loop is entered and unlocked as the loop exits.

LockTest.java

for (ReentrantLock lock : withLock(getLock())) {
    assertTrue(lock.isHeldByCurrentThread());
    assertTrue(lock.isLocked());
}

assertFalse(getLock().isHeldByCurrentThread());
assertFalse(getLock().isLocked());

Multiple control structures.

The following example has three "loops". The two outer "loops" only loop once but it is a loops ability to return to a previous object which provides closure.

The first loop starts a timer which prints the time taken when the loop finishes. The second loop closes the "out" PrintWriter when it completes . The third loop reads a file one line at a time and closes the resource when finished.

CopyFile.java

public static void main(String... args) throws FileNotFoundException {
    for (Void _ : time("file copy"))
        for (PrintWriter out : closeAfter(new PrintWriter(args[1])))
            for (String line : fileByLine(args[0]))
                out.println(line);
}

The implementation

Controls.time()

public static Iterable<Void> time(final String message) {
    return new Once<Void>() {
        long start = System.nanoTime();

        public void after() {
            System.out.println(message + " took " + (System.nanoTime() - start) / 1000 / 100 / 10.0 + " ms.");
        }
    };
}

Controls.withLock()

public static <L extends Lock> Iterable<L> withLock(final L lock) {
    return new Once<L>() {
        public void before() {
            lock.lock();
        }

        public L value() {
            return lock;
        }

        public void after() {
            lock.unlock();
        }
     };
}

Controls.closeAfter()

public static <C extends Closeable> Iterable<C> closeAfter(final C closeable) {
    return new Once<C>() {
        public C value() {
            return closeable;
        }

        public void after() {
            System.out.println("<< close " + closeable + ">>");
            try {
                closeable.close();
            } catch (IOException ignored) {
                // ignored.
            }
        }
    };
}

Controls.fileByLine()

public static Iterable<String> fileByLine(final String filename) throws FileNotFoundException {
    final BufferedReader br = new BufferedReader(new FileReader(filename));

    return new ManyValues<String>() {
        public String value() throws Exception {
            return br.readLine();
        }

        public void after() {
            try {
                br.close();
            } catch (IOException ignored) {
                // ignored.
            }
        }
    };
}

Limitations.

When the loop break unexpectedly, there is no guarentee when, if ever, the iterator will be closed/finalised.
Escape analysis in Java 7 should help with this as the variable created could be added to the local stack. However ther may still be unexpected behaviour.

One way to support reliable handling is to ensure that the Iterable is closed as soon as the loop exists. The CloseableIterator interface exposes a close method which could be called.
However, it should be possible for this method to be called implicitly without the developer needing to remember to do this.

This can be done two ways:

code injection to add a finally { if (iterator instanceof CloseableIterator) ((CloseableIterator) iterator.close()) } block. This could be added to Java 5.
support in the compiler to do this for you. This could be added to Java 7+

Other control blocks.

An iterator which takes an SQL String and provides a ResultSet foreach result and closes the query when finished. Note: it could return the same resultSet object each time.