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.
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.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.
The default implementation of this is based on foldLeft, and thus will
always fold across the entire structure. Certain structures are able to
implement this in such a way that folds can be short-circuited (not
traverse the entirety of the structure), depending on the G result
produced at a given step.
Fold implemented by mapping A values into B and then
combining them using the given Monoid[B] instance.
Monadic folding on F by mapping A values to G[B], combining the B
values using the given Monoid[B] instance.
Monadic folding on F by mapping A values to G[B], combining the B
values using the given Monoid[B] instance.
Similar to foldM, but using a Monoid[B].
scala> import cats.Foldable scala> import cats.implicits._ scala> val evenNumbers = List(2,4,6,8,10) scala> val evenOpt: Int => Option[Int] = | i => if (i % 2 == 0) Some(i) else None scala> Foldable[List].foldMapM(evenNumbers)(evenOpt) res0: Option[Int] = Some(30) scala> Foldable[List].foldMapM(evenNumbers :+ 11)(evenOpt) res1: Option[Int] = None
Check whether all elements satisfy the predicate.
Check whether all elements satisfy the predicate.
If there are no elements, the result is true.
Intercalate/insert an element between the existing elements while folding.
Intercalate/insert an element between the existing elements while folding.
scala> import cats.implicits._ scala> Foldable[List].intercalate(List("a","b","c"), "-") res0: String = a-b-c scala> Foldable[List].intercalate(List("a"), "-") res1: String = a scala> Foldable[List].intercalate(List.empty[String], "-") res2: String = "" scala> Foldable[Vector].intercalate(Vector(1,2,3), 1) res3: Int = 8
Returns true if there are no elements.
Returns true if there are no elements. Otherwise false.
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
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].
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.
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