trait Foldable[F[_]] extends UnorderedFoldable[F] with FoldableNFunctions[F]
Data structures that can be folded to a summary value.
In the case of a collection (such as List
or Vector
), 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.
Instances of Foldable should be ordered collections to allow for consistent folding.
Use the UnorderedFoldable
type class if you want to fold over unordered collections.
Foldable[F] is implemented in terms of two basic methods:
foldLeft(fa, b)(f)
eagerly foldsfa
from left-to-right.foldRight(fa, b)(f)
lazily foldsfa
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]
- Source
- Foldable.scala
- Grouped
- Alphabetic
- By Inheritance
- Foldable
- FoldableNFunctions
- UnorderedFoldable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def foldLeft[A, B](fa: F[A], b: B)(f: (B, A) => B): B
Left associative fold on 'F' using the function 'f'.
Left associative fold on 'F' using the function 'f'.
Example:
scala> import cats.Foldable, cats.implicits._ scala> val fa = Option(1) Folding by addition to zero: scala> Foldable[Option].foldLeft(fa, Option(0))((a, n) => a.map(_ + n)) res0: Option[Int] = Some(1)
With syntax extensions,
foldLeft
can be used like:Folding `Option` with addition from zero: scala> fa.foldLeft(Option(0))((a, n) => a.map(_ + n)) res1: Option[Int] = Some(1) There's also an alias `foldl` which is equivalent: scala> fa.foldl(Option(0))((a, n) => a.map(_ + n)) res2: Option[Int] = Some(1)
- 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[_]
.Example:
scala> import cats.Foldable, cats.Eval, cats.implicits._ scala> val fa = Option(1) Folding by addition to zero: scala> val folded1 = Foldable[Option].foldRight(fa, Eval.now(0))((n, a) => a.map(_ + n)) Since `foldRight` yields a lazy computation, we need to force it to inspect the result: scala> folded1.value res0: Int = 1 With syntax extensions, we can write the same thing like this: scala> val folded2 = fa.foldRight(Eval.now(0))((n, a) => a.map(_ + n)) scala> folded2.value res1: Int = 1 Unfortunately, since `foldRight` is defined on many collections - this extension clashes with the operation defined in `Foldable`. To get past this and make sure you're getting the lazy `foldRight` defined in `Foldable`, there's an alias `foldr`: scala> val folded3 = fa.foldr(Eval.now(0))((n, a) => a.map(_ + n)) scala> folded3.value res1: Int = 1
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collectFirst[A, B](fa: F[A])(pf: PartialFunction[A, B]): Option[B]
- def collectFirstSome[A, B](fa: F[A])(f: (A) => Option[B]): Option[B]
Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s.Like
collectFirst
fromscala.collection.Traversable
but takesA => Option[B]
instead ofPartialFunction
s.scala> import cats.implicits._ scala> val keys = List(1, 2, 4, 5) scala> val map = Map(4 -> "Four", 5 -> "Five") scala> keys.collectFirstSome(map.get) res0: Option[String] = Some(Four) scala> val map2 = Map(6 -> "Six", 7 -> "Seven") scala> keys.collectFirstSome(map2.get) res1: Option[String] = None
- def collectFirstSomeM[G[_], A, B](fa: F[A])(f: (A) => G[Option[B]])(implicit G: Monad[G]): G[Option[B]]
Monadic version of
collectFirstSome
.Monadic version of
collectFirstSome
.If there are no elements, the result is
None
.collectFirstSomeM
short-circuits, i.e. once a Some element is found, no further effects are produced.For example:
scala> import cats.implicits._ scala> def parseInt(s: String): Either[String, Int] = Either.catchOnly[NumberFormatException](s.toInt).leftMap(_.getMessage) scala> val keys1 = List("1", "2", "4", "5") scala> val map1 = Map(4 -> "Four", 5 -> "Five") scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map1.get) res0: scala.util.Either[String,Option[String]] = Right(Some(Four)) scala> val map2 = Map(6 -> "Six", 7 -> "Seven") scala> Foldable[List].collectFirstSomeM(keys1)(parseInt(_) map map2.get) res1: scala.util.Either[String,Option[String]] = Right(None) scala> val keys2 = List("1", "x", "4", "5") scala> Foldable[List].collectFirstSomeM(keys2)(parseInt(_) map map1.get) res2: scala.util.Either[String,Option[String]] = Left(For input string: "x") scala> val keys3 = List("1", "2", "4", "x") scala> Foldable[List].collectFirstSomeM(keys3)(parseInt(_) map map1.get) res3: scala.util.Either[String,Option[String]] = Right(Some(Four))
- def collectFold[A, B](fa: F[A])(f: PartialFunction[A, B])(implicit B: Monoid[B]): B
Tear down a subset of this structure using a
PartialFunction
.Tear down a subset of this structure using a
PartialFunction
.scala> import cats.implicits._ scala> val xs = List(1, 2, 3, 4) scala> Foldable[List].collectFold(xs) { case n if n % 2 == 0 => n } res0: Int = 6
- def collectFoldSome[A, B](fa: F[A])(f: (A) => Option[B])(implicit B: Monoid[B]): B
Tear down a subset of this structure using a
A => Option[M]
.Tear down a subset of this structure using a
A => Option[M]
.scala> import cats.implicits._ scala> val xs = List(1, 2, 3, 4) scala> def f(n: Int): Option[Int] = if (n % 2 == 0) Some(n) else None scala> Foldable[List].collectFoldSome(xs)(f) res0: Int = 6
- def combineAll[A](fa: F[A])(implicit arg0: Monoid[A]): A
Alias for fold.
- def combineAllOption[A](fa: F[A])(implicit ev: Semigroup[A]): Option[A]
- def compose[G[_]](implicit arg0: Foldable[G]): Foldable[[α]F[G[α]]]
- def contains_[A](fa: F[A], v: A)(implicit ev: Eq[A]): Boolean
Tests if
fa
containsv
using theEq
instance forA
Tests if
fa
containsv
using theEq
instance forA
- Definition Classes
- UnorderedFoldable
- def count[A](fa: F[A])(p: (A) => Boolean): Long
Count the number of elements in the structure that satisfy the given predicate.
Count the number of elements in the structure that satisfy the given predicate.
For example:
scala> import cats.implicits._ scala> val map1 = Map[Int, String]() scala> val p1: String => Boolean = _.length > 0 scala> UnorderedFoldable[Map[Int, *]].count(map1)(p1) res0: Long = 0 scala> val map2 = Map(1 -> "hello", 2 -> "world", 3 -> "!") scala> val p2: String => Boolean = _.length > 1 scala> UnorderedFoldable[Map[Int, *]].count(map2)(p2) res1: Long = 2
- Definition Classes
- UnorderedFoldable
- 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
. - final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- 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
.- Definition Classes
- Foldable → UnorderedFoldable
- def existsM[G[_], A](fa: F[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
Check whether at least one element satisfies the effectful predicate.
Check whether at least one element satisfies the effectful predicate.
If there are no elements, the result is
false
.existsM
short-circuits, i.e. once atrue
result is encountered, no further effects are produced.For example:
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.existsM(List(1,2,3,4))(n => Option(n <= 4)) res0: Option[Boolean] = Some(true) scala> F.existsM(List(1,2,3,4))(n => Option(n > 4)) res1: Option[Boolean] = Some(false) scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) Option(true) else Option(false)) res2: Option[Boolean] = Some(true) scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) Option(true) else None) res3: Option[Boolean] = Some(true) scala> F.existsM(List(1,2,3,4))(n => if (n <= 2) None else Option(true)) res4: Option[Boolean] = None
- def filter_[A](fa: F[A])(p: (A) => Boolean): List[A]
Convert F[A] to a List[A], only including elements which match
p
. - def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def find[A](fa: F[A])(f: (A) => Boolean): Option[A]
Find the first element matching the predicate, if one exists.
- def findM[G[_], A](fa: F[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Option[A]]
Find the first element matching the effectful predicate, if one exists.
Find the first element matching the effectful predicate, if one exists.
If there are no elements, the result is
None
.findM
short-circuits, i.e. once an element is found, no further effects are produced.For example:
scala> import cats.implicits._ scala> val list = List(1,2,3,4) scala> Foldable[List].findM(list)(n => (n >= 2).asRight[String]) res0: Either[String,Option[Int]] = Right(Some(2)) scala> Foldable[List].findM(list)(n => (n > 4).asRight[String]) res1: Either[String,Option[Int]] = Right(None) scala> Foldable[List].findM(list)(n => Either.cond(n < 3, n >= 2, "error")) res2: Either[String,Option[Int]] = Right(Some(2)) scala> Foldable[List].findM(list)(n => Either.cond(n < 3, false, "error")) res3: Either[String,Option[Int]] = Left(error)
- def fold[A](fa: F[A])(implicit A: Monoid[A]): A
Fold implemented using the given
Monoid[A]
instance. - def foldA[G[_], A](fga: F[G[A]])(implicit G: Applicative[G], A: Monoid[A]): G[A]
Fold implemented using the given
Applicative[G]
andMonoid[A]
instance.Fold implemented using the given
Applicative[G]
andMonoid[A]
instance.This method is similar to fold, but may short-circuit.
For example:
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.foldA(List(Either.right[String, Int](1), Either.right[String, Int](2))) res0: Either[String, Int] = Right(3)
- 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 aMonoid[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)
- final def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
Alias for foldM.
- def foldM[G[_], A, B](fa: F[A], z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
Perform a stack-safe monadic left fold from the source context
F
into the target monadG
.Perform a stack-safe monadic left fold from the source context
F
into the target monadG
.This method can express short-circuiting semantics. Even when
fa
is an infinite structure, this method can potentially terminate if thefoldRight
implementation forF
and thetailRecM
implementation forG
are sufficiently lazy.Instances for concrete structures (e.g.
List
) will often have a more efficient implementation than the default one in terms offoldRight
. - def foldMap[A, B](fa: F[A])(f: (A) => B)(implicit B: Monoid[B]): B
Fold implemented by mapping
A
values intoB
and then combining them using the givenMonoid[B]
instance. - def foldMapA[G[_], A, B](fa: F[A])(f: (A) => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]
Fold in an Applicative context by mapping the
A
values toG[B]
.Fold in an Applicative context by mapping the
A
values toG[B]
. combining theB
values using the givenMonoid[B]
instance.Similar to foldMapM, but will typically be less efficient.
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].foldMapA(evenNumbers)(evenOpt) res0: Option[Int] = Some(30) scala> Foldable[List].foldMapA(evenNumbers :+ 11)(evenOpt) res1: Option[Int] = None
- def foldMapK[G[_], A, B](fa: F[A])(f: (A) => G[B])(implicit G: MonoidK[G]): G[B]
Fold implemented by mapping
A
values intoB
in a contextG
and then combining them using theMonoidK[G]
instance.Fold implemented by mapping
A
values intoB
in a contextG
and then combining them using theMonoidK[G]
instance.scala> import cats._, cats.implicits._ scala> val f: Int => Endo[String] = i => (s => s + i) scala> val x: Endo[String] = Foldable[List].foldMapK(List(1, 2, 3))(f) scala> val a = x("foo") a: String = "foo321"
- 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 mappingA
values toG[B]
, combining theB
values using the givenMonoid[B]
instance.Monadic folding on
F
by mappingA
values toG[B]
, combining theB
values using the givenMonoid[B]
instance.Similar to foldM, but using a
Monoid[B]
. Will typically be more efficient than foldMapA.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
- def foldRightDefer[G[_], A, B](fa: F[A], gb: G[B])(fn: (A, G[B]) => G[B])(implicit arg0: Defer[G]): G[B]
- 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
.- Definition Classes
- Foldable → UnorderedFoldable
- def forallM[G[_], A](fa: F[A])(p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
Check whether all elements satisfy the effectful predicate.
Check whether all elements satisfy the effectful predicate.
If there are no elements, the result is
true
.forallM
short-circuits, i.e. once afalse
result is encountered, no further effects are produced.For example:
scala> import cats.implicits._ scala> val F = Foldable[List] scala> F.forallM(List(1,2,3,4))(n => Option(n <= 4)) res0: Option[Boolean] = Some(true) scala> F.forallM(List(1,2,3,4))(n => Option(n <= 1)) res1: Option[Boolean] = Some(false) scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) Option(true) else Option(false)) res2: Option[Boolean] = Some(false) scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) Option(false) else None) res3: Option[Boolean] = Some(false) scala> F.forallM(List(1,2,3,4))(n => if (n <= 2) None else Option(false)) res4: Option[Boolean] = None
- def get[A](fa: F[A])(idx: Long): Option[A]
Get the element at the index of the
Foldable
. - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- 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
- def intersperseList[A](xs: List[A], x: A): List[A]
- Attributes
- protected
- def isEmpty[A](fa: F[A]): Boolean
Returns true if there are no elements.
Returns true if there are no elements. Otherwise false.
- Definition Classes
- Foldable → UnorderedFoldable
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def maximumByList[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): List[A]
Find all the maximum
A
items in this structure according to anOrder.by(f)
.Find all the maximum
A
items in this structure according to anOrder.by(f)
. For all elements in the result Order.eqv(x, y) is true. Preserves order.- See also
Reducible#maximumByNel for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.minimumByList for minimum instead of maximum.
- def maximumByOption[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
Find the maximum
A
item in this structure according to anOrder.by(f)
.Find the maximum
A
item in this structure according to anOrder.by(f)
.- returns
None
if the structure is empty, otherwise the maximum element wrapped in aSome
.
- See also
Reducible#maximumBy for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.minimumByOption for minimum instead of maximum.
- def maximumList[A](fa: F[A])(implicit A: Order[A]): List[A]
Find all the maximum
A
items in this structure.Find all the maximum
A
items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.- See also
Reducible#maximumNel for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.minimumList for minimum instead of maximum.
- def maximumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]
Find the maximum
A
item in this structure according to theOrder[A]
.Find the maximum
A
item in this structure according to theOrder[A]
.- returns
None
if the structure is empty, otherwise the maximum element wrapped in aSome
.
- See also
Reducible#maximum for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.minimumOption for minimum instead of maximum.
- def minimumByList[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): List[A]
Find all the minimum
A
items in this structure according to anOrder.by(f)
.Find all the minimum
A
items in this structure according to anOrder.by(f)
. For all elements in the result Order.eqv(x, y) is true. Preserves order.- See also
Reducible#minimumByNel for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.maximumByList for maximum instead of minimum.
- def minimumByOption[A, B](fa: F[A])(f: (A) => B)(implicit arg0: Order[B]): Option[A]
Find the minimum
A
item in this structure according to anOrder.by(f)
.Find the minimum
A
item in this structure according to anOrder.by(f)
.- returns
None
if the structure is empty, otherwise the minimum element wrapped in aSome
.
- See also
Reducible#minimumBy for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.maximumByOption for maximum instead of minimum.
- def minimumList[A](fa: F[A])(implicit A: Order[A]): List[A]
Find all the minimum
A
items in this structure.Find all the minimum
A
items in this structure. For all elements in the result Order.eqv(x, y) is true. Preserves order.- See also
Reducible#minimumNel for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.maximumList for maximum instead of minimum.
- def minimumOption[A](fa: F[A])(implicit A: Order[A]): Option[A]
Find the minimum
A
item in this structure according to theOrder[A]
.Find the minimum
A
item in this structure according to theOrder[A]
.- returns
None
if the structure is empty, otherwise the minimum element wrapped in aSome
.
- See also
Reducible#minimum for a version that doesn't need to return an
Option
for structures that are guaranteed to be non-empty.maximumOption for maximum instead of minimum.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def nonEmpty[A](fa: F[A]): Boolean
- Definition Classes
- Foldable → UnorderedFoldable
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def partitionBifold[H[_, _], A, B, C](fa: F[A])(f: (A) => H[B, C])(implicit A: Alternative[F], H: Bifoldable[H]): (F[B], F[C])
Separate this Foldable into a Tuple by a separating function
A => H[B, C]
for someBifoldable[H]
Equivalent toFunctor#map
and thenAlternative#separate
.Separate this Foldable into a Tuple by a separating function
A => H[B, C]
for someBifoldable[H]
Equivalent toFunctor#map
and thenAlternative#separate
.scala> import cats.implicits._, cats.Foldable, cats.data.Const scala> val list = List(1,2,3,4) scala> Foldable[List].partitionBifold(list)(a => ("value " + a.toString(), if (a % 2 == 0) -a else a)) res0: (List[String], List[Int]) = (List(value 1, value 2, value 3, value 4),List(1, -2, 3, -4)) scala> Foldable[List].partitionBifold(list)(a => Const[Int, Nothing with Any](a)) res1: (List[Int], List[Nothing with Any]) = (List(1, 2, 3, 4),List())
- def partitionBifoldM[G[_], H[_, _], A, B, C](fa: F[A])(f: (A) => G[H[B, C]])(implicit A: Alternative[F], M: Monad[G], H: Bifoldable[H]): G[(F[B], F[C])]
Separate this Foldable into a Tuple by an effectful separating function
A => G[H[B, C]]
for someBifoldable[H]
Equivalent toTraverse#traverse
overAlternative#separate
Separate this Foldable into a Tuple by an effectful separating function
A => G[H[B, C]]
for someBifoldable[H]
Equivalent toTraverse#traverse
overAlternative#separate
scala> import cats.implicits._, cats.Foldable, cats.data.Const scala> val list = List(1,2,3,4) `Const`'s second parameter is never instantiated, so we can use an impossible type: scala> Foldable[List].partitionBifoldM(list)(a => Option(Const[Int, Nothing with Any](a))) res0: Option[(List[Int], List[Nothing with Any])] = Some((List(1, 2, 3, 4),List()))
- def partitionEither[A, B, C](fa: F[A])(f: (A) => Either[B, C])(implicit A: Alternative[F]): (F[B], F[C])
Separate this Foldable into a Tuple by a separating function
A => Either[B, C]
Equivalent toFunctor#map
and thenAlternative#separate
.Separate this Foldable into a Tuple by a separating function
A => Either[B, C]
Equivalent toFunctor#map
and thenAlternative#separate
.scala> import cats.implicits._ scala> val list = List(1,2,3,4) scala> Foldable[List].partitionEither(list)(a => if (a % 2 == 0) Left(a.toString) else Right(a)) res0: (List[String], List[Int]) = (List(2, 4),List(1, 3)) scala> Foldable[List].partitionEither(list)(a => Right(a * 4)) res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))
- def partitionEitherM[G[_], A, B, C](fa: F[A])(f: (A) => G[Either[B, C]])(implicit A: Alternative[F], M: Monad[G]): G[(F[B], F[C])]
Separate this Foldable into a Tuple by an effectful separating function
A => G[Either[B, C]]
Equivalent toTraverse#traverse
overAlternative#separate
Separate this Foldable into a Tuple by an effectful separating function
A => G[Either[B, C]]
Equivalent toTraverse#traverse
overAlternative#separate
scala> import cats.implicits._, cats.Foldable, cats.Eval scala> val list = List(1,2,3,4) scala> val partitioned1 = Foldable[List].partitionEitherM(list)(a => if (a % 2 == 0) Eval.now(Either.left[String, Int](a.toString)) else Eval.now(Either.right[String, Int](a))) Since `Eval.now` yields a lazy computation, we need to force it to inspect the result: scala> partitioned1.value res0: (List[String], List[Int]) = (List(2, 4),List(1, 3)) scala> val partitioned2 = Foldable[List].partitionEitherM(list)(a => Eval.later(Either.right(a * 4))) scala> partitioned2.value res1: (List[Nothing], List[Int]) = (List(),List(4, 8, 12, 16))
- def productAll[A](fa: F[A])(implicit A: Numeric[A]): A
- 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 thef
operation over all of the elements.
- See also
reduceRightOption for a right-associative alternative.
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
- def reduceLeftToOption[A, B](fa: F[A])(f: (A) => B)(g: (B, A) => B): Option[B]
- 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 thef
operation over theA
elements.
- See also
reduceLeftOption for a left-associative alternative
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 equivalent 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
- def reduceRightToOption[A, B](fa: F[A])(f: (A) => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]
- def sequence_[G[_], A](fga: F[G[A]])(implicit arg0: Applicative[G]): G[Unit]
Sequence
F[G[A]]
usingApplicative[G]
.Sequence
F[G[A]]
usingApplicative[G]
.This is similar to
traverse_
except it operates onF[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
- def size[A](fa: F[A]): Long
The size of this UnorderedFoldable.
The size of this UnorderedFoldable.
This is overridden in structures that have more efficient size implementations (e.g. Vector, Set, Map).
Note: will not terminate for infinite-sized collections.
- Definition Classes
- UnorderedFoldable
- def sliding10[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding11[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding12[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding13[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding14[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding15[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding16[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding17[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding18[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding19[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding2[A](fa: F[A]): List[(A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding20[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding21[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding22[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding3[A](fa: F[A]): List[(A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding4[A](fa: F[A]): List[(A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding5[A](fa: F[A]): List[(A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding6[A](fa: F[A]): List[(A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding7[A](fa: F[A]): List[(A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding8[A](fa: F[A]): List[(A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sliding9[A](fa: F[A]): List[(A, A, A, A, A, A, A, A, A)]
- Definition Classes
- FoldableNFunctions
- def sumAll[A](fa: F[A])(implicit A: Numeric[A]): A
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- 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
. - def toIterable[A](fa: F[A]): Iterable[A]
Convert F[A] to an Iterable[A].
Convert F[A] to an Iterable[A].
This method may be overridden for the sake of performance, but implementers should take care not to force a full materialization of the collection.
- def toList[A](fa: F[A]): List[A]
Convert F[A] to a List[A].
- def toString(): String
- Definition Classes
- AnyRef → Any
- def traverse_[G[_], A, B](fa: F[A])(f: (A) => G[B])(implicit G: Applicative[G]): G[Unit]
Traverse
F[A]
usingApplicative[G]
.Traverse
F[A]
usingApplicative[G]
.A
values will be mapped intoG[B]
and combined usingApplicative#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 specificA
aspect ofG[A]
is not otherwise needed. - def unorderedFold[A](fa: F[A])(implicit arg0: CommutativeMonoid[A]): A
- Definition Classes
- Foldable → UnorderedFoldable
- def unorderedFoldMap[A, B](fa: F[A])(f: (A) => B)(implicit arg0: CommutativeMonoid[B]): B
- Definition Classes
- Foldable → UnorderedFoldable
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
Inherited from FoldableNFunctions[F]
Inherited from UnorderedFoldable[F]
Inherited from Serializable
Inherited from AnyRef
Inherited from Any
Ungrouped
foldable arity
Group sequential elements into fixed sized tuples by passing a "sliding window" over them.
A foldable with fewer elements than the window size will return an empty list unlike Iterable#sliding(size: Int)
.
Example:
import cats.Foldable scala> Foldable[List].sliding2((1 to 10).toList) val res0: List[(Int, Int)] = List((1,2), (2,3), (3,4), (4,5), (5,6), (6,7), (7,8), (8,9), (9,10)) scala> Foldable[List].sliding4((1 to 10).toList) val res1: List[(Int, Int, Int, Int)] = List((1,2,3,4), (2,3,4,5), (3,4,5,6), (4,5,6,7), (5,6,7,8), (6,7,8,9), (7,8,9,10)) scala> Foldable[List].sliding4((1 to 2).toList) val res2: List[(Int, Int, Int, Int)] = List()