Is there a standard Java 8 FunctionalInterface for a block throwing a checked exception?

Question

Callable throws Exception, Runnable doesn't.

Is there anything standard that looks like

@FunctionalInterface
public interface TypedBlock<E extends Exception> {
    public void run() throws E;
}

Answer 1

No, there is no built in functionality as I know. But you can use an external library for that (and many other cool features).

You can either use JOOL, where you can use the Unchecked class for this.

The example from there page demonstrates this with an IOException

Arrays.stream(dir.listFiles()).forEach(
    Unchecked.consumer(file -> { System.out.println(file.getCanonicalPath()); })
);

Another (and in my opinion better) approach would be to use a functional designed library like Functionaljava.

A good approach would be to wrap your task in a Validation to decide afterwards, if the result was successful. This could look like this:

TypedBlock<IOException> foo = ...;

// do your work
final Validation<IOException, Unit> validation = Try.f(() -> {
  foo.run();
  return Unit.unit(); // Unit equals nothing in functional languages
})._1();

// check if we got a failure
if (validation.isFail()) {
  System.err.println("Got err " + validation.fail());
}

// check for success
if (validation.isSuccess()) {
  System.out.println("All was good :-)");
}

// this will just print out a message if we got no error
validation.forEach(unit -> System.out.println("All was good"));

Answer 2

There is java.lang.AutoCloseable which has a ()->{} throws Exception signature, however, it is burden with a predefined semantic. So for an ad-hoc use it might be suitable but when you design an API, I recommend defining your own interface.

Note that your specialized interface could still extend Callable<Void> to be a standard interface:

interface Block<E extends Exception> extends Callable<Void>{
    void run() throws E;
    @Override default Void call() throws E { run(); return null; }
    /** This little helper method avoids type casts when a Callable is expected */
    static <T extends Exception> Block<T> make(Block<T> b) { return b; }
}

This way you can use your Block interface with existing APIs:

// Example
ExecutorService e=Executors.newSingleThreadExecutor();
try {
    e.submit(Block.make(()->{ throw new IOException("test"); })).get();
} catch (InterruptedException ex) {
    throw new AssertionError(ex);
} catch (ExecutionException ex) {
    System.out.println("received \""+ex.getCause().getMessage()+'"');
}
e.shutdown();

Note the trick with the static method Block.make. Without it you would have to cast the lambda expression to (Block<IOException>) instead of profiting from the improved type inference. This is only necessary where a Callable is expected, for your own API where a Block is expected, you can use lambda expressions and method references directly.