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

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[[α]F[α, 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[[α]F[X, α]]

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