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, Choice2._A, Choice2._B, Choice3, Choice3._A, Choice3._B, Choice3._C, Choice4, Choice4._A, Choice4._B, Choice4._C, Choice4._D, Choice5, Choice5._A, Choice5._B, Choice5._C, Choice5._D, Choice5._E, Choice6, Choice6._A, Choice6._B, Choice6._C, Choice6._D, Choice6._E, Choice6._F, Choice7, Choice7._A, Choice7._B, Choice7._C, Choice7._D, Choice7._E, Choice7._F, Choice7._G, Choice8, Choice8._A, Choice8._B, Choice8._C, Choice8._D, Choice8._E, Choice8._F, Choice8._G, Choice8._H, Const, Either, Either.Left, Either.Right, EitherT, RecursiveResult, RecursiveResult.Recurse, RecursiveResult.Terminate, These, These._A, These._B, These.Both, 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:

  • Method Details

    • 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)