/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.lang3.function;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.Collection;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

import org.apache.commons.lang3.stream.Streams.FailableStream;

This class provides utility functions, and classes for working with the java.util.function package, or more generally, with Java 8 lambdas. More specifically, it attempts to address the fact that lambdas are supposed not to throw Exceptions, at least not checked Exceptions, AKA instances of Exception. This enforces the use of constructs like: 
Consumer<java.lang.reflect.Method-> consumer = (m) -> {
    try {
        m.invoke(o, args);
    } catch (Throwable t) {
        throw Failable.rethrow(t);
    }
};

 By replacing a Consumer<O> with a 
FailableConsumer<O,? extends Throwable>, this can be written like follows: 
Functions.accept((m) -> m.invoke(o, args));


Obviously, the second version is much more concise and the spirit of Lambda expressions is met better than the second
version.

Since:
3.11/**
 * This class provides utility functions, and classes for working with the {@code java.util.function} package, or more
 * generally, with Java 8 lambdas. More specifically, it attempts to address the fact that lambdas are supposed not to
 * throw Exceptions, at least not checked Exceptions, AKA instances of {@link Exception}. This enforces the use of
 * constructs like:
 *
 * <pre>
 * Consumer&lt;java.lang.reflect.Method-&gt; consumer = (m) -&gt; {
 *     try {
 *         m.invoke(o, args);
 *     } catch (Throwable t) {
 *         throw Failable.rethrow(t);
 *     }
 * };
 * </pre>
 *
 * <p>
 * By replacing a {@link java.util.function.Consumer Consumer&lt;O&gt;} with a {@link FailableConsumer
 * FailableConsumer&lt;O,? extends Throwable&gt;}, this can be written like follows:
 * </p>
 *
 * <pre>
 * Functions.accept((m) -&gt; m.invoke(o, args));
 * </pre>
 *
 * <p>
 * Obviously, the second version is much more concise and the spirit of Lambda expressions is met better than the second
 * version.
 * </p>
 *
 * @since 3.11
 */
public class Failable {

    
Consumes a consumer and rethrows any exception as a RuntimeException. 
Params:
consumer – the consumer to consume
object1 – the first object to consume by consumer
object2 – the second object to consume by consumer
Type parameters:
<T> – the type of the first argument the consumer accepts
<U> – the type of the second argument the consumer accepts
<E> – the type of checked exception the consumer may throw/**
     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
     *
     * @param consumer the consumer to consume
     * @param object1 the first object to consume by {@code consumer}
     * @param object2 the second object to consume by {@code consumer}
     * @param <T> the type of the first argument the consumer accepts
     * @param <U> the type of the second argument the consumer accepts
     * @param <E> the type of checked exception the consumer may throw
     */
    public static <T, U, E extends Throwable> void accept(final FailableBiConsumer<T, U, E> consumer, final T object1,
        final U object2) {
        run(() -> consumer.accept(object1, object2));
    }

    
Consumes a consumer and rethrows any exception as a RuntimeException. 
Params:
consumer – the consumer to consume
object – the object to consume by consumer
Type parameters:
<T> – the type the consumer accepts
<E> – the type of checked exception the consumer may throw/**
     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
     *
     * @param consumer the consumer to consume
     * @param object the object to consume by {@code consumer}
     * @param <T> the type the consumer accepts
     * @param <E> the type of checked exception the consumer may throw
     */
    public static <T, E extends Throwable> void accept(final FailableConsumer<T, E> consumer, final T object) {
        run(() -> consumer.accept(object));
    }

    
Consumes a consumer and rethrows any exception as a RuntimeException. 
Params:
consumer – the consumer to consume
value – the value to consume by consumer
Type parameters:
<E> – the type of checked exception the consumer may throw/**
     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
     *
     * @param consumer the consumer to consume
     * @param value the value to consume by {@code consumer}
     * @param <E> the type of checked exception the consumer may throw
     */
    public static <E extends Throwable> void accept(final FailableDoubleConsumer<E> consumer, final double value) {
        run(() -> consumer.accept(value));
    }

    
Consumes a consumer and rethrows any exception as a RuntimeException. 
Params:
consumer – the consumer to consume
value – the value to consume by consumer
Type parameters:
<E> – the type of checked exception the consumer may throw/**
     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
     *
     * @param consumer the consumer to consume
     * @param value the value to consume by {@code consumer}
     * @param <E> the type of checked exception the consumer may throw
     */
    public static <E extends Throwable> void accept(final FailableIntConsumer<E> consumer, final int value) {
        run(() -> consumer.accept(value));
    }

    
Consumes a consumer and rethrows any exception as a RuntimeException. 
Params:
consumer – the consumer to consume
value – the value to consume by consumer
Type parameters:
<E> – the type of checked exception the consumer may throw/**
     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
     *
     * @param consumer the consumer to consume
     * @param value the value to consume by {@code consumer}
     * @param <E> the type of checked exception the consumer may throw
     */
    public static <E extends Throwable> void accept(final FailableLongConsumer<E> consumer, final long value) {
        run(() -> consumer.accept(value));
    }

    
Applies a function and rethrows any exception as a RuntimeException. 
Params:
function – the function to apply
input1 – the first input to apply function on
input2 – the second input to apply function on
Type parameters:
<T> – the type of the first argument the function accepts
<U> – the type of the second argument the function accepts
<R> – the return type of the function
<E> – the type of checked exception the function may throw
Returns:
the value returned from the function/**
     * Applies a function and rethrows any exception as a {@link RuntimeException}.
     *
     * @param function the function to apply
     * @param input1 the first input to apply {@code function} on
     * @param input2 the second input to apply {@code function} on
     * @param <T> the type of the first argument the function accepts
     * @param <U> the type of the second argument the function accepts
     * @param <R> the return type of the function
     * @param <E> the type of checked exception the function may throw
     * @return the value returned from the function
     */
    public static <T, U, R, E extends Throwable> R apply(final FailableBiFunction<T, U, R, E> function, final T input1,
        final U input2) {
        return get(() -> function.apply(input1, input2));
    }

    
Applies a function and rethrows any exception as a RuntimeException. 
Params:
function – the function to apply
input – the input to apply function on
Type parameters:
<T> – the type of the argument the function accepts
<R> – the return type of the function
<E> – the type of checked exception the function may throw
Returns:
the value returned from the function/**
     * Applies a function and rethrows any exception as a {@link RuntimeException}.
     *
     * @param function the function to apply
     * @param input the input to apply {@code function} on
     * @param <T> the type of the argument the function accepts
     * @param <R> the return type of the function
     * @param <E> the type of checked exception the function may throw
     * @return the value returned from the function
     */
    public static <T, R, E extends Throwable> R apply(final FailableFunction<T, R, E> function, final T input) {
        return get(() -> function.apply(input));
    }

    
Applies a function and rethrows any exception as a RuntimeException. 
Params:
function – the function to apply
left – the first input to apply function on
right – the second input to apply function on
Type parameters:
<E> – the type of checked exception the function may throw
Returns:
the value returned from the function/**
     * Applies a function and rethrows any exception as a {@link RuntimeException}.
     *
     * @param function the function to apply
     * @param left the first input to apply {@code function} on
     * @param right the second input to apply {@code function} on
     * @param <E> the type of checked exception the function may throw
     * @return the value returned from the function
     */
    public static <E extends Throwable> double applyAsDouble(final FailableDoubleBinaryOperator<E> function,
        final double left, final double right) {
        return getAsDouble(() -> function.applyAsDouble(left, right));
    }

    
Converts the given FailableBiConsumer into a standard BiConsumer. 
Params:
consumer – a failable BiConsumer
Type parameters:
<T> – the type of the first argument of the consumers
<U> – the type of the second argument of the consumers
Returns:
a standard BiConsumer/**
     * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}.
     *
     * @param <T> the type of the first argument of the consumers
     * @param <U> the type of the second argument of the consumers
     * @param consumer a failable {@code BiConsumer}
     * @return a standard {@code BiConsumer}
     */
    public static <T, U> BiConsumer<T, U> asBiConsumer(final FailableBiConsumer<T, U, ?> consumer) {
        return (input1, input2) -> accept(consumer, input1, input2);
    }

    
Converts the given FailableBiFunction into a standard BiFunction. 
Params:
function – a FailableBiFunction
Type parameters:
<T> – the type of the first argument of the input of the functions
<U> – the type of the second argument of the input of the functions
<R> – the type of the output of the functions
Returns:
a standard BiFunction/**
     * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}.
     *
     * @param <T> the type of the first argument of the input of the functions
     * @param <U> the type of the second argument of the input of the functions
     * @param <R> the type of the output of the functions
     * @param function a {@code FailableBiFunction}
     * @return a standard {@code BiFunction}
     */
    public static <T, U, R> BiFunction<T, U, R> asBiFunction(final FailableBiFunction<T, U, R, ?> function) {
        return (input1, input2) -> apply(function, input1, input2);
    }

    
Converts the given FailableBiPredicate into a standard BiPredicate. 
Params:
predicate – a FailableBiPredicate
Type parameters:
<T> – the type of the first argument used by the predicates
<U> – the type of the second argument used by the predicates
Returns:
a standard BiPredicate/**
     * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}.
     *
     * @param <T> the type of the first argument used by the predicates
     * @param <U> the type of the second argument used by the predicates
     * @param predicate a {@code FailableBiPredicate}
     * @return a standard {@code BiPredicate}
     */
    public static <T, U> BiPredicate<T, U> asBiPredicate(final FailableBiPredicate<T, U, ?> predicate) {
        return (input1, input2) -> test(predicate, input1, input2);
    }

    
Converts the given FailableCallable into a standard Callable. 
Params:
callable – a FailableCallable
Type parameters:
<V> – the type used by the callables
Returns:
a standard Callable/**
     * Converts the given {@link FailableCallable} into a standard {@link Callable}.
     *
     * @param <V> the type used by the callables
     * @param callable a {@code FailableCallable}
     * @return a standard {@code Callable}
     */
    public static <V> Callable<V> asCallable(final FailableCallable<V, ?> callable) {
        return () -> call(callable);
    }

    
Converts the given FailableConsumer into a standard Consumer. 
Params:
consumer – a FailableConsumer
Type parameters:
<T> – the type used by the consumers
Returns:
a standard Consumer/**
     * Converts the given {@link FailableConsumer} into a standard {@link Consumer}.
     *
     * @param <T> the type used by the consumers
     * @param consumer a {@code FailableConsumer}
     * @return a standard {@code Consumer}
     */
    public static <T> Consumer<T> asConsumer(final FailableConsumer<T, ?> consumer) {
        return input -> accept(consumer, input);
    }

    
Converts the given FailableFunction into a standard Function. 
Params:
function – a {code FailableFunction}
Type parameters:
<T> – the type of the input of the functions
<R> – the type of the output of the functions
Returns:
a standard Function/**
     * Converts the given {@link FailableFunction} into a standard {@link Function}.
     *
     * @param <T> the type of the input of the functions
     * @param <R> the type of the output of the functions
     * @param function a {code FailableFunction}
     * @return a standard {@code Function}
     */
    public static <T, R> Function<T, R> asFunction(final FailableFunction<T, R, ?> function) {
        return input -> apply(function, input);
    }

    
Converts the given FailablePredicate into a standard Predicate. 
Params:
predicate – a FailablePredicate
Type parameters:
<T> – the type used by the predicates
Returns:
a standard Predicate/**
     * Converts the given {@link FailablePredicate} into a standard {@link Predicate}.
     *
     * @param <T> the type used by the predicates
     * @param predicate a {@code FailablePredicate}
     * @return a standard {@code Predicate}
     */
    public static <T> Predicate<T> asPredicate(final FailablePredicate<T, ?> predicate) {
        return input -> test(predicate, input);
    }

    
Converts the given FailableRunnable into a standard Runnable. 
Params:
runnable – a FailableRunnable
Returns:
a standard Runnable/**
     * Converts the given {@link FailableRunnable} into a standard {@link Runnable}.
     *
     * @param runnable a {@code FailableRunnable}
     * @return a standard {@code Runnable}
     */
    public static Runnable asRunnable(final FailableRunnable<?> runnable) {
        return () -> run(runnable);
    }

    
Converts the given FailableSupplier into a standard Supplier. 
Params:
supplier – a FailableSupplier
Type parameters:
<T> – the type supplied by the suppliers
Returns:
a standard Supplier/**
     * Converts the given {@link FailableSupplier} into a standard {@link Supplier}.
     *
     * @param <T> the type supplied by the suppliers
     * @param supplier a {@code FailableSupplier}
     * @return a standard {@code Supplier}
     */
    public static <T> Supplier<T> asSupplier(final FailableSupplier<T, ?> supplier) {
        return () -> get(supplier);
    }

    
Calls a callable and rethrows any exception as a RuntimeException. 
Params:
callable – the callable to call
Type parameters:
<V> – the return type of the callable
<E> – the type of checked exception the callable may throw
Returns:
the value returned from the callable/**
     * Calls a callable and rethrows any exception as a {@link RuntimeException}.
     *
     * @param callable the callable to call
     * @param <V> the return type of the callable
     * @param <E> the type of checked exception the callable may throw
     * @return the value returned from the callable
     */
    public static <V, E extends Throwable> V call(final FailableCallable<V, E> callable) {
        return get(callable::call);
    }

    
Invokes a supplier, and returns the result.
Params:
supplier – The supplier to invoke.
Type parameters:
<T> – The suppliers output type.
<E> – The type of checked exception, which the supplier can throw.
Returns:
The object, which has been created by the supplier/**
     * Invokes a supplier, and returns the result.
     *
     * @param supplier The supplier to invoke.
     * @param <T> The suppliers output type.
     * @param <E> The type of checked exception, which the supplier can throw.
     * @return The object, which has been created by the supplier
     */
    public static <T, E extends Throwable> T get(final FailableSupplier<T, E> supplier) {
        try {
            return supplier.get();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
Invokes a boolean supplier, and returns the result.
Params:
supplier – The boolean supplier to invoke.
Type parameters:
<E> – The type of checked exception, which the supplier can throw.
Returns:
The boolean, which has been created by the supplier/**
     * Invokes a boolean supplier, and returns the result.
     *
     * @param supplier The boolean supplier to invoke.
     * @param <E> The type of checked exception, which the supplier can throw.
     * @return The boolean, which has been created by the supplier
     */
    public static <E extends Throwable> boolean getAsBoolean(final FailableBooleanSupplier<E> supplier) {
        try {
            return supplier.getAsBoolean();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
Invokes a double supplier, and returns the result.
Params:
supplier – The double supplier to invoke.
Type parameters:
<E> – The type of checked exception, which the supplier can throw.
Returns:
The boolean, which has been created by the supplier/**
     * Invokes a double supplier, and returns the result.
     *
     * @param supplier The double supplier to invoke.
     * @param <E> The type of checked exception, which the supplier can throw.
     * @return The boolean, which has been created by the supplier
     */
    public static <E extends Throwable> double getAsDouble(final FailableDoubleSupplier<E> supplier) {
        try {
            return supplier.getAsDouble();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
Invokes an int supplier, and returns the result.
Params:
supplier – The int supplier to invoke.
Type parameters:
<E> – The type of checked exception, which the supplier can throw.
Returns:
The boolean, which has been created by the supplier/**
     * Invokes an int supplier, and returns the result.
     *
     * @param supplier The int supplier to invoke.
     * @param <E> The type of checked exception, which the supplier can throw.
     * @return The boolean, which has been created by the supplier
     */
    public static <E extends Throwable> int getAsInt(final FailableIntSupplier<E> supplier) {
        try {
            return supplier.getAsInt();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
Invokes a long supplier, and returns the result.
Params:
supplier – The long supplier to invoke.
Type parameters:
<E> – The type of checked exception, which the supplier can throw.
Returns:
The boolean, which has been created by the supplier/**
     * Invokes a long supplier, and returns the result.
     *
     * @param supplier The long supplier to invoke.
     * @param <E> The type of checked exception, which the supplier can throw.
     * @return The boolean, which has been created by the supplier
     */
    public static <E extends Throwable> long getAsLong(final FailableLongSupplier<E> supplier) {
        try {
            return supplier.getAsLong();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
 Rethrows a Throwable as an unchecked exception. If the argument is already unchecked, namely a RuntimeException or Error then the argument will be rethrown without modification. If the exception is IOException then it will be wrapped into a UncheckedIOException. In every other cases the exception will be wrapped into a 
UndeclaredThrowableException 

Note that there is a declared return type for this method, even though it never returns. The reason for that is
to support the usual pattern:

throw rethrow(myUncheckedException);

 instead of just calling the method. This pattern may help the Java compiler to recognize that at that point an exception will be thrown and the code flow analysis will not demand otherwise mandatory commands that could follow the method call, like a return statement from a value returning method. 
Params:
throwable – The throwable to rethrow ossibly wrapped into an unchecked exception
Returns:
Never returns anything, this method never terminates normally./**
     * <p>
     * Rethrows a {@link Throwable} as an unchecked exception. If the argument is already unchecked, namely a
     * {@code RuntimeException} or {@code Error} then the argument will be rethrown without modification. If the
     * exception is {@code IOException} then it will be wrapped into a {@code UncheckedIOException}. In every other
     * cases the exception will be wrapped into a {@code
     * UndeclaredThrowableException}
     * </p>
     *
     * <p>
     * Note that there is a declared return type for this method, even though it never returns. The reason for that is
     * to support the usual pattern:
     * </p>
     *
     * <pre>
     * throw rethrow(myUncheckedException);
     * </pre>
     *
     * <p>
     * instead of just calling the method. This pattern may help the Java compiler to recognize that at that point an
     * exception will be thrown and the code flow analysis will not demand otherwise mandatory commands that could
     * follow the method call, like a {@code return} statement from a value returning method.
     * </p>
     *
     * @param throwable The throwable to rethrow ossibly wrapped into an unchecked exception
     * @return Never returns anything, this method never terminates normally.
     */
    public static RuntimeException rethrow(final Throwable throwable) {
        Objects.requireNonNull(throwable, "throwable");
        if (throwable instanceof RuntimeException) {
            throw (RuntimeException) throwable;
        } else if (throwable instanceof Error) {
            throw (Error) throwable;
        } else if (throwable instanceof IOException) {
            throw new UncheckedIOException((IOException) throwable);
        } else {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    
Runs a runnable and rethrows any exception as a RuntimeException. 
Params:
runnable – The runnable to run
Type parameters:
<E> – the type of checked exception the runnable may throw/**
     * Runs a runnable and rethrows any exception as a {@link RuntimeException}.
     *
     * @param runnable The runnable to run
     * @param <E> the type of checked exception the runnable may throw
     */
    public static <E extends Throwable> void run(final FailableRunnable<E> runnable) {
        try {
            runnable.run();
        } catch (final Throwable t) {
            throw rethrow(t);
        }
    }

    
Converts the given collection into a FailableStream. The FailableStream consists of the collections elements. Shortcut for 
Functions.stream(collection.stream());

Params:
collection – The collection, which is being converted into a FailableStream.
Type parameters:
<E> – The collections element type. (In turn, the result streams element type.)
Returns:
The created FailableStream./**
     * Converts the given collection into a {@link FailableStream}. The {@link FailableStream} consists of the
     * collections elements. Shortcut for
     *
     * <pre>
     * Functions.stream(collection.stream());
     * </pre>
     *
     * @param collection The collection, which is being converted into a {@link FailableStream}.
     * @param <E> The collections element type. (In turn, the result streams element type.)
     * @return The created {@link FailableStream}.
     */
    public static <E> FailableStream<E> stream(final Collection<E> collection) {
        return new FailableStream<>(collection.stream());
    }

    
Converts the given stream into a FailableStream. The FailableStream consists of the same elements, than the input stream. However, failable lambdas, like FailablePredicate, FailableFunction, and FailableConsumer may be applied, rather than Predicate, Function, Consumer, etc. 
Params:
stream – The stream, which is being converted into a FailableStream.
Type parameters:
<T> – The streams element type.
Returns:
The created FailableStream./**
     * Converts the given stream into a {@link FailableStream}. The {@link FailableStream} consists of the same
     * elements, than the input stream. However, failable lambdas, like {@link FailablePredicate},
     * {@link FailableFunction}, and {@link FailableConsumer} may be applied, rather than {@link Predicate},
     * {@link Function}, {@link Consumer}, etc.
     *
     * @param stream The stream, which is being converted into a {@link FailableStream}.
     * @param <T> The streams element type.
     * @return The created {@link FailableStream}.
     */
    public static <T> FailableStream<T> stream(final Stream<T> stream) {
        return new FailableStream<>(stream);
    }

    
Tests a predicate and rethrows any exception as a RuntimeException. 
Params:
predicate – the predicate to test
object1 – the first input to test by predicate
object2 – the second input to test by predicate
Type parameters:
<T> – the type of the first argument the predicate tests
<U> – the type of the second argument the predicate tests
<E> – the type of checked exception the predicate may throw
Returns:
the boolean value returned by the predicate/**
     * Tests a predicate and rethrows any exception as a {@link RuntimeException}.
     *
     * @param predicate the predicate to test
     * @param object1 the first input to test by {@code predicate}
     * @param object2 the second input to test by {@code predicate}
     * @param <T> the type of the first argument the predicate tests
     * @param <U> the type of the second argument the predicate tests
     * @param <E> the type of checked exception the predicate may throw
     * @return the boolean value returned by the predicate
     */
    public static <T, U, E extends Throwable> boolean test(final FailableBiPredicate<T, U, E> predicate,
        final T object1, final U object2) {
        return getAsBoolean(() -> predicate.test(object1, object2));
    }

    
Tests a predicate and rethrows any exception as a RuntimeException. 
Params:
predicate – the predicate to test
object – the input to test by predicate
Type parameters:
<T> – the type of argument the predicate tests
<E> – the type of checked exception the predicate may throw
Returns:
the boolean value returned by the predicate/**
     * Tests a predicate and rethrows any exception as a {@link RuntimeException}.
     *
     * @param predicate the predicate to test
     * @param object the input to test by {@code predicate}
     * @param <T> the type of argument the predicate tests
     * @param <E> the type of checked exception the predicate may throw
     * @return the boolean value returned by the predicate
     */
    public static <T, E extends Throwable> boolean test(final FailablePredicate<T, E> predicate, final T object) {
        return getAsBoolean(() -> predicate.test(object));
    }

    
A simple try-with-resources implementation, that can be used, if your objects do not implement the AutoCloseable interface. The method executes the action. The method guarantees, that all the resources are being executed, in the given order, afterwards, and regardless of success, or failure. If either the original action, or any of the resource action fails, then the first failure (AKA Throwable is rethrown. Example use: 
final FileInputStream fis = new FileInputStream("my.file");
Functions.tryWithResources(useInputStream(fis), null, () -> fis.close());

Params:
action – The action to execute. This object will always be invoked.
errorHandler – An optional error handler, which will be invoked finally, if any error occurred. The error handler will receive the first error, AKA Throwable.
resources – The resource actions to execute. All resource actions will be invoked, in the given order. A resource action is an instance of FailableRunnable, which will be executed.
See Also:
tryWithResources(FailableRunnable<? extends Throwable>, FailableRunnable<? extends Throwable>...)/**
     * A simple try-with-resources implementation, that can be used, if your objects do not implement the
     * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em>
     * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure.
     * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA
     * {@link Throwable} is rethrown. Example use:
     *
     * <pre>
     * final FileInputStream fis = new FileInputStream("my.file");
     * Functions.tryWithResources(useInputStream(fis), null, () -&gt; fis.close());
     * </pre>
     *
     * @param action The action to execute. This object <em>will</em> always be invoked.
     * @param errorHandler An optional error handler, which will be invoked finally, if any error occurred. The error
     *        handler will receive the first error, AKA {@link Throwable}.
     * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given
     *        order. A resource action is an instance of {@link FailableRunnable}, which will be executed.
     * @see #tryWithResources(FailableRunnable, FailableRunnable...)
     */
    @SafeVarargs
    public static void tryWithResources(final FailableRunnable<? extends Throwable> action,
        final FailableConsumer<Throwable, ? extends Throwable> errorHandler,
        final FailableRunnable<? extends Throwable>... resources) {
        final FailableConsumer<Throwable, ? extends Throwable> actualErrorHandler;
        if (errorHandler == null) {
            actualErrorHandler = Failable::rethrow;
        } else {
            actualErrorHandler = errorHandler;
        }
        if (resources != null) {
            for (final FailableRunnable<? extends Throwable> failableRunnable : resources) {
                Objects.requireNonNull(failableRunnable, "runnable");
            }
        }
        Throwable th = null;
        try {
            action.run();
        } catch (final Throwable t) {
            th = t;
        }
        if (resources != null) {
            for (final FailableRunnable<?> runnable : resources) {
                try {
                    runnable.run();
                } catch (final Throwable t) {
                    if (th == null) {
                        th = t;
                    }
                }
            }
        }
        if (th != null) {
            try {
                actualErrorHandler.accept(th);
            } catch (final Throwable t) {
                throw rethrow(t);
            }
        }
    }

    
A simple try-with-resources implementation, that can be used, if your objects do not implement the AutoCloseable interface. The method executes the action. The method guarantees, that all the resources are being executed, in the given order, afterwards, and regardless of success, or failure. If either the original action, or any of the resource action fails, then the first failure (AKA Throwable is rethrown. Example use: 
final FileInputStream fis = new FileInputStream("my.file");
Functions.tryWithResources(useInputStream(fis), () -> fis.close());

Params:
action – The action to execute. This object will always be invoked.
resources – The resource actions to execute. All resource actions will be invoked, in the given order. A resource action is an instance of FailableRunnable, which will be executed.
See Also:
tryWithResources(FailableRunnable<? extends Throwable>, FailableConsumer<Throwable,? extends Throwable>, FailableRunnable<? extends Throwable>...)/**
     * A simple try-with-resources implementation, that can be used, if your objects do not implement the
     * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em>
     * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure.
     * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA
     * {@link Throwable} is rethrown. Example use:
     *
     * <pre>
     * final FileInputStream fis = new FileInputStream("my.file");
     * Functions.tryWithResources(useInputStream(fis), () -&gt; fis.close());
     * </pre>
     *
     * @param action The action to execute. This object <em>will</em> always be invoked.
     * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given
     *        order. A resource action is an instance of {@link FailableRunnable}, which will be executed.
     * @see #tryWithResources(FailableRunnable, FailableConsumer, FailableRunnable...)
     */
    @SafeVarargs
    public static void tryWithResources(final FailableRunnable<? extends Throwable> action,
        final FailableRunnable<? extends Throwable>... resources) {
        tryWithResources(action, null, resources);
    }

    private Failable() {
        // empty
    }

}