de.caff.generics.function

## Interface ByteOperator1

- 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 ByteOperator1

  Unaray operator with a byte argument and result.
  Since:
    October 31, 2019
  Author:
    Rammi

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static ByteOperator1` | `BIT_FLIP` Byte operator BIT FLIP (`~`).
    `static ByteOperator1` | `NEGATE` Byte operator NEGATE.

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default ByteOperator1` | `andThen(ByteOperator1 after)` Create a function which applies this function and feeds the result into the next function.
    `byte` | `applyAsByte(byte value)` Apply the function.
    `default ByteOperator0` | `partial(byte argument)` Create a zero argument function from this one by applying a constant argument.

- - ### Field Detail

    - #### NEGATE

          static final ByteOperator1 NEGATE

      Byte operator NEGATE. In difference to the standard NEGATE this operator returns a `byte` result. This means that besides `0` also `Byte.MIN_VALUE` is its own negative.

    - #### BIT_FLIP

          static final ByteOperator1 BIT_FLIP

      Byte operator BIT FLIP (`~`). In difference to the standard BIT FLIP this operator returns a `byte` result.

  - ### Method Detail

    - #### applyAsByte

          byte applyAsByte(byte value)

      Apply the function.
      Parameters:
        `value` - parameter value of the function
      Returns:
        result of the function

    - #### partial

          @NotNull
          default ByteOperator0 partial(byte argument)

      Create a zero argument function from this one by applying a constant argument. Although useless for pure functions it can be useful in cases where the zero argument function is a factory (and therefore not pure).
      Parameters:
        `argument` - constant argument
      Returns:
        zero argument function

    - #### andThen

          @NotNull
          default ByteOperator1 andThen(@NotNull
                                                 ByteOperator1 after)

      Create a function which applies this function and feeds the result into the next function.
      Parameters:
        `after` - function called with the result of this function
      Returns:
        chained function