trait Foldable[F[_]] extends Serializable

Data structures that can be folded to a summary value.

In the case of a collection (such as List or Set), these methods will fold together (combine) the values contained in the collection to produce a single result. Most collection types have foldLeft methods, which will usually be used by the associated Foldable[_] instance.

Foldable[F] is implemented in terms of two basic methods:

  • foldLeft(fa, b)(f) eagerly folds fa from left-to-right.
  • foldRight(fa, b)(f) lazily folds fa from 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

Self Type
Foldable[F]
Linear Supertypes
Serializable, Serializable, Any
Known Subclasses
NonEmptyReducible, Reducible, Traverse, TraverseFilter
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Foldable
  2. Serializable
  3. Serializable
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) ⇒ B): B

    Left associative fold on 'F' using the function 'f'.

  2. abstract def foldRight[A, B](fa: F[A], lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

    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[_].

  3. abstract def getClass(): Class[_]
    Definition Classes
    Any

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def combineAll[A](fa: F[A])(implicit arg0: Monoid[A]): A

    Alias for fold.

  6. def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]F[G[α]]]
  7. def dropWhile_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

    Convert F[A] to a List[A], dropping all initial elements which match p.

  8. def equals(arg0: Any): Boolean
    Definition Classes
    Any
  9. def exists[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

    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.

  10. def filter_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

    Convert F[A] to a List[A], only including elements which match p.

  11. def find[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]

    Find the first element matching the predicate, if one exists.

  12. def fold[A](fa: F[A])(implicit A: Monoid[A]): A

    Fold implemented using the given Monoid[A] instance.

  13. def foldK[G[_], A](fga: F[G[A]])(implicit G: MonoidK[G]): G[A]

    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)
  14. def foldM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit G: Monad[G]): G[B]

    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.

  15. def foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit B: Monoid[B]): B

    Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

  16. def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]

    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
  17. def forall[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

    Check whether all elements satisfy the predicate.

    Check whether all elements satisfy the predicate.

    If there are no elements, the result is true.

  18. def hashCode(): Int
    Definition Classes
    Any
  19. def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A

    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
  20. def intersperseList[A](xs: List[A], x: A): List[A]
    Attributes
    protected
  21. def isEmpty[A](fa: F[A]): Boolean

    Returns true if there are no elements.

    Returns true if there are no elements. Otherwise false.

  22. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  23. def maximumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]

    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].

    returns

    None if the structure is empty, otherwise the maximum element wrapped in a Some.

    See also

    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.

  24. def minimumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]

    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].

    returns

    None if the structure is empty, otherwise the minimum element wrapped in a Some.

    See also

    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.

  25. def nonEmpty[A](fa: F[A]): Boolean
  26. def reduceLeftOption[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]

    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.

    returns

    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.

    See also

    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.

  27. def reduceLeftToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (B, A) ⇒ B): Option[B]
  28. def reduceRightOption[A](fa: F[A])(f: (A, Eval[A]) ⇒ Eval[A]): Eval[Option[A]]

    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.

    returns

    None if the structure is empty, otherwise the result of combining the cumulative right-associative result of the f operation over the A elements.

    See also

    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

  29. def reduceRightToOption[A, B](fa: F[A])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]
  30. def sequenceU_[GA](fa: F[GA])(implicit U: Unapply[Applicative, GA]): M[Unit]

    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.

  31. def sequence_[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[Unit]

    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
  32. def size[A](fa: F[A]): Long

    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.

  33. def takeWhile_[A](fa: F[A])(p: (A) ⇒ Boolean): List[A]

    Convert F[A] to a List[A], retaining only initial elements which match p.

  34. def toList[A](fa: F[A]): List[A]

    Convert F[A] to a List[A].

  35. def toString(): String
    Definition Classes
    Any
  36. def traverseU_[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit U: Unapply[Applicative, GB]): M[Unit]

    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.

  37. def traverse_[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit G: Applicative[G]): G[Unit]

    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.

Inherited from Serializable

Inherited from Serializable

Inherited from Any

Ungrouped