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` - Thrown exception.

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

### Field Summary

Fields
`static FailableFunction` `NOP` NOP singleton

### Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
`default <V> FailableFunction<T,​V,​E>` `andThen​(FailableFunction<? super R,​? extends V,​E> after)` Returns a composed `FailableFunction` like `Function.andThen(Function)`.
`R` `apply​(T input)` Applies this function.
`default <V> FailableFunction<V,​R,​E>` `compose​(FailableFunction<? super V,​? extends T,​E> before)` Returns a composed `FailableFunction` like `Function.compose(Function)`.
`static <T,​E extends java.lang.Throwable> FailableFunction<T,​T,​E>` `identity()` Returns a function that always returns its input argument.
`static <T,​R,​E extends java.lang.Throwable> FailableFunction<T,​R,​E>` `nop()` Returns The NOP singleton.

### Field Detail

#### NOP

    static final FailableFunction NOP

NOP singleton

### Method Detail

#### 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` - Thrown exception.
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 1.
  `R` - Return type.
  `E` - Thrown exception.
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 a composed `FailableFunction` like `Function.compose(Function)`.
Throws:
  `java.lang.NullPointerException` - if before is null.
See Also:
  `andThen(FailableFunction)`