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.

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.

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 fold on 'F' using the function '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.

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

Check whether all elements satisfy the predicate.

If there are no elements, the result is true.

Returns true if there are no elements. Otherwise false.

Find the maximum A item in this structure according to the Order[A].

Find the minimum A item in this structure according to the Order[A].

Reduce a F[A] value using the given Semigroup[A].

Reduce a F[G[A]] value using SemigroupK[G], a universal semigroup for G[_].

This method is a generalization of reduce.

Left-associative reduction on F using the function f.

Implementations should override this method when possible.

Monadic variant of reduceLeftTo

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a left-associative manner.

Apply f to the "initial element" of fa and combine it with every other value using the given function g.

Overriden from Foldable[_] for efficiency.

Apply f to each element of fa and combine them using the given Semigroup[B].

Right-associative reduction on F using the function f.

Reduce the elements of this structure down to a single value by applying the provided aggregation function in a right-associative manner.

Apply f to the "initial element" of fa and lazily combine it with every other value using the given function g.

Overriden from Foldable[_] for efficiency.

Sequence F[G[A]] using Apply[G].

This method is similar to Foldable.sequence_ but requires only an Apply instance for G instead of Applicative. See the traverse1_ documentation for a description of the differences.

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

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.

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

Traverse F[A] using Apply[G].

A values will be mapped into G[B] and combined using Applicative#map2.

This method is similar to Foldable.traverse_. There are two main differences:

1. We only need an Apply instance for G here, since we don't need to call Applicative.pure for a starting value. 2. This performs a strict left-associative traversal and thus must always traverse the entire data structure. Prefer Foldable.traverse_ if you have an Applicative instance available for G and want to take advantage of short-circuiting the traversal.

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

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.