BinestedBitraverse

implicit abstract def F: Bitraverse[F]

implicit abstract def G: Traverse[G]

implicit abstract def H: Traverse[H]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bifoldLeft[A, B, C](fab: Binested[F, G, H, A, B], c: C)(f: (C, A) ⇒ C, g: (C, B) ⇒ C): C

Collapse the structure with a left-associative function

def bifoldMap[A, B, C](fab: Binested[F, G, H, A, B])(f: (A) ⇒ C, g: (B) ⇒ C)(implicit C: Monoid[C]): C

Collapse the structure by mapping each element to an element of a type that has a cats.Monoid

def bifoldRight[A, B, C](fab: Binested[F, G, H, A, B], c: Eval[C])(f: (A, Eval[C]) ⇒ Eval[C], g: (B, Eval[C]) ⇒ Eval[C]): Eval[C]

Collapse the structure with a right-associative function

def bimap[A, B, C, D](fab: Binested[F, G, H, A, B])(f: (A) ⇒ C, g: (B) ⇒ D): Binested[F, G, H, 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)

def bisequence[G[_], A, B](fab: Binested[F, G, H, G[A], G[B]])(implicit arg0: Applicative[G]): G[Binested[F, G, H, A, B]]

Invert the structure from F[G[A], G[B]] to G[F[A, B]].

scala> import cats.implicits._

scala> val rightSome: Either[Option[String], Option[Int]] = Either.right(Some(3))
scala> rightSome.bisequence
res0: Option[Either[String, Int]] = Some(Right(3))

scala> val rightNone: Either[Option[String], Option[Int]] = Either.right(None)
scala> rightNone.bisequence
res1: Option[Either[String, Int]] = None

scala> val leftSome: Either[Option[String], Option[Int]] = Either.left(Some("foo"))
scala> leftSome.bisequence
res2: Option[Either[String, Int]] = Some(Left(foo))

scala> val leftNone: Either[Option[String], Option[Int]] = Either.left(None)
scala> leftNone.bisequence
res3: Option[Either[String, Int]] = None

def bitraverse[I[_], A, B, C, D](fab: Binested[F, G, H, A, B])(f: (A) ⇒ I[C], g: (B) ⇒ I[D])(implicit I: Applicative[I]): I[Binested[F, G, H, C, D]]

Traverse each side of the structure with the given functions.

scala> import cats.implicits._

scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption

scala> ("1", "2").bitraverse(parseInt, parseInt)
res0: Option[(Int, Int)] = Some((1,2))

scala> ("1", "two").bitraverse(parseInt, parseInt)
res1: Option[(Int, Int)] = None

def clone(): AnyRef

def compose[G[_, _]](implicit ev: Bitraverse[G]): Bitraverse[[α, β]Binested[F, G, H, G[α, β], G[α, β]]]

If F and G are both cats.Bitraverse then so is their composition F[G[_, _], G[_, _]]

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

The composition of two Bifunctors is itself a Bifunctor

def compose[G[_, _]](implicit ev: Bifoldable[G]): Bifoldable[[α, β]Binested[F, G, H, G[α, β], G[α, β]]]

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[[α$1$]Binested[F, G, H, α$1$, X]]

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

apply a function to the "left" functor

def leftWiden[A, B, AA >: A](fab: Binested[F, G, H, A, B]): Binested[F, G, H, 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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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