cats-docs
2.9.0
API
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL
cats-docs/cats.data/BinestedBitraverse

BinestedBitraverse

cats.data.BinestedBitraverse
sealed abstract class BinestedBitraverse[F[_, _], G[_], H[_]] extends BinestedBifoldable[F, G, H] with Bitraverse[[_, _] =>> Binested[F, G, H, _$52, _$53]]

Attributes

Source:
Binested.scala
Graph
Supertypes
trait Bitraverse[[_, _] =>> Binested[F, G, H, _$52, _$53]]
trait Bifunctor[[_, _] =>> Binested[F, G, H, _$52, _$53]]
class BinestedBifoldable[F, G, H]
trait Bifoldable[[_, _] =>> Binested[F, G, H, _$52, _$53]]
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Concrete methods

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

Attributes

Source:
Binested.scala

Inherited methods

def bifold[A, B](fab: Binested[F, G, H, A, B])(implicit A: Monoid[A], B: Monoid[B]): (A, B)

Attributes

Inherited from:
Bifoldable
Source:
Bifoldable.scala
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, bifoldLeft can 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)

Attributes

Inherited from:
BinestedBifoldable
Source:
Binested.scala
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

Attributes

Inherited from:
Bifoldable
Source:
Bifoldable.scala
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 F using the folding function 'f' and 'g'.

Collapse the structure with a right-associative function Right associative lazy bifold on F using the folding function 'f' and 'g'.

This method evaluates c lazily (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, bifoldRight can 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

Attributes

Inherited from:
BinestedBifoldable
Source:
Binested.scala
override def bimap[A, B, C, D](fab: Binested[F, G, H, 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.

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)

Attributes

Definition Classes
Inherited from:
Bitraverse
Source:
Bitraverse.scala
def bisequence[G[_] : Applicative, A, B](fab: Binested[F, G, H, G[A], G[B]]): G[F[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

Attributes

Inherited from:
Bitraverse
Source:
Bitraverse.scala
def compose[G[_, _]](implicit ev: Bitraverse[G]): Bitraverse[[α, β] =>> F[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[_, _]]

Attributes

Inherited from:
Bitraverse
Source:
Bitraverse.scala
def compose[G[_, _]](implicit G0: Bifunctor[G]): Bifunctor[[α, β] =>> F[G[α, β], G[α, β]]]

The composition of two Bifunctors is itself a Bifunctor

The composition of two Bifunctors is itself a Bifunctor

Attributes

Inherited from:
Bifunctor
Source:
Bifunctor.scala
def compose[G[_, _]](implicit ev: Bifoldable[G]): Bifoldable[[α, β] =>> F[G[α, β], G[α, β]]]

Attributes

Inherited from:
Bifoldable
Source:
Bifoldable.scala
def leftFunctor[X]: Functor[F]

Attributes

Inherited from:
Bifunctor
Source:
Bifunctor.scala
def leftMap[A, B, C](fab: Binested[F, G, H, A, B])(f: A => C): F[C, B]

apply a function to the "left" functor

apply a function to the "left" functor

Attributes

Inherited from:
Bifunctor
Source:
Bifunctor.scala
def leftSequence[G[_], A, B](fgab: Binested[F, G, H, G[A], B])(implicit G: Applicative[G]): G[F[A, B]]

Sequence the left side of the structure. For the right side, use the standard sequence from cats.Traverse.

Sequence the left side of the structure. For the right side, use the standard sequence from 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

Attributes

Inherited from:
Bitraverse
Source:
Bitraverse.scala
def leftTraverse[G[_], A, B, C](fab: Binested[F, G, H, A, B])(f: A => G[C])(implicit G: Applicative[G]): G[F[C, B]]

Traverse over the left side of the structure. For the right side, use the standard traverse from cats.Traverse.

Traverse over the left side of the structure. For the right side, use the standard traverse from 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

Attributes

Inherited from:
Bitraverse
Source:
Bitraverse.scala
def leftWiden[A, B, AA >: A](fab: Binested[F, G, H, A, B]): F[AA, B]

Widens A into a supertype AA. Example:

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

Attributes

Inherited from:
Bifunctor
Source:
Bifunctor.scala
def rightFunctor[X]: Functor[[_] =>> F[X, _$3]]

Attributes

Inherited from:
Bifunctor
Source:
Bifunctor.scala

Implicits

Implicits

implicit override def F: Bitraverse[F]

Attributes

Definition Classes
Source:
Binested.scala
implicit override def G: Traverse[G]

Attributes

Definition Classes
Source:
Binested.scala
implicit override def H: Traverse[H]

Attributes

Definition Classes
Source:
Binested.scala
Generated with
© 2002-2021 · LAMP/EPFL
© 2002-2021 · LAMP/EPFL