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 fold on 'F' using the function 'f'.
Left associative fold on 'F' using the function 'f'.
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.
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'.
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.
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.
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], retaining only initial elements which
match p
.
Convert F[A] to a List[A].
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.