Traverse
Related Docs:
object Traverse
| package cats
Left associative fold on 'F' using the function 'f'.
Left associative fold on 'F' using the function 'f'.
Right associative lazy fold on F using the folding function 'f'.
Right associative lazy fold on F using the folding function 'f'.
This method evaluates lb lazily (in some cases it will not be
needed), and returns a lazy value. We are using (A, Eval[B]) =>
Eval[B] 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[_].
Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.
Given a function which returns a G effect, thread this effect through the running of this function on all the values in F, returning an F[B] in a G context.
Example:
scala> import cats.implicits._ scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption scala> List("1", "2", "3").traverse(parseInt) res0: Option[List[Int]] = Some(List(1, 2, 3)) scala> List("1", "two", "3").traverse(parseInt) res1: Option[List[Int]] = None
Replaces the A value in F[A] with the supplied value.
Replaces the A value in F[A] with the supplied value.
Alias for fold.
Convert F[A] to a List[A], dropping all initial elements which
match p.
Convert F[A] to a List[A], dropping all initial elements which
match p.
Check whether at least one element satisfies the predicate.
Check whether at least one element satisfies the predicate.
If there are no elements, the result is false.
Convert F[A] to a List[A], only including elements which match p.
Convert F[A] to a List[A], only including elements which match p.
Find the first element matching the predicate, if one exists.
Find the first element matching the predicate, if one exists.
Fold implemented using the given Monoid[A] instance.
Fold implemented using the given Monoid[A] instance.
Fold implemented using the given MonoidK[G] instance.
Fold implemented using the given MonoidK[G] instance.
This method is identical to fold, except that we use the universal monoid (MonoidK[G])
to get a Monoid[G[A]] instance.
For example:
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil)) res0: List[Int] = List(1, 2, 3, 4, 5)
Left associative monadic folding on F.
Left associative monadic folding on F.
Fold implemented by mapping A values into B and then
combining them using the given Monoid[B] instance.
Fold implemented by mapping A values into B and then
combining them using the given Monoid[B] instance.
Check whether all elements satisfy the predicate.
Check whether all elements satisfy the predicate.
If there are no elements, the result is true.
Tuple the values in fa with the result of applying a function with the value
Tuple the values in fa with the result of applying a function with the value
Returns true if there are no elements.
Returns true if there are no elements. Otherwise false.
Lift a function f to operate on Functors
Lift a function f to operate on Functors
Find the maximum A item in this structure according to the Order[A].
Find the maximum A item in this structure according to the Order[A].
None if the structure is empty, otherwise the maximum element
wrapped in a Some.
minimumOption for minimum instead of maximum.
Reducible#maximum for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
Find the minimum A item in this structure according to the Order[A].
Find the minimum A item in this structure according to the Order[A].
None if the structure is empty, otherwise the minimum element
wrapped in a Some.
maximumOption for maximum instead of minimum.
Reducible#minimum for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.
None if the structure is empty, otherwise the result of combining
the cumulative left-associative result of the f operation over all of the
elements.
Reducible#reduceLeft for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
Example:
scala> import cats.implicits._ scala> val l = List(6, 3, 2) This is equivalent to (6 - 3) - 2 scala> Foldable[List].reduceLeftOption(l)(_ - _) res0: Option[Int] = Some(1) scala> Foldable[List].reduceLeftOption(List.empty[Int])(_ - _) res1: Option[Int] = None
reduceRightOption for a right-associative alternative.
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.
Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.
None if the structure is empty, otherwise the result of combining
the cumulative right-associative result of the f operation over the
A elements.
Reducible#reduceRight for a version that doesn't need to return an
Option for structures that are guaranteed to be non-empty.
Example:
scala> import cats.implicits._ scala> val l = List(6, 3, 2) This is eqivalent to 6 - (3 - 2) scala> Foldable[List].reduceRightOption(l)((current, rest) => rest.map(current - _)).value res0: Option[Int] = Some(5) scala> Foldable[List].reduceRightOption(List.empty[Int])((current, rest) => rest.map(current - _)).value res1: Option[Int] = None
reduceLeftOption for a left-associative alternative
Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].
Thread all the G effects through the F structure to invert the structure from F[G[A]] to G[F[A]].
Example:
scala> import cats.implicits._ scala> val x: List[Option[Int]] = List(Some(1), Some(2)) scala> val y: List[Option[Int]] = List(None, Some(2)) scala> x.sequence res0: Option[List[Int]] = Some(List(1, 2)) scala> y.sequence res1: Option[List[Int]] = None
Behaves just like sequence, but uses Unapply to find the Applicative instance for G.
Behaves just like sequence, but uses Unapply to find the Applicative instance for G.
Example:
scala> import cats.data.{Validated, ValidatedNel} scala> import cats.implicits._ scala> val x: List[ValidatedNel[String, Int]] = List(Validated.valid(1), Validated.invalid("a"), Validated.invalid("b")).map(_.toValidatedNel) scala> x.sequenceU res0: cats.data.ValidatedNel[String,List[Int]] = Invalid(NonEmptyList(a, b)) scala> x.sequence[ValidatedNel[String, ?], Int] res1: cats.data.ValidatedNel[String,List[Int]] = Invalid(NonEmptyList(a, b))
Behaves like sequence_, but uses Unapply to find the
Applicative instance for G - used when G is a
type constructor with two or more parameters such as scala.util.Either
Behaves like sequence_, but uses Unapply to find the
Applicative instance for G - used when G is a
type constructor with two or more parameters such as scala.util.Either
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.sequenceU_(List(Either.right[String, Int](333), Right(444))) res0: Either[String, Unit] = Right(()) scala> F.sequenceU_(List(Either.right[String, Int](333), Left("boo"))) res1: Either[String, Unit] = Left(boo)
Note that using sequence_ instead of sequenceU_ would not compile without
explicitly passing in the type parameters - the type checker has trouble
inferring the appropriate instance.
Sequence F[G[A]] using Applicative[G].
Sequence F[G[A]] using Applicative[G].
This is similar to traverse_ except it operates on F[G[A]]
values, so no additional functions are needed.
For example:
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.sequence_(List(Option(1), Option(2), Option(3))) res0: Option[Unit] = Some(()) scala> F.sequence_(List(Option(1), None, Option(3))) res1: Option[Unit] = None
The size of this Foldable.
The size of this Foldable.
This is overriden in structures that have more efficient size implementations (e.g. Vector, Set, Map).
Note: will not terminate for infinite-sized collections.
Convert F[A] to a List[A], retaining only initial elements which
match p.
Convert F[A] to a List[A], retaining only initial elements which
match p.
Convert F[A] to a List[A].
Convert F[A] to a List[A].
A traverse followed by flattening the inner result.
A traverse followed by flattening the inner result.
Example:
scala> import cats.implicits._ scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption scala> val x = Option(List("1", "two", "3")) scala> x.traverseM(_.map(parseInt)) res0: List[Option[Int]] = List(Some(1), None, Some(3))
Behaves just like traverse, but uses Unapply to find the Applicative instance for G.
Behaves just like traverse, but uses Unapply to find the Applicative instance for G.
Example:
scala> import cats.implicits._ scala> def parseInt(s: String): Either[String, Int] = Either.catchOnly[NumberFormatException](s.toInt).leftMap(_ => "no number") scala> val ns = List("1", "2", "3") scala> ns.traverseU(parseInt) res0: Either[String, List[Int]] = Right(List(1, 2, 3)) scala> ns.traverse[Either[String, ?], Int](parseInt) res1: Either[String, List[Int]] = Right(List(1, 2, 3))
Behaves like traverse_, but uses Unapply to find the
Applicative instance for G - used when G is a
type constructor with two or more parameters such as scala.util.Either
Behaves like traverse_, but uses Unapply to find the
Applicative instance for G - used when G is a
type constructor with two or more parameters such as scala.util.Either
scala> import cats.implicits._ scala> def parseInt(s: String): Either[String, Int] = | try { Right(s.toInt) } | catch { case _: NumberFormatException => Left("boo") } scala> val F = Foldable[List] scala> F.traverseU_(List("333", "444"))(parseInt) res0: Either[String, Unit] = Right(()) scala> F.traverseU_(List("333", "zzz"))(parseInt) res1: Either[String, Unit] = Left(boo)
Note that using traverse_ instead of traverseU_ would not compile without
explicitly passing in the type parameters - the type checker has trouble
inferring the appropriate instance.
Traverse F[A] using Applicative[G].
Traverse F[A] using Applicative[G].
A values will be mapped into G[B] and combined using
Applicative#map2.
For example:
scala> import cats.implicits._ scala> def parseInt(s: String): Option[Int] = Either.catchOnly[NumberFormatException](s.toInt).toOption scala> val F = Foldable[List] scala> F.traverse_(List("333", "444"))(parseInt) res0: Option[Unit] = Some(()) scala> F.traverse_(List("333", "zzz"))(parseInt) res1: Option[Unit] = None
This method is primarily useful when G[_] represents an action
or effect, and the specific A aspect of G[A] is not otherwise
needed.
Empty the fa of the values, preserving the structure
Empty the fa of the values, preserving the structure
Lifts natural subtyping covariance of covariant Functors.
Lifts natural subtyping covariance of covariant Functors.
NOTE: In certain (perhaps contrived) situations that rely on universal
equality this can result in a ClassCastException, because it is
implemented as a type cast. It could be implemented as map(identity), but
according to the functor laws, that should be equal to fa, and a type
cast is often much more performant.
See this example
of widen creating a ClassCastException.
Traverse, also known as Traversable.
Traversal over a structure with an effect.
Traversing with the cats.Id effect is equivalent to cats.Functor#map. Traversing with the cats.data.Const effect where the first type parameter has a cats.Monoid instance is equivalent to cats.Foldable#fold.
See: The Essence of the Iterator Pattern