Rethrow exceptions from Lamdba

I have this code:

public static void processConditions(@NotNull List<EntityCondition> conditions)
      throws UnsatisfiedConditionException {
    conditions.forEach(
       consumerWrapper(
           entityCondition -> {
              throw new UnsatisfiedConditionException(entityCondition);
           }, UnsatisfiedConditionException.class));
}

Which throws an exception and having this consumer:

public interface ThrowingConsumer<T> {
  void accept(T t) throws Exception;
}

And wrapper:

public static <T, E extends Exception> Consumer<T> consumerWrapper(
      ThrowingConsumer<T> consumer, Class<E> clazz) {
    return i -> {
      try {
        consumer.accept(i);
      } catch (Exception ex) {
        ex.printStackTrace();
        try {
          E exCast = clazz.cast(ex);
          System.err.println(
              "Exception occurred : " + exCast.getMessage());
        } catch (ClassCastException ccEx) {
          //throw ex;
        }
      }
    };
  }

With this consumerWrapper can swallow the exceptions thrown by the lambda, however I need it to "rethrow" it, thus throw ex; As such the method processConditions here can throw it.

How can that be achieved?

The reason why throwing ex doesn't work is because you can't throw checked exceptions in regular Consumers, and ex could be a checked exception.

A simple workaround would be to throw an unchecked RuntimeException, with the cause being ex:

throw new RuntimeException(ex);

Note that this will create a slightly different error message from just throwing ex. It will say "java.lang.RuntimeException" followed by the stack trace of the RuntimeException, followed by "Caused by WhateverExceptionExIs ..." followed by the stack trace of WhateverExceptionExIs.

You can make your consumerWrapper a bit safer by introducing another type parameter to ThrowingConsumer:

interface ThrowingConsumer<T, E extends Throwable> {
    void accept(T t) throws E;
}

...

public static <T, E extends Exception> Consumer<T> consumerWrapper(
            ThrowingConsumer<T, E> consumer, Class<E> clazz) {

So that silly calls like this can be detected at compile time:

consumerWrapper(Foo::thisThrowsExceptionFoo, ExceptionBar.class);

Here's how to make it work:

@FunctionalInterface
public interface ThrowingConsumer<T> extends Consumer<T>{
  @Override
  default void accept(final T e) {
    try {
      accept0(e);
    } catch (Throwable ex) {
      Throwing.sneakyThrow(ex);
    }
  }
  void accept0(T t) throws Throwable;
}

public final class Throwing {

  private Throwing() {}

  @Nonnull
  public static <T> Consumer<T> rethrow(@Nonnull final ThrowingConsumer<T> consumer) {
    return consumer;
  }

  @SuppressWarnings("unchecked")
  @Nonnull
  public static <E extends Throwable> void sneakyThrow(@Nonnull Throwable ex) throws E {
    throw (E) ex;
  }

}

And use it like this:

public static void processConditions(@NotNull List<EntityCondition> conditions)
      throws UnsatisfiedConditionException {
    conditions.forEach(
       rethrow(
           entityCondition -> {
              throw new UnsatisfiedConditionException(entityCondition);
           }, UnsatisfiedConditionException.class));
}