sealed abstract class BinestedBitraverse[F[_, _], G[_], H[_]] extends BinestedBifoldable[F, G, H] with Bitraverse[[δ$14$, ε$15$]Binested[F, G, H, δ$14$, ε$15$]]
- Alphabetic
- By Inheritance
- BinestedBitraverse
- Bitraverse
- Bifunctor
- BinestedBifoldable
- Bifoldable
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
implicit abstract
def
F: Bitraverse[F]
- Definition Classes
- BinestedBitraverse → BinestedBifoldable
-
implicit abstract
def
G: Traverse[G]
- Definition Classes
- BinestedBitraverse → BinestedBifoldable
-
implicit abstract
def
H: Traverse[H]
- Definition Classes
- BinestedBitraverse → BinestedBifoldable
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bifold[A, B](fab: Binested[F, G, H, A, B])(implicit A: Monoid[A], B: Monoid[B]): (A, B)
- Definition Classes
- Bifoldable
-
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
Collapse the structure with a left-associative function
Example:
scala> import cats.Bifoldable scala> val fab = (List(1), 2) Folding by addition to zero: scala> Bifoldable[Tuple2].bifoldLeft(fab, Option(0))((c, a) => c.map(_ + a.head), (c, b) => c.map(_ + b)) res0: Option[Int] = Some(3)
With syntax extensions,
bifoldLeftcan be used like:scala> import cats.implicits._ scala> fab.bifoldLeft(Option(0))((c, a) => c.map(_ + a.head), (c, b) => c.map(_ + b)) res1: Option[Int] = Some(3)
- Definition Classes
- BinestedBifoldable → Bifoldable
-
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
Collapse the structure by mapping each element to an element of a type that has a cats.Monoid
- Definition Classes
- Bifoldable
-
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 Right associative lazy bifold on
Fusing the folding function 'f' and 'g'.Collapse the structure with a right-associative function Right associative lazy bifold on
Fusing the folding function 'f' and 'g'.This method evaluates
clazily (in some cases it will not be needed), and returns a lazy value. We are using(_, Eval[C]) => Eval[C]to support laziness in a stack-safe way. Chained computation should be performed via .map and .flatMap.For more detailed information about how this method works see the documentation for
Eval[_].Example:
scala> import cats.Bifoldable scala> val fab = (List(1), 2) Folding by addition to zero: scala> val bifolded1 = Bifoldable[Tuple2].bifoldRight(fab, Eval.now(0))((a, c) => c.map(_ + a.head), (b, c) => c.map(_ + b)) scala> bifolded1.value res0: Int = 3
With syntax extensions,
bifoldRightcan be used like:scala> import cats.implicits._ scala> val bifolded2 = fab.bifoldRight(Eval.now(0))((a, c) => c.map(_ + a.head), (b, c) => c.map(_ + b)) scala> bifolded2.value res1: Int = 3
- Definition Classes
- BinestedBifoldable → Bifoldable
-
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.
The quintessential method of the Bifunctor trait, it applies a function to each "side" of the bifunctor.
Example:
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)
- Definition Classes
- Bitraverse → Bifunctor
-
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]].
Invert the structure from F[G[A], G[B]] to G[F[A, B]].
Example:
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
- Definition Classes
- Bitraverse
-
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.
Traverse each side of the structure with the given functions.
Example:
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
- Definition Classes
- BinestedBitraverse → Bitraverse
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @IntrinsicCandidate()
-
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[_, _]]
If F and G are both cats.Bitraverse then so is their composition F[G[_, _], G[_, _]]
- Definition Classes
- Bitraverse
-
def
compose[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β]Binested[F, G, H, G[α, β], G[α, β]]]
The composition of two Bifunctors is itself a Bifunctor
The composition of two Bifunctors is itself a Bifunctor
- Definition Classes
- Bifunctor
-
def
compose[G[_, _]](implicit ev: Bifoldable[G]): Bifoldable[[α, β]Binested[F, G, H, G[α, β], G[α, β]]]
- Definition Classes
- Bifoldable
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
leftFunctor[X]: Functor[[α$1$]Binested[F, G, H, α$1$, X]]
- Definition Classes
- Bifunctor
-
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
apply a function to the "left" functor
- Definition Classes
- Bifunctor
-
def
leftSequence[G[_], A, B](fgab: Binested[F, G, H, G[A], B])(implicit G: Applicative[G]): G[Binested[F, G, H, A, B]]
Sequence the left side of the structure.
Sequence the left side of the structure. For the right side, use the standard
sequencefrom cats.Traverse.Example:
scala> import cats.implicits._ scala> val optionalErrorRight: Either[Option[String], Int] = Either.right(123) scala> optionalErrorRight.leftSequence res1: Option[Either[String, Int]] = Some(Right(123)) scala> val optionalErrorLeftSome: Either[Option[String], Int] = Either.left(Some("something went wrong")) scala> optionalErrorLeftSome.leftSequence res2: Option[Either[String, Int]] = Some(Left(something went wrong)) scala> val optionalErrorLeftNone: Either[Option[String], Int] = Either.left(None) scala> optionalErrorLeftNone.leftSequence res3: Option[Either[String,Int]] = None
- Definition Classes
- Bitraverse
- Annotations
- @noop()
-
def
leftTraverse[G[_], A, B, C](fab: Binested[F, G, H, A, B])(f: (A) ⇒ G[C])(implicit G: Applicative[G]): G[Binested[F, G, H, C, B]]
Traverse over the left side of the structure.
Traverse over the left side of the structure. For the right side, use the standard
traversefrom cats.Traverse.Example:
scala> import cats.implicits._ scala> val intAndString: (Int, String) = (7, "test") scala> Bitraverse[Tuple2].leftTraverse(intAndString)(i => Option(i).filter(_ > 5)) res1: Option[(Int, String)] = Some((7,test)) scala> Bitraverse[Tuple2].leftTraverse(intAndString)(i => Option(i).filter(_ < 5)) res2: Option[(Int, String)] = None
- Definition Classes
- Bitraverse
- Annotations
- @noop()
-
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.
Widens A into a supertype AA. Example:
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
- Definition Classes
- Bifunctor
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
def
rightFunctor[X]: Functor[[β$0$]Binested[F, G, H, X, β$0$]]
- Definition Classes
- Bifunctor
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )