Bifunctor

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

The quintessential method of the Bifunctor trait, it applies a function to each "side" of the bifunctor.

scala> import cats.implicits._

scala> val x: (List[String], Int) = (List("foo", "bar"), 3)
scala> x.bimap(_.headOption, _.toLong + 1)
res0: (Option[String], Long) = (Some(foo),4)

abstract def getClass(): Class[_]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

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

The composition of two Bifunctors is itself a Bifunctor

def equals(arg0: Any): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

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

apply a function to the "left" functor

def leftWiden[A, B, AA >: A](fab: F[A, B]): F[AA, B]

Widens A into a supertype AA.

scala> import cats.implicits._
scala> sealed trait Foo
scala> case object Bar extends Foo
scala> val x1: Either[Bar.type, Int] = Either.left(Bar)
scala> val x2: Either[Foo, Int] = x1.leftWiden

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

def toString(): String