# Interface FailableFunction<T, R, E extends Throwable>

Type Parameters:
  `T` - Input type 1.
  `R` - Return type.
  `E` - The type 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 Throwable>
A functional interface like `Function` that declares a `Throwable`.

Since:
  3.11

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final FailableFunction`
  `NOP`
  NOP singleton

- ## Method Summary

  Modifier and Type
  Method
  Description
  `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, R, E extends Throwable>
  FailableFunction<T,R,E>`
  `function(FailableFunction<T,R,E> function)`
  Starts a fluent chain like `function(foo::bar).andThen(...).andThen(...).apply(...);`
  `static <T, E extends Throwable>
  FailableFunction<T,T,E>`
  `identity()`
  Returns a function that always returns its input argument.
  `static <T, R, E extends Throwable>
  FailableFunction<T,R,E>`
  `nop()`
  Gets the NOP singleton.

- ## Field Details

  - ### NOP

    static final FailableFunction NOP
    NOP singleton

- ## Method Details

  - ### function

    static <T, R, E extends 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 type of thrown exception or error.
    Parameters:
      `function` - the argument to return.
    Returns:
      the argument
    Since:
      3.14.0

  - ### identity

    static <T, E extends 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 type of thrown exception or error.
    Returns:
      a function that always returns its input argument

  - ### nop

    static <T, R, E extends Throwable> FailableFunction<T,R,E> nop()
    Gets the NOP singleton.
    Type Parameters:
      `T` - Consumed type.
      `R` - Return type.
      `E` - The type 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:
      `NullPointerException` - when `after` is null.

  - ### apply

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

  - ### 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:
      `NullPointerException` - if before is null.
    See Also:
      - `andThen(FailableFunction)`