com.jnape.palatable.lambda.adt.product

## Interface Product3<_1,_2,_3>

- Type Parameters:
    `_1` - The first element type
    `_2` - The second element type
    `_3` - The third element type
  All Superinterfaces:
    Map.Entry<_1,_2>, Product2<_1,_2>
  All Known Subinterfaces:
    Product4<_1,_2,_3,_4>, Product5<_1,_2,_3,_4,_5>, Product6<_1,_2,_3,_4,_5,_6>, Product7<_1,_2,_3,_4,_5,_6,_7>, Product8<_1,_2,_3,_4,_5,_6,_7,_8>
  All Known Implementing Classes:
    Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8

      public interface Product3<_1,_2,_3>
      extends Product2<_1,_2>

  A product with three values.
  See Also:
    `Product2`, `Tuple3`

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `_3` | `_3()` Retrieve the third element.
    `default <R> R` | `into(Fn3<? super _1,? super _2,? super _3,? extends R> fn)` Destructure and apply this product to a function accepting the same number of arguments as this product's slots.
    `default Product3<_2,_1,_3>` | `invert()` Rotate the first two slots of this product.
    `static <_1,_2,_3> Product3<_1,_2,_3>` | `product(_1 _1, _2 _2, _3 _3)` Static factory method for creating a generic `Product3`.
    `default Product3<_2,_3,_1>` | `rotateL3()` Rotate the first three values of this product one slot to the left.
    `default Product3<_3,_1,_2>` | `rotateR3()` Rotate the first three values of this product one slot to the right.

    - ### Methods inherited from interface com.jnape.palatable.lambda.adt.product.Product2

      `_1, _2, getKey, getValue, into, product, setValue`

    - ### Methods inherited from interface java.util.Map.Entry

      `comparingByKey, comparingByKey, comparingByValue, comparingByValue, equals, hashCode`

- - ### Method Detail

    - #### _3

          _3 _3()

      Retrieve the third element.
      Returns:
        the third element

    - #### into

          default <R> R into(Fn3<? super _1,? super _2,? super _3,? extends R> fn)

      Destructure and apply this product to a function accepting the same number of arguments as this product's slots. This can be thought of as a kind of dual to uncurrying a function and applying a product to it.
      Type Parameters:
        `R` - the return type of the function
      Parameters:
        `fn` - the function to apply
      Returns:
        the result of applying the destructured product to the function

    - #### rotateL3

          default Product3<_2,_3,_1> rotateL3()

      Rotate the first three values of this product one slot to the left.
      Returns:
        the left-rotated product

    - #### rotateR3

          default Product3<_3,_1,_2> rotateR3()

      Rotate the first three values of this product one slot to the right.
      Returns:
        the right-rotated product

    - #### invert

          default Product3<_2,_1,_3> invert()

      Description copied from interface: `Product2`
      Rotate the first two slots of this product.
      Specified by:
        `invert` in interface `Product2<_1,_2>`
      Returns:
        the rotated product

    - #### product

          static <_1,_2,_3> Product3<_1,_2,_3> product(_1 _1,
                                                       _2 _2,
                                                       _3 _3)

      Static factory method for creating a generic `Product3`.
      Type Parameters:
        `_1` - the first slot type
        `_2` - the second slot type
        `_3` - the third slot type
      Parameters:
        `_1` - the first slot
        `_2` - the second slot
        `_3` - the third slot
      Returns:
        the `Product3`