com.jnape.palatable.lambda.functor

## Interface BoundedBifunctor<A extends ContraA,B extends ContraB,ContraA,ContraB,BF extends BoundedBifunctor<?,?,?,?,BF>>

- Type Parameters:
    `A` - The type of the left parameter
    `B` - The type of the right parameter
    `ContraA` - The type of the left parameter upper type bound
    `ContraB` - The type of the right parameter upper type bound
    `BF` - The unification parameter
  All Known Subinterfaces:
    Bifunctor<A,B,BF>
  All Known Implementing Classes:
    Choice2, Choice3, Choice4, Choice5, Choice6, Choice7, Choice8, Const, Either, EitherT, RecursiveResult, These, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, Tuple8
  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 BoundedBifunctor<A extends ContraA,B extends ContraB,ContraA,ContraB,BF extends BoundedBifunctor<?,?,?,?,BF>>

  A `Bifunctor` that has both parameter types upper bounded; that is, neither parameters can be mapped to a value that is not covariant to their respective upper bounds
  See Also:
    `Bifunctor`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `<C extends ContraA,D extends ContraB> BoundedBifunctor<C,D,ContraA,ContraB,BF>` | `biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually covariantly map both the left and right parameters into values that are covariant to `ContraA` and `ContraB`, respectively.
    `default <C extends ContraA> BoundedBifunctor<C,B,ContraA,ContraB,BF>` | `biMapL(Fn1<? super A,? extends C> fn)` Covariantly map the left parameter into a value that is covariant to `ContraA`.
    `default <C extends ContraB> BoundedBifunctor<A,C,ContraA,ContraB,BF>` | `biMapR(Fn1<? super B,? extends C> fn)` Covariantly map the right parameter into a value that is covariant to `ContraB`.

- - ### Method Detail

    - #### biMapL

          default <C extends ContraA> BoundedBifunctor<C,B,ContraA,ContraB,BF> biMapL(Fn1<? super A,? extends C> fn)

      Covariantly map the left parameter into a value that is covariant to `ContraA`.
      Type Parameters:
        `C` - the new left parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a bifunctor of C (the new parameter type) and B (the same right parameter)

    - #### biMapR

          default <C extends ContraB> BoundedBifunctor<A,C,ContraA,ContraB,BF> biMapR(Fn1<? super B,? extends C> fn)

      Covariantly map the right parameter into a value that is covariant to `ContraB`.
      Type Parameters:
        `C` - the new right parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a bifunctor of A (the same left parameter) and C (the new parameter type)

    - #### biMap

          <C extends ContraA,D extends ContraB> BoundedBifunctor<C,D,ContraA,ContraB,BF> biMap(Fn1<? super A,? extends C> lFn,
                                                                                               Fn1<? super B,? extends D> rFn)

      Dually covariantly map both the left and right parameters into values that are covariant to `ContraA` and `ContraB`, respectively. This is isomorphic to `biMapL(lFn).biMapR(rFn)`.
      Type Parameters:
        `C` - the new left parameter type
        `D` - the new right parameter type
      Parameters:
        `lFn` - the left parameter mapping function
        `rFn` - the right parameter mapping function
      Returns:
        a bifunctor over C (the new left parameter type) and D (the new right parameter type)