Inferring that what exceptions are thrown from a lambda

Stuart Marks stuart.marks at
Thu Sep 5 19:22:43 PDT 2013

Applying this to the OP's example, this would propagate "throws 
Exception" out to the callers, forcing them to catch or to throw 
Exception themselves. That's not what the OP wanted. Instead, the 
example using a lambda that throws IOException should only be forced to 
handle or declare IOException, and the example using a lambda that 
doesn't throw any checked exceptions shouldn't have to deal with 
exceptions at all.

With the new inference work in the compiler, the additional "X extends 
Throwable" type argument seems to do the trick for some common cases. (I 
tend to prefer type variable X -- "exception" -- over E, since E is 
already used for enums and for collection element types.) It doesn't 
work if the lambda throws multiple different checked exception types. 
For example, the following doesn't work:

     public void multiple() throws ExecutionException, 
InterruptedException {
         String result = tryRepeatedly(10, () -> {
             if (/*condition*/)
                 throw new ExecutionException(null);
                 throw new InterruptedException();

Here, the compiler infers the least upper bound for the lambda's 
exception type, which in this case is Exception, so that's what has to 
be listed in the throws clause instead of listing multiple exception 
types. Oh well.


On 9/4/13 7:22 PM, Howard Lovatt wrote:
> It is generally easier to do this:
>      public interface Action<T> {
>           T run() throws Exception;
>       }
> Which is what Callable does, infact the above is Callable apart from 
> the name changes (Callable -> Action, call -> run).
> On 5 September 2013 06:11, Stuart Marks <stuart.marks at 
> <mailto:stuart.marks at>> wrote:
>     On 8/31/13 11:04 AM, Esko Luontola wrote:
>     > But if the lambda doesn't thrown anything, the compiler thinks
>     that the
>     > method may throw the most generic exception. The following code
>     fails to
>     > compile with "error: unreported exception Throwable; must be
>     caught or
>     > declared to be thrown"
>     >
>     >       public void doesNotCompile() {
>     >           String result = Resilient.tryRepeatedly(10, () ->
>     "result");
>     >       }
>     A change to support this went in fairly recently. This now
>     compiles for
>     me using JDK 8 b105. It fails with the error you mention when using
>     older builds, e.g., JDK 8 b88, which is one I happened to have lying
>     around. (Note, I am referring to JDK 8 builds, not Lambda builds.)
>     I believe that if a lambda throws no checked exceptions, and its
>     functional interface method is declared "throws E", then E is now
>     inferred to be RuntimeException.
>     s'marks
> -- 
>   -- Howard.

More information about the lambda-dev mailing list