Bifunctor

abstract def bimap[A, B, C, D](fab: F[A, B])(f: (A) ⇒ C, g: (B) ⇒ D): F[C, D]

map over both type parameters.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val bifunctorSyntax: BifunctorSyntax[F]

def clone(): AnyRef

def compose[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β]F[G[α, β], G[α, β]]]

The composition of Bifunctors F and G, [x,y]F[G[x,y],G[x,y]], is a Bifunctor

def embed[G[_], H[_]](implicit G0: Functor[G], H0: Functor[H]): Bifunctor[[α, β]F[G[α], H[β]]]

Embed two Functors , one on each side

def embedLeft[G[_]](implicit G0: Functor[G]): Bifunctor[[α, β]F[G[α], β]]

Embed one Functor to the left

def embedRight[H[_]](implicit H0: Functor[H]): Bifunctor[[α, β]F[α, H[β]]]

Embed one Functor to the right

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def leftFunctor[X]: Functor[[α$0$]F[α$0$, X]]

Extract the Functor on the first param.

def leftMap[A, B, C](fab: F[A, B])(f: (A) ⇒ C): F[C, B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β](F[α, β], G[α, β])]

The product of Bifunctors F and G, [x,y](F[x,y], G[x,y]), is a Bifunctor

def rightFunctor[X]: Functor[[β$1$]F[X, β$1$]]

Extract the Functor on the second param.

def rightMap[A, B, D](fab: F[A, B])(g: (B) ⇒ D): F[A, D]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def uFunctor: Functor[[α]F[α, α]]

Unify the functor over both params.

def umap[A, B](faa: F[A, A])(f: (A) ⇒ B): F[B, B]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit