You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by Alex Herbert <al...@gmail.com> on 2020/06/18 11:22:25 UTC
Re: [commons-lang] branch master updated: Create the new package
org.apache.commons.function to parallel the JRE's java.util.function to
provide home for our "failable" version of the JRE's functional interfaces.
I've added a skeleton package-info for the new o.a.c.lang3.stream
and o.a.c.lang3.functions packages and fixed the checkstyle issues. The
build should now pass and green light Travis CI.
I'm not too familiar with how much detail should be in the package info so
this may have to be rewritten. The changes at least get Jenkins builds to
pass again.
On Wed, 17 Jun 2020 at 20:58, <gg...@apache.org> wrote:
> This is an automated email from the ASF dual-hosted git repository.
>
> ggregory pushed a commit to branch master
> in repository https://gitbox.apache.org/repos/asf/commons-lang.git
>
>
> The following commit(s) were added to refs/heads/master by this push:
> new 8b54728 Create the new package org.apache.commons.function to
> parallel the JRE's java.util.function to provide home for our "failable"
> version of the JRE's functional interfaces.
> 8b54728 is described below
>
> commit 8b54728564e3e0c75ef915fb17f172326e8be197
> Author: Gary Gregory <ga...@gmail.com>
> AuthorDate: Wed Jun 17 15:58:26 2020 -0400
>
> Create the new package org.apache.commons.function to parallel the
> JRE's
> java.util.function to provide home for our "failable" version of the
> JRE's functional interfaces.
> ---
> .../java/org/apache/commons/lang3/Functions.java | 657 +--------------
> .../lang3/function/FailableBooleanSupplier.java | 38 +
> .../function/FailableDoubleBinaryOperator.java | 40 +
> .../lang3/function/FailableDoubleConsumer.java | 38 +
> .../lang3/function/FailableDoubleFunction.java | 40 +
> .../lang3/function/FailableDoublePredicate.java | 39 +
> .../lang3/function/FailableDoubleSupplier.java | 38 +
> .../function/FailableDoubleToIntFunction.java | 39 +
> .../function/FailableDoubleToLongFunction.java | 39 +
> .../lang3/function/FailableIntBinaryOperator.java | 40 +
> .../lang3/function/FailableIntConsumer.java | 38 +
> .../lang3/function/FailableIntFunction.java | 40 +
> .../lang3/function/FailableIntPredicate.java | 39 +
> .../lang3/function/FailableIntSupplier.java | 38 +
> .../function/FailableIntToDoubleFunction.java | 39 +
> .../lang3/function/FailableIntToLongFunction.java | 39 +
> .../lang3/function/FailableLongBinaryOperator.java | 40 +
> .../lang3/function/FailableLongConsumer.java | 38 +
> .../lang3/function/FailableLongFunction.java | 40 +
> .../lang3/function/FailableLongPredicate.java | 39 +
> .../lang3/function/FailableLongSupplier.java | 38 +
> .../function/FailableLongToDoubleFunction.java | 39 +
> .../lang3/function/FailableLongToIntFunction.java | 39 +
> .../lang3/function/FailableObjDoubleConsumer.java | 40 +
> .../lang3/function/FailableObjIntConsumer.java | 40 +
> .../lang3/function/FailableObjLongConsumer.java | 40 +
> .../lang3/function/FailableToDoubleBiFunction.java | 42 +
> .../lang3/function/FailableToDoubleFunction.java | 40 +
> .../lang3/function/FailableToIntBiFunction.java | 42 +
> .../lang3/function/FailableToIntFunction.java | 40 +
> .../lang3/function/FailableToLongBiFunction.java | 42 +
> .../lang3/function/FailableToLongFunction.java | 40 +
> .../org/apache/commons/lang3/FunctionsTest.java | 908
> +--------------------
> .../FailableFunctionsTest.java} | 574 ++++---------
> 34 files changed, 1414 insertions(+), 1948 deletions(-)
>
> diff --git a/src/main/java/org/apache/commons/lang3/Functions.java
> b/src/main/java/org/apache/commons/lang3/Functions.java
> index 16e7a0c..4aa7209 100644
> --- a/src/main/java/org/apache/commons/lang3/Functions.java
> +++ b/src/main/java/org/apache/commons/lang3/Functions.java
> @@ -25,44 +25,21 @@ import java.util.concurrent.Callable;
> import java.util.function.BiConsumer;
> import java.util.function.BiFunction;
> import java.util.function.BiPredicate;
> -import java.util.function.BooleanSupplier;
> import java.util.function.Consumer;
> -import java.util.function.DoubleBinaryOperator;
> -import java.util.function.DoubleConsumer;
> -import java.util.function.DoubleFunction;
> -import java.util.function.DoublePredicate;
> -import java.util.function.DoubleSupplier;
> -import java.util.function.DoubleToIntFunction;
> -import java.util.function.DoubleToLongFunction;
> import java.util.function.Function;
> -import java.util.function.IntBinaryOperator;
> -import java.util.function.IntConsumer;
> -import java.util.function.IntFunction;
> -import java.util.function.IntPredicate;
> -import java.util.function.IntSupplier;
> -import java.util.function.IntToDoubleFunction;
> -import java.util.function.IntToLongFunction;
> -import java.util.function.LongBinaryOperator;
> -import java.util.function.LongConsumer;
> -import java.util.function.LongFunction;
> -import java.util.function.LongPredicate;
> -import java.util.function.LongSupplier;
> -import java.util.function.LongToDoubleFunction;
> -import java.util.function.LongToIntFunction;
> -import java.util.function.ObjDoubleConsumer;
> -import java.util.function.ObjIntConsumer;
> -import java.util.function.ObjLongConsumer;
> import java.util.function.Predicate;
> import java.util.function.Supplier;
> -import java.util.function.ToDoubleBiFunction;
> -import java.util.function.ToDoubleFunction;
> -import java.util.function.ToIntBiFunction;
> -import java.util.function.ToIntFunction;
> -import java.util.function.ToLongBiFunction;
> -import java.util.function.ToLongFunction;
> import java.util.stream.Stream;
>
> import org.apache.commons.lang3.Streams.FailableStream;
> +import org.apache.commons.lang3.function.FailableBooleanSupplier;
> +import org.apache.commons.lang3.function.FailableDoubleBinaryOperator;
> +import org.apache.commons.lang3.function.FailableDoubleConsumer;
> +import org.apache.commons.lang3.function.FailableDoubleSupplier;
> +import org.apache.commons.lang3.function.FailableIntConsumer;
> +import org.apache.commons.lang3.function.FailableIntSupplier;
> +import org.apache.commons.lang3.function.FailableLongConsumer;
> +import org.apache.commons.lang3.function.FailableLongSupplier;
>
> /**
> * This class provides utility functions, and classes for working with
> the {@code java.util.function} package, or more
> @@ -101,6 +78,8 @@ public class Functions {
>
> /**
> * A functional interface like {@link BiConsumer} that declares a
> {@code Throwable}.
> + *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> *
> * @param <O1> Consumed type 1.
> * @param <O2> Consumed type 2.
> @@ -122,6 +101,8 @@ public class Functions {
> /**
> * A functional interface like {@link BiFunction} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <O1> Input type 1.
> * @param <O2> Input type 2.
> * @param <R> Return type.
> @@ -144,6 +125,8 @@ public class Functions {
> /**
> * A functional interface like {@link BiPredicate} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <O1> Predicate type 1.
> * @param <O2> Predicate type 2.
> * @param <T> Thrown exception.
> @@ -163,26 +146,10 @@ public class Functions {
> }
>
> /**
> - * A functional interface like {@link BooleanSupplier} that declares
> a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableBooleanSupplier<T extends Throwable> {
> -
> - /**
> - * Supplies a boolean.
> - *
> - * @return a result
> - * @throws T if the supplier fails
> - */
> - boolean getAsBoolean() throws T;
> - }
> -
> - /**
> * A functional interface like {@link java.util.concurrent.Callable}
> that declares a {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <R> Return type.
> * @param <T> Thrown exception.
> */
> @@ -201,6 +168,8 @@ public class Functions {
> /**
> * A functional interface like {@link Consumer} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <O> Consumed type 1.
> * @param <T> Thrown exception.
> */
> @@ -217,140 +186,10 @@ public class Functions {
> }
>
> /**
> - * A functional interface like {@link DoubleBinaryOperator} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoubleBinaryOperator<T extends Throwable> {
> -
> - /**
> - * Applies this operator to the given operands.
> - *
> - * @param left the first operand
> - * @param right the second operand
> - * @return the operator result
> - * @throws T if the operation fails
> - */
> - double applyAsDouble(double left, double right) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoubleConsumer} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoubleConsumer<T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param value the parameter for the consumable to accept
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(double value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoubleFunction} that declares a
> {@code Throwable}.
> - *
> - * @param <R> Return type.
> - * @param <T> Thrown exception.
> - */
> - @FunctionalInterface
> - public interface FailableDoubleFunction<R, T extends Throwable> {
> -
> - /**
> - * Applies this function.
> - *
> - * @param input the input for the function
> - * @return the result of the function
> - * @throws T Thrown when the function fails.
> - */
> - R apply(double input) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoublePredicate} that declares
> a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoublePredicate<T extends Throwable> {
> -
> - /**
> - * Tests the predicate.
> - *
> - * @param value the parameter for the predicate to accept.
> - * @return {@code true} if the input argument matches the
> predicate, {@code false} otherwise.
> - * @throws T Thrown when the consumer fails.
> - */
> - boolean test(double value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoubleSupplier} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoubleSupplier<T extends Throwable> {
> -
> - /**
> - * Supplies a double.
> - *
> - * @return a result
> - * @throws T if the supplier fails
> - */
> - double getAsDouble() throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoubleToIntFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoubleToIntFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - int applyAsInt(double value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link DoubleToLongFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableDoubleToLongFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T if the operation fails
> - */
> - int applyAsLong(double value) throws T;
> - }
> -
> - /**
> * A functional interface like {@link Function} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <I> Input type 1.
> * @param <R> Return type.
> * @param <T> Thrown exception.
> @@ -369,332 +208,10 @@ public class Functions {
> }
>
> /**
> - * A functional interface like {@link IntBinaryOperator} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntBinaryOperator<T extends Throwable> {
> -
> - /**
> - * Applies this operator to the given operands.
> - *
> - * @param left the first operand
> - * @param right the second operand
> - * @return the operator result
> - * @throws T if the operation fails
> - */
> - int applyAsInt(int left, int right) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntConsumer} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntConsumer<T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param value the parameter for the consumable to accept
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(int value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntFunction} that declares a
> {@code Throwable}.
> - *
> - * @param <R> Return type.
> - * @param <T> Thrown exception.
> - */
> - @FunctionalInterface
> - public interface FailableIntFunction<R, T extends Throwable> {
> -
> - /**
> - * Applies this function.
> - *
> - * @param input the input for the function
> - * @return the result of the function
> - * @throws T Thrown when the function fails.
> - */
> - R apply(int input) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntPredicate} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntPredicate<T extends Throwable> {
> -
> - /**
> - * Tests the predicate.
> - *
> - * @param value the parameter for the predicate to accept.
> - * @return {@code true} if the input argument matches the
> predicate, {@code false} otherwise.
> - * @throws T Thrown when the consumer fails.
> - */
> - boolean test(int value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntSupplier} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntSupplier<T extends Throwable> {
> -
> - /**
> - * Supplies an int.
> - *
> - * @return a result
> - * @throws T if the supplier fails
> - */
> - int getAsInt() throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntToDoubleFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntToDoubleFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - double applyAsDouble(int value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link IntToLongFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableIntToLongFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - long applyAsLong(int value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongBinaryOperator} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongBinaryOperator<T extends Throwable> {
> -
> - /**
> - * Applies this operator to the given operands.
> - *
> - * @param left the first operand
> - * @param right the second operand
> - * @return the operator result
> - * @throws T if the operation fails
> - */
> - long applyAsLong(long left, long right) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongConsumer} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongConsumer<T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param object the parameter for the consumable to accept
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(long object) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongFunction} that declares a
> {@code Throwable}.
> - *
> - * @param <R> Return type.
> - * @param <T> Thrown exception.
> - */
> - @FunctionalInterface
> - public interface FailableLongFunction<R, T extends Throwable> {
> -
> - /**
> - * Applies this function.
> - *
> - * @param input the input for the function
> - * @return the result of the function
> - * @throws T Thrown when the function fails.
> - */
> - R apply(long input) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongPredicate} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongPredicate<T extends Throwable> {
> -
> - /**
> - * Tests the predicate.
> - *
> - * @param value the parameter for the predicate to accept.
> - * @return {@code true} if the input argument matches the
> predicate, {@code false} otherwise.
> - * @throws T Thrown when the consumer fails.
> - */
> - boolean test(long value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongSupplier} that declares a
> {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongSupplier<T extends Throwable> {
> -
> - /**
> - * Supplies a long.
> - *
> - * @return a result
> - * @throws T if the supplier fails
> - */
> - long getAsLong() throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongToDoubleFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongToDoubleFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - double applyAsDouble(long value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link LongToIntFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableLongToIntFunction<T extends Throwable> {
> -
> - /**
> - * Applies this function to the given argument.
> - *
> - * @param value the function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - int applyAsInt(long value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ObjDoubleConsumer} that
> declares a {@code Throwable}.
> - *
> - * @param <O> the type of the object argument to the operation.
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableObjDoubleConsumer<O, T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param object the object parameter for the consumable to
> accept.
> - * @param value the double parameter for the consumable to
> accept.
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(O object, double value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ObjIntConsumer} that declares a
> {@code Throwable}.
> - *
> - * @param <O> the type of the object argument to the operation.
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableObjIntConsumer<O, T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param object the object parameter for the consumable to
> accept.
> - * @param value the int parameter for the consumable to accept.
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(O object, int value) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ObjLongConsumer} that declares
> a {@code Throwable}.
> - *
> - * @param <O> the type of the object argument to the operation.
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableObjLongConsumer<O, T extends Throwable> {
> -
> - /**
> - * Accepts the consumer.
> - *
> - * @param object the object parameter for the consumable to
> accept.
> - * @param value the long parameter for the consumable to accept.
> - * @throws T Thrown when the consumer fails.
> - */
> - void accept(O object, long value) throws T;
> - }
> -
> - /**
> * A functional interface like {@link Predicate} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <I> Predicate type 1.
> * @param <T> Thrown exception.
> */
> @@ -714,6 +231,8 @@ public class Functions {
> /**
> * A functional interface like {@link Runnable} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <T> Thrown exception.
> */
> @FunctionalInterface
> @@ -730,6 +249,8 @@ public class Functions {
> /**
> * A functional interface like {@link Supplier} that declares a
> {@code Throwable}.
> *
> + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> + *
> * @param <R> Return type.
> * @param <T> Thrown exception.
> */
> @@ -746,132 +267,6 @@ public class Functions {
> }
>
> /**
> - * A functional interface like {@link ToDoubleBiFunction} that
> declares a {@code Throwable}.
> - *
> - * @param <O1> the type of the first argument to the function
> - * @param <O2> the type of the second argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToDoubleBiFunction<O1, O2, T extends
> Throwable> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @param u the second function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - double applyAsDouble(O1 t, O2 u) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ToDoubleFunction} that declares
> a {@code Throwable}.
> - *
> - * @param <I> the type of the first argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToDoubleFunction<I, T extends Throwable> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - double applyAsDouble(I t) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ToIntBiFunction} that declares
> a {@code Throwable}.
> - *
> - * @param <O1> the type of the first argument to the function
> - * @param <O2> the type of the second argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToIntBiFunction<O1, O2, T extends Throwable>
> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @param u the second function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - int applyAsInt(O1 t, O2 u) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ToIntFunction} that declares a
> {@code Throwable}.
> - *
> - * @param <I> the type of the first argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToIntFunction<I, T extends Throwable> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - int applyAsInt(I t) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ToLongBiFunction} that declares
> a {@code Throwable}.
> - *
> - * @param <O1> the type of the first argument to the function
> - * @param <O2> the type of the second argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToLongBiFunction<O1, O2, T extends
> Throwable> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @param u the second function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - long applyAsLong(O1 t, O2 u) throws T;
> - }
> -
> - /**
> - * A functional interface like {@link ToLongFunction} that declares a
> {@code Throwable}.
> - *
> - * @param <I> the type of the first argument to the function
> - * @param <T> Thrown exception.
> - * @since 3.11
> - */
> - @FunctionalInterface
> - public interface FailableToLongFunction<I, T extends Throwable> {
> -
> - /**
> - * Applies this function to the given arguments.
> - *
> - * @param t the first function argument
> - * @return the function result
> - * @throws T Thrown when the function fails.
> - */
> - long applyAsLong(I t) throws T;
> - }
> -
> - /**
> * Consumes a consumer and rethrows any exception as a {@link
> RuntimeException}.
> *
> * @param consumer the consumer to consume
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> new file mode 100644
> index 0000000..0deaef5
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.BooleanSupplier;
> +
> +/**
> + * A functional interface like {@link BooleanSupplier} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableBooleanSupplier<T extends Throwable> {
> +
> + /**
> + * Supplies a boolean.
> + *
> + * @return a result
> + * @throws T if the supplier fails
> + */
> + boolean getAsBoolean() throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> new file mode 100644
> index 0000000..db58976
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleBinaryOperator;
> +
> +/**
> + * A functional interface like {@link DoubleBinaryOperator} that declares
> a {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleBinaryOperator<T extends Throwable> {
> +
> + /**
> + * Applies this operator to the given operands.
> + *
> + * @param left the first operand
> + * @param right the second operand
> + * @return the operator result
> + * @throws T if the operation fails
> + */
> + double applyAsDouble(double left, double right) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> new file mode 100644
> index 0000000..ade6e0c
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleConsumer;
> +
> +/**
> + * A functional interface like {@link DoubleConsumer} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleConsumer<T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param value the parameter for the consumable to accept
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(double value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> new file mode 100644
> index 0000000..156b204
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleFunction;
> +
> +/**
> + * A functional interface like {@link DoubleFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <R> Return type.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleFunction<R, T extends Throwable> {
> +
> + /**
> + * Applies this function.
> + *
> + * @param input the input for the function
> + * @return the result of the function
> + * @throws T Thrown when the function fails.
> + */
> + R apply(double input) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> new file mode 100644
> index 0000000..fda8786
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoublePredicate;
> +
> +/**
> + * A functional interface like {@link DoublePredicate} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoublePredicate<T extends Throwable> {
> +
> + /**
> + * Tests the predicate.
> + *
> + * @param value the parameter for the predicate to accept.
> + * @return {@code true} if the input argument matches the predicate,
> {@code false} otherwise.
> + * @throws T Thrown when the consumer fails.
> + */
> + boolean test(double value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> new file mode 100644
> index 0000000..9fb751b
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleSupplier;
> +
> +/**
> + * A functional interface like {@link DoubleSupplier} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleSupplier<T extends Throwable> {
> +
> + /**
> + * Supplies a double.
> + *
> + * @return a result
> + * @throws T if the supplier fails
> + */
> + double getAsDouble() throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> new file mode 100644
> index 0000000..00db9f3
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleToIntFunction;
> +
> +/**
> + * A functional interface like {@link DoubleToIntFunction} that declares
> a {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleToIntFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + int applyAsInt(double value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> new file mode 100644
> index 0000000..0eae76c
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.DoubleToLongFunction;
> +
> +/**
> + * A functional interface like {@link DoubleToLongFunction} that declares
> a {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableDoubleToLongFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T if the operation fails
> + */
> + int applyAsLong(double value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> new file mode 100644
> index 0000000..3eaca9d
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntBinaryOperator;
> +
> +/**
> + * A functional interface like {@link IntBinaryOperator} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntBinaryOperator<T extends Throwable> {
> +
> + /**
> + * Applies this operator to the given operands.
> + *
> + * @param left the first operand
> + * @param right the second operand
> + * @return the operator result
> + * @throws T if the operation fails
> + */
> + int applyAsInt(int left, int right) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> new file mode 100644
> index 0000000..54e7710
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntConsumer;
> +
> +/**
> + * A functional interface like {@link IntConsumer} that declares a {@code
> Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntConsumer<T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param value the parameter for the consumable to accept
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(int value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> new file mode 100644
> index 0000000..07e35c6
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntFunction;
> +
> +/**
> + * A functional interface like {@link IntFunction} that declares a {@code
> Throwable}.
> + *
> + * @param <R> Return type.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntFunction<R, T extends Throwable> {
> +
> + /**
> + * Applies this function.
> + *
> + * @param input the input for the function
> + * @return the result of the function
> + * @throws T Thrown when the function fails.
> + */
> + R apply(int input) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> new file mode 100644
> index 0000000..40e3877
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntPredicate;
> +
> +/**
> + * A functional interface like {@link IntPredicate} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntPredicate<T extends Throwable> {
> +
> + /**
> + * Tests the predicate.
> + *
> + * @param value the parameter for the predicate to accept.
> + * @return {@code true} if the input argument matches the predicate,
> {@code false} otherwise.
> + * @throws T Thrown when the consumer fails.
> + */
> + boolean test(int value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> new file mode 100644
> index 0000000..fed9cd2
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntSupplier;
> +
> +/**
> + * A functional interface like {@link IntSupplier} that declares a {@code
> Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntSupplier<T extends Throwable> {
> +
> + /**
> + * Supplies an int.
> + *
> + * @return a result
> + * @throws T if the supplier fails
> + */
> + int getAsInt() throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> new file mode 100644
> index 0000000..f0d9164
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntToDoubleFunction;
> +
> +/**
> + * A functional interface like {@link IntToDoubleFunction} that declares
> a {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntToDoubleFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + double applyAsDouble(int value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> new file mode 100644
> index 0000000..f88d5ef
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.IntToLongFunction;
> +
> +/**
> + * A functional interface like {@link IntToLongFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableIntToLongFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + long applyAsLong(int value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> new file mode 100644
> index 0000000..e58acf4
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongBinaryOperator;
> +
> +/**
> + * A functional interface like {@link LongBinaryOperator} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongBinaryOperator<T extends Throwable> {
> +
> + /**
> + * Applies this operator to the given operands.
> + *
> + * @param left the first operand
> + * @param right the second operand
> + * @return the operator result
> + * @throws T if the operation fails
> + */
> + long applyAsLong(long left, long right) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> new file mode 100644
> index 0000000..7eb784f
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongConsumer;
> +
> +/**
> + * A functional interface like {@link LongConsumer} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongConsumer<T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param object the parameter for the consumable to accept
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(long object) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> new file mode 100644
> index 0000000..904f946
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongFunction;
> +
> +/**
> + * A functional interface like {@link LongFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <R> Return type.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongFunction<R, T extends Throwable> {
> +
> + /**
> + * Applies this function.
> + *
> + * @param input the input for the function
> + * @return the result of the function
> + * @throws T Thrown when the function fails.
> + */
> + R apply(long input) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> new file mode 100644
> index 0000000..259b82e
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongPredicate;
> +
> +/**
> + * A functional interface like {@link LongPredicate} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongPredicate<T extends Throwable> {
> +
> + /**
> + * Tests the predicate.
> + *
> + * @param value the parameter for the predicate to accept.
> + * @return {@code true} if the input argument matches the predicate,
> {@code false} otherwise.
> + * @throws T Thrown when the consumer fails.
> + */
> + boolean test(long value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> new file mode 100644
> index 0000000..67a1aa4
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> @@ -0,0 +1,38 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongSupplier;
> +
> +/**
> + * A functional interface like {@link LongSupplier} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongSupplier<T extends Throwable> {
> +
> + /**
> + * Supplies a long.
> + *
> + * @return a result
> + * @throws T if the supplier fails
> + */
> + long getAsLong() throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
> new file mode 100644
> index 0000000..dcd64ec
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongToDoubleFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongToDoubleFunction;
> +
> +/**
> + * A functional interface like {@link LongToDoubleFunction} that declares
> a {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongToDoubleFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + double applyAsDouble(long value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
> new file mode 100644
> index 0000000..80cb6ae
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableLongToIntFunction.java
> @@ -0,0 +1,39 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.LongToIntFunction;
> +
> +/**
> + * A functional interface like {@link LongToIntFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableLongToIntFunction<T extends Throwable> {
> +
> + /**
> + * Applies this function to the given argument.
> + *
> + * @param value the function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + int applyAsInt(long value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
> new file mode 100644
> index 0000000..a18d3f3
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableObjDoubleConsumer.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ObjDoubleConsumer;
> +
> +/**
> + * A functional interface like {@link ObjDoubleConsumer} that declares a
> {@code Throwable}.
> + *
> + * @param <O> the type of the object argument to the operation.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableObjDoubleConsumer<O, T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param object the object parameter for the consumable to accept.
> + * @param value the double parameter for the consumable to accept.
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(O object, double value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
> new file mode 100644
> index 0000000..21bf5cd
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableObjIntConsumer.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ObjIntConsumer;
> +
> +/**
> + * A functional interface like {@link ObjIntConsumer} that declares a
> {@code Throwable}.
> + *
> + * @param <O> the type of the object argument to the operation.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableObjIntConsumer<O, T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param object the object parameter for the consumable to accept.
> + * @param value the int parameter for the consumable to accept.
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(O object, int value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
> b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
> new file mode 100644
> index 0000000..32c4256
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableObjLongConsumer.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ObjLongConsumer;
> +
> +/**
> + * A functional interface like {@link ObjLongConsumer} that declares a
> {@code Throwable}.
> + *
> + * @param <O> the type of the object argument to the operation.
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableObjLongConsumer<O, T extends Throwable> {
> +
> + /**
> + * Accepts the consumer.
> + *
> + * @param object the object parameter for the consumable to accept.
> + * @param value the long parameter for the consumable to accept.
> + * @throws T Thrown when the consumer fails.
> + */
> + void accept(O object, long value) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
> new file mode 100644
> index 0000000..de932f4
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleBiFunction.java
> @@ -0,0 +1,42 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToDoubleBiFunction;
> +
> +/**
> + * A functional interface like {@link ToDoubleBiFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <O1> the type of the first argument to the function
> + * @param <O2> the type of the second argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToDoubleBiFunction<O1, O2, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @param u the second function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + double applyAsDouble(O1 t, O2 u) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
> new file mode 100644
> index 0000000..1edc934
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToDoubleFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToDoubleFunction;
> +
> +/**
> + * A functional interface like {@link ToDoubleFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <I> the type of the first argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToDoubleFunction<I, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + double applyAsDouble(I t) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
> new file mode 100644
> index 0000000..126a80c
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToIntBiFunction.java
> @@ -0,0 +1,42 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToIntBiFunction;
> +
> +/**
> + * A functional interface like {@link ToIntBiFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <O1> the type of the first argument to the function
> + * @param <O2> the type of the second argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToIntBiFunction<O1, O2, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @param u the second function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + int applyAsInt(O1 t, O2 u) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
> new file mode 100644
> index 0000000..27c2dae
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToIntFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToIntFunction;
> +
> +/**
> + * A functional interface like {@link ToIntFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <I> the type of the first argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToIntFunction<I, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + int applyAsInt(I t) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
> new file mode 100644
> index 0000000..dcf2fca
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToLongBiFunction.java
> @@ -0,0 +1,42 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToLongBiFunction;
> +
> +/**
> + * A functional interface like {@link ToLongBiFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <O1> the type of the first argument to the function
> + * @param <O2> the type of the second argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToLongBiFunction<O1, O2, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @param u the second function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + long applyAsLong(O1 t, O2 u) throws T;
> +}
> \ No newline at end of file
> diff --git
> a/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
> b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
> new file mode 100644
> index 0000000..9995411
> --- /dev/null
> +++
> b/src/main/java/org/apache/commons/lang3/function/FailableToLongFunction.java
> @@ -0,0 +1,40 @@
> +/*
> + * Licensed to the Apache Software Foundation (ASF) under one or more
> + * contributor license agreements. See the NOTICE file distributed with
> + * this work for additional information regarding copyright ownership.
> + * The ASF licenses this file to You under the Apache License, Version 2.0
> + * (the "License"); you may not use this file except in compliance with
> + * the License. You may obtain a copy of the License at
> + *
> + * http://www.apache.org/licenses/LICENSE-2.0
> + *
> + * Unless required by applicable law or agreed to in writing, software
> + * distributed under the License is distributed on an "AS IS" BASIS,
> + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> implied.
> + * See the License for the specific language governing permissions and
> + * limitations under the License.
> + */
> +
> +package org.apache.commons.lang3.function;
> +
> +import java.util.function.ToLongFunction;
> +
> +/**
> + * A functional interface like {@link ToLongFunction} that declares a
> {@code Throwable}.
> + *
> + * @param <I> the type of the first argument to the function
> + * @param <T> Thrown exception.
> + * @since 3.11
> + */
> +@FunctionalInterface
> +public interface FailableToLongFunction<I, T extends Throwable> {
> +
> + /**
> + * Applies this function to the given arguments.
> + *
> + * @param t the first function argument
> + * @return the function result
> + * @throws T Thrown when the function fails.
> + */
> + long applyAsLong(I t) throws T;
> +}
> \ No newline at end of file
> diff --git a/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> b/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> index 36ed6ca..3fec18e 100644
> --- a/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> +++ b/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> @@ -710,15 +710,6 @@ class FunctionsTest {
> }
>
> @Test
> - public void testDoublePredicate() throws Throwable {
> - FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableDoublePredicate<Throwable>
> failablePredicate = t1 -> FailureOnOddInvocations
> - .testDouble(t1);
> - assertThrows(SomeException.class, () ->
> failablePredicate.test(1d));
> - failablePredicate.test(1d);
> - }
> -
> - @Test
> public void testFunction() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<?, ?> testable = new Testable<>(ise);
> @@ -881,24 +872,6 @@ class FunctionsTest {
> }
>
> @Test
> - public void testIntPredicate() throws Throwable {
> - FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableIntPredicate<Throwable> failablePredicate
> = t1 -> FailureOnOddInvocations
> - .testInt(t1);
> - assertThrows(SomeException.class, () ->
> failablePredicate.test(1));
> - failablePredicate.test(1);
> - }
> -
> - @Test
> - public void testLongPredicate() throws Throwable {
> - FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableLongPredicate<Throwable>
> failablePredicate = t1 -> FailureOnOddInvocations
> - .testLong(t1);
> - assertThrows(SomeException.class, () ->
> failablePredicate.test(1l));
> - failablePredicate.test(1l);
> - }
> -
> - @Test
> @DisplayName("Test that asPredicate(FailablePredicate) is converted
> to -> Predicate ")
> public void testPredicate() {
> FailureOnOddInvocations.invocations = 0;
> @@ -1025,36 +998,6 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableBooleanSupplier_Object_Throwable() {
> - new Functions.FailableBooleanSupplier<Throwable>() {
> -
> - @Override
> - public boolean getAsBoolean() throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableBooleanSupplier_String_IOException() {
> - new Functions.FailableBooleanSupplier<IOException>() {
> -
> - @Override
> - public boolean getAsBoolean() throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> void testThrows_FailableCallable_Object_Throwable() {
> new Functions.FailableCallable<Object, Throwable>() {
>
> @@ -1117,187 +1060,6 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleBinaryOperator_Object_Throwable() {
> - new Functions.FailableDoubleBinaryOperator<Throwable>() {
> -
> - @Override
> - public double applyAsDouble(double left, double right) throws
> Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleBinaryOperator_String_IOException() {
> - new Functions.FailableDoubleBinaryOperator<IOException>() {
> -
> - @Override
> - public double applyAsDouble(double left, double right) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableDoubleConsumer_Object_Throwable() {
> - new Functions.FailableDoubleConsumer<Throwable>() {
> -
> - @Override
> - public void accept(double value) throws Throwable {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleConsumer_String_IOException() {
> - new Functions.FailableDoubleConsumer<IOException>() {
> -
> - @Override
> - public void accept(double value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableDoubleFunction_Object_Throwable() {
> - new Functions.FailableDoubleFunction<Object, Throwable>() {
> -
> - @Override
> - public Object apply(double input) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleFunction_String_IOException() {
> - new Functions.FailableDoubleFunction<String, IOException>() {
> -
> - @Override
> - public String apply(double input) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableDoubleSupplier_Object_Throwable() {
> - new Functions.FailableDoubleSupplier<Throwable>() {
> -
> - @Override
> - public double getAsDouble() throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleSupplier_String_IOException() {
> - new Functions.FailableDoubleSupplier<IOException>() {
> -
> - @Override
> - public double getAsDouble() throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableDoubleToIntFunction_Object_Throwable() {
> - new Functions.FailableDoubleToIntFunction<Throwable>() {
> -
> - @Override
> - public int applyAsInt(double value) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleToIntFunction_String_IOException() {
> - new Functions.FailableDoubleToIntFunction<IOException>() {
> -
> - @Override
> - public int applyAsInt(double value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableDoubleToLongFunction_Object_Throwable() {
> - new Functions.FailableDoubleToLongFunction<Throwable>() {
> -
> - @Override
> - public int applyAsLong(double value) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableDoubleToLongFunction_String_IOException() {
> - new Functions.FailableDoubleToLongFunction<IOException>() {
> -
> - @Override
> - public int applyAsLong(double value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> void testThrows_FailableFunction_Object_Throwable() {
> new Functions.FailableFunction<Object, Object, Throwable>() {
>
> @@ -1328,43 +1090,12 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntBinaryOperator_Object_Throwable() {
> - new Functions.FailableIntBinaryOperator<Throwable>() {
> -
> - @Override
> - public int applyAsInt(int left, int right) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableIntBinaryOperator_String_IOException() {
> - new Functions.FailableIntBinaryOperator<IOException>() {
> -
> - @Override
> - public int applyAsInt(int left, int right) throws IOException
> {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableIntConsumer_Object_Throwable() {
> - new Functions.FailableIntConsumer<Throwable>() {
> + void testThrows_FailablePredicate_Object_Throwable() {
> + new Functions.FailablePredicate<Object, Throwable>() {
>
> @Override
> - public void accept(int value) throws Throwable {
> + public boolean test(Object object) throws Throwable {
> throw new IOException("test");
> -
> }
> };
> }
> @@ -1374,11 +1105,11 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntConsumer_String_IOException() {
> - new Functions.FailableIntConsumer<IOException>() {
> + void testThrows_FailablePredicate_String_IOException() {
> + new Functions.FailablePredicate<String, IOException>() {
>
> @Override
> - public void accept(int value) throws IOException {
> + public boolean test(String object) throws IOException {
> throw new IOException("test");
> }
> };
> @@ -1389,42 +1120,13 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntFunction_Object_Throwable() {
> - new Functions.FailableIntFunction<Object, Throwable>() {
> -
> - @Override
> - public Object apply(int input) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableIntFunction_String_IOException() {
> - new Functions.FailableIntFunction<String, IOException>() {
> + void testThrows_FailableRunnable_Object_Throwable() {
> + new Functions.FailableRunnable<Throwable>() {
>
> @Override
> - public String apply(int input) throws IOException {
> + public void run() throws Throwable {
> throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableIntSupplier_Object_Throwable() {
> - new Functions.FailableIntSupplier<Throwable>() {
>
> - @Override
> - public int getAsInt() throws Throwable {
> - throw new IOException("test");
> }
> };
> }
> @@ -1434,11 +1136,11 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntSupplier_String_IOException() {
> - new Functions.FailableIntSupplier<IOException>() {
> + void testThrows_FailableRunnable_String_IOException() {
> + new Functions.FailableRunnable<IOException>() {
>
> @Override
> - public int getAsInt() throws IOException {
> + public void run() throws IOException {
> throw new IOException("test");
> }
> };
> @@ -1449,11 +1151,11 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntToDoubleFunction_Object_Throwable() {
> - new Functions.FailableIntToDoubleFunction<Throwable>() {
> + void testThrows_FailableSupplier_Object_Throwable() {
> + new Functions.FailableSupplier<Object, Throwable>() {
>
> @Override
> - public double applyAsDouble(int value) throws Throwable {
> + public Object get() throws Throwable {
> throw new IOException("test");
> }
> };
> @@ -1464,404 +1166,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntToDoubleFunction_String_IOException() {
> - new Functions.FailableIntToDoubleFunction<IOException>() {
> -
> - @Override
> - public double applyAsDouble(int value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableIntToLongFunction_Object_Throwable() {
> - new Functions.FailableIntToLongFunction<Throwable>() {
> -
> - @Override
> - public long applyAsLong(int value) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableIntToLongFunction_String_IOException() {
> - new Functions.FailableIntToLongFunction<IOException>() {
> -
> - @Override
> - public long applyAsLong(int value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongBinaryOperator_Object_Throwable() {
> - new Functions.FailableLongBinaryOperator<Throwable>() {
> -
> - @Override
> - public long applyAsLong(long left, long right) throws
> Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongBinaryOperator_String_IOException() {
> - new Functions.FailableLongBinaryOperator<IOException>() {
> -
> - @Override
> - public long applyAsLong(long left, long right) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongConsumer_Object_Throwable() {
> - new Functions.FailableLongConsumer<Throwable>() {
> -
> - @Override
> - public void accept(long object) throws Throwable {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongConsumer_String_IOException() {
> - new Functions.FailableLongConsumer<IOException>() {
> -
> - @Override
> - public void accept(long object) throws IOException {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongFunction_Object_Throwable() {
> - new Functions.FailableLongFunction<Object, Throwable>() {
> -
> - @Override
> - public Object apply(long input) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongFunction_String_IOException() {
> - new Functions.FailableLongFunction<String, IOException>() {
> -
> - @Override
> - public String apply(long input) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongSupplier_Object_Throwable() {
> - new Functions.FailableLongSupplier<Throwable>() {
> -
> - @Override
> - public long getAsLong() throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongSupplier_String_IOException() {
> - new Functions.FailableLongSupplier<IOException>() {
> -
> - @Override
> - public long getAsLong() throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongToDoubleFunction_Object_Throwable() {
> - new Functions.FailableLongToDoubleFunction<Throwable>() {
> -
> - @Override
> - public double applyAsDouble(long value) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongToDoubleFunction_String_IOException() {
> - new Functions.FailableLongToDoubleFunction<IOException>() {
> -
> - @Override
> - public double applyAsDouble(long value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableLongToIntFunction_Object_Throwable() {
> - new Functions.FailableLongToIntFunction<Throwable>() {
> -
> - @Override
> - public int applyAsInt(long value) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableLongToIntFunction_String_IOException() {
> - new Functions.FailableLongToIntFunction<IOException>() {
> -
> - @Override
> - public int applyAsInt(long value) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableObjDoubleConsumer_Object_Throwable() {
> - new Functions.FailableObjDoubleConsumer<Object, Throwable>() {
> -
> - @Override
> - public void accept(Object object, double value) throws
> Throwable {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableObjDoubleConsumer_String_IOException() {
> - new Functions.FailableObjDoubleConsumer<String, IOException>() {
> -
> - @Override
> - public void accept(String object, double value) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableObjIntConsumer_Object_Throwable() {
> - new Functions.FailableObjIntConsumer<Object, Throwable>() {
> -
> - @Override
> - public void accept(Object object, int value) throws Throwable
> {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableObjIntConsumer_String_IOException() {
> - new Functions.FailableObjIntConsumer<String, IOException>() {
> -
> - @Override
> - public void accept(String object, int value) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableObjLongConsumer_Object_Throwable() {
> - new Functions.FailableObjLongConsumer<Object, Throwable>() {
> -
> - @Override
> - public void accept(Object object, long value) throws
> Throwable {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableObjLongConsumer_String_IOException() {
> - new Functions.FailableObjLongConsumer<String, IOException>() {
> -
> - @Override
> - public void accept(String object, long value) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailablePredicate_Object_Throwable() {
> - new Functions.FailablePredicate<Object, Throwable>() {
> -
> - @Override
> - public boolean test(Object object) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailablePredicate_String_IOException() {
> - new Functions.FailablePredicate<String, IOException>() {
> -
> - @Override
> - public boolean test(String object) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableRunnable_Object_Throwable() {
> - new Functions.FailableRunnable<Throwable>() {
> -
> - @Override
> - public void run() throws Throwable {
> - throw new IOException("test");
> -
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableRunnable_String_IOException() {
> - new Functions.FailableRunnable<IOException>() {
> -
> - @Override
> - public void run() throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableSupplier_Object_Throwable() {
> - new Functions.FailableSupplier<Object, Throwable>() {
> -
> - @Override
> - public Object get() throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableSupplier_String_IOException() {
> - new Functions.FailableSupplier<String, IOException>() {
> + void testThrows_FailableSupplier_String_IOException() {
> + new Functions.FailableSupplier<String, IOException>() {
>
> @Override
> public String get() throws IOException {
> @@ -1870,186 +1176,6 @@ class FunctionsTest {
> };
> }
>
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToDoubleBiFunction_Object_Throwable() {
> - new Functions.FailableToDoubleBiFunction<Object, Object,
> Throwable>() {
> -
> - @Override
> - public double applyAsDouble(Object t, Object u) throws
> Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToDoubleBiFunction_String_IOException() {
> - new Functions.FailableToDoubleBiFunction<String, String,
> IOException>() {
> -
> - @Override
> - public double applyAsDouble(String t, String u) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToDoubleFunction_Object_Throwable() {
> - new Functions.FailableToDoubleFunction<Object, Throwable>() {
> -
> - @Override
> - public double applyAsDouble(Object t) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToDoubleFunction_String_IOException() {
> - new Functions.FailableToDoubleFunction<String, IOException>() {
> -
> - @Override
> - public double applyAsDouble(String t) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToIntBiFunction_Object_Throwable() {
> - new Functions.FailableToIntBiFunction<Object, Object,
> Throwable>() {
> -
> - @Override
> - public int applyAsInt(Object t, Object u) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToIntBiFunction_String_IOException() {
> - new Functions.FailableToIntBiFunction<String, String,
> IOException>() {
> -
> - @Override
> - public int applyAsInt(String t, String u) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToIntFunction_Object_Throwable() {
> - new Functions.FailableToIntFunction<Object, Throwable>() {
> -
> - @Override
> - public int applyAsInt(Object t) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToIntFunction_String_IOException() {
> - new Functions.FailableToIntFunction<String, IOException>() {
> -
> - @Override
> - public int applyAsInt(String t) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToLongBiFunction_Object_Throwable() {
> - new Functions.FailableToLongBiFunction<Object, Object,
> Throwable>() {
> -
> - @Override
> - public long applyAsLong(Object t, Object u) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToLongBiFunction_String_IOException() {
> - new Functions.FailableToLongBiFunction<String, String,
> IOException>() {
> -
> - @Override
> - public long applyAsLong(String t, String u) throws
> IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception. using the top level generic types
> - * Object and Throwable.
> - */
> - @Test
> - void testThrows_FailableToLongFunction_Object_Throwable() {
> - new Functions.FailableToLongFunction<Object, Throwable>() {
> -
> - @Override
> - public long applyAsLong(Object t) throws Throwable {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> - /**
> - * Tests that our failable interface is properly defined to throw any
> exception using String and IOExceptions as
> - * generic test types.
> - */
> - @Test
> - void testThrows_FailableToLongFunction_String_IOException() {
> - new Functions.FailableToLongFunction<String, IOException>() {
> -
> - @Override
> - public long applyAsLong(String t) throws IOException {
> - throw new IOException("test");
> - }
> - };
> - }
> -
> @Test
> public void testTryWithResources() {
> final CloseableObject co = new CloseableObject();
> diff --git a/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
> similarity index 70%
> copy from src/test/java/org/apache/commons/lang3/FunctionsTest.java
> copy to
> src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
> index 36ed6ca..c0ce3af 100644
> --- a/src/test/java/org/apache/commons/lang3/FunctionsTest.java
> +++
> b/src/test/java/org/apache/commons/lang3/function/FailableFunctionsTest.java
> @@ -14,7 +14,7 @@
> * See the License for the specific language governing permissions and
> * limitations under the License.
> */
> -package org.apache.commons.lang3;
> +package org.apache.commons.lang3.function;
>
> import static org.junit.jupiter.api.Assertions.assertEquals;
> import static org.junit.jupiter.api.Assertions.assertFalse;
> @@ -27,25 +27,14 @@ import static
> org.junit.jupiter.api.Assertions.assertTrue;
> import java.io.IOException;
> import java.io.UncheckedIOException;
> import java.lang.reflect.UndeclaredThrowableException;
> -import java.util.concurrent.Callable;
> -import java.util.function.BiConsumer;
> -import java.util.function.BiFunction;
> -import java.util.function.BiPredicate;
> -import java.util.function.Consumer;
> -import java.util.function.Function;
> -import java.util.function.Predicate;
> -import java.util.function.Supplier;
> -
> -import org.apache.commons.lang3.Functions.FailableBiConsumer;
> -import org.apache.commons.lang3.Functions.FailableBiFunction;
> -import org.apache.commons.lang3.Functions.FailableCallable;
> -import org.apache.commons.lang3.Functions.FailableConsumer;
> -import org.apache.commons.lang3.Functions.FailableFunction;
> -import org.apache.commons.lang3.Functions.FailableSupplier;
> -import org.junit.jupiter.api.DisplayName;
> +
> +import org.apache.commons.lang3.Functions;
> import org.junit.jupiter.api.Test;
>
> -class FunctionsTest {
> +/**
> + * Tests "failable" interfaces defined in this package.
> + */
> +public class FailableFunctionsTest {
>
> public static class CloseableObject {
> private boolean closed;
> @@ -268,52 +257,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptBiConsumer() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(null);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(Testable::test, testable, ise));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - e = assertThrows(OutOfMemoryError.class, () ->
> Functions.accept(Testable::test, testable, error));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> Functions.accept(Testable::test, testable, ioe));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - testable.setThrowable(null);
> - Functions.accept(Testable::test, testable, (Throwable) null);
> - }
> -
> - @Test
> - void testAcceptConsumer() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(ise);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(Testable::test, testable));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - testable.setThrowable(error);
> - e = assertThrows(OutOfMemoryError.class, () ->
> Functions.accept(Testable::test, testable));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> Functions.accept(Testable::test, testable));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - testable.setThrowable(null);
> - Functions.accept(Testable::test, testable);
> - }
> -
> - @Test
> - void testAcceptDoubleConsumer() {
> + public void testAcceptDoubleConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<?, Double> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(testable::testDouble, 1d));
> @@ -340,7 +284,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptIntConsumer() {
> + public void testAcceptIntConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<?, Integer> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(testable::testInt, 1));
> @@ -367,7 +311,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptLongConsumer() {
> + public void testAcceptLongConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<?, Long> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(testable::testLong, 1L));
> @@ -394,7 +338,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptObjDoubleConsumer() {
> + public void testAcceptObjDoubleConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<String, Double> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class,
> @@ -426,7 +370,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptObjIntConsumer() {
> + public void testAcceptObjIntConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<String, Integer> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(testable::testObjInt, "X", 1));
> @@ -457,7 +401,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAcceptObjLongConsumer() {
> + public void testAcceptObjLongConsumer() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<String, Long> testable = new Testable<>(ise);
> Throwable e = assertThrows(IllegalStateException.class, () ->
> Functions.accept(testable::testObjLong, "X", 1L));
> @@ -550,50 +494,7 @@ class FunctionsTest {
> }
>
> @Test
> - void testAsCallable() {
> - FailureOnOddInvocations.invocations = 0;
> - final FailableCallable<FailureOnOddInvocations, SomeException>
> failableCallable = FailureOnOddInvocations::new;
> - final Callable<FailureOnOddInvocations> callable =
> Functions.asCallable(failableCallable);
> - final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class, callable::call);
> - final Throwable cause = e.getCause();
> - assertNotNull(cause);
> - assertTrue(cause instanceof SomeException);
> - assertEquals("Odd Invocation: 1", cause.getMessage());
> - final FailureOnOddInvocations instance;
> - try {
> - instance = callable.call();
> - } catch (final Exception ex) {
> - throw Functions.rethrow(ex);
> - }
> - assertNotNull(instance);
> - }
> -
> - @Test
> - void testAsConsumer() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(ise);
> - final Consumer<Testable<?, ?>> consumer =
> Functions.asConsumer(Testable::test);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> consumer.accept(testable));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - testable.setThrowable(error);
> - e = assertThrows(OutOfMemoryError.class, () ->
> consumer.accept(testable));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> consumer.accept(testable));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - testable.setThrowable(null);
> - Functions.accept(Testable::test, testable);
> - }
> -
> - @Test
> - void testAsRunnable() {
> + public void testAsRunnable() {
> FailureOnOddInvocations.invocations = 0;
> final Runnable runnable =
> Functions.asRunnable(FailureOnOddInvocations::new);
> final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class, runnable::run);
> @@ -607,145 +508,14 @@ class FunctionsTest {
> }
>
> @Test
> - public void testAsSupplier() {
> - FailureOnOddInvocations.invocations = 0;
> - final FailableSupplier<FailureOnOddInvocations, Throwable>
> failableSupplier = FailureOnOddInvocations::new;
> - final Supplier<FailureOnOddInvocations> supplier =
> Functions.asSupplier(failableSupplier);
> - final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class, supplier::get);
> - final Throwable cause = e.getCause();
> - assertNotNull(cause);
> - assertTrue(cause instanceof SomeException);
> - assertEquals("Odd Invocation: 1", cause.getMessage());
> - assertNotNull(supplier.get());
> - }
> -
> - @Test
> - void testBiConsumer() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(null);
> - final FailableBiConsumer<Testable<?, ?>, Throwable, Throwable>
> failableBiConsumer = (t, th) -> {
> - t.setThrowable(th);
> - t.test();
> - };
> - final BiConsumer<Testable<?, ?>, Throwable> consumer =
> Functions.asBiConsumer(failableBiConsumer);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> consumer.accept(testable, ise));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - e = assertThrows(OutOfMemoryError.class, () ->
> consumer.accept(testable, error));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> consumer.accept(testable, ioe));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - consumer.accept(testable, null);
> - }
> -
> - @Test
> - public void testBiFunction() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(ise);
> - final FailableBiFunction<Testable<?, ?>, Throwable, Integer,
> Throwable> failableBiFunction = (t, th) -> {
> - t.setThrowable(th);
> - return Integer.valueOf(t.testAsInteger());
> - };
> - final BiFunction<Testable<?, ?>, Throwable, Integer> biFunction =
> Functions.asBiFunction(failableBiFunction);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> biFunction.apply(testable, ise));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - testable.setThrowable(error);
> - e = assertThrows(OutOfMemoryError.class, () ->
> biFunction.apply(testable, error));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> biFunction.apply(testable, ioe));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - assertEquals(0, biFunction.apply(testable, null).intValue());
> - }
> -
> - @Test
> - @DisplayName("Test that asPredicate(FailableBiPredicate) is converted
> to -> BiPredicate ")
> - public void testBiPredicate() {
> - FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableBiPredicate<Object, Object, Throwable>
> failableBiPredicate = (t1,
> - t2) -> FailureOnOddInvocations.failingBool();
> - final BiPredicate<?, ?> predicate =
> Functions.asBiPredicate(failableBiPredicate);
> - final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class,
> - () -> predicate.test(null, null));
> - final Throwable cause = e.getCause();
> - assertNotNull(cause);
> - assertTrue(cause instanceof SomeException);
> - assertEquals("Odd Invocation: 1", cause.getMessage());
> - final boolean instance = predicate.test(null, null);
> - assertNotNull(instance);
> - }
> -
> - @Test
> - void testCallable() {
> - FailureOnOddInvocations.invocations = 0;
> - final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class,
> - () -> Functions.run(FailureOnOddInvocations::new));
> - final Throwable cause = e.getCause();
> - assertNotNull(cause);
> - assertTrue(cause instanceof SomeException);
> - assertEquals("Odd Invocation: 1", cause.getMessage());
> - final FailureOnOddInvocations instance =
> Functions.call(FailureOnOddInvocations::new);
> - assertNotNull(instance);
> - }
> -
> - @Test
> - public void testConstructor() {
> - // We allow this, which must have been an omission to make the
> ctor private.
> - // We could make the ctor private in 4.0.
> - new Functions();
> - }
> -
> - @Test
> public void testDoublePredicate() throws Throwable {
> FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableDoublePredicate<Throwable>
> failablePredicate = t1 -> FailureOnOddInvocations
> - .testDouble(t1);
> + final FailableDoublePredicate<Throwable> failablePredicate = t1
> -> FailureOnOddInvocations.testDouble(t1);
> assertThrows(SomeException.class, () ->
> failablePredicate.test(1d));
> failablePredicate.test(1d);
> }
>
> @Test
> - public void testFunction() {
> - final IllegalStateException ise = new IllegalStateException();
> - final Testable<?, ?> testable = new Testable<>(ise);
> - final FailableFunction<Throwable, Integer, Throwable>
> failableFunction = th -> {
> - testable.setThrowable(th);
> - return Integer.valueOf(testable.testAsInteger());
> - };
> - final Function<Throwable, Integer> function =
> Functions.asFunction(failableFunction);
> - Throwable e = assertThrows(IllegalStateException.class, () ->
> function.apply(ise));
> - assertSame(ise, e);
> -
> - final Error error = new OutOfMemoryError();
> - testable.setThrowable(error);
> - e = assertThrows(OutOfMemoryError.class, () ->
> function.apply(error));
> - assertSame(error, e);
> -
> - final IOException ioe = new IOException("Unknown I/O error");
> - testable.setThrowable(ioe);
> - e = assertThrows(UncheckedIOException.class, () ->
> function.apply(ioe));
> - final Throwable t = e.getCause();
> - assertNotNull(t);
> - assertSame(ioe, t);
> -
> - assertEquals(0, function.apply(null).intValue());
> - }
> -
> - @Test
> public void testGetAsBooleanSupplier() {
> final IllegalStateException ise = new IllegalStateException();
> final Testable<?, ?> testable = new Testable<>(ise);
> @@ -883,8 +653,7 @@ class FunctionsTest {
> @Test
> public void testIntPredicate() throws Throwable {
> FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableIntPredicate<Throwable> failablePredicate
> = t1 -> FailureOnOddInvocations
> - .testInt(t1);
> + final FailableIntPredicate<Throwable> failablePredicate = t1 ->
> FailureOnOddInvocations.testInt(t1);
> assertThrows(SomeException.class, () ->
> failablePredicate.test(1));
> failablePredicate.test(1);
> }
> @@ -892,31 +661,13 @@ class FunctionsTest {
> @Test
> public void testLongPredicate() throws Throwable {
> FailureOnOddInvocations.invocations = 0;
> - final Functions.FailableLongPredicate<Throwable>
> failablePredicate = t1 -> FailureOnOddInvocations
> - .testLong(t1);
> + final FailableLongPredicate<Throwable> failablePredicate = t1 ->
> FailureOnOddInvocations.testLong(t1);
> assertThrows(SomeException.class, () ->
> failablePredicate.test(1l));
> failablePredicate.test(1l);
> }
>
> @Test
> - @DisplayName("Test that asPredicate(FailablePredicate) is converted
> to -> Predicate ")
> - public void testPredicate() {
> - FailureOnOddInvocations.invocations = 0;
> - final Functions.FailablePredicate<Object, Throwable>
> failablePredicate = t -> FailureOnOddInvocations
> - .failingBool();
> - final Predicate<?> predicate =
> Functions.asPredicate(failablePredicate);
> - final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class,
> - () -> predicate.test(null));
> - final Throwable cause = e.getCause();
> - assertNotNull(cause);
> - assertTrue(cause instanceof SomeException);
> - assertEquals("Odd Invocation: 1", cause.getMessage());
> - final boolean instance = predicate.test(null);
> - assertNotNull(instance);
> - }
> -
> - @Test
> - void testRunnable() {
> + public void testRunnable() {
> FailureOnOddInvocations.invocations = 0;
> final UndeclaredThrowableException e =
> assertThrows(UndeclaredThrowableException.class,
> () -> Functions.run(FailureOnOddInvocations::new));
> @@ -934,7 +685,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableBiConsumer_Object_Throwable() {
> + public void testThrows_FailableBiConsumer_Object_Throwable() {
> new Functions.FailableBiConsumer<Object, Object, Throwable>() {
>
> @Override
> @@ -949,7 +700,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableBiConsumer_String_IOException() {
> + public void testThrows_FailableBiConsumer_String_IOException() {
> new Functions.FailableBiConsumer<String, String, IOException>() {
>
> @Override
> @@ -965,7 +716,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableBiFunction_Object_Throwable() {
> + public void testThrows_FailableBiFunction_Object_Throwable() {
> new Functions.FailableBiFunction<Object, Object, Object,
> Throwable>() {
>
> @Override
> @@ -980,7 +731,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableBiFunction_String_IOException() {
> + public void testThrows_FailableBiFunction_String_IOException() {
> new Functions.FailableBiFunction<String, String, String,
> IOException>() {
>
> @Override
> @@ -995,7 +746,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableBiPredicate_Object_Throwable() {
> + public void testThrows_FailableBiPredicate_Object_Throwable() {
> new Functions.FailableBiPredicate<Object, Object, Throwable>() {
>
> @Override
> @@ -1010,7 +761,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableBiPredicate_String_IOException() {
> + public void testThrows_FailableBiPredicate_String_IOException() {
> new Functions.FailableBiPredicate<String, String, IOException>() {
>
> @Override
> @@ -1025,8 +776,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableBooleanSupplier_Object_Throwable() {
> - new Functions.FailableBooleanSupplier<Throwable>() {
> + public void testThrows_FailableBooleanSupplier_Object_Throwable() {
> + new FailableBooleanSupplier<Throwable>() {
>
> @Override
> public boolean getAsBoolean() throws Throwable {
> @@ -1040,8 +791,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableBooleanSupplier_String_IOException() {
> - new Functions.FailableBooleanSupplier<IOException>() {
> + public void testThrows_FailableBooleanSupplier_String_IOException() {
> + new FailableBooleanSupplier<IOException>() {
>
> @Override
> public boolean getAsBoolean() throws IOException {
> @@ -1055,7 +806,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableCallable_Object_Throwable() {
> + public void testThrows_FailableCallable_Object_Throwable() {
> new Functions.FailableCallable<Object, Throwable>() {
>
> @Override
> @@ -1070,7 +821,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableCallable_String_IOException() {
> + public void testThrows_FailableCallable_String_IOException() {
> new Functions.FailableCallable<String, IOException>() {
>
> @Override
> @@ -1085,7 +836,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableConsumer_Object_Throwable() {
> + public void testThrows_FailableConsumer_Object_Throwable() {
> new Functions.FailableConsumer<Object, Throwable>() {
>
> @Override
> @@ -1101,7 +852,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableConsumer_String_IOException() {
> + public void testThrows_FailableConsumer_String_IOException() {
> new Functions.FailableConsumer<String, IOException>() {
>
> @Override
> @@ -1117,8 +868,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleBinaryOperator_Object_Throwable() {
> - new Functions.FailableDoubleBinaryOperator<Throwable>() {
> + public void
> testThrows_FailableDoubleBinaryOperator_Object_Throwable() {
> + new FailableDoubleBinaryOperator<Throwable>() {
>
> @Override
> public double applyAsDouble(double left, double right) throws
> Throwable {
> @@ -1132,8 +883,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleBinaryOperator_String_IOException() {
> - new Functions.FailableDoubleBinaryOperator<IOException>() {
> + public void
> testThrows_FailableDoubleBinaryOperator_String_IOException() {
> + new FailableDoubleBinaryOperator<IOException>() {
>
> @Override
> public double applyAsDouble(double left, double right) throws
> IOException {
> @@ -1147,8 +898,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleConsumer_Object_Throwable() {
> - new Functions.FailableDoubleConsumer<Throwable>() {
> + public void testThrows_FailableDoubleConsumer_Object_Throwable() {
> + new FailableDoubleConsumer<Throwable>() {
>
> @Override
> public void accept(double value) throws Throwable {
> @@ -1163,8 +914,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleConsumer_String_IOException() {
> - new Functions.FailableDoubleConsumer<IOException>() {
> + public void testThrows_FailableDoubleConsumer_String_IOException() {
> + new FailableDoubleConsumer<IOException>() {
>
> @Override
> public void accept(double value) throws IOException {
> @@ -1178,8 +929,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleFunction_Object_Throwable() {
> - new Functions.FailableDoubleFunction<Object, Throwable>() {
> + public void testThrows_FailableDoubleFunction_Object_Throwable() {
> + new FailableDoubleFunction<Object, Throwable>() {
>
> @Override
> public Object apply(double input) throws Throwable {
> @@ -1193,8 +944,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleFunction_String_IOException() {
> - new Functions.FailableDoubleFunction<String, IOException>() {
> + public void testThrows_FailableDoubleFunction_String_IOException() {
> + new FailableDoubleFunction<String, IOException>() {
>
> @Override
> public String apply(double input) throws IOException {
> @@ -1208,8 +959,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleSupplier_Object_Throwable() {
> - new Functions.FailableDoubleSupplier<Throwable>() {
> + public void testThrows_FailableDoubleSupplier_Object_Throwable() {
> + new FailableDoubleSupplier<Throwable>() {
>
> @Override
> public double getAsDouble() throws Throwable {
> @@ -1223,8 +974,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleSupplier_String_IOException() {
> - new Functions.FailableDoubleSupplier<IOException>() {
> + public void testThrows_FailableDoubleSupplier_String_IOException() {
> + new FailableDoubleSupplier<IOException>() {
>
> @Override
> public double getAsDouble() throws IOException {
> @@ -1238,8 +989,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleToIntFunction_Object_Throwable() {
> - new Functions.FailableDoubleToIntFunction<Throwable>() {
> + public void testThrows_FailableDoubleToIntFunction_Object_Throwable()
> {
> + new FailableDoubleToIntFunction<Throwable>() {
>
> @Override
> public int applyAsInt(double value) throws Throwable {
> @@ -1253,8 +1004,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleToIntFunction_String_IOException() {
> - new Functions.FailableDoubleToIntFunction<IOException>() {
> + public void
> testThrows_FailableDoubleToIntFunction_String_IOException() {
> + new FailableDoubleToIntFunction<IOException>() {
>
> @Override
> public int applyAsInt(double value) throws IOException {
> @@ -1268,8 +1019,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableDoubleToLongFunction_Object_Throwable() {
> - new Functions.FailableDoubleToLongFunction<Throwable>() {
> + public void
> testThrows_FailableDoubleToLongFunction_Object_Throwable() {
> + new FailableDoubleToLongFunction<Throwable>() {
>
> @Override
> public int applyAsLong(double value) throws Throwable {
> @@ -1283,8 +1034,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableDoubleToLongFunction_String_IOException() {
> - new Functions.FailableDoubleToLongFunction<IOException>() {
> + public void
> testThrows_FailableDoubleToLongFunction_String_IOException() {
> + new FailableDoubleToLongFunction<IOException>() {
>
> @Override
> public int applyAsLong(double value) throws IOException {
> @@ -1298,7 +1049,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableFunction_Object_Throwable() {
> + public void testThrows_FailableFunction_Object_Throwable() {
> new Functions.FailableFunction<Object, Object, Throwable>() {
>
> @Override
> @@ -1313,7 +1064,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableFunction_String_IOException() {
> + public void testThrows_FailableFunction_String_IOException() {
> new Functions.FailableFunction<String, String, IOException>() {
>
> @Override
> @@ -1328,8 +1079,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntBinaryOperator_Object_Throwable() {
> - new Functions.FailableIntBinaryOperator<Throwable>() {
> + public void testThrows_FailableIntBinaryOperator_Object_Throwable() {
> + new FailableIntBinaryOperator<Throwable>() {
>
> @Override
> public int applyAsInt(int left, int right) throws Throwable {
> @@ -1343,8 +1094,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntBinaryOperator_String_IOException() {
> - new Functions.FailableIntBinaryOperator<IOException>() {
> + public void testThrows_FailableIntBinaryOperator_String_IOException()
> {
> + new FailableIntBinaryOperator<IOException>() {
>
> @Override
> public int applyAsInt(int left, int right) throws IOException
> {
> @@ -1358,8 +1109,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntConsumer_Object_Throwable() {
> - new Functions.FailableIntConsumer<Throwable>() {
> + public void testThrows_FailableIntConsumer_Object_Throwable() {
> + new FailableIntConsumer<Throwable>() {
>
> @Override
> public void accept(int value) throws Throwable {
> @@ -1374,8 +1125,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntConsumer_String_IOException() {
> - new Functions.FailableIntConsumer<IOException>() {
> + public void testThrows_FailableIntConsumer_String_IOException() {
> + new FailableIntConsumer<IOException>() {
>
> @Override
> public void accept(int value) throws IOException {
> @@ -1389,8 +1140,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntFunction_Object_Throwable() {
> - new Functions.FailableIntFunction<Object, Throwable>() {
> + public void testThrows_FailableIntFunction_Object_Throwable() {
> + new FailableIntFunction<Object, Throwable>() {
>
> @Override
> public Object apply(int input) throws Throwable {
> @@ -1404,8 +1155,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntFunction_String_IOException() {
> - new Functions.FailableIntFunction<String, IOException>() {
> + public void testThrows_FailableIntFunction_String_IOException() {
> + new FailableIntFunction<String, IOException>() {
>
> @Override
> public String apply(int input) throws IOException {
> @@ -1419,8 +1170,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntSupplier_Object_Throwable() {
> - new Functions.FailableIntSupplier<Throwable>() {
> + public void testThrows_FailableIntSupplier_Object_Throwable() {
> + new FailableIntSupplier<Throwable>() {
>
> @Override
> public int getAsInt() throws Throwable {
> @@ -1434,8 +1185,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntSupplier_String_IOException() {
> - new Functions.FailableIntSupplier<IOException>() {
> + public void testThrows_FailableIntSupplier_String_IOException() {
> + new FailableIntSupplier<IOException>() {
>
> @Override
> public int getAsInt() throws IOException {
> @@ -1449,8 +1200,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntToDoubleFunction_Object_Throwable() {
> - new Functions.FailableIntToDoubleFunction<Throwable>() {
> + public void testThrows_FailableIntToDoubleFunction_Object_Throwable()
> {
> + new FailableIntToDoubleFunction<Throwable>() {
>
> @Override
> public double applyAsDouble(int value) throws Throwable {
> @@ -1464,8 +1215,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntToDoubleFunction_String_IOException() {
> - new Functions.FailableIntToDoubleFunction<IOException>() {
> + public void
> testThrows_FailableIntToDoubleFunction_String_IOException() {
> + new FailableIntToDoubleFunction<IOException>() {
>
> @Override
> public double applyAsDouble(int value) throws IOException {
> @@ -1479,8 +1230,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableIntToLongFunction_Object_Throwable() {
> - new Functions.FailableIntToLongFunction<Throwable>() {
> + public void testThrows_FailableIntToLongFunction_Object_Throwable() {
> + new FailableIntToLongFunction<Throwable>() {
>
> @Override
> public long applyAsLong(int value) throws Throwable {
> @@ -1494,8 +1245,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableIntToLongFunction_String_IOException() {
> - new Functions.FailableIntToLongFunction<IOException>() {
> + public void testThrows_FailableIntToLongFunction_String_IOException()
> {
> + new FailableIntToLongFunction<IOException>() {
>
> @Override
> public long applyAsLong(int value) throws IOException {
> @@ -1509,8 +1260,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongBinaryOperator_Object_Throwable() {
> - new Functions.FailableLongBinaryOperator<Throwable>() {
> + public void testThrows_FailableLongBinaryOperator_Object_Throwable() {
> + new FailableLongBinaryOperator<Throwable>() {
>
> @Override
> public long applyAsLong(long left, long right) throws
> Throwable {
> @@ -1524,8 +1275,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongBinaryOperator_String_IOException() {
> - new Functions.FailableLongBinaryOperator<IOException>() {
> + public void
> testThrows_FailableLongBinaryOperator_String_IOException() {
> + new FailableLongBinaryOperator<IOException>() {
>
> @Override
> public long applyAsLong(long left, long right) throws
> IOException {
> @@ -1539,8 +1290,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongConsumer_Object_Throwable() {
> - new Functions.FailableLongConsumer<Throwable>() {
> + public void testThrows_FailableLongConsumer_Object_Throwable() {
> + new FailableLongConsumer<Throwable>() {
>
> @Override
> public void accept(long object) throws Throwable {
> @@ -1555,8 +1306,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongConsumer_String_IOException() {
> - new Functions.FailableLongConsumer<IOException>() {
> + public void testThrows_FailableLongConsumer_String_IOException() {
> + new FailableLongConsumer<IOException>() {
>
> @Override
> public void accept(long object) throws IOException {
> @@ -1571,8 +1322,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongFunction_Object_Throwable() {
> - new Functions.FailableLongFunction<Object, Throwable>() {
> + public void testThrows_FailableLongFunction_Object_Throwable() {
> + new FailableLongFunction<Object, Throwable>() {
>
> @Override
> public Object apply(long input) throws Throwable {
> @@ -1586,8 +1337,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongFunction_String_IOException() {
> - new Functions.FailableLongFunction<String, IOException>() {
> + public void testThrows_FailableLongFunction_String_IOException() {
> + new FailableLongFunction<String, IOException>() {
>
> @Override
> public String apply(long input) throws IOException {
> @@ -1601,8 +1352,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongSupplier_Object_Throwable() {
> - new Functions.FailableLongSupplier<Throwable>() {
> + public void testThrows_FailableLongSupplier_Object_Throwable() {
> + new FailableLongSupplier<Throwable>() {
>
> @Override
> public long getAsLong() throws Throwable {
> @@ -1616,8 +1367,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongSupplier_String_IOException() {
> - new Functions.FailableLongSupplier<IOException>() {
> + public void testThrows_FailableLongSupplier_String_IOException() {
> + new FailableLongSupplier<IOException>() {
>
> @Override
> public long getAsLong() throws IOException {
> @@ -1631,8 +1382,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongToDoubleFunction_Object_Throwable() {
> - new Functions.FailableLongToDoubleFunction<Throwable>() {
> + public void
> testThrows_FailableLongToDoubleFunction_Object_Throwable() {
> + new FailableLongToDoubleFunction<Throwable>() {
>
> @Override
> public double applyAsDouble(long value) throws Throwable {
> @@ -1646,8 +1397,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongToDoubleFunction_String_IOException() {
> - new Functions.FailableLongToDoubleFunction<IOException>() {
> + public void
> testThrows_FailableLongToDoubleFunction_String_IOException() {
> + new FailableLongToDoubleFunction<IOException>() {
>
> @Override
> public double applyAsDouble(long value) throws IOException {
> @@ -1661,8 +1412,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableLongToIntFunction_Object_Throwable() {
> - new Functions.FailableLongToIntFunction<Throwable>() {
> + public void testThrows_FailableLongToIntFunction_Object_Throwable() {
> + new FailableLongToIntFunction<Throwable>() {
>
> @Override
> public int applyAsInt(long value) throws Throwable {
> @@ -1676,8 +1427,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableLongToIntFunction_String_IOException() {
> - new Functions.FailableLongToIntFunction<IOException>() {
> + public void testThrows_FailableLongToIntFunction_String_IOException()
> {
> + new FailableLongToIntFunction<IOException>() {
>
> @Override
> public int applyAsInt(long value) throws IOException {
> @@ -1691,8 +1442,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableObjDoubleConsumer_Object_Throwable() {
> - new Functions.FailableObjDoubleConsumer<Object, Throwable>() {
> + public void testThrows_FailableObjDoubleConsumer_Object_Throwable() {
> + new FailableObjDoubleConsumer<Object, Throwable>() {
>
> @Override
> public void accept(Object object, double value) throws
> Throwable {
> @@ -1707,8 +1458,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableObjDoubleConsumer_String_IOException() {
> - new Functions.FailableObjDoubleConsumer<String, IOException>() {
> + public void testThrows_FailableObjDoubleConsumer_String_IOException()
> {
> + new FailableObjDoubleConsumer<String, IOException>() {
>
> @Override
> public void accept(String object, double value) throws
> IOException {
> @@ -1722,8 +1473,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableObjIntConsumer_Object_Throwable() {
> - new Functions.FailableObjIntConsumer<Object, Throwable>() {
> + public void testThrows_FailableObjIntConsumer_Object_Throwable() {
> + new FailableObjIntConsumer<Object, Throwable>() {
>
> @Override
> public void accept(Object object, int value) throws Throwable
> {
> @@ -1738,8 +1489,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableObjIntConsumer_String_IOException() {
> - new Functions.FailableObjIntConsumer<String, IOException>() {
> + public void testThrows_FailableObjIntConsumer_String_IOException() {
> + new FailableObjIntConsumer<String, IOException>() {
>
> @Override
> public void accept(String object, int value) throws
> IOException {
> @@ -1753,8 +1504,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableObjLongConsumer_Object_Throwable() {
> - new Functions.FailableObjLongConsumer<Object, Throwable>() {
> + public void testThrows_FailableObjLongConsumer_Object_Throwable() {
> + new FailableObjLongConsumer<Object, Throwable>() {
>
> @Override
> public void accept(Object object, long value) throws
> Throwable {
> @@ -1769,8 +1520,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableObjLongConsumer_String_IOException() {
> - new Functions.FailableObjLongConsumer<String, IOException>() {
> + public void testThrows_FailableObjLongConsumer_String_IOException() {
> + new FailableObjLongConsumer<String, IOException>() {
>
> @Override
> public void accept(String object, long value) throws
> IOException {
> @@ -1784,7 +1535,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailablePredicate_Object_Throwable() {
> + public void testThrows_FailablePredicate_Object_Throwable() {
> new Functions.FailablePredicate<Object, Throwable>() {
>
> @Override
> @@ -1799,7 +1550,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailablePredicate_String_IOException() {
> + public void testThrows_FailablePredicate_String_IOException() {
> new Functions.FailablePredicate<String, IOException>() {
>
> @Override
> @@ -1814,7 +1565,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableRunnable_Object_Throwable() {
> + public void testThrows_FailableRunnable_Object_Throwable() {
> new Functions.FailableRunnable<Throwable>() {
>
> @Override
> @@ -1830,7 +1581,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableRunnable_String_IOException() {
> + public void testThrows_FailableRunnable_String_IOException() {
> new Functions.FailableRunnable<IOException>() {
>
> @Override
> @@ -1845,7 +1596,7 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableSupplier_Object_Throwable() {
> + public void testThrows_FailableSupplier_Object_Throwable() {
> new Functions.FailableSupplier<Object, Throwable>() {
>
> @Override
> @@ -1860,7 +1611,7 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableSupplier_String_IOException() {
> + public void testThrows_FailableSupplier_String_IOException() {
> new Functions.FailableSupplier<String, IOException>() {
>
> @Override
> @@ -1875,8 +1626,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToDoubleBiFunction_Object_Throwable() {
> - new Functions.FailableToDoubleBiFunction<Object, Object,
> Throwable>() {
> + public void testThrows_FailableToDoubleBiFunction_Object_Throwable() {
> + new FailableToDoubleBiFunction<Object, Object, Throwable>() {
>
> @Override
> public double applyAsDouble(Object t, Object u) throws
> Throwable {
> @@ -1890,8 +1641,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToDoubleBiFunction_String_IOException() {
> - new Functions.FailableToDoubleBiFunction<String, String,
> IOException>() {
> + public void
> testThrows_FailableToDoubleBiFunction_String_IOException() {
> + new FailableToDoubleBiFunction<String, String, IOException>() {
>
> @Override
> public double applyAsDouble(String t, String u) throws
> IOException {
> @@ -1905,8 +1656,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToDoubleFunction_Object_Throwable() {
> - new Functions.FailableToDoubleFunction<Object, Throwable>() {
> + public void testThrows_FailableToDoubleFunction_Object_Throwable() {
> + new FailableToDoubleFunction<Object, Throwable>() {
>
> @Override
> public double applyAsDouble(Object t) throws Throwable {
> @@ -1920,8 +1671,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToDoubleFunction_String_IOException() {
> - new Functions.FailableToDoubleFunction<String, IOException>() {
> + public void testThrows_FailableToDoubleFunction_String_IOException() {
> + new FailableToDoubleFunction<String, IOException>() {
>
> @Override
> public double applyAsDouble(String t) throws IOException {
> @@ -1935,8 +1686,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToIntBiFunction_Object_Throwable() {
> - new Functions.FailableToIntBiFunction<Object, Object,
> Throwable>() {
> + public void testThrows_FailableToIntBiFunction_Object_Throwable() {
> + new FailableToIntBiFunction<Object, Object, Throwable>() {
>
> @Override
> public int applyAsInt(Object t, Object u) throws Throwable {
> @@ -1950,8 +1701,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToIntBiFunction_String_IOException() {
> - new Functions.FailableToIntBiFunction<String, String,
> IOException>() {
> + public void testThrows_FailableToIntBiFunction_String_IOException() {
> + new FailableToIntBiFunction<String, String, IOException>() {
>
> @Override
> public int applyAsInt(String t, String u) throws IOException {
> @@ -1965,8 +1716,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToIntFunction_Object_Throwable() {
> - new Functions.FailableToIntFunction<Object, Throwable>() {
> + public void testThrows_FailableToIntFunction_Object_Throwable() {
> + new FailableToIntFunction<Object, Throwable>() {
>
> @Override
> public int applyAsInt(Object t) throws Throwable {
> @@ -1980,8 +1731,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToIntFunction_String_IOException() {
> - new Functions.FailableToIntFunction<String, IOException>() {
> + public void testThrows_FailableToIntFunction_String_IOException() {
> + new FailableToIntFunction<String, IOException>() {
>
> @Override
> public int applyAsInt(String t) throws IOException {
> @@ -1995,8 +1746,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToLongBiFunction_Object_Throwable() {
> - new Functions.FailableToLongBiFunction<Object, Object,
> Throwable>() {
> + public void testThrows_FailableToLongBiFunction_Object_Throwable() {
> + new FailableToLongBiFunction<Object, Object, Throwable>() {
>
> @Override
> public long applyAsLong(Object t, Object u) throws Throwable {
> @@ -2010,8 +1761,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToLongBiFunction_String_IOException() {
> - new Functions.FailableToLongBiFunction<String, String,
> IOException>() {
> + public void testThrows_FailableToLongBiFunction_String_IOException() {
> + new FailableToLongBiFunction<String, String, IOException>() {
>
> @Override
> public long applyAsLong(String t, String u) throws
> IOException {
> @@ -2025,8 +1776,8 @@ class FunctionsTest {
> * Object and Throwable.
> */
> @Test
> - void testThrows_FailableToLongFunction_Object_Throwable() {
> - new Functions.FailableToLongFunction<Object, Throwable>() {
> + public void testThrows_FailableToLongFunction_Object_Throwable() {
> + new FailableToLongFunction<Object, Throwable>() {
>
> @Override
> public long applyAsLong(Object t) throws Throwable {
> @@ -2040,8 +1791,8 @@ class FunctionsTest {
> * generic test types.
> */
> @Test
> - void testThrows_FailableToLongFunction_String_IOException() {
> - new Functions.FailableToLongFunction<String, IOException>() {
> + public void testThrows_FailableToLongFunction_String_IOException() {
> + new FailableToLongFunction<String, IOException>() {
>
> @Override
> public long applyAsLong(String t) throws IOException {
> @@ -2050,33 +1801,4 @@ class FunctionsTest {
> };
> }
>
> - @Test
> - public void testTryWithResources() {
> - final CloseableObject co = new CloseableObject();
> - final FailableConsumer<Throwable, ? extends Throwable> consumer =
> co::run;
> - final IllegalStateException ise = new IllegalStateException();
> - Throwable e = assertThrows(IllegalStateException.class,
> - () -> Functions.tryWithResources(() -> consumer.accept(ise),
> co::close));
> - assertSame(ise, e);
> -
> - assertTrue(co.isClosed());
> - co.reset();
> - final Error error = new OutOfMemoryError();
> - e = assertThrows(OutOfMemoryError.class,
> - () -> Functions.tryWithResources(() ->
> consumer.accept(error), co::close));
> - assertSame(error, e);
> -
> - assertTrue(co.isClosed());
> - co.reset();
> - final IOException ioe = new IOException("Unknown I/O error");
> - final UncheckedIOException uioe =
> assertThrows(UncheckedIOException.class,
> - () -> Functions.tryWithResources(() -> consumer.accept(ioe),
> co::close));
> - final IOException cause = uioe.getCause();
> - assertSame(ioe, cause);
> -
> - assertTrue(co.isClosed());
> - co.reset();
> - Functions.tryWithResources(() -> consumer.accept(null),
> co::close);
> - assertTrue(co.isClosed());
> - }
> }
>
>
Re: [commons-lang] branch master updated: Create the new package
org.apache.commons.function to parallel the JRE's java.util.function to
provide home for our "failable" version of the JRE's functional interfaces.
Posted by Gary Gregory <ga...@gmail.com>.
Thank you Alex!
Gary
On Thu, Jun 18, 2020, 07:23 Alex Herbert <al...@gmail.com> wrote:
> I've added a skeleton package-info for the new o.a.c.lang3.stream
> and o.a.c.lang3.functions packages and fixed the checkstyle issues. The
> build should now pass and green light Travis CI.
>
> I'm not too familiar with how much detail should be in the package info so
> this may have to be rewritten. The changes at least get Jenkins builds to
> pass again.
>
>
> On Wed, 17 Jun 2020 at 20:58, <gg...@apache.org> wrote:
>
> > This is an automated email from the ASF dual-hosted git repository.
> >
> > ggregory pushed a commit to branch master
> > in repository https://gitbox.apache.org/repos/asf/commons-lang.git
> >
> >
> > The following commit(s) were added to refs/heads/master by this push:
> > new 8b54728 Create the new package org.apache.commons.function to
> > parallel the JRE's java.util.function to provide home for our "failable"
> > version of the JRE's functional interfaces.
> > 8b54728 is described below
> >
> > commit 8b54728564e3e0c75ef915fb17f172326e8be197
> > Author: Gary Gregory <ga...@gmail.com>
> > AuthorDate: Wed Jun 17 15:58:26 2020 -0400
> >
> > Create the new package org.apache.commons.function to parallel the
> > JRE's
> > java.util.function to provide home for our "failable" version of the
> > JRE's functional interfaces.
> > ---
> > .../java/org/apache/commons/lang3/Functions.java | 657 +--------------
> > .../lang3/function/FailableBooleanSupplier.java | 38 +
> > .../function/FailableDoubleBinaryOperator.java | 40 +
> > .../lang3/function/FailableDoubleConsumer.java | 38 +
> > .../lang3/function/FailableDoubleFunction.java | 40 +
> > .../lang3/function/FailableDoublePredicate.java | 39 +
> > .../lang3/function/FailableDoubleSupplier.java | 38 +
> > .../function/FailableDoubleToIntFunction.java | 39 +
> > .../function/FailableDoubleToLongFunction.java | 39 +
> > .../lang3/function/FailableIntBinaryOperator.java | 40 +
> > .../lang3/function/FailableIntConsumer.java | 38 +
> > .../lang3/function/FailableIntFunction.java | 40 +
> > .../lang3/function/FailableIntPredicate.java | 39 +
> > .../lang3/function/FailableIntSupplier.java | 38 +
> > .../function/FailableIntToDoubleFunction.java | 39 +
> > .../lang3/function/FailableIntToLongFunction.java | 39 +
> > .../lang3/function/FailableLongBinaryOperator.java | 40 +
> > .../lang3/function/FailableLongConsumer.java | 38 +
> > .../lang3/function/FailableLongFunction.java | 40 +
> > .../lang3/function/FailableLongPredicate.java | 39 +
> > .../lang3/function/FailableLongSupplier.java | 38 +
> > .../function/FailableLongToDoubleFunction.java | 39 +
> > .../lang3/function/FailableLongToIntFunction.java | 39 +
> > .../lang3/function/FailableObjDoubleConsumer.java | 40 +
> > .../lang3/function/FailableObjIntConsumer.java | 40 +
> > .../lang3/function/FailableObjLongConsumer.java | 40 +
> > .../lang3/function/FailableToDoubleBiFunction.java | 42 +
> > .../lang3/function/FailableToDoubleFunction.java | 40 +
> > .../lang3/function/FailableToIntBiFunction.java | 42 +
> > .../lang3/function/FailableToIntFunction.java | 40 +
> > .../lang3/function/FailableToLongBiFunction.java | 42 +
> > .../lang3/function/FailableToLongFunction.java | 40 +
> > .../org/apache/commons/lang3/FunctionsTest.java | 908
> > +--------------------
> > .../FailableFunctionsTest.java} | 574 ++++---------
> > 34 files changed, 1414 insertions(+), 1948 deletions(-)
> >
> > diff --git a/src/main/java/org/apache/commons/lang3/Functions.java
> > b/src/main/java/org/apache/commons/lang3/Functions.java
> > index 16e7a0c..4aa7209 100644
> > --- a/src/main/java/org/apache/commons/lang3/Functions.java
> > +++ b/src/main/java/org/apache/commons/lang3/Functions.java
> > @@ -25,44 +25,21 @@ import java.util.concurrent.Callable;
> > import java.util.function.BiConsumer;
> > import java.util.function.BiFunction;
> > import java.util.function.BiPredicate;
> > -import java.util.function.BooleanSupplier;
> > import java.util.function.Consumer;
> > -import java.util.function.DoubleBinaryOperator;
> > -import java.util.function.DoubleConsumer;
> > -import java.util.function.DoubleFunction;
> > -import java.util.function.DoublePredicate;
> > -import java.util.function.DoubleSupplier;
> > -import java.util.function.DoubleToIntFunction;
> > -import java.util.function.DoubleToLongFunction;
> > import java.util.function.Function;
> > -import java.util.function.IntBinaryOperator;
> > -import java.util.function.IntConsumer;
> > -import java.util.function.IntFunction;
> > -import java.util.function.IntPredicate;
> > -import java.util.function.IntSupplier;
> > -import java.util.function.IntToDoubleFunction;
> > -import java.util.function.IntToLongFunction;
> > -import java.util.function.LongBinaryOperator;
> > -import java.util.function.LongConsumer;
> > -import java.util.function.LongFunction;
> > -import java.util.function.LongPredicate;
> > -import java.util.function.LongSupplier;
> > -import java.util.function.LongToDoubleFunction;
> > -import java.util.function.LongToIntFunction;
> > -import java.util.function.ObjDoubleConsumer;
> > -import java.util.function.ObjIntConsumer;
> > -import java.util.function.ObjLongConsumer;
> > import java.util.function.Predicate;
> > import java.util.function.Supplier;
> > -import java.util.function.ToDoubleBiFunction;
> > -import java.util.function.ToDoubleFunction;
> > -import java.util.function.ToIntBiFunction;
> > -import java.util.function.ToIntFunction;
> > -import java.util.function.ToLongBiFunction;
> > -import java.util.function.ToLongFunction;
> > import java.util.stream.Stream;
> >
> > import org.apache.commons.lang3.Streams.FailableStream;
> > +import org.apache.commons.lang3.function.FailableBooleanSupplier;
> > +import org.apache.commons.lang3.function.FailableDoubleBinaryOperator;
> > +import org.apache.commons.lang3.function.FailableDoubleConsumer;
> > +import org.apache.commons.lang3.function.FailableDoubleSupplier;
> > +import org.apache.commons.lang3.function.FailableIntConsumer;
> > +import org.apache.commons.lang3.function.FailableIntSupplier;
> > +import org.apache.commons.lang3.function.FailableLongConsumer;
> > +import org.apache.commons.lang3.function.FailableLongSupplier;
> >
> > /**
> > * This class provides utility functions, and classes for working with
> > the {@code java.util.function} package, or more
> > @@ -101,6 +78,8 @@ public class Functions {
> >
> > /**
> > * A functional interface like {@link BiConsumer} that declares a
> > {@code Throwable}.
> > + *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > *
> > * @param <O1> Consumed type 1.
> > * @param <O2> Consumed type 2.
> > @@ -122,6 +101,8 @@ public class Functions {
> > /**
> > * A functional interface like {@link BiFunction} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <O1> Input type 1.
> > * @param <O2> Input type 2.
> > * @param <R> Return type.
> > @@ -144,6 +125,8 @@ public class Functions {
> > /**
> > * A functional interface like {@link BiPredicate} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <O1> Predicate type 1.
> > * @param <O2> Predicate type 2.
> > * @param <T> Thrown exception.
> > @@ -163,26 +146,10 @@ public class Functions {
> > }
> >
> > /**
> > - * A functional interface like {@link BooleanSupplier} that declares
> > a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableBooleanSupplier<T extends Throwable> {
> > -
> > - /**
> > - * Supplies a boolean.
> > - *
> > - * @return a result
> > - * @throws T if the supplier fails
> > - */
> > - boolean getAsBoolean() throws T;
> > - }
> > -
> > - /**
> > * A functional interface like {@link java.util.concurrent.Callable}
> > that declares a {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <R> Return type.
> > * @param <T> Thrown exception.
> > */
> > @@ -201,6 +168,8 @@ public class Functions {
> > /**
> > * A functional interface like {@link Consumer} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <O> Consumed type 1.
> > * @param <T> Thrown exception.
> > */
> > @@ -217,140 +186,10 @@ public class Functions {
> > }
> >
> > /**
> > - * A functional interface like {@link DoubleBinaryOperator} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleBinaryOperator<T extends Throwable> {
> > -
> > - /**
> > - * Applies this operator to the given operands.
> > - *
> > - * @param left the first operand
> > - * @param right the second operand
> > - * @return the operator result
> > - * @throws T if the operation fails
> > - */
> > - double applyAsDouble(double left, double right) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoubleConsumer} that declares
> a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleConsumer<T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param value the parameter for the consumable to accept
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(double value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoubleFunction} that declares
> a
> > {@code Throwable}.
> > - *
> > - * @param <R> Return type.
> > - * @param <T> Thrown exception.
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleFunction<R, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function.
> > - *
> > - * @param input the input for the function
> > - * @return the result of the function
> > - * @throws T Thrown when the function fails.
> > - */
> > - R apply(double input) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoublePredicate} that declares
> > a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoublePredicate<T extends Throwable> {
> > -
> > - /**
> > - * Tests the predicate.
> > - *
> > - * @param value the parameter for the predicate to accept.
> > - * @return {@code true} if the input argument matches the
> > predicate, {@code false} otherwise.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - boolean test(double value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoubleSupplier} that declares
> a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleSupplier<T extends Throwable> {
> > -
> > - /**
> > - * Supplies a double.
> > - *
> > - * @return a result
> > - * @throws T if the supplier fails
> > - */
> > - double getAsDouble() throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoubleToIntFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleToIntFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - int applyAsInt(double value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link DoubleToLongFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableDoubleToLongFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T if the operation fails
> > - */
> > - int applyAsLong(double value) throws T;
> > - }
> > -
> > - /**
> > * A functional interface like {@link Function} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <I> Input type 1.
> > * @param <R> Return type.
> > * @param <T> Thrown exception.
> > @@ -369,332 +208,10 @@ public class Functions {
> > }
> >
> > /**
> > - * A functional interface like {@link IntBinaryOperator} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntBinaryOperator<T extends Throwable> {
> > -
> > - /**
> > - * Applies this operator to the given operands.
> > - *
> > - * @param left the first operand
> > - * @param right the second operand
> > - * @return the operator result
> > - * @throws T if the operation fails
> > - */
> > - int applyAsInt(int left, int right) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntConsumer} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntConsumer<T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param value the parameter for the consumable to accept
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(int value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntFunction} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <R> Return type.
> > - * @param <T> Thrown exception.
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntFunction<R, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function.
> > - *
> > - * @param input the input for the function
> > - * @return the result of the function
> > - * @throws T Thrown when the function fails.
> > - */
> > - R apply(int input) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntPredicate} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntPredicate<T extends Throwable> {
> > -
> > - /**
> > - * Tests the predicate.
> > - *
> > - * @param value the parameter for the predicate to accept.
> > - * @return {@code true} if the input argument matches the
> > predicate, {@code false} otherwise.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - boolean test(int value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntSupplier} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntSupplier<T extends Throwable> {
> > -
> > - /**
> > - * Supplies an int.
> > - *
> > - * @return a result
> > - * @throws T if the supplier fails
> > - */
> > - int getAsInt() throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntToDoubleFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntToDoubleFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - double applyAsDouble(int value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link IntToLongFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableIntToLongFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - long applyAsLong(int value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongBinaryOperator} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongBinaryOperator<T extends Throwable> {
> > -
> > - /**
> > - * Applies this operator to the given operands.
> > - *
> > - * @param left the first operand
> > - * @param right the second operand
> > - * @return the operator result
> > - * @throws T if the operation fails
> > - */
> > - long applyAsLong(long left, long right) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongConsumer} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongConsumer<T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param object the parameter for the consumable to accept
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(long object) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongFunction} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <R> Return type.
> > - * @param <T> Thrown exception.
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongFunction<R, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function.
> > - *
> > - * @param input the input for the function
> > - * @return the result of the function
> > - * @throws T Thrown when the function fails.
> > - */
> > - R apply(long input) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongPredicate} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongPredicate<T extends Throwable> {
> > -
> > - /**
> > - * Tests the predicate.
> > - *
> > - * @param value the parameter for the predicate to accept.
> > - * @return {@code true} if the input argument matches the
> > predicate, {@code false} otherwise.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - boolean test(long value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongSupplier} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongSupplier<T extends Throwable> {
> > -
> > - /**
> > - * Supplies a long.
> > - *
> > - * @return a result
> > - * @throws T if the supplier fails
> > - */
> > - long getAsLong() throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongToDoubleFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongToDoubleFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - double applyAsDouble(long value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link LongToIntFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableLongToIntFunction<T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given argument.
> > - *
> > - * @param value the function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - int applyAsInt(long value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ObjDoubleConsumer} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <O> the type of the object argument to the operation.
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableObjDoubleConsumer<O, T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param object the object parameter for the consumable to
> > accept.
> > - * @param value the double parameter for the consumable to
> > accept.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(O object, double value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ObjIntConsumer} that declares
> a
> > {@code Throwable}.
> > - *
> > - * @param <O> the type of the object argument to the operation.
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableObjIntConsumer<O, T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param object the object parameter for the consumable to
> > accept.
> > - * @param value the int parameter for the consumable to accept.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(O object, int value) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ObjLongConsumer} that declares
> > a {@code Throwable}.
> > - *
> > - * @param <O> the type of the object argument to the operation.
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableObjLongConsumer<O, T extends Throwable> {
> > -
> > - /**
> > - * Accepts the consumer.
> > - *
> > - * @param object the object parameter for the consumable to
> > accept.
> > - * @param value the long parameter for the consumable to
> accept.
> > - * @throws T Thrown when the consumer fails.
> > - */
> > - void accept(O object, long value) throws T;
> > - }
> > -
> > - /**
> > * A functional interface like {@link Predicate} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <I> Predicate type 1.
> > * @param <T> Thrown exception.
> > */
> > @@ -714,6 +231,8 @@ public class Functions {
> > /**
> > * A functional interface like {@link Runnable} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <T> Thrown exception.
> > */
> > @FunctionalInterface
> > @@ -730,6 +249,8 @@ public class Functions {
> > /**
> > * A functional interface like {@link Supplier} that declares a
> > {@code Throwable}.
> > *
> > + * <p>TODO for 4.0: Move to org.apache.commons.lang3.function.</p>
> > + *
> > * @param <R> Return type.
> > * @param <T> Thrown exception.
> > */
> > @@ -746,132 +267,6 @@ public class Functions {
> > }
> >
> > /**
> > - * A functional interface like {@link ToDoubleBiFunction} that
> > declares a {@code Throwable}.
> > - *
> > - * @param <O1> the type of the first argument to the function
> > - * @param <O2> the type of the second argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToDoubleBiFunction<O1, O2, T extends
> > Throwable> {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @param u the second function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - double applyAsDouble(O1 t, O2 u) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ToDoubleFunction} that
> declares
> > a {@code Throwable}.
> > - *
> > - * @param <I> the type of the first argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToDoubleFunction<I, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - double applyAsDouble(I t) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ToIntBiFunction} that declares
> > a {@code Throwable}.
> > - *
> > - * @param <O1> the type of the first argument to the function
> > - * @param <O2> the type of the second argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToIntBiFunction<O1, O2, T extends
> Throwable>
> > {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @param u the second function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - int applyAsInt(O1 t, O2 u) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ToIntFunction} that declares a
> > {@code Throwable}.
> > - *
> > - * @param <I> the type of the first argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToIntFunction<I, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - int applyAsInt(I t) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ToLongBiFunction} that
> declares
> > a {@code Throwable}.
> > - *
> > - * @param <O1> the type of the first argument to the function
> > - * @param <O2> the type of the second argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToLongBiFunction<O1, O2, T extends
> > Throwable> {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @param u the second function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - long applyAsLong(O1 t, O2 u) throws T;
> > - }
> > -
> > - /**
> > - * A functional interface like {@link ToLongFunction} that declares
> a
> > {@code Throwable}.
> > - *
> > - * @param <I> the type of the first argument to the function
> > - * @param <T> Thrown exception.
> > - * @since 3.11
> > - */
> > - @FunctionalInterface
> > - public interface FailableToLongFunction<I, T extends Throwable> {
> > -
> > - /**
> > - * Applies this function to the given arguments.
> > - *
> > - * @param t the first function argument
> > - * @return the function result
> > - * @throws T Thrown when the function fails.
> > - */
> > - long applyAsLong(I t) throws T;
> > - }
> > -
> > - /**
> > * Consumes a consumer and rethrows any exception as a {@link
> > RuntimeException}.
> > *
> > * @param consumer the consumer to consume
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> > new file mode 100644
> > index 0000000..0deaef5
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableBooleanSupplier.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.BooleanSupplier;
> > +
> > +/**
> > + * A functional interface like {@link BooleanSupplier} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableBooleanSupplier<T extends Throwable> {
> > +
> > + /**
> > + * Supplies a boolean.
> > + *
> > + * @return a result
> > + * @throws T if the supplier fails
> > + */
> > + boolean getAsBoolean() throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> > new file mode 100644
> > index 0000000..db58976
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleBinaryOperator.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleBinaryOperator;
> > +
> > +/**
> > + * A functional interface like {@link DoubleBinaryOperator} that
> declares
> > a {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleBinaryOperator<T extends Throwable> {
> > +
> > + /**
> > + * Applies this operator to the given operands.
> > + *
> > + * @param left the first operand
> > + * @param right the second operand
> > + * @return the operator result
> > + * @throws T if the operation fails
> > + */
> > + double applyAsDouble(double left, double right) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> > new file mode 100644
> > index 0000000..ade6e0c
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleConsumer.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleConsumer;
> > +
> > +/**
> > + * A functional interface like {@link DoubleConsumer} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleConsumer<T extends Throwable> {
> > +
> > + /**
> > + * Accepts the consumer.
> > + *
> > + * @param value the parameter for the consumable to accept
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + void accept(double value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> > new file mode 100644
> > index 0000000..156b204
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleFunction.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleFunction;
> > +
> > +/**
> > + * A functional interface like {@link DoubleFunction} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <R> Return type.
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleFunction<R, T extends Throwable> {
> > +
> > + /**
> > + * Applies this function.
> > + *
> > + * @param input the input for the function
> > + * @return the result of the function
> > + * @throws T Thrown when the function fails.
> > + */
> > + R apply(double input) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> > new file mode 100644
> > index 0000000..fda8786
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoublePredicate.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoublePredicate;
> > +
> > +/**
> > + * A functional interface like {@link DoublePredicate} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoublePredicate<T extends Throwable> {
> > +
> > + /**
> > + * Tests the predicate.
> > + *
> > + * @param value the parameter for the predicate to accept.
> > + * @return {@code true} if the input argument matches the predicate,
> > {@code false} otherwise.
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + boolean test(double value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> > new file mode 100644
> > index 0000000..9fb751b
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleSupplier.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleSupplier;
> > +
> > +/**
> > + * A functional interface like {@link DoubleSupplier} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleSupplier<T extends Throwable> {
> > +
> > + /**
> > + * Supplies a double.
> > + *
> > + * @return a result
> > + * @throws T if the supplier fails
> > + */
> > + double getAsDouble() throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> > new file mode 100644
> > index 0000000..00db9f3
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToIntFunction.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleToIntFunction;
> > +
> > +/**
> > + * A functional interface like {@link DoubleToIntFunction} that declares
> > a {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleToIntFunction<T extends Throwable> {
> > +
> > + /**
> > + * Applies this function to the given argument.
> > + *
> > + * @param value the function argument
> > + * @return the function result
> > + * @throws T Thrown when the function fails.
> > + */
> > + int applyAsInt(double value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> > new file mode 100644
> > index 0000000..0eae76c
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableDoubleToLongFunction.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.DoubleToLongFunction;
> > +
> > +/**
> > + * A functional interface like {@link DoubleToLongFunction} that
> declares
> > a {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableDoubleToLongFunction<T extends Throwable> {
> > +
> > + /**
> > + * Applies this function to the given argument.
> > + *
> > + * @param value the function argument
> > + * @return the function result
> > + * @throws T if the operation fails
> > + */
> > + int applyAsLong(double value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> > new file mode 100644
> > index 0000000..3eaca9d
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntBinaryOperator.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntBinaryOperator;
> > +
> > +/**
> > + * A functional interface like {@link IntBinaryOperator} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntBinaryOperator<T extends Throwable> {
> > +
> > + /**
> > + * Applies this operator to the given operands.
> > + *
> > + * @param left the first operand
> > + * @param right the second operand
> > + * @return the operator result
> > + * @throws T if the operation fails
> > + */
> > + int applyAsInt(int left, int right) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> > new file mode 100644
> > index 0000000..54e7710
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntConsumer.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntConsumer;
> > +
> > +/**
> > + * A functional interface like {@link IntConsumer} that declares a
> {@code
> > Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntConsumer<T extends Throwable> {
> > +
> > + /**
> > + * Accepts the consumer.
> > + *
> > + * @param value the parameter for the consumable to accept
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + void accept(int value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> > new file mode 100644
> > index 0000000..07e35c6
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntFunction.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntFunction;
> > +
> > +/**
> > + * A functional interface like {@link IntFunction} that declares a
> {@code
> > Throwable}.
> > + *
> > + * @param <R> Return type.
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntFunction<R, T extends Throwable> {
> > +
> > + /**
> > + * Applies this function.
> > + *
> > + * @param input the input for the function
> > + * @return the result of the function
> > + * @throws T Thrown when the function fails.
> > + */
> > + R apply(int input) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> > new file mode 100644
> > index 0000000..40e3877
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntPredicate.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntPredicate;
> > +
> > +/**
> > + * A functional interface like {@link IntPredicate} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntPredicate<T extends Throwable> {
> > +
> > + /**
> > + * Tests the predicate.
> > + *
> > + * @param value the parameter for the predicate to accept.
> > + * @return {@code true} if the input argument matches the predicate,
> > {@code false} otherwise.
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + boolean test(int value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> > new file mode 100644
> > index 0000000..fed9cd2
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntSupplier.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntSupplier;
> > +
> > +/**
> > + * A functional interface like {@link IntSupplier} that declares a
> {@code
> > Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntSupplier<T extends Throwable> {
> > +
> > + /**
> > + * Supplies an int.
> > + *
> > + * @return a result
> > + * @throws T if the supplier fails
> > + */
> > + int getAsInt() throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> > new file mode 100644
> > index 0000000..f0d9164
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToDoubleFunction.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntToDoubleFunction;
> > +
> > +/**
> > + * A functional interface like {@link IntToDoubleFunction} that declares
> > a {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntToDoubleFunction<T extends Throwable> {
> > +
> > + /**
> > + * Applies this function to the given argument.
> > + *
> > + * @param value the function argument
> > + * @return the function result
> > + * @throws T Thrown when the function fails.
> > + */
> > + double applyAsDouble(int value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> > new file mode 100644
> > index 0000000..f88d5ef
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableIntToLongFunction.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.IntToLongFunction;
> > +
> > +/**
> > + * A functional interface like {@link IntToLongFunction} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableIntToLongFunction<T extends Throwable> {
> > +
> > + /**
> > + * Applies this function to the given argument.
> > + *
> > + * @param value the function argument
> > + * @return the function result
> > + * @throws T Thrown when the function fails.
> > + */
> > + long applyAsLong(int value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> > new file mode 100644
> > index 0000000..e58acf4
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongBinaryOperator.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.LongBinaryOperator;
> > +
> > +/**
> > + * A functional interface like {@link LongBinaryOperator} that declares
> a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableLongBinaryOperator<T extends Throwable> {
> > +
> > + /**
> > + * Applies this operator to the given operands.
> > + *
> > + * @param left the first operand
> > + * @param right the second operand
> > + * @return the operator result
> > + * @throws T if the operation fails
> > + */
> > + long applyAsLong(long left, long right) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> > new file mode 100644
> > index 0000000..7eb784f
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongConsumer.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.LongConsumer;
> > +
> > +/**
> > + * A functional interface like {@link LongConsumer} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableLongConsumer<T extends Throwable> {
> > +
> > + /**
> > + * Accepts the consumer.
> > + *
> > + * @param object the parameter for the consumable to accept
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + void accept(long object) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> > new file mode 100644
> > index 0000000..904f946
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongFunction.java
> > @@ -0,0 +1,40 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.LongFunction;
> > +
> > +/**
> > + * A functional interface like {@link LongFunction} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <R> Return type.
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableLongFunction<R, T extends Throwable> {
> > +
> > + /**
> > + * Applies this function.
> > + *
> > + * @param input the input for the function
> > + * @return the result of the function
> > + * @throws T Thrown when the function fails.
> > + */
> > + R apply(long input) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> > new file mode 100644
> > index 0000000..259b82e
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongPredicate.java
> > @@ -0,0 +1,39 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.LongPredicate;
> > +
> > +/**
> > + * A functional interface like {@link LongPredicate} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableLongPredicate<T extends Throwable> {
> > +
> > + /**
> > + * Tests the predicate.
> > + *
> > + * @param value the parameter for the predicate to accept.
> > + * @return {@code true} if the input argument matches the predicate,
> > {@code false} otherwise.
> > + * @throws T Thrown when the consumer fails.
> > + */
> > + boolean test(long value) throws T;
> > +}
> > \ No newline at end of file
> > diff --git
> >
> a/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> > new file mode 100644
> > index 0000000..67a1aa4
> > --- /dev/null
> > +++
> >
> b/src/main/java/org/apache/commons/lang3/function/FailableLongSupplier.java
> > @@ -0,0 +1,38 @@
> > +/*
> > + * Licensed to the Apache Software Foundation (ASF) under one or more
> > + * contributor license agreements. See the NOTICE file distributed with
> > + * this work for additional information regarding copyright ownership.
> > + * The ASF licenses this file to You under the Apache License, Version
> 2.0
> > + * (the "License"); you may not use this file except in compliance with
> > + * the License. You may obtain a copy of the License at
> > + *
> > + * http://www.apache.org/licenses/LICENSE-2.0
> > + *
> > + * Unless required by applicable law or agreed to in writing, software
> > + * distributed under the License is distributed on an "AS IS" BASIS,
> > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
> > implied.
> > + * See the License for the specific language governing permissions and
> > + * limitations under the License.
> > + */
> > +
> > +package org.apache.commons.lang3.function;
> > +
> > +import java.util.function.LongSupplier;
> > +
> > +/**
> > + * A functional interface like {@link LongSupplier} that declares a
> > {@code Throwable}.
> > + *
> > + * @param <T> Thrown exception.
> > + * @since 3.11
> > + */
> > +@FunctionalInterface
> > +public interface FailableLongSupplier<T extends Throwable> {
> > +
> > + /**
> > + * Supplies a long.
> > + *
> > + * @return a result
> > + * @throws T if