Package org.apache.commons.lang3.function

# Class Failable

java.lang.Object
org.apache.commons.lang3.function.Failable

public class Failable extends Object
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, like instances of `Exception`. This enforces the use of constructs like:

     Consumer<java.lang.reflect.Method> consumer = m -&gt; {
         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

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <T, U, E extends Throwable>
  void`
  `accept(FailableBiConsumer<T,U,E> consumer, T object1, U object2)`
  Consumes a consumer and rethrows any exception as a `RuntimeException`.
  `static <T, E extends Throwable>
  void`
  `accept(FailableConsumer<T,E> consumer, T object)`
  Consumes a consumer and rethrows any exception as a `RuntimeException`.
  `static <E extends Throwable>
  void`
  `accept(FailableDoubleConsumer<E> consumer, double value)`
  Consumes a consumer and rethrows any exception as a `RuntimeException`.
  `static <E extends Throwable>
  void`
  `accept(FailableIntConsumer<E> consumer, int value)`
  Consumes a consumer and rethrows any exception as a `RuntimeException`.
  `static <E extends Throwable>
  void`
  `accept(FailableLongConsumer<E> consumer, long value)`
  Consumes a consumer and rethrows any exception as a `RuntimeException`.
  `static <T, U, R, E extends Throwable>
  R`
  `apply(FailableBiFunction<T,U,R,E> function, T input1, U input2)`
  Applies a function and rethrows any exception as a `RuntimeException`.
  `static <T, R, E extends Throwable>
  R`
  `apply(FailableFunction<T,R,E> function, T input)`
  Applies a function and rethrows any exception as a `RuntimeException`.
  `static <E extends Throwable>
  double`
  `applyAsDouble(FailableDoubleBinaryOperator<E> function, double left, double right)`
  Applies a function and rethrows any exception as a `RuntimeException`.
  `static <T, R, E extends Throwable>
  R`
  `applyNonNull(T value, FailableFunction<? super T,? extends R,E> mapper)`
  Applies a value to a function if the value isn't `null`, otherwise the method returns `null`.
  `static <T, U, R, E1 extends Throwable, E2 extends Throwable>
  R`
  `applyNonNull(T value1, FailableFunction<? super T,? extends U,E1> mapper1, FailableFunction<? super U,? extends R,E2> mapper2)`
  Applies values to a chain of functions, where a `null` can short-circuit each step.
  `static <T, U, V, R, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable>
  R`
  `applyNonNull(T value1, FailableFunction<? super T,? extends U,E1> mapper1, FailableFunction<? super U,? extends V,E2> mapper2, FailableFunction<? super V,? extends R,E3> mapper3)`
  Applies values to a chain of functions, where a `null` can short-circuit each step.
  `static <T, U> BiConsumer<T,U>`
  `asBiConsumer(FailableBiConsumer<T,U,?> consumer)`
  Converts the given `FailableBiConsumer` into a standard `BiConsumer`.
  `static <T, U, R> BiFunction<T,U,R>`
  `asBiFunction(FailableBiFunction<T,U,R,?> function)`
  Converts the given `FailableBiFunction` into a standard `BiFunction`.
  `static <T, U> BiPredicate<T,U>`
  `asBiPredicate(FailableBiPredicate<T,U,?> predicate)`
  Converts the given `FailableBiPredicate` into a standard `BiPredicate`.
  `static <V> Callable<V>`
  `asCallable(FailableCallable<V,?> callable)`
  Converts the given `FailableCallable` into a standard `Callable`.
  `static <T> Consumer<T>`
  `asConsumer(FailableConsumer<T,?> consumer)`
  Converts the given `FailableConsumer` into a standard `Consumer`.
  `static <T, R> Function<T,R>`
  `asFunction(FailableFunction<T,R,?> function)`
  Converts the given `FailableFunction` into a standard `Function`.
  `static <T> Predicate<T>`
  `asPredicate(FailablePredicate<T,?> predicate)`
  Converts the given `FailablePredicate` into a standard `Predicate`.
  `static Runnable`
  `asRunnable(FailableRunnable<?> runnable)`
  Converts the given `FailableRunnable` into a standard `Runnable`.
  `static <T> Supplier<T>`
  `asSupplier(FailableSupplier<T,?> supplier)`
  Converts the given `FailableSupplier` into a standard `Supplier`.
  `static <V, E extends Throwable>
  V`
  `call(FailableCallable<V,E> callable)`
  Calls a callable and rethrows any exception as a `RuntimeException`.
  `static <T, E extends Throwable>
  T`
  `get(FailableSupplier<T,E> supplier)`
  Invokes a supplier, and returns the result.
  `static <E extends Throwable>
  boolean`
  `getAsBoolean(FailableBooleanSupplier<E> supplier)`
  Invokes a boolean supplier, and returns the result.
  `static <E extends Throwable>
  double`
  `getAsDouble(FailableDoubleSupplier<E> supplier)`
  Invokes a double supplier, and returns the result.
  `static <E extends Throwable>
  int`
  `getAsInt(FailableIntSupplier<E> supplier)`
  Invokes an int supplier, and returns the result.
  `static <E extends Throwable>
  long`
  `getAsLong(FailableLongSupplier<E> supplier)`
  Invokes a long supplier, and returns the result.
  `static <E extends Throwable>
  short`
  `getAsShort(FailableShortSupplier<E> supplier)`
  Invokes a short supplier, and returns the result.
  `static RuntimeException`
  `rethrow(Throwable throwable)`
  Rethrows a `Throwable` as an unchecked exception.
  `static <E extends Throwable>
  void`
  `run(FailableRunnable<E> runnable)`
  Runs a runnable and rethrows any exception as a `RuntimeException`.
  `static <E> Streams.FailableStream<E>`
  `stream(Collection<E> collection)`
  Converts the given collection into a `Streams.FailableStream`.
  `static <T> Streams.FailableStream<T>`
  `stream(Stream<T> stream)`
  Converts the given stream into a `Streams.FailableStream`.
  `static <T, U, E extends Throwable>
  boolean`
  `test(FailableBiPredicate<T,U,E> predicate, T object1, U object2)`
  Tests a predicate and rethrows any exception as a `RuntimeException`.
  `static <T, E extends Throwable>
  boolean`
  `test(FailablePredicate<T,E> predicate, T object)`
  Tests a predicate and rethrows any exception as a `RuntimeException`.
  `static void`
  `tryWithResources(FailableRunnable<? extends Throwable> action, FailableConsumer<Throwable,? extends Throwable> errorHandler, FailableRunnable<? extends Throwable>... resources)`
  A simple try-with-resources implementation, that can be used, if your objects do not implement the `AutoCloseable` interface.
  `static void`
  `tryWithResources(FailableRunnable<? extends Throwable> action, FailableRunnable<? extends Throwable>... resources)`
  A simple try-with-resources implementation, that can be used, if your objects do not implement the `AutoCloseable` interface.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Method Details

  - ### accept

    public static <T, U, E extends Throwable> void accept(FailableBiConsumer<T,U,E> consumer, T object1, U object2)
    Consumes a consumer and rethrows any exception as a `RuntimeException`.
    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
    Parameters:
      `consumer` - the consumer to accept, may be null for a noop.
      `object1` - the first object to consume by `consumer`
      `object2` - the second object to consume by `consumer`

  - ### accept

    public static <T, E extends Throwable> void accept(FailableConsumer<T,E> consumer, T object)
    Consumes a consumer and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `T` - the type the consumer accepts
      `E` - the type of checked exception the consumer may throw
    Parameters:
      `consumer` - the consumer to accept, may be null for a noop.
      `object` - the object to consume by `consumer`

  - ### accept

    public static <E extends Throwable> void accept(FailableDoubleConsumer<E> consumer, double value)
    Consumes a consumer and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `E` - the type of checked exception the consumer may throw
    Parameters:
      `consumer` - the consumer to accept, may be null for a noop.
      `value` - the value to consume by `consumer`

  - ### accept

    public static <E extends Throwable> void accept(FailableIntConsumer<E> consumer, int value)
    Consumes a consumer and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `E` - the type of checked exception the consumer may throw
    Parameters:
      `consumer` - the consumer to accept, may be null for a noop.
      `value` - the value to consume by `consumer`

  - ### accept

    public static <E extends Throwable> void accept(FailableLongConsumer<E> consumer, long value)
    Consumes a consumer and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `E` - the type of checked exception the consumer may throw
    Parameters:
      `consumer` - the consumer to accept, may be null for a noop.
      `value` - the value to consume by `consumer`

  - ### apply

    public static <T, U, R, E extends Throwable> R apply(FailableBiFunction<T,U,R,E> function, T input1, U input2)
    Applies a function and rethrows any exception as a `RuntimeException`.
    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
    Parameters:
      `function` - the function to apply
      `input1` - the first input to apply `function` on
      `input2` - the second input to apply `function` on
    Returns:
      the value returned from the function

  - ### apply

    public static <T, R, E extends Throwable> R apply(FailableFunction<T,R,E> function, T input)
    Applies a function and rethrows any exception as a `RuntimeException`.
    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
    Parameters:
      `function` - the function to apply
      `input` - the input to apply `function` on
    Returns:
      the value returned from the function

  - ### applyAsDouble

    public static <E extends Throwable> double applyAsDouble(FailableDoubleBinaryOperator<E> function, double left, double right)
    Applies a function and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `E` - the type of checked exception the function may throw
    Parameters:
      `function` - the function to apply
      `left` - the first input to apply `function` on
      `right` - the second input to apply `function` on
    Returns:
      the value returned from the function

  - ### applyNonNull

    public static <T, R, E extends Throwable> R applyNonNull(T value, FailableFunction<? super T,? extends R,E> mapper) throws E
    Applies a value to a function if the value isn't `null`, otherwise the method returns `null`. If the value isn't `null` then return the result of the applying function.

         Failable.applyNonNull("a", String::toUpperCase)  = "A"
         Failable.applyNonNull(null, String::toUpperCase) = null
         Failable.applyNonNull("a", s -> null)            = null

    Useful when working with expressions that may return `null` as it allows a single-line expression without using temporary local variables or evaluating expressions twice. Provides an alternative to using `Optional` that is shorter and has less allocation.

    Type Parameters:
      `T` - The type of the input of this method and the function.
      `R` - The type of the result of the function and this method.
      `E` - The type of thrown exception or error.
    Parameters:
      `value` - The value to apply the function to, may be `null`.
      `mapper` - The function to apply, must not be `null`.
    Returns:
      The result of the function (which may be `null`) or `null` if the input value is `null`.
    Throws:
      `E` - Thrown by the given function.
    Since:
      3.19.0
    See Also:
      - `applyNonNull(Object, FailableFunction, FailableFunction)`
      - `applyNonNull(Object, FailableFunction, FailableFunction, FailableFunction)`

  - ### applyNonNull

    public static <T, U, R, E1 extends Throwable, E2 extends Throwable> R applyNonNull(T value1, FailableFunction<? super T,? extends U,E1> mapper1, FailableFunction<? super U,? extends R,E2> mapper2) throws E1, E2
    Applies values to a chain of functions, where a `null` can short-circuit each step. A function is only applied if the previous value is not `null`, otherwise this method returns `null`.

         Failable.applyNonNull(" a ", String::toUpperCase, String::trim) = "A"
         Failable.applyNonNull(null, String::toUpperCase, String::trim)  = null
         Failable.applyNonNull(" a ", s -> null, String::trim)           = null
         Failable.applyNonNull(" a ", String::toUpperCase, s -> null)    = null

    Useful when working with expressions that may return `null` as it allows a single-line expression without using temporary local variables or evaluating expressions twice. Provides an alternative to using `Optional` that is shorter and has less allocation.

    Type Parameters:
      `T` - The type of the input of this method and the first function.
      `U` - The type of the result of the first function and the input to the second function.
      `R` - The type of the result of the second function and this method.
      `E1` - The type of thrown exception or error by the first function.
      `E2` - The type of thrown exception or error by the second function.
    Parameters:
      `value1` - The value to apply the functions to, may be `null`.
      `mapper1` - The first function to apply, must not be `null`.
      `mapper2` - The second function to apply, must not be `null`.
    Returns:
      The result of the final function (which may be `null`) or `null` if the input value or any intermediate value is `null`.
    Throws:
      `E1` - Thrown by the first function.
      `E2` - Thrown by the second function.
    Since:
      3.19.0
    See Also:
      - `applyNonNull(Object, FailableFunction)`
      - `applyNonNull(Object, FailableFunction, FailableFunction, FailableFunction)`

  - ### applyNonNull

    public static <T, U, V, R, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> R applyNonNull(T value1, FailableFunction<? super T,? extends U,E1> mapper1, FailableFunction<? super U,? extends V,E2> mapper2, FailableFunction<? super V,? extends R,E3> mapper3) throws E1, E2, E3
    Applies values to a chain of functions, where a `null` can short-circuit each step. A function is only applied if the previous value is not `null`, otherwise this method returns `null`.

         Failable.applyNonNull(" abc ", String::toUpperCase, String::trim, StringUtils::reverse) = "CBA"
         Failable.applyNonNull(null, String::toUpperCase, String::trim, StringUtils::reverse)    = null
         Failable.applyNonNull(" abc ", s -> null, String::trim, StringUtils::reverse)           = null
         Failable.applyNonNull(" abc ", String::toUpperCase, s -> null, StringUtils::reverse)    = null
         Failable.applyNonNull(" abc ", String::toUpperCase, String::trim, s -> null)            = null

    Useful when working with expressions that may return `null` as it allows a single-line expression without using temporary local variables or evaluating expressions twice. Provides an alternative to using `Optional` that is shorter and has less allocation.

    Type Parameters:
      `T` - The type of the input of this method and the first function.
      `U` - The type of the result of the first function and the input to the second function.
      `V` - The type of the result of the second function and the input to the third function.
      `R` - The type of the result of the third function and this method.
      `E1` - The type of thrown exception or error by the first function.
      `E2` - The type of thrown exception or error by the second function.
      `E3` - The type of thrown exception or error by the second function.
    Parameters:
      `value1` - The value to apply the first function, may be `null`.
      `mapper1` - The first function to apply, must not be `null`.
      `mapper2` - The second function to apply, must not be `null`.
      `mapper3` - The third function to apply, must not be `null`.
    Returns:
      The result of the final function (which may be `null`) or `null` if the input value or any intermediate value is `null`.
    Throws:
      `E1` - Thrown by the first function.
      `E2` - Thrown by the second function.
      `E3` - Thrown by the third function.
    Since:
      3.19.0
    See Also:
      - `applyNonNull(Object, FailableFunction)`
      - `applyNonNull(Object, FailableFunction, FailableFunction)`

  - ### asBiConsumer

    public static <T, U> BiConsumer<T,U> asBiConsumer(FailableBiConsumer<T,U,?> consumer)
    Converts the given `FailableBiConsumer` into a standard `BiConsumer`.
    Type Parameters:
      `T` - the type of the first argument of the consumers
      `U` - the type of the second argument of the consumers
    Parameters:
      `consumer` - a failable `BiConsumer`
    Returns:
      a standard `BiConsumer`

  - ### asBiFunction

    public static <T, U, R> BiFunction<T,U,R> asBiFunction(FailableBiFunction<T,U,R,?> function)
    Converts the given `FailableBiFunction` into a standard `BiFunction`.
    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
    Parameters:
      `function` - a `FailableBiFunction`
    Returns:
      a standard `BiFunction`

  - ### asBiPredicate

    public static <T, U> BiPredicate<T,U> asBiPredicate(FailableBiPredicate<T,U,?> predicate)
    Converts the given `FailableBiPredicate` into a standard `BiPredicate`.
    Type Parameters:
      `T` - the type of the first argument used by the predicates
      `U` - the type of the second argument used by the predicates
    Parameters:
      `predicate` - a `FailableBiPredicate`
    Returns:
      a standard `BiPredicate`

  - ### asCallable

    public static <V> Callable<V> asCallable(FailableCallable<V,?> callable)
    Converts the given `FailableCallable` into a standard `Callable`.
    Type Parameters:
      `V` - the type used by the callables
    Parameters:
      `callable` - a `FailableCallable`
    Returns:
      a standard `Callable`

  - ### asConsumer

    public static <T> Consumer<T> asConsumer(FailableConsumer<T,?> consumer)
    Converts the given `FailableConsumer` into a standard `Consumer`.
    Type Parameters:
      `T` - the type used by the consumers
    Parameters:
      `consumer` - a `FailableConsumer`
    Returns:
      a standard `Consumer`

  - ### asFunction

    public static <T, R> Function<T,R> asFunction(FailableFunction<T,R,?> function)
    Converts the given `FailableFunction` into a standard `Function`.
    Type Parameters:
      `T` - the type of the input of the functions
      `R` - the type of the output of the functions
    Parameters:
      `function` - a {code FailableFunction}
    Returns:
      a standard `Function`

  - ### asPredicate

    public static <T> Predicate<T> asPredicate(FailablePredicate<T,?> predicate)
    Converts the given `FailablePredicate` into a standard `Predicate`.
    Type Parameters:
      `T` - the type used by the predicates
    Parameters:
      `predicate` - a `FailablePredicate`
    Returns:
      a standard `Predicate`

  - ### asRunnable

    public static Runnable asRunnable(FailableRunnable<?> runnable)
    Converts the given `FailableRunnable` into a standard `Runnable`.
    Parameters:
      `runnable` - a `FailableRunnable`
    Returns:
      a standard `Runnable`

  - ### asSupplier

    public static <T> Supplier<T> asSupplier(FailableSupplier<T,?> supplier)
    Converts the given `FailableSupplier` into a standard `Supplier`.
    Type Parameters:
      `T` - the type supplied by the suppliers
    Parameters:
      `supplier` - a `FailableSupplier`
    Returns:
      a standard `Supplier`

  - ### call

    public static <V, E extends Throwable> V call(FailableCallable<V,E> callable)
    Calls a callable and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `V` - the return type of the callable
      `E` - the type of checked exception the callable may throw
    Parameters:
      `callable` - the callable to call
    Returns:
      the value returned from the callable

  - ### get

    public static <T, E extends Throwable> T get(FailableSupplier<T,E> supplier)
    Invokes a supplier, and returns the result.
    Type Parameters:
      `T` - The suppliers output type.
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The supplier to invoke.
    Returns:
      The object, which has been created by the supplier

  - ### getAsBoolean

    public static <E extends Throwable> boolean getAsBoolean(FailableBooleanSupplier<E> supplier)
    Invokes a boolean supplier, and returns the result.
    Type Parameters:
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The boolean supplier to invoke.
    Returns:
      The boolean, which has been created by the supplier

  - ### getAsDouble

    public static <E extends Throwable> double getAsDouble(FailableDoubleSupplier<E> supplier)
    Invokes a double supplier, and returns the result.
    Type Parameters:
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The double supplier to invoke.
    Returns:
      The double, which has been created by the supplier

  - ### getAsInt

    public static <E extends Throwable> int getAsInt(FailableIntSupplier<E> supplier)
    Invokes an int supplier, and returns the result.
    Type Parameters:
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The int supplier to invoke.
    Returns:
      The int, which has been created by the supplier

  - ### getAsLong

    public static <E extends Throwable> long getAsLong(FailableLongSupplier<E> supplier)
    Invokes a long supplier, and returns the result.
    Type Parameters:
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The long supplier to invoke.
    Returns:
      The long, which has been created by the supplier

  - ### getAsShort

    public static <E extends Throwable> short getAsShort(FailableShortSupplier<E> supplier)
    Invokes a short supplier, and returns the result.
    Type Parameters:
      `E` - The type of checked exception, which the supplier can throw.
    Parameters:
      `supplier` - The short supplier to invoke.
    Returns:
      The short, which has been created by the supplier

  - ### rethrow

    public static RuntimeException rethrow(Throwable throwable)
    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.

    Parameters:
      `throwable` - The throwable to rethrow possibly wrapped into an unchecked exception
    Returns:
      Never returns anything, this method never terminates normally.

  - ### run

    public static <E extends Throwable> void run(FailableRunnable<E> runnable)
    Runs a runnable and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `E` - the type of checked exception the runnable may throw.
    Parameters:
      `runnable` - The runnable to run, may be null for a noop.

  - ### stream

    public static <E> Streams.FailableStream<E> stream(Collection<E> collection)
    Converts the given collection into a `Streams.FailableStream`. The `Streams.FailableStream` consists of the collections elements. Shortcut for

         Functions.stream(collection.stream());

    Type Parameters:
      `E` - The collections element type. (In turn, the result streams element type.)
    Parameters:
      `collection` - The collection, which is being converted into a `Streams.FailableStream`.
    Returns:
      The created `Streams.FailableStream`.

  - ### stream

    public static <T> Streams.FailableStream<T> stream(Stream<T> stream)
    Converts the given stream into a `Streams.FailableStream`. The `Streams.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.
    Type Parameters:
      `T` - The streams element type.
    Parameters:
      `stream` - The stream, which is being converted into a `Streams.FailableStream`.
    Returns:
      The created `Streams.FailableStream`.

  - ### test

    public static <T, U, E extends Throwable> boolean test(FailableBiPredicate<T,U,E> predicate, T object1, U object2)
    Tests a predicate and rethrows any exception as a `RuntimeException`.
    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
    Parameters:
      `predicate` - the predicate to test
      `object1` - the first input to test by `predicate`
      `object2` - the second input to test by `predicate`
    Returns:
      the boolean value returned by the predicate

  - ### test

    public static <T, E extends Throwable> boolean test(FailablePredicate<T,E> predicate, T object)
    Tests a predicate and rethrows any exception as a `RuntimeException`.
    Type Parameters:
      `T` - the type of argument the predicate tests
      `E` - the type of checked exception the predicate may throw
    Parameters:
      `predicate` - the predicate to test
      `object` - the input to test by `predicate`
    Returns:
      the boolean value returned by the predicate

  - ### tryWithResources

    @SafeVarargs public static void tryWithResources(FailableRunnable<? extends Throwable> action, FailableConsumer<Throwable,? extends Throwable> errorHandler, FailableRunnable<? extends Throwable>... resources)
    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());

    Parameters:
      `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, FailableRunnable...)`

  - ### tryWithResources

    @SafeVarargs public static void tryWithResources(FailableRunnable<? extends Throwable> action, FailableRunnable<? extends Throwable>... resources)
    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());

    Parameters:
      `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, FailableConsumer, FailableRunnable...)`