Foldable
Related Docs:
object Foldable
| package cats
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[_].
Alias for fold.
Compose this Foldable[F] with a Foldable[G] to create
a Foldable[F[G]] instance.
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.
Find the first element matching the predicate, if one exists.
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.std.list._ 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.
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.
Returns true if there are no elements.
Returns true if there are no elements. Otherwise false.
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 cats.data.Xor
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 cats.data.Xor
scala> import cats.data.Xor scala> import cats.std.list._ scala> val F = Foldable[List] scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Right(444))) res0: Xor[String, Unit] = Right(()) scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Left("boo"))) res1: Xor[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.std.list._ scala> import cats.std.option._ 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
Convert F[A] to a List[A], retaining only initial elements which
match p.
Convert F[A] to a List[A].
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 cats.data.Xor
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 cats.data.Xor
scala> import cats.data.Xor scala> import cats.std.list._ scala> def parseInt(s: String): Xor[String, Int] = | try { Xor.Right(s.toInt) } | catch { case _: NumberFormatException => Xor.Left("boo") } scala> val F = Foldable[List] scala> F.traverseU_(List("333", "444"))(parseInt) res0: Xor[String, Unit] = Right(()) scala> F.traverseU_(List("333", "zzz"))(parseInt) res1: Xor[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.data.Xor scala> import cats.std.list._ scala> import cats.std.option._ scala> def parseInt(s: String): Option[Int] = Xor.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.
Data structures that can be folded to a summary value.
In the case of a collection (such as
ListorSet), these methods will fold together (combine) the values contained in the collection to produce a single result. Most collection types havefoldLeftmethods, which will usually be used by the associatedFoldable[_]instance.Foldable[F] is implemented in terms of two basic methods:
foldLeft(fa, b)(f)eagerly foldsfafrom left-to-right.foldRight(fa, b)(f)lazily foldsfafrom right-to-left.Beyond these it provides many other useful methods related to folding over F[A] values.
See: A tutorial on the universality and expressiveness of fold