We need special processing for InterruptedException. If we will be wrapping this exception and will not be restoring interrupted status for the thread pool thread, then we may broke the termination of this thread pool

Hello,

This is not an issue per-se, just wondering why the implementation of ExceptionSmuggler is not actually more like this for example:

final class ExceptionSmuggler extends CheckedExceptionHandler {

    @Override
    public RuntimeException handle(Exception exception) {
        return sneakyThrow(exception);
    }

    static <T extends Throwable> RuntimeException sneakyThrow(Throwable t) throws T {
        throw (T) t;
    }
}

you do want a "sneaky" throw after all here...

also I've actually wondered why CheckedExceptionHandler::function for example, is not a lambda too, in the form:

    public final <T, R> Function<T, R> function(ThrowingFunction<T, R> function) {

        return t -> {
            try {
                return function.apply(t);
            } catch (RuntimeException exception) {
                throw exception;
            } catch (Exception exception) {
                throw handle(exception);
            }
        };

    }

And the last nitpick is that those constants in Exceptions should really be upper-case (it's just easier to read since it's a common convention)... :

private static final Logger LOGGER = LoggerFactory.getLogger(Exceptions.class);

The thing is, we started looking for something like this for our code and while evaluating some other projects on github, your code seems the closest I would accept. I could submit a PR with these changes if you agree with them.

Eugene.

Hi,

Thanks for the package. I really find it useful.

Is there any plan to have a try() method similar to the Try in Scala, which handles both checked and unchecked exceptions?

It could be essentially syntactic sugar for

Exceptions.log().get(Exceptions.sneak().supplier(() -> my_throwing_lambda)).orElse(fallback)

Thanks Best