From e968ad5a3f42f9eb7b3bd9ed95f827918d884e77 Mon Sep 17 00:00:00 2001 From: Gary Gregory Date: Thu, 11 Jun 2020 09:43:11 -0400 Subject: [PATCH] Add missing @since 3.9 and 3.10 Javadoc tags. Clean up formatting. Clean up Javadocs. Sort methods in AB order. --- .../org/apache/commons/lang3/Functions.java | 743 ++++++++++-------- 1 file changed, 396 insertions(+), 347 deletions(-) diff --git a/src/main/java/org/apache/commons/lang3/Functions.java b/src/main/java/org/apache/commons/lang3/Functions.java index 2029b2e11..896c93a29 100644 --- a/src/main/java/org/apache/commons/lang3/Functions.java +++ b/src/main/java/org/apache/commons/lang3/Functions.java @@ -33,66 +33,48 @@ import org.apache.commons.lang3.Streams.FailableStream; - -/** 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 - * 
{@code
- *   Consumer consumer = (m) -> {
- *       try {
- *           m.invoke(o, args);
- *       } catch (Throwable t) {
- *           throw Functions.rethrow(t);
- *       }
- *   };
+/**
+ * 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:
+ *
+ * 
+ * {
+ *     @code
+ *     Consumer consumer = (m) -> {
+ *         try {
+ *             m.invoke(o, args);
+ *         } catch (Throwable t) {
+ *             throw Functions.rethrow(t);
+ *         }
+ *     };
  * }

- * By replacing a {@link java.util.function.Consumer Consumer<O>} with a
- * {@link FailableConsumer FailableConsumer<O,? extends Throwable>}, this can be
- * written like follows:
- * 
{@code
+ *
+ * 

+ * By replacing a {@link java.util.function.Consumer Consumer<O>} with a {@link FailableConsumer
+ * FailableConsumer<O,? extends Throwable>}, this can be written like follows:
+ * 

+ *
+ * 
+ * {@code
  *   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.
+ *
+ * 

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

+ * @since 3.9
  */
 public class Functions {
 
-    @FunctionalInterface
-    public interface FailableRunnable {
-        /**
-         * Runs the function.
-         * @throws T if the function fails
-         */
-        void run() throws T;
-    }
-
-    @FunctionalInterface
-    public interface FailableCallable {
-        /**
-         * Calls the callable.
-         * @return The value returned from the callable
-         * @throws T if the callable fails
-         */
-        O call() throws T;
-    }
-
-    @FunctionalInterface
-    public interface FailableConsumer {
-        /**
-         * Accepts the consumer.
-         * @param object the parameter for the consumable to accept
-         * @throws T if the consumer fails
-         */
-        void accept(O object) throws T;
-    }
-
     @FunctionalInterface
     public interface FailableBiConsumer {
+
         /**
          * Accepts the consumer.
+         *
          * @param object1 the first parameter for the consumable to accept
          * @param object2 the second parameter for the consumable to accept
          * @throws T if the consumer fails
@@ -100,21 +82,12 @@ public interface FailableBiConsumer {
         void accept(O1 object1, O2 object2) throws T;
     }
 
-    @FunctionalInterface
-    public interface FailableFunction {
-        /**
-         * Applies this function.
-         * @param input the input for the function
-         * @return the result of the function
-         * @throws T if the function fails
-         */
-        O apply(I input) throws T;
-    }
-
     @FunctionalInterface
     public interface FailableBiFunction {
+
         /**
          * Applies this function.
+         *
          * @param input1 the first input for the function
          * @param input2 the second input for the function
          * @return the result of the function
@@ -123,21 +96,12 @@ public interface FailableBiFunction {
         O apply(I1 input1, I2 input2) throws T;
     }
 
-    @FunctionalInterface
-    public interface FailablePredicate {
-        /**
-         * Test the predicate.
-         * @param object the object to test the predicate on
-         * @return the predicate's evaluation
-         * @throws T if the predicate fails
-         */
-        boolean test(O object) throws T;
-    }
-
     @FunctionalInterface
     public interface FailableBiPredicate {
+
         /**
          * Test the predicate.
+         *
          * @param object1 the first object to test the predicate on
          * @param object2 the second object to test the predicate on
          * @return the predicate's evaluation
@@ -146,10 +110,74 @@ public interface FailableBiPredicate {
         boolean test(O1 object1, O2 object2) throws T;
     }
 
+    @FunctionalInterface
+    public interface FailableCallable {
+
+        /**
+         * Calls the callable.
+         *
+         * @return The value returned from the callable
+         * @throws T if the callable fails
+         */
+        O call() throws T;
+    }
+
+    @FunctionalInterface
+    public interface FailableConsumer {
+
+
+        /**
+         * Accepts the consumer.
+         *
+         * @param object the parameter for the consumable to accept
+         * @throws T if the consumer fails
+         */
+        void accept(O object) throws T;
+    }
+
+    @FunctionalInterface
+    public interface FailableFunction {
+
+        /**
+         * Applies this function.
+         *
+         * @param input the input for the function
+         * @return the result of the function
+         * @throws T if the function fails
+         */
+        O apply(I input) throws T;
+    }
+
+    @FunctionalInterface
+    public interface FailablePredicate {
+
+        /**
+         * Test the predicate.
+         *
+         * @param object the object to test the predicate on
+         * @return the predicate's evaluation
+         * @throws T if the predicate fails
+         */
+        boolean test(O object) throws T;
+    }
+
+    @FunctionalInterface
+    public interface FailableRunnable {
+
+        /**
+         * Runs the function.
+         *
+         * @throws T if the function fails
+         */
+        void run() throws T;
+    }
+
     @FunctionalInterface
     public interface FailableSupplier {
+
         /**
          * Supplies an object
+         *
          * @return the suppliers result
          * @throws T if the supplier fails
          */
@@ -157,134 +185,23 @@ public interface FailableSupplier {
     }
 
     /**
-     * Converts the given {@link FailableRunnable} into a standard {@link Runnable}.
+     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
      *
-     * @param runnable a {@code FailableRunnable}
-     * @return a standard {@code Runnable}
+     * @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  the type of the first argument the consumer accepts
+     * @param  the type of the second argument the consumer accepts
+     * @param  the type of checked exception the consumer may throw
      */
-    public static Runnable asRunnable(final FailableRunnable runnable) {
-        return () -> run(runnable);
-    }
-
-    /**
-     * Converts the given {@link FailableConsumer} into a standard {@link Consumer}.
-     *
-     * @param  the type used by the consumers
-     * @param consumer a {@code FailableConsumer}
-     * @return a standard {@code Consumer}
-     */
-    public static  Consumer asConsumer(final FailableConsumer consumer) {
-        return input -> accept(consumer, input);
-    }
-
-    /**
-     * Converts the given {@link FailableCallable} into a standard {@link Callable}.
-     *
-     * @param  the type used by the callables
-     * @param callable a {@code FailableCallable}
-     * @return a standard {@code Callable}
-     */
-    public static  Callable asCallable(final FailableCallable callable) {
-        return () -> call(callable);
-    }
-
-    /**
-     * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}.
-     *
-     * @param  the type of the first argument of the consumers
-     * @param  the type of the second argument of the consumers
-     * @param consumer a failable {@code BiConsumer}
-     * @return a standard {@code BiConsumer}
-     */
-    public static  BiConsumer asBiConsumer(final FailableBiConsumer consumer) {
-        return (input1, input2) -> accept(consumer, input1, input2);
-    }
-
-    /**
-     * Converts the given {@link FailableFunction} into a standard {@link Function}.
-     *
-     * @param  the type of the input of the functions
-     * @param  the type of the output of the functions
-     * @param function a {code FailableFunction}
-     * @return a standard {@code Function}
-     */
-    public static  Function asFunction(final FailableFunction function) {
-        return input -> apply(function, input);
-    }
-
-    /**
-     * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}.
-     *
-     * @param  the type of the first argument of the input of the functions
-     * @param  the type of the second argument of the input of the functions
-     * @param  the type of the output of the functions
-     * @param function a {@code FailableBiFunction}
-     * @return a standard {@code BiFunction}
-     */
-    public static  BiFunction asBiFunction(final FailableBiFunction function) {
-        return (input1, input2) -> apply(function, input1, input2);
-    }
-
-    /**
-     * Converts the given {@link FailablePredicate} into a standard {@link Predicate}.
-     *
-     * @param  the type used by the predicates
-     * @param predicate a {@code FailablePredicate}
-     * @return a standard {@code Predicate}
-     */
-    public static  Predicate asPredicate(final FailablePredicate predicate) {
-        return input -> test(predicate, input);
-    }
-
-    /**
-     * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}.
-     *
-     * @param  the type of the first argument used by the predicates
-     * @param  the type of the second argument used by the predicates
-     * @param predicate a {@code FailableBiPredicate}
-     * @return a standard {@code BiPredicate}
-     */
-    public static  BiPredicate asBiPredicate(final FailableBiPredicate predicate) {
-        return (input1, input2) -> test(predicate, input1, input2);
-    }
-
-    /**
-     * Converts the given {@link FailableSupplier} into a standard {@link Supplier}.
-     *
-     * @param  the type supplied by the suppliers
-     * @param supplier a {@code FailableSupplier}
-     * @return a standard {@code Supplier}
-     */
-    public static  Supplier asSupplier(final FailableSupplier supplier) {
-        return () -> get(supplier);
-    }
-
-    /**
-     * Runs a runnable and rethrows any exception as a {@link RuntimeException}.
-     * @param runnable The runnable to run
-     * @param  the type of checked exception the runnable may throw
-     */
-    public static  void run(final FailableRunnable runnable) {
-        try {
-            runnable.run();
-        } catch (final Throwable t) {
-            throw rethrow(t);
-        }
-    }
-
-    /**
-     * Calls a callable and rethrows any exception as a {@link RuntimeException}.
-     * @param callable the callable to call
-     * @param  the return type of the callable
-     * @param  the type of checked exception the callable may throw
-     * @return the value returned from the callable
-     */
-    public static  O call(final FailableCallable callable) {
-        return get(callable::call);
+    public static  void accept(final FailableBiConsumer consumer,
+        final O1 object1, final O2 object2) {
+        run(() -> consumer.accept(object1, object2));
     }
 
     /**
      * 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  the type the consumer accepts
@@ -295,20 +212,25 @@ public static  void accept(final FailableConsumer
     }
 
     /**
-     * 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  the type of the first argument the consumer accepts
-     * @param  the type of the second argument the consumer accepts
-     * @param  the type of checked exception the consumer may throw
+     * 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  the type of the first argument the function accepts
+     * @param  the type of the second argument the function accepts
+     * @param  the return type of the function
+     * @param  the type of checked exception the function may throw
+     * @return the value returned from the function
      */
-    public static  void accept(final FailableBiConsumer consumer, final O1 object1, final O2 object2) {
-        run(() -> consumer.accept(object1, object2));
+    public static  O apply(final FailableBiFunction function,
+        final I1 input1, final I2 input2) {
+        return get(() -> function.apply(input1, input2));
     }
 
     /**
      * 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  the type of the argument the function accepts
@@ -321,22 +243,249 @@ public static  O apply(final FailableFunction the type of the first argument the function accepts
-     * @param  the type of the second argument the function accepts
-     * @param  the return type of the function
-     * @param  the type of checked exception the function may throw
-     * @return the value returned from the function
+     * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}.
+     *
+     * @param  the type of the first argument of the consumers
+     * @param  the type of the second argument of the consumers
+     * @param consumer a failable {@code BiConsumer}
+     * @return a standard {@code BiConsumer}
+     * @since 3.10
      */
-    public static  O apply(final FailableBiFunction function, final I1 input1, final I2 input2) {
-        return get(() -> function.apply(input1, input2));
+    public static  BiConsumer asBiConsumer(final FailableBiConsumer consumer) {
+        return (input1, input2) -> accept(consumer, input1, input2);
+    }
+
+    /**
+     * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}.
+     *
+     * @param  the type of the first argument of the input of the functions
+     * @param  the type of the second argument of the input of the functions
+     * @param  the type of the output of the functions
+     * @param function a {@code FailableBiFunction}
+     * @return a standard {@code BiFunction}
+     * @since 3.10
+     */
+    public static  BiFunction asBiFunction(final FailableBiFunction function) {
+        return (input1, input2) -> apply(function, input1, input2);
+    }
+
+    /**
+     * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}.
+     *
+     * @param  the type of the first argument used by the predicates
+     * @param  the type of the second argument used by the predicates
+     * @param predicate a {@code FailableBiPredicate}
+     * @return a standard {@code BiPredicate}
+     * @since 3.10
+     */
+    public static  BiPredicate asBiPredicate(final FailableBiPredicate predicate) {
+        return (input1, input2) -> test(predicate, input1, input2);
+    }
+
+    /**
+     * Converts the given {@link FailableCallable} into a standard {@link Callable}.
+     *
+     * @param  the type used by the callables
+     * @param callable a {@code FailableCallable}
+     * @return a standard {@code Callable}
+     * @since 3.10
+     */
+    public static  Callable asCallable(final FailableCallable callable) {
+        return () -> call(callable);
+    }
+
+    /**
+     * Converts the given {@link FailableConsumer} into a standard {@link Consumer}.
+     *
+     * @param  the type used by the consumers
+     * @param consumer a {@code FailableConsumer}
+     * @return a standard {@code Consumer}
+     * @since 3.10
+     */
+    public static  Consumer asConsumer(final FailableConsumer consumer) {
+        return input -> accept(consumer, input);
+    }
+
+    /**
+     * Converts the given {@link FailableFunction} into a standard {@link Function}.
+     *
+     * @param  the type of the input of the functions
+     * @param  the type of the output of the functions
+     * @param function a {code FailableFunction}
+     * @return a standard {@code Function}
+     * @since 3.10
+     */
+    public static  Function asFunction(final FailableFunction function) {
+        return input -> apply(function, input);
+    }
+
+    /**
+     * Converts the given {@link FailablePredicate} into a standard {@link Predicate}.
+     *
+     * @param  the type used by the predicates
+     * @param predicate a {@code FailablePredicate}
+     * @return a standard {@code Predicate}
+     * @since 3.10
+     */
+    public static  Predicate asPredicate(final FailablePredicate predicate) {
+        return input -> test(predicate, input);
+    }
+
+    /**
+     * Converts the given {@link FailableRunnable} into a standard {@link Runnable}.
+     *
+     * @param runnable a {@code FailableRunnable}
+     * @return a standard {@code Runnable}
+     * @since 3.10
+     */
+    public static Runnable asRunnable(final FailableRunnable runnable) {
+        return () -> run(runnable);
+    }
+
+    /**
+     * Converts the given {@link FailableSupplier} into a standard {@link Supplier}.
+     *
+     * @param  the type supplied by the suppliers
+     * @param supplier a {@code FailableSupplier}
+     * @return a standard {@code Supplier}
+     * @since 3.10
+     */
+    public static  Supplier asSupplier(final FailableSupplier supplier) {
+        return () -> get(supplier);
+    }
+
+    /**
+     * Calls a callable and rethrows any exception as a {@link RuntimeException}.
+     *
+     * @param callable the callable to call
+     * @param  the return type of the callable
+     * @param  the type of checked exception the callable may throw
+     * @return the value returned from the callable
+     */
+    public static  O call(final FailableCallable callable) {
+        return get(callable::call);
+    }
+
+    /**
+     * Invokes the supplier, and returns the result.
+     *
+     * @param supplier The supplier to invoke.
+     * @param  The suppliers output type.
+     * @param  The type of checked exception, which the supplier can throw.
+     * @return The object, which has been created by the supplier
+     * @since 3.10
+     */
+    public static  O get(final FailableSupplier supplier) {
+        try {
+            return supplier.get();
+        } catch (final Throwable t) {
+            throw rethrow(t);
+        }
+    }
+
+    /**
+     * 

+     * 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}
+     * 

+     *
+     * 

+     * 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 {@code return} statement from a value returning method.
+     * 

+     *
+     * @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 {@link RuntimeException}.
+     *
+     * @param runnable The runnable to run
+     * @param  the type of checked exception the runnable may throw
+     */
+    public static  void run(final FailableRunnable runnable) {
+        try {
+            runnable.run();
+        } catch (final Throwable t) {
+            throw rethrow(t);
+        }
+    }
+
+    /**
+     * Converts the given collection into a {@link FailableStream}. The {@link FailableStream} consists of the
+     * collections elements. Shortcut for
+     *
+     * 
+     * Functions.stream(collection.stream());

+     *
+     * @param collection The collection, which is being converted into a {@link FailableStream}.
+     * @param  The collections element type. (In turn, the result streams element type.)
+     * @return The created {@link FailableStream}.
+     * @since 3.10
+     */
+    public static  FailableStream stream(final Collection collection) {
+        return new FailableStream<>(collection.stream());
+    }
+
+    /**
+     * 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  The streams element type.
+     * @return The created {@link FailableStream}.
+     * @since 3.10
+     */
+    public static  FailableStream stream(final Stream stream) {
+        return new FailableStream<>(stream);
     }
 
     /**
      * 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  the type of the first argument the predicate tests
+     * @param  the type of the second argument the predicate tests
+     * @param  the type of checked exception the predicate may throw
+     * @return the boolean value returned by the predicate
+     */
+    public static  boolean test(final FailableBiPredicate predicate,
+        final O1 object1, final O2 object2) {
+        return get(() -> predicate.test(object1, object2));
+    }
+
+    /**
+     * 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  the type of argument the predicate tests
@@ -348,94 +497,30 @@ public static  boolean test(final FailablePredicate the type of the first argument the predicate tests
-     * @param  the type of the second argument the predicate tests
-     * @param  the type of checked exception the predicate may throw
-     * @return the boolean value returned by the predicate
-     */
-    public static  boolean test(final FailableBiPredicate predicate, final O1 object1, final O2 object2) {
-        return get(() -> predicate.test(object1, object2));
-    }
-
-    /**
-     * Invokes the supplier, and returns the result.
-     * @param supplier The supplier to invoke.
-     * @param  The suppliers output type.
-     * @param  The type of checked exception, which the supplier can throw.
-     * @return The object, which has been created by the supplier
-     */
-    public static  O get(final FailableSupplier supplier) {
-        try {
-            return supplier.get();
-        } catch (final Throwable t) {
-            throw rethrow(t);
-        }
-    }
-
-    /**
-     * 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  The streams element type.
-     * @return The created {@link FailableStream}.
-     */
-    public static  FailableStream stream(final Stream stream) {
-        return new FailableStream<>(stream);
-    }
-
-    /**
-     * Converts the given collection into a {@link FailableStream}.
-     * The {@link FailableStream} consists of the collections
-     * elements. Shortcut for
-     * 
-     *   Functions.stream(collection.stream());
-     * 

-     * @param collection The collection, which is being converted into a
-     *   {@link FailableStream}.
-     * @param  The collections element type. (In turn, the result
-     *   streams element type.)
-     * @return The created {@link FailableStream}.
-     */
-    public static  FailableStream stream(final Collection collection) {
-        return new FailableStream<>(collection.stream());
-    }
-
-
-    /**
-     * 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 all
-     * 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 first failure (aka
+     * 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 all
+     * 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 first failure (AKA
      * {@link Throwable} is rethrown. Example use:
-     * 
{@code
-     *   final FileInputStream fis = new FileInputStream("my.file");
-     *   Functions.tryWithResources(useInputStream(fis), null, () -> fis.close());
+     *
+     * 
+     * {
+     *     @code
+     *     final FileInputStream fis = new FileInputStream("my.file");
+     *     Functions.tryWithResources(useInputStream(fis), null, () -> fis.close());
      * }

-     * @param action The action to execute. This object will 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. All resource
-     *   actions will be invoked, in the given order. A resource action is an
-     *   instance of {@link FailableRunnable}, which will be executed.
+     *
+     * @param action The action to execute. This object will 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. All 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 action,
-                                            final FailableConsumer errorHandler,
-                                            final FailableRunnable... resources) {
+        final FailableConsumer errorHandler,
+        final FailableRunnable... resources) {
         final FailableConsumer actualErrorHandler;
         if (errorHandler == null) {
             actualErrorHandler = Functions::rethrow;
@@ -474,63 +559,27 @@ public static void tryWithResources(final FailableRunnable
     }
 
     /**
-     * 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 all
-     * 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 first failure (aka
+     * 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 all
+     * 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 first failure (AKA
      * {@link Throwable} is rethrown. Example use:
-     * 
{@code
-     *   final FileInputStream fis = new FileInputStream("my.file");
-     *   Functions.tryWithResources(useInputStream(fis), () -> fis.close());
+     *
+     * 
+     * {
+     *     @code
+     *     final FileInputStream fis = new FileInputStream("my.file");
+     *     Functions.tryWithResources(useInputStream(fis), () -> fis.close());
      * }

-     * @param action The action to execute. This object will always
-     *   be invoked.
-     * @param resources The resource actions to execute. All resource
-     *   actions will be invoked, in the given order. A resource action is an
-     *   instance of {@link FailableRunnable}, which will be executed.
+     *
+     * @param action The action to execute. This object will always be invoked.
+     * @param resources The resource actions to execute. All 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 action,
-                                            final FailableRunnable... resources) {
+        final FailableRunnable... resources) {
         tryWithResources(action, null, resources);
     }
-
-    /**
-     * 
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}

-     *
-     * 
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 {@code return} statement from a value returning method.

-     *
-     * @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);
-        }
-    }
 }