Choice

abstract def choice[A, B, C](f: F[A, C], g: F[B, C]): F[Either[A, B], C]

Given two Fs (f and g) with a common target type, create a new F with the same target type, but with a source type of either f's source type OR g's source type.

scala> import cats.implicits._
scala> val b: Boolean => String = _ + " is a boolean"
scala> val i: Int => String =  _ + " is an integer"
scala> val f: (Either[Boolean, Int]) => String = b ||| i

scala> f(Right(3))
res0: String = 3 is an integer

scala> f(Left(false))
res0: String = false is a boolean

abstract def compose[A, B, C](f: F[B, C], g: F[A, B]): F[A, C]

abstract def id[A]: F[A, A]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def algebra[A]: Monoid[F[A, A]]

def algebraK: MonoidK[[α]F[α, α]]

def andThen[A, B, C](f: F[A, B], g: F[B, C]): F[A, C]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def codiagonal[A]: F[Either[A, A], A]

An F that, given a source A on either the right or left side, will return that same A object.

scala> import cats.implicits._
scala> val f: (Either[Int, Int]) => Int = Choice[Function1].codiagonal[Int]

scala> f(Right(3))
res0: Int = 3

scala> f(Left(3))
res1: Int = 3

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit