de.caff.generics.function

## Interface FragileProcedure0<E extends java.lang.Exception>

- Type Parameters:
    `E` - exception thrown by the procedure
  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 FragileProcedure0<E extends java.lang.Exception>

  Function without return and with no paramete, but a possible expectionr. In a pure functional world this is useless, but in the real world it can be useful sometimes.
  Author:
    Rammi
  See Also:
    `Procedure0`, `FragileProcedure1`, `FragileProcedure2`, `FragileProcedure3`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static FragileProcedure0<?>` | `NULL` Fragile procedure with no arguments which does nothing, not even throw.

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `apply()` Run the function.
    `static <X extends java.lang.Exception> FragileProcedure0<X>` | `empty()` Return a zero argument procedure which does nothing, not even throw.
    `default Procedure0` | `nonFragile()` Convert this to a non-fragile procedure which does not throw a checked exception.
    `default Procedure0` | `nonFragileX(java.util.function.Consumer<? super E> exceptionHandler)` Convert this to a non-fragile procedure which does not a checked exception.

- - ### Field Detail

    - #### NULL

          @NotNull
          static final FragileProcedure0<?> NULL

      Fragile procedure with no arguments which does nothing, not even throw. Use `empty()` instead.

  - ### Method Detail

    - #### apply

          void apply()
              throws E extends java.lang.Exception

      Run the function.
      Throws:
        `E` - exception
        `E extends java.lang.Exception`

    - #### nonFragile

          @NotNull
          default Procedure0 nonFragile()

      Convert this to a non-fragile procedure which does not throw a checked exception. This will instead throw an unchecked `WrappedFragileException` for any checked exception thrown during `apply()`.
      Returns:
        non-fragile function
      See Also:
        `Procedure0.nonFragile(FragileProcedure0)`

    - #### nonFragileX

          @NotNull
          default Procedure0 nonFragileX(@NotNull
                                                  java.util.function.Consumer<? super E> exceptionHandler)

      Convert this to a non-fragile procedure which does not a checked exception. This will instead throw an unchecked `WrappedFragileException` for any checked exception thrown during `apply()`.
      Parameters:
        `exceptionHandler` - handler called when an exception is encountered. It may either ignore it, throw an unchecked exception, or collect the exceptions
      Returns:
        non-fragile function
      See Also:
        `Procedure0.nonFragileX(FragileProcedure0, Consumer)`

    - #### empty

          @NotNull
          static <X extends java.lang.Exception> FragileProcedure0<X> empty()

      Return a zero argument procedure which does nothing, not even throw.
      Type Parameters:
        `X` - exception type
      Returns:
        empty do-nothing procedure