Java – how to declare a function parameter to accept the thrown function?

I defined a function in kotlin:

fun convertExceptionToEmpty(requestFunc: () -> List<Widget>): Stream<Widget> {
    try {
        return requestFunc().stream()
    } catch (th: Throwable) {
        // Log the exception...
        return Stream.empty()
    }
}

I have defined a Java method using this signature:

List<Widget> getStaticWidgets() throws IOException;

I try to compose them like this:

Stream<Widget> widgets = convertExceptionToEmpty(() ->  getStaticWidgets())

When I compile, I receive this error:

How do I define my function parameters to accept thrown functions?

Solution

The problem is that Java has checked exceptions, but kotlin doesn't Requestfunc parameter type () – > list and lt; Widget > will map to function interface function0 < list < widget > >, but operator invoke will not throw checked exception in kotlin code

Therefore, you can not call getStaticWidgets () in the lambda expression, because it throws IOException, which is an checked exception in Java.

Since you control both kotlin and Java code, the simplest solution is to change the parameter type () – > list and lt; Widget > to callable < list < widget > >, for example:

// change the parameter type to `Callable` ---v
fun convertExceptionToEmpty(requestFunc: Callable<List<Widget>>): Stream<Widget> {
    try {
        //                 v--- get the `List<Widget>` from `Callable`
        return requestFunc.call().stream()
    } catch (th: Throwable) {
        return Stream.empty()
    }
}

You can then further use method reference expressions in Java 8, for example:

Stream<Widget> widgets = convertExceptionToEmpty(this::getStaticWidgets);

//OR if `getStaticWidgets` is static `T` is the class belong to
//                                               v
Stream<Widget> widgets = convertExceptionToEmpty(T::getStaticWidgets);