trait Foldable1[F[_]] extends Foldable[F] with Foldable1Parent[F]
A scalaz.Foldable where foldMap is total over semigroups.
That is, toList cannot return an empty list.
- Self Type
- Foldable1[F]
- Source
- Foldable1.scala
- Alphabetic
- By Inheritance
- Foldable1
- Foldable1Parent
- Foldable
- FoldableParent
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
FoldableLaw extends AnyRef
- Definition Classes
- Foldable
- trait Foldable1Law extends FoldableLaw
Abstract Value Members
-
abstract
def
foldMap1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): B
Map each element of the structure to a scalaz.Semigroup, and combine the results.
-
abstract
def
foldMapRight1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): B
Right-associative fold of a structure.
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
-
def
all[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean
Whether all
As infayield true fromp.Whether all
As infayield true fromp.- Definition Classes
- Foldable
-
def
allM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]
allwith monadic traversal.allwith monadic traversal.- Definition Classes
- Foldable
-
def
any[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean
Whether any
As infayield true fromp.Whether any
As infayield true fromp.- Definition Classes
- Foldable
-
def
anyM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]
anywith monadic traversal.anywith monadic traversal.- Definition Classes
- Foldable
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[a, b]F[G[a, b]]]
The composition of Foldable
Fand BifoldableG,[x, y]F[G[x, y]], is a BifoldableThe composition of Foldable
Fand BifoldableG,[x, y]F[G[x, y]], is a Bifoldable- Definition Classes
- Foldable
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
def
collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
- Definition Classes
- Foldable
-
def
compose[G[_]](implicit arg0: Foldable1[G]): Foldable1[[α]F[G[α]]]
The composition of Foldable1
FandG,[x]F[G[x]], is a Foldable1 -
def
compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]
The composition of Foldables
FandG,[x]F[G[x]], is a FoldableThe composition of Foldables
FandG,[x]F[G[x]], is a Foldable- Definition Classes
- Foldable
-
final
def
count[A](fa: F[A]): Int
Alias for
length.Alias for
length.- Definition Classes
- Foldable
-
def
element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean
Whether
ais an element offa.Whether
ais an element offa.- Definition Classes
- Foldable
-
final
def
empty[A](fa: F[A]): Boolean
always return
false -
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
extrema[A](fa: F[A])(implicit arg0: Order[A]): Option[(A, A)]
The smallest and largest elements of
faor None iffais emptyThe smallest and largest elements of
faor None iffais empty- Definition Classes
- FoldableParent
-
def
extremaBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(A, A)]
The elements (amin, amax) of
fawhich yield the smallest and largest values off(a), respectively, or None iffais emptyThe elements (amin, amax) of
fawhich yield the smallest and largest values off(a), respectively, or None iffais empty- Definition Classes
- FoldableParent
-
def
extremaOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(B, B)]
The smallest and largest values of
f(a)for each elementaoffa, or None iffais emptyThe smallest and largest values of
f(a)for each elementaoffa, or None iffais empty- Definition Classes
- FoldableParent
-
def
filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int
- Definition Classes
- FoldableParent
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
- Definition Classes
- FoldableParent
-
def
findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]
- Definition Classes
- FoldableParent
-
def
findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
- Definition Classes
- FoldableParent
-
def
fold[M](t: F[M])(implicit arg0: Monoid[M]): M
Combine the elements of a structure using a monoid.
Combine the elements of a structure using a monoid.
- Definition Classes
- Foldable
- def fold1[M](t: F[M])(implicit arg0: Semigroup[M]): M
-
def
fold1Opt[A](fa: F[A])(implicit arg0: Semigroup[A]): Option[A]
Like
foldbut returningNoneif the foldable is empty andSomeotherwiseLike
foldbut returningNoneif the foldable is empty andSomeotherwise- Definition Classes
- FoldableParent
-
def
foldLeft[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): B
Left-associative fold of a structure.
Left-associative fold of a structure.
- Definition Classes
- Foldable
-
def
foldLeft1[A](fa: F[A])(f: (A, A) ⇒ A): A
Left-associative fold of a structure.
-
def
foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]
- Definition Classes
- Foldable
-
def
foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]
Left-associative, monadic fold of a structure.
Left-associative, monadic fold of a structure.
- Definition Classes
- Foldable
-
def
foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Monoid[B]): B
Map each element of the structure to a scalaz.Monoid, and combine the results.
Map each element of the structure to a scalaz.Monoid, and combine the results.
-
def
foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]
As
foldMapbut returningNoneif the foldable is empty andSomeotherwise -
def
foldMapLeft1[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): B
Left-associative fold of a structure.
- def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
-
def
foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]
Specialization of foldRightM when
Bhas aMonoid.Specialization of foldRightM when
Bhas aMonoid.- Definition Classes
- Foldable
- def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]
-
def
foldRight[A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B
Right-associative fold of a structure.
-
def
foldRight1[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): A
Right-associative fold of a structure.
-
def
foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]
- Definition Classes
- Foldable
-
def
foldRightM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]
Right-associative, monadic fold of a structure.
Right-associative, monadic fold of a structure.
- Definition Classes
- Foldable
- def foldable1Law: Foldable1Law
- val foldable1Syntax: Foldable1Syntax[F]
-
def
foldableLaw: FoldableLaw
- Definition Classes
- Foldable
-
val
foldableSyntax: FoldableSyntax[F]
- Definition Classes
- Foldable
-
final
def
foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B
Curried version of
foldLeftCurried version of
foldLeft- Definition Classes
- Foldable
-
final
def
foldl1[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): A
Curried
foldLeft1. - def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]
-
final
def
foldlM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]
Curried version of
foldLeftMCurried version of
foldLeftM- Definition Classes
- Foldable
-
final
def
foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B
Curried version of
foldRightCurried version of
foldRight- Definition Classes
- Foldable
-
final
def
foldr1[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): A
Curried
foldRight1. - def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
-
final
def
foldrM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]
Curried version of
foldRightMCurried version of
foldRightM- Definition Classes
- Foldable
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
index[A](fa: F[A], i: Int): Option[A]
- returns
the element at index
iin aSome, orNoneif the given index falls outside of the range
- Definition Classes
- Foldable
-
def
indexOr[A](fa: F[A], default: ⇒ A, i: Int): A
- returns
the element at index
i, ordefaultif the given index falls outside of the range
- Definition Classes
- Foldable
-
def
intercalate[A](fa: F[A], a: A)(implicit arg0: Monoid[A]): A
Insert an
Abetween every A, yielding the sum. -
def
intercalate1[A](fa: F[A], a: A)(implicit A: Semigroup[A]): A
Insert an
Abetween every A, yielding the sum. -
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
length[A](fa: F[A]): Int
Deforested alias for
toStream(fa).size.Deforested alias for
toStream(fa).size.- Definition Classes
- Foldable
-
def
longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long
- Definition Classes
- Foldable
-
def
maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The greatest element of
fa, or None iffais empty. -
def
maximum1[A](fa: F[A])(implicit arg0: Order[A]): A
The greatest element of
fa. -
def
maximumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]
The element
aoffawhich yields the greatest value off(a), or None iffais empty. -
def
maximumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A
The element
aoffawhich yield the greatest value off(a). -
def
maximumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]
The greatest value of
f(a)for each elementaoffa, or None iffais empty. -
def
maximumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B
The greatest value of
f(a)for each elementaoffa. -
def
minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]
The smallest element of
fa, or None iffais empty. -
def
minimum1[A](fa: F[A])(implicit arg0: Order[A]): A
The smallest element of
fa. -
def
minimumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]
The element
aoffawhich yields the smallest value off(a), or None iffais empty. -
def
minimumBy1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): A
The element
aoffawhich yield the smallest value off(a). -
def
minimumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]
The smallest value of
f(a)for each elementaoffa, or None iffais empty. -
def
minimumOf1[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): B
The smallest value of
f(a)for each elementaoffa. -
def
msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
- Definition Classes
- FoldableParent
-
def
msuml1[G[_], A](fa: F[G[A]])(implicit arg0: Plus[G]): G[A]
- Definition Classes
- Foldable1Parent
-
def
msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
- Definition Classes
- FoldableParent
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
product[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable1
FandG,[x](F[x], G[x]]), is a Foldable1 -
def
product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]
The product of Foldables
FandG,[x](F[x], G[x]]), is a FoldableThe product of Foldables
FandG,[x](F[x], G[x]]), is a Foldable- Definition Classes
- Foldable
-
def
product0[G[_]](implicit G0: Foldable[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable1
Fand FoldableG,[x](F[x], G[x]]), is a Foldable1 -
def
product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]
The product of Foldable
Fand Foldable1G,[x](F[x], G[x]]), is a Foldable1The product of Foldable
Fand Foldable1G,[x](F[x], G[x]]), is a Foldable1- Definition Classes
- Foldable
-
def
selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]
Selects groups of elements that satisfy p and discards others.
Selects groups of elements that satisfy p and discards others.
- Definition Classes
- Foldable
- def sequence1_[M[_], A](fa: F[M[A]])(implicit a: Apply[M], x: Semigroup[M[A]]): M[Unit]
-
def
sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]
sequence_for Free.sequence_for Free. collapses into a single Free *- Definition Classes
- Foldable
-
def
sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]
sequence_specialized toState*sequence_specialized toState*- Definition Classes
- Foldable
-
def
sequence_[M[_], A](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]
Strict sequencing in an applicative functor
Mthat ignores the value infa.Strict sequencing in an applicative functor
Mthat ignores the value infa.- Definition Classes
- Foldable
-
def
splitBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]
Splits the elements into groups that produce the same result by a function f.
Splits the elements into groups that produce the same result by a function f.
- Definition Classes
- FoldableParent
-
def
splitByRelation[A](fa: F[A])(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]
Splits into groups of elements that are transitively dependant by a relation r.
Splits into groups of elements that are transitively dependant by a relation r.
- Definition Classes
- FoldableParent
-
def
splitWith[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]
Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.
Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.
- Definition Classes
- Foldable
-
def
suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- FoldableParent
-
def
sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
- Definition Classes
- FoldableParent
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
to[A, G[_]](fa: F[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]
- Definition Classes
- Foldable
-
def
toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
- Definition Classes
- Foldable
-
def
toIList[A](fa: F[A]): IList[A]
- Definition Classes
- Foldable
-
def
toIndexedSeq[A](fa: F[A]): IndexedSeq[A]
- Definition Classes
- Foldable
-
def
toList[A](fa: F[A]): List[A]
- Definition Classes
- Foldable
-
def
toNel[A](fa: F[A]): NonEmptyList[A]
- Definition Classes
- Foldable1Parent
-
def
toSet[A](fa: F[A]): Set[A]
- Definition Classes
- Foldable
-
def
toStream[A](fa: F[A]): Stream[A]
- Definition Classes
- Foldable
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- def traverse1_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Apply[M], x: Semigroup[M[B]]): M[Unit]
-
def
traverseS_[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, Unit]
traverse_specialized toState*traverse_specialized toState*- Definition Classes
- Foldable
-
final
def
traverseU_[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Unit]
A version of
traverse_that infers the type constructorM.A version of
traverse_that infers the type constructorM.- Definition Classes
- Foldable
-
def
traverse_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Applicative[M]): M[Unit]
Strict traversal in an applicative functor
Mthat ignores the result off.Strict traversal in an applicative functor
Mthat ignores the result off.- Definition Classes
- Foldable
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )