Package org.apache.commons.lang3.function

Interface FailableFunction<T,​R,​E extends java.lang.Throwable>

  • Type Parameters:
    T - Input type 1.
    R - Return type.
    E - The kind of thrown exception or error.
    Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
    @FunctionalInterface
public interface FailableFunction<T,​R,​E extends java.lang.Throwable>
    A functional interface like Function that declares a Throwable.
    Since:
    3.11

    • Method Detail

      • function

        static <T,​R,​E extends java.lang.Throwable> FailableFunction<T,​R,​E> function​(FailableFunction<T,​R,​E> function)
        Starts a fluent chain like function(foo::bar).andThen(...).andThen(...).apply(...);
        Type Parameters:
        T - Input type.
        R - Return type.
        E - The kind of thrown exception or error.
        Parameters:
        function - the argument to return.
        Returns:
        the argument
        Since:
        3.14.0

      • identity

        static <T,​E extends java.lang.Throwable> FailableFunction<T,​T,​E> identity()
        Returns a function that always returns its input argument.
        Type Parameters:
        T - the type of the input and output objects to the function
        E - The kind of thrown exception or error.
        Returns:
        a function that always returns its input argument

      • nop

        static <T,​R,​E extends java.lang.Throwable> FailableFunction<T,​R,​E> nop()
        Returns The NOP singleton.
        Type Parameters:
        T - Consumed type.
        R - Return type.
        E - The kind of thrown exception or error.
        Returns:
        The NOP singleton.

      • andThen

        default <V> FailableFunction<T,​V,​E> andThen​(FailableFunction<? super R,​? extends V,​E> after)
        Returns a composed FailableFunction like Function.andThen(Function).
        Type Parameters:
        V - the output type of the after function, and of the composed function.
        Parameters:
        after - the operation to perform after this one.
        Returns:
        a composed FailableFunction like Function.andThen(Function).
        Throws:
        java.lang.NullPointerException - when after is null.

      • apply

        R apply​(T input)
 throws E extends java.lang.Throwable
        Applies this function.
        Parameters:
        input - the input for the function
        Returns:
        the result of the function
        Throws:
        E - Thrown when the function fails.
        E extends java.lang.Throwable

      • compose

        default <V> FailableFunction<V,​R,​E> compose​(FailableFunction<? super V,​? extends T,​E> before)
        Returns a composed FailableFunction like Function.compose(Function).
        Type Parameters:
        V - the input type to the before function, and to the composed function.
        Parameters:
        before - the operator to apply before this one.
        Returns:
        a composed FailableFunction like Function.compose(Function).
        Throws:
        java.lang.NullPointerException - if before is null.
        See Also:
        andThen(FailableFunction)