com.jnape.palatable.lambda.adt.coproduct

## Interface CoProduct5<A,B,C,D,E,CP5 extends CoProduct5<A,B,C,D,E,?>>

- Type Parameters:
    `A` - the first possible type
    `B` - the second possible type
    `C` - the third possible type
    `D` - the fourth possible type
    `E` - the fifth possible type
    `CP5` - the recursive type of this coproduct (used for embedding)
  All Known Implementing Classes:
    Choice5
  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 CoProduct5<A,B,C,D,E,CP5 extends CoProduct5<A,B,C,D,E,?>>

  A generalization of the coproduct of five types.
  See Also:
    `CoProduct2`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `default CoProduct4<A,B,C,D,? extends CoProduct4<A,B,C,D,?>>` | `converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)` Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
    `default <F> CoProduct6<A,B,C,D,E,F,? extends CoProduct6<A,B,C,D,E,F,?>>` | `diverge()` Diverge this coproduct by introducing another possible type that it could represent.
    `default <R> R` | `embed(Fn1<? super CP5,? extends R> aFn, Fn1<? super CP5,? extends R> bFn, Fn1<? super CP5,? extends R> cFn, Fn1<? super CP5,? extends R> dFn, Fn1<? super CP5,? extends R> eFn)` Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole.
    `<R> R` | `match(Fn1<? super A,? extends R> aFn, Fn1<? super B,? extends R> bFn, Fn1<? super C,? extends R> cFn, Fn1<? super D,? extends R> dFn, Fn1<? super E,? extends R> eFn)` Type-safe convergence requiring a match against all potential types.
    `default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>>` | `project()` Project this coproduct onto a product.
    `default Maybe<A>` | `projectA()` Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
    `default Maybe<B>` | `projectB()` Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
    `default Maybe<C>` | `projectC()` Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
    `default Maybe<D>` | `projectD()` Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
    `default Maybe<E>` | `projectE()` Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.

- - ### Method Detail

    - #### match

          <R> R match(Fn1<? super A,? extends R> aFn,
                      Fn1<? super B,? extends R> bFn,
                      Fn1<? super C,? extends R> cFn,
                      Fn1<? super D,? extends R> dFn,
                      Fn1<? super E,? extends R> eFn)

      Type-safe convergence requiring a match against all potential types.
      Type Parameters:
        `R` - result type
      Parameters:
        `aFn` - morphism `A -> R`
        `bFn` - morphism `B -> R`
        `cFn` - morphism `C -> R`
        `dFn` - morphism `D -> R`
        `eFn` - morphism `E -> R`
      Returns:
        the result of applying the appropriate morphism from whichever type is represented by this coproduct to R
      See Also:
        `CoProduct2.match(Fn1, Fn1)`

    - #### diverge

          default <F> CoProduct6<A,B,C,D,E,F,? extends CoProduct6<A,B,C,D,E,F,?>> diverge()

      Diverge this coproduct by introducing another possible type that it could represent.
      Type Parameters:
        `F` - the additional possible type of this coproduct
      Returns:
        a Coproduct6<A, B, C, D, E, F>
      See Also:
        `CoProduct2.diverge()`

    - #### converge

          default CoProduct4<A,B,C,D,? extends CoProduct4<A,B,C,D,?>> converge(Fn1<? super E,? extends CoProduct4<A,B,C,D,?>> convergenceFn)

      Converge this coproduct down to a lower order coproduct by mapping the last possible type into an earlier possible type.
      Parameters:
        `convergenceFn` - morphism `E -> `CoProduct4`<A, B, C, D>`
      Returns:
        a `CoProduct4`<A, B, C, D>

    - #### project

          default Product5<Maybe<A>,Maybe<B>,Maybe<C>,Maybe<D>,Maybe<E>> project()

      Project this coproduct onto a product.
      Returns:
        a product of the coproduct projection
      See Also:
        `CoProduct2.project()`

    - #### projectA

          default Maybe<A> projectA()

      Convenience method for projecting this coproduct onto a product and then extracting the first slot value.
      Returns:
        an optional value representing the projection of the "a" type index

    - #### projectB

          default Maybe<B> projectB()

      Convenience method for projecting this coproduct onto a product and then extracting the second slot value.
      Returns:
        an optional value representing the projection of the "b" type index

    - #### projectC

          default Maybe<C> projectC()

      Convenience method for projecting this coproduct onto a product and then extracting the third slot value.
      Returns:
        an optional value representing the projection of the "c" type index

    - #### projectD

          default Maybe<D> projectD()

      Convenience method for projecting this coproduct onto a product and then extracting the fourth slot value.
      Returns:
        an optional value representing the projection of the "d" type index

    - #### projectE

          default Maybe<E> projectE()

      Convenience method for projecting this coproduct onto a product and then extracting the fifth slot value.
      Returns:
        an optional value representing the projection of the "e" type index

    - #### embed

          default <R> R embed(Fn1<? super CP5,? extends R> aFn,
                              Fn1<? super CP5,? extends R> bFn,
                              Fn1<? super CP5,? extends R> cFn,
                              Fn1<? super CP5,? extends R> dFn,
                              Fn1<? super CP5,? extends R> eFn)

      Embed this coproduct inside another value; that is, given morphisms from this coproduct to `R`, apply the appropriate morphism to this coproduct as a whole. Like `match(com.jnape.palatable.lambda.functions.Fn1<? super A, ? extends R>, com.jnape.palatable.lambda.functions.Fn1<? super B, ? extends R>, com.jnape.palatable.lambda.functions.Fn1<? super C, ? extends R>, com.jnape.palatable.lambda.functions.Fn1<? super D, ? extends R>, com.jnape.palatable.lambda.functions.Fn1<? super E, ? extends R>)`, but without unwrapping the value.
      Type Parameters:
        `R` - result type
      Parameters:
        `aFn` - morphism `A v B v C v D v E -> R`, applied in the `A` case
        `bFn` - morphism `A v B v C v D v E -> R`, applied in the `B` case
        `cFn` - morphism `A v B v C v D v E -> R`, applied in the `C` case
        `dFn` - morphism `A v B v C v D v E -> R`, applied in the `D` case
        `eFn` - morphism `A v B v C v D v E -> R`, applied in the `E` case
      Returns:
        the result of applying the appropriate morphism to this coproduct