Reducible
Related Docs:
object Reducible
| package cats
Left associative fold on 'F' using the function 'f'.
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[_].
Apply f to the "initial element" of fa and combine it with
every other value using the given function g.
Apply f to the "initial element" of fa and lazily combine it
with every other value using the given function g.
Alias for fold.
Compose two Reducible instances into a new one.
Compose this Foldable[F] with a Foldable[G] to create
a Foldable[F[G]] instance.
Compose this Foldable[F] with a Foldable[G] to create
a Foldable[F[G]] instance.
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.std.list._ 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.
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.
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.
Reduce a F[A] value using the given Semigroup[A].
Reduce a F[G[A]] value using SemigroupK[G], a universal
semigroup for G[_].
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.
Left-associative reduction on F using the function f.
Implementations should override this method when possible.
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.
Overriden from Foldable[_] for efficiency.
Sequence F[G[A]] using Apply[G].
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 cats.data.Xor
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 cats.data.Xor
scala> import cats.data.Xor scala> import cats.std.list._ scala> val F = Foldable[List] scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Right(444))) res0: Xor[String, Unit] = Right(()) scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Left("boo"))) res1: Xor[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.std.list._ scala> import cats.std.option._ 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
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].
Traverse F[A] using Apply[G].
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 cats.data.Xor
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 cats.data.Xor
scala> import cats.data.Xor scala> import cats.std.list._ scala> def parseInt(s: String): Xor[String, Int] = | try { Xor.Right(s.toInt) } | catch { case _: NumberFormatException => Xor.Left("boo") } scala> val F = Foldable[List] scala> F.traverseU_(List("333", "444"))(parseInt) res0: Xor[String, Unit] = Right(()) scala> F.traverseU_(List("333", "zzz"))(parseInt) res1: Xor[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.data.Xor scala> import cats.std.list._ scala> import cats.std.option._ scala> def parseInt(s: String): Option[Int] = Xor.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 reduced to a summary value.
Reducibleis like a non-emptyFoldable. In addition to the fold methods it provides reduce methods which do not require an initial value.In addition to the methods needed by
Foldable,Reducibleis implemented in terms of two methods:reduceLeftTo(fa)(f)(g)eagerly reduces with an additional mapping functionreduceRightTo(fa)(f)(g)lazily reduces with an additional mapping function