Left associative fold on 'F' using the function 'f'.
Left associative fold on 'F' using the function 'f'.
Low-level method that powers foldRight.
Low-level method that powers foldRight.
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.
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.
Returns true if there are no elements.
Returns true if there are no elements. Otherwise false.
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:
val F = Foldable[List] F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil)) // List(1, 2, 3, 4, 5)
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 b lazily (in some cases it will not be
needed), and returns a lazy value. We are using A => Fold[B] to
support laziness in a stack-safe way.
For more detailed information about how this method works see the
documentation for Fold[_].
Check whether all elements satisfy the predicate.
Check whether all elements satisfy the predicate.
If there are no elements, the result is true.
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_. The difference is
that we only need Apply[G] here, since we don't need to call
Applicative#pure for a starting value.
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:
val F = Foldable[List] F.sequence_(List(Option(1), Option(2), Option(3))) // Some(()) F.sequence_(List(Option(1), None, Option(3))) // None
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 does the same thing as Foldable#traverse_. The
difference is that we only need Apply[G] here, since we don't
need to call Applicative#pure for a starting value.
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:
def parseInt(s: String): Option[Int] = ... val F = Foldable[List] F.traverse_(List("333", "444"))(parseInt) // Some(()) F.traverse_(List("333", "zzz"))(parseInt) // 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