com.jnape.palatable.lambda.functor

## Interface Bifunctor<A,B,BF extends Bifunctor<?,?,BF>>

- Type Parameters:
    `A` - The type of the left parameter
    `B` - The type of the right parameter
    `BF` - The unification parameter
  All Superinterfaces:
    BoundedBifunctor<A,B,Object,Object,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 Bifunctor<A,B,BF extends Bifunctor<?,?,BF>>
      extends BoundedBifunctor<A,B,Object,Object,BF>

  A dually-parametric functor that maps covariantly over both parameters.

  For more information, read about Bifunctors.

  See Also:
    `Functor`, `Profunctor`, `Tuple2`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `<C,D> Bifunctor<C,D,BF>` | `biMap(Fn1<? super A,? extends C> lFn, Fn1<? super B,? extends D> rFn)` Dually map covariantly over both the left and right parameters.
    `default <C> Bifunctor<C,B,BF>` | `biMapL(Fn1<? super A,? extends C> fn)` Covariantly map over the left parameter.
    `default <C> Bifunctor<A,C,BF>` | `biMapR(Fn1<? super B,? extends C> fn)` Covariantly map over the right parameter.

- - ### Method Detail

    - #### biMapL

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

      Covariantly map over the left parameter.
      Specified by:
        `biMapL` in interface `BoundedBifunctor<A,B,Object,Object,BF extends Bifunctor<?,?,BF>>`
      Type Parameters:
        `C` - the new left parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a bifunctor over C (the new left parameter) and B (the same right parameter)

    - #### biMapR

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

      Covariantly map over the right parameter. For all bifunctors that are also functors, it should hold that `biMapR(f) == fmap(f)`.
      Specified by:
        `biMapR` in interface `BoundedBifunctor<A,B,Object,Object,BF extends Bifunctor<?,?,BF>>`
      Type Parameters:
        `C` - the new right parameter type
      Parameters:
        `fn` - the mapping function
      Returns:
        a bifunctor over A (the same left parameter) and C (the new right parameter)

    - #### biMap

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

      Dually map covariantly over both the left and right parameters. This is isomorphic to `biMapL(lFn).biMapR(rFn)`.
      Specified by:
        `biMap` in interface `BoundedBifunctor<A,B,Object,Object,BF extends Bifunctor<?,?,BF>>`
      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)