Source code
Description: source: package: org.apache.commons.lang3, class: Functions, interface: FailableBiPredicate

    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      https://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.lang3;
    018
    019import java.io.IOException;
    020import java.io.UncheckedIOException;
    021import java.lang.reflect.UndeclaredThrowableException;
    022import java.util.Arrays;
    023import java.util.Collection;
    024import java.util.Objects;
    025import java.util.concurrent.Callable;
    026import java.util.function.BiConsumer;
    027import java.util.function.BiFunction;
    028import java.util.function.BiPredicate;
    029import java.util.function.Consumer;
    030import java.util.function.Function;
    031import java.util.function.Predicate;
    032import java.util.function.Supplier;
    033import java.util.stream.Stream;
    034
    035import org.apache.commons.lang3.Streams.FailableStream;
    036import org.apache.commons.lang3.exception.ExceptionUtils;
    037import org.apache.commons.lang3.function.Failable;
    038import org.apache.commons.lang3.function.FailableBooleanSupplier;
    039
    040/**
    041 * This class provides utility functions, and classes for working with the {@code java.util.function} package, or more
    042 * generally, with Java 8 lambdas. More specifically, it attempts to address the fact that lambdas are supposed not to
    043 * throw Exceptions, at least not checked Exceptions, AKA instances of {@link Exception}. This enforces the use of
    044 * constructs like:
    045 *
    046 * <pre>
    047 * {@code
    048 *     Consumer<java.lang.reflect.Method> consumer = m -> {
    049 *         try {
    050 *             m.invoke(o, args);
    051 *         } catch (Throwable t) {
    052 *             throw Functions.rethrow(t);
    053 *         }
    054 *     };
    055 * }</pre>
    056 *
    057 * <p>
    058 * By replacing a {@link java.util.function.Consumer Consumer&lt;O&gt;} with a {@link FailableConsumer
    059 * FailableConsumer&lt;O,? extends Throwable&gt;}, this can be written like follows:
    060 * </p>
    061 *
    062 * <pre>
    063 * {@code
    064 *   Functions.accept((m) -> m.invoke(o,args));
    065 * }</pre>
    066 *
    067 * <p>
    068 * Obviously, the second version is much more concise and the spirit of Lambda expressions is met better than the second
    069 * version.
    070 * </p>
    071 * @since 3.9
    072 * @deprecated Use {@link org.apache.commons.lang3.function.Failable}.
    073 */
    074@Deprecated
    075public class Functions {
    076
    077    /**
    078     * A functional interface like {@link BiConsumer} that declares a {@link Throwable}.
    079     *
    080     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    081     *
    082     * @param <O1> Consumed type 1.
    083     * @param <O2> Consumed type 2.
    084     * @param <T> Thrown exception.
    085     * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiConsumer}.
    086     */
    087    @Deprecated
    088    @FunctionalInterface
    089    public interface FailableBiConsumer<O1, O2, T extends Throwable> {
    090
    091        /**
    092         * Accepts the consumer.
    093         *
    094         * @param object1 the first parameter for the consumable to accept
    095         * @param object2 the second parameter for the consumable to accept
    096         * @throws T Thrown when the consumer fails.
    097         */
    098        void accept(O1 object1, O2 object2) throws T;
    099    }
    100
    101    /**
    102     * A functional interface like {@link BiFunction} that declares a {@link Throwable}.
    103     *
    104     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    105     *
    106     * @param <O1> Input type 1.
    107     * @param <O2> Input type 2.
    108     * @param <R> Return type.
    109     * @param <T> Thrown exception.
    110     * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiFunction}.
    111     */
    112    @Deprecated
    113    @FunctionalInterface
    114    public interface FailableBiFunction<O1, O2, R, T extends Throwable> {
    115
    116        /**
    117         * Applies this function.
    118         *
    119         * @param input1 the first input for the function
    120         * @param input2 the second input for the function
    121         * @return the result of the function
    122         * @throws T Thrown when the function fails.
    123         */
    124        R apply(O1 input1, O2 input2) throws T;
    125    }
    126
    127    /**
    128     * A functional interface like {@link BiPredicate} that declares a {@link Throwable}.
    129     *
    130     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    131     *
    132     * @param <O1> Predicate type 1.
    133     * @param <O2> Predicate type 2.
    134     * @param <T> Thrown exception.
    135     * @deprecated Use {@link org.apache.commons.lang3.function.FailableBiPredicate}.
    136     */
    137    @Deprecated
    138    @FunctionalInterface
    139    public interface FailableBiPredicate<O1, O2, T extends Throwable> {
    140
    141        /**
    142         * Tests the predicate.
    143         *
    144         * @param object1 the first object to test the predicate on
    145         * @param object2 the second object to test the predicate on
    146         * @return the predicate's evaluation
    147         * @throws T if the predicate fails
    148         */
    149        boolean test(O1 object1, O2 object2) throws T;
    150    }
    151
    152    /**
    153     * A functional interface like {@link java.util.concurrent.Callable} that declares a {@link Throwable}.
    154     *
    155     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    156     *
    157     * @param <R> Return type.
    158     * @param <T> Thrown exception.
    159     * @deprecated Use {@link org.apache.commons.lang3.function.FailableCallable}.
    160     */
    161    @Deprecated
    162    @FunctionalInterface
    163    public interface FailableCallable<R, T extends Throwable> {
    164
    165        /**
    166         * Calls the callable.
    167         *
    168         * @return The value returned from the callable
    169         * @throws T if the callable fails
    170         */
    171        R call() throws T;
    172    }
    173
    174    /**
    175     * A functional interface like {@link Consumer} that declares a {@link Throwable}.
    176     *
    177     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    178     *
    179     * @param <O> Consumed type 1.
    180     * @param <T> Thrown exception.
    181     * @deprecated Use {@link org.apache.commons.lang3.function.FailableConsumer}.
    182     */
    183    @Deprecated
    184    @FunctionalInterface
    185    public interface FailableConsumer<O, T extends Throwable> {
    186
    187        /**
    188         * Accepts the consumer.
    189         *
    190         * @param object the parameter for the consumable to accept
    191         * @throws T Thrown when the consumer fails.
    192         */
    193        void accept(O object) throws T;
    194    }
    195
    196    /**
    197     * A functional interface like {@link Function} that declares a {@link Throwable}.
    198     *
    199     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    200     *
    201     * @param <I> Input type 1.
    202     * @param <R> Return type.
    203     * @param <T> Thrown exception.
    204     * @deprecated Use {@link org.apache.commons.lang3.function.FailableFunction}.
    205     */
    206    @Deprecated
    207    @FunctionalInterface
    208    public interface FailableFunction<I, R, T extends Throwable> {
    209
    210        /**
    211         * Applies this function.
    212         *
    213         * @param input the input for the function
    214         * @return the result of the function
    215         * @throws T Thrown when the function fails.
    216         */
    217        R apply(I input) throws T;
    218    }
    219
    220    /**
    221     * A functional interface like {@link Predicate} that declares a {@link Throwable}.
    222     *
    223     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    224     *
    225     * @param <I> Predicate type 1.
    226     * @param <T> Thrown exception.
    227     * @deprecated Use {@link org.apache.commons.lang3.function.FailablePredicate}.
    228     */
    229    @Deprecated
    230    @FunctionalInterface
    231    public interface FailablePredicate<I, T extends Throwable> {
    232
    233        /**
    234         * Tests the predicate.
    235         *
    236         * @param object the object to test the predicate on
    237         * @return the predicate's evaluation
    238         * @throws T if the predicate fails
    239         */
    240        boolean test(I object) throws T;
    241    }
    242
    243    /**
    244     * A functional interface like {@link Runnable} that declares a {@link Throwable}.
    245     *
    246     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    247     *
    248     * @param <T> Thrown exception.
    249     * @deprecated Use {@link org.apache.commons.lang3.function.FailableRunnable}.
    250     */
    251    @Deprecated
    252    @FunctionalInterface
    253    public interface FailableRunnable<T extends Throwable> {
    254
    255        /**
    256         * Runs the function.
    257         *
    258         * @throws T Thrown when the function fails.
    259         */
    260        void run() throws T;
    261    }
    262
    263    /**
    264     * A functional interface like {@link Supplier} that declares a {@link Throwable}.
    265     *
    266     * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
    267     *
    268     * @param <R> Return type.
    269     * @param <T> Thrown exception.
    270     * @deprecated Use {@link org.apache.commons.lang3.function.FailableSupplier}.
    271     */
    272    @Deprecated
    273    @FunctionalInterface
    274    public interface FailableSupplier<R, T extends Throwable> {
    275
    276        /**
    277         * Supplies an object
    278         *
    279         * @return a result
    280         * @throws T if the supplier fails
    281         */
    282        R get() throws T;
    283    }
    284
    285    /**
    286     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
    287     *
    288     * @param consumer the consumer to consume
    289     * @param object1 the first object to consume by {@code consumer}
    290     * @param object2 the second object to consume by {@code consumer}
    291     * @param <O1> the type of the first argument the consumer accepts
    292     * @param <O2> the type of the second argument the consumer accepts
    293     * @param <T> the type of checked exception the consumer may throw
    294     */
    295    public static <O1, O2, T extends Throwable> void accept(final FailableBiConsumer<O1, O2, T> consumer,
    296        final O1 object1, final O2 object2) {
    297        run(() -> consumer.accept(object1, object2));
    298    }
    299
    300    /**
    301     * Consumes a consumer and rethrows any exception as a {@link RuntimeException}.
    302     *
    303     * @param consumer the consumer to consume
    304     * @param object the object to consume by {@code consumer}
    305     * @param <O> the type the consumer accepts
    306     * @param <T> the type of checked exception the consumer may throw
    307     */
    308    public static <O, T extends Throwable> void accept(final FailableConsumer<O, T> consumer, final O object) {
    309        run(() -> consumer.accept(object));
    310    }
    311
    312    /**
    313     * Applies a function and rethrows any exception as a {@link RuntimeException}.
    314     *
    315     * @param function the function to apply
    316     * @param input1 the first input to apply {@code function} on
    317     * @param input2 the second input to apply {@code function} on
    318     * @param <O1> the type of the first argument the function accepts
    319     * @param <O2> the type of the second argument the function accepts
    320     * @param <O> the return type of the function
    321     * @param <T> the type of checked exception the function may throw
    322     * @return the value returned from the function
    323     */
    324    public static <O1, O2, O, T extends Throwable> O apply(final FailableBiFunction<O1, O2, O, T> function,
    325        final O1 input1, final O2 input2) {
    326        return get(() -> function.apply(input1, input2));
    327    }
    328
    329    /**
    330     * Applies a function and rethrows any exception as a {@link RuntimeException}.
    331     *
    332     * @param function the function to apply
    333     * @param input the input to apply {@code function} on
    334     * @param <I> the type of the argument the function accepts
    335     * @param <O> the return type of the function
    336     * @param <T> the type of checked exception the function may throw
    337     * @return the value returned from the function
    338     */
    339    public static <I, O, T extends Throwable> O apply(final FailableFunction<I, O, T> function, final I input) {
    340        return get(() -> function.apply(input));
    341    }
    342
    343    /**
    344     * Converts the given {@link FailableBiConsumer} into a standard {@link BiConsumer}.
    345     *
    346     * @param <O1> the type of the first argument of the consumers
    347     * @param <O2> the type of the second argument of the consumers
    348     * @param consumer a failable {@link BiConsumer}
    349     * @return a standard {@link BiConsumer}
    350     * @since 3.10
    351     */
    352    public static <O1, O2> BiConsumer<O1, O2> asBiConsumer(final FailableBiConsumer<O1, O2, ?> consumer) {
    353        return (input1, input2) -> accept(consumer, input1, input2);
    354    }
    355
    356    /**
    357     * Converts the given {@link FailableBiFunction} into a standard {@link BiFunction}.
    358     *
    359     * @param <O1> the type of the first argument of the input of the functions
    360     * @param <O2> the type of the second argument of the input of the functions
    361     * @param <O> the type of the output of the functions
    362     * @param function a {@link FailableBiFunction}
    363     * @return a standard {@link BiFunction}
    364     * @since 3.10
    365     */
    366    public static <O1, O2, O> BiFunction<O1, O2, O> asBiFunction(final FailableBiFunction<O1, O2, O, ?> function) {
    367        return (input1, input2) -> apply(function, input1, input2);
    368    }
    369
    370    /**
    371     * Converts the given {@link FailableBiPredicate} into a standard {@link BiPredicate}.
    372     *
    373     * @param <O1> the type of the first argument used by the predicates
    374     * @param <O2> the type of the second argument used by the predicates
    375     * @param predicate a {@link FailableBiPredicate}
    376     * @return a standard {@link BiPredicate}
    377     * @since 3.10
    378     */
    379    public static <O1, O2> BiPredicate<O1, O2> asBiPredicate(final FailableBiPredicate<O1, O2, ?> predicate) {
    380        return (input1, input2) -> test(predicate, input1, input2);
    381    }
    382
    383    /**
    384     * Converts the given {@link FailableCallable} into a standard {@link Callable}.
    385     *
    386     * @param <O> the type used by the callables
    387     * @param callable a {@link FailableCallable}
    388     * @return a standard {@link Callable}
    389     * @since 3.10
    390     */
    391    public static <O> Callable<O> asCallable(final FailableCallable<O, ?> callable) {
    392        return () -> call(callable);
    393    }
    394
    395    /**
    396     * Converts the given {@link FailableConsumer} into a standard {@link Consumer}.
    397     *
    398     * @param <I> the type used by the consumers
    399     * @param consumer a {@link FailableConsumer}
    400     * @return a standard {@link Consumer}
    401     * @since 3.10
    402     */
    403    public static <I> Consumer<I> asConsumer(final FailableConsumer<I, ?> consumer) {
    404        return input -> accept(consumer, input);
    405    }
    406
    407    /**
    408     * Converts the given {@link FailableFunction} into a standard {@link Function}.
    409     *
    410     * @param <I> the type of the input of the functions
    411     * @param <O> the type of the output of the functions
    412     * @param function a {code FailableFunction}
    413     * @return a standard {@link Function}
    414     * @since 3.10
    415     */
    416    public static <I, O> Function<I, O> asFunction(final FailableFunction<I, O, ?> function) {
    417        return input -> apply(function, input);
    418    }
    419
    420    /**
    421     * Converts the given {@link FailablePredicate} into a standard {@link Predicate}.
    422     *
    423     * @param <I> the type used by the predicates
    424     * @param predicate a {@link FailablePredicate}
    425     * @return a standard {@link Predicate}
    426     * @since 3.10
    427     */
    428    public static <I> Predicate<I> asPredicate(final FailablePredicate<I, ?> predicate) {
    429        return input -> test(predicate, input);
    430    }
    431
    432    /**
    433     * Converts the given {@link FailableRunnable} into a standard {@link Runnable}.
    434     *
    435     * @param runnable a {@link FailableRunnable}
    436     * @return a standard {@link Runnable}
    437     * @since 3.10
    438     */
    439    public static Runnable asRunnable(final FailableRunnable<?> runnable) {
    440        return () -> run(runnable);
    441    }
    442
    443    /**
    444     * Converts the given {@link FailableSupplier} into a standard {@link Supplier}.
    445     *
    446     * @param <O> the type supplied by the suppliers
    447     * @param supplier a {@link FailableSupplier}
    448     * @return a standard {@link Supplier}
    449     * @since 3.10
    450     */
    451    public static <O> Supplier<O> asSupplier(final FailableSupplier<O, ?> supplier) {
    452        return () -> get(supplier);
    453    }
    454
    455    /**
    456     * Calls a callable and rethrows any exception as a {@link RuntimeException}.
    457     *
    458     * @param callable the callable to call
    459     * @param <O> the return type of the callable
    460     * @param <T> the type of checked exception the callable may throw
    461     * @return the value returned from the callable
    462     */
    463    public static <O, T extends Throwable> O call(final FailableCallable<O, T> callable) {
    464        return get(callable::call);
    465    }
    466
    467    /**
    468     * Invokes a supplier, and returns the result.
    469     *
    470     * @param supplier The supplier to invoke.
    471     * @param <O> The suppliers output type.
    472     * @param <T> The type of checked exception, which the supplier can throw.
    473     * @return The object, which has been created by the supplier
    474     * @since 3.10
    475     */
    476    public static <O, T extends Throwable> O get(final FailableSupplier<O, T> supplier) {
    477        try {
    478            return supplier.get();
    479        } catch (final Throwable t) {
    480            throw rethrow(t);
    481        }
    482    }
    483
    484    /**
    485     * Invokes a boolean supplier, and returns the result.
    486     *
    487     * @param supplier The boolean supplier to invoke.
    488     * @param <T> The type of checked exception, which the supplier can throw.
    489     * @return The boolean, which has been created by the supplier
    490     */
    491    private static <T extends Throwable> boolean getAsBoolean(final FailableBooleanSupplier<T> supplier) {
    492        try {
    493            return supplier.getAsBoolean();
    494        } catch (final Throwable t) {
    495            throw rethrow(t);
    496        }
    497    }
    498
    499    /**
    500     * Rethrows a {@link Throwable} as an unchecked exception. If the argument is already unchecked, namely a
    501     * {@link RuntimeException} or {@link Error} then the argument will be rethrown without modification. If the
    502     * exception is {@link IOException} then it will be wrapped into a {@link UncheckedIOException}. In every other
    503     * cases the exception will be wrapped into a {@code
    504     * UndeclaredThrowableException}
    505     *
    506     * <p>
    507     * Note that there is a declared return type for this method, even though it never returns. The reason for that is
    508     * to support the usual pattern:
    509     * </p>
    510     *
    511     * <pre>
    512     * throw rethrow(myUncheckedException);</pre>
    513     *
    514     * <p>
    515     * instead of just calling the method. This pattern may help the Java compiler to recognize that at that point an
    516     * exception will be thrown and the code flow analysis will not demand otherwise mandatory commands that could
    517     * follow the method call, like a {@code return} statement from a value returning method.
    518     * </p>
    519     *
    520     * @param throwable The throwable to rethrow possibly wrapped into an unchecked exception
    521     * @return Never returns anything, this method never terminates normally.
    522     */
    523    public static RuntimeException rethrow(final Throwable throwable) {
    524        Objects.requireNonNull(throwable, "throwable");
    525        ExceptionUtils.throwUnchecked(throwable);
    526        if (throwable instanceof IOException) {
    527            throw new UncheckedIOException((IOException) throwable);
    528        }
    529        throw new UndeclaredThrowableException(throwable);
    530    }
    531
    532    /**
    533     * Runs a runnable and rethrows any exception as a {@link RuntimeException}.
    534     *
    535     * @param runnable The runnable to run
    536     * @param <T> the type of checked exception the runnable may throw
    537     */
    538    public static <T extends Throwable> void run(final FailableRunnable<T> runnable) {
    539        try {
    540            runnable.run();
    541        } catch (final Throwable t) {
    542            throw rethrow(t);
    543        }
    544    }
    545
    546    /**
    547     * Converts the given collection into a {@link FailableStream}. The {@link FailableStream} consists of the
    548     * collections elements. Shortcut for
    549     *
    550     * <pre>
    551     * Functions.stream(collection.stream());</pre>
    552     *
    553     * @param collection The collection, which is being converted into a {@link FailableStream}.
    554     * @param <O> The collections element type. (In turn, the result streams element type.)
    555     * @return The created {@link FailableStream}.
    556     * @since 3.10
    557     */
    558    public static <O> FailableStream<O> stream(final Collection<O> collection) {
    559        return new FailableStream<>(collection.stream());
    560    }
    561
    562    /**
    563     * Converts the given stream into a {@link FailableStream}. The {@link FailableStream} consists of the same
    564     * elements, than the input stream. However, failable lambdas, like {@link FailablePredicate},
    565     * {@link FailableFunction}, and {@link FailableConsumer} may be applied, rather than {@link Predicate},
    566     * {@link Function}, {@link Consumer}, etc.
    567     *
    568     * @param stream The stream, which is being converted into a {@link FailableStream}.
    569     * @param <O> The streams element type.
    570     * @return The created {@link FailableStream}.
    571     * @since 3.10
    572     */
    573    public static <O> FailableStream<O> stream(final Stream<O> stream) {
    574        return new FailableStream<>(stream);
    575    }
    576
    577    /**
    578     * Tests a predicate and rethrows any exception as a {@link RuntimeException}.
    579     *
    580     * @param predicate the predicate to test
    581     * @param object1 the first input to test by {@code predicate}
    582     * @param object2 the second input to test by {@code predicate}
    583     * @param <O1> the type of the first argument the predicate tests
    584     * @param <O2> the type of the second argument the predicate tests
    585     * @param <T> the type of checked exception the predicate may throw
    586     * @return the boolean value returned by the predicate
    587     */
    588    public static <O1, O2, T extends Throwable> boolean test(final FailableBiPredicate<O1, O2, T> predicate,
    589        final O1 object1, final O2 object2) {
    590        return getAsBoolean(() -> predicate.test(object1, object2));
    591    }
    592
    593    /**
    594     * Tests a predicate and rethrows any exception as a {@link RuntimeException}.
    595     *
    596     * @param predicate the predicate to test
    597     * @param object the input to test by {@code predicate}
    598     * @param <O> the type of argument the predicate tests
    599     * @param <T> the type of checked exception the predicate may throw
    600     * @return the boolean value returned by the predicate
    601     */
    602    public static <O, T extends Throwable> boolean test(final FailablePredicate<O, T> predicate, final O object) {
    603        return getAsBoolean(() -> predicate.test(object));
    604    }
    605
    606    /**
    607     * A simple try-with-resources implementation, that can be used, if your objects do not implement the
    608     * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em>
    609     * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure.
    610     * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA
    611     * {@link Throwable}) is rethrown. Example use:
    612     *
    613     * <pre>
    614     * {@code
    615     *     final FileInputStream fis = new FileInputStream("my.file");
    616     *     Functions.tryWithResources(useInputStream(fis), null, () -> fis.close());
    617     * }</pre>
    618     *
    619     * @param action The action to execute. This object <em>will</em> always be invoked.
    620     * @param errorHandler An optional error handler, which will be invoked finally, if any error occurred. The error
    621     *        handler will receive the first error, AKA {@link Throwable}.
    622     * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given
    623     *        order. A resource action is an instance of {@link FailableRunnable}, which will be executed.
    624     * @see #tryWithResources(FailableRunnable, FailableRunnable...)
    625     */
    626    @SafeVarargs
    627    public static void tryWithResources(final FailableRunnable<? extends Throwable> action,
    628        final FailableConsumer<Throwable, ? extends Throwable> errorHandler,
    629        final FailableRunnable<? extends Throwable>... resources) {
    630        final org.apache.commons.lang3.function.FailableRunnable<?>[] fr = new org.apache.commons.lang3.function.FailableRunnable[resources.length];
    631        Arrays.setAll(fr, i -> () -> resources[i].run());
    632        Failable.tryWithResources(action::run, errorHandler != null ? errorHandler::accept : null, fr);
    633    }
    634
    635    /**
    636     * A simple try-with-resources implementation, that can be used, if your objects do not implement the
    637     * {@link AutoCloseable} interface. The method executes the {@code action}. The method guarantees, that <em>all</em>
    638     * the {@code resources} are being executed, in the given order, afterwards, and regardless of success, or failure.
    639     * If either the original action, or any of the resource action fails, then the <em>first</em> failure (AKA
    640     * {@link Throwable}) is rethrown. Example use:
    641     *
    642     * <pre>
    643     * {@code
    644     *     final FileInputStream fis = new FileInputStream("my.file");
    645     *     Functions.tryWithResources(useInputStream(fis), () -> fis.close());
    646     * }</pre>
    647     *
    648     * @param action The action to execute. This object <em>will</em> always be invoked.
    649     * @param resources The resource actions to execute. <em>All</em> resource actions will be invoked, in the given
    650     *        order. A resource action is an instance of {@link FailableRunnable}, which will be executed.
    651     * @see #tryWithResources(FailableRunnable, FailableConsumer, FailableRunnable...)
    652     */
    653    @SafeVarargs
    654    public static void tryWithResources(final FailableRunnable<? extends Throwable> action,
    655        final FailableRunnable<? extends Throwable>... resources) {
    656        tryWithResources(action, null, resources);
    657    }
    658
    659    /**
    660     * Constructs a new instance.
    661     */
    662    public Functions() {
    663        // empty
    664    }
    665}