NonEmptyReducible
Related Doc:
package cats
Alias for fold.
Compose two Reducible instances into a new one.
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 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.
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.
Reduce a F[A] value using the given Semigroup[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[_].
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.
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 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].
Apply f to each element of fa and combine them using the
given Semigroup[B].
Right-associative reduction on F using the function f.
Right-associative reduction on F using the function f.
Apply f to the "initial element" of fa and lazily 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.
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.
This class defines a
Reducible[F]in terms of aFoldable[G]together with asplit method,F[A]=>(A, G[A]).This class can be used on any type where the first value (
A) and the "rest" of the values (G[A]) can be easily found.