Foldable

abstract 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.

abstract def foldRight[A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B

Right-associative fold of a structure.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def all[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

Whether all As in fa yield true from p.

def allM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

all with monadic traversal.

def any[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

Whether any As in fa yield true from p.

def anyM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

any with monadic traversal.

final def asInstanceOf[T0]: T0

def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[a, b]F[G[a, b]]]

The composition of Foldable F and Bifoldable G, [x, y]F[G[x, y]], is a Bifoldable

def clone(): AnyRef

def collapse[X[_], A](x: F[A])(implicit F: Foldable[F], A: ApplicativePlus[X]): X[A]

def collapse2[G[_], X[_], A](x: F[G[A]])(implicit F: Foldable[F], G: Foldable[G], A: ApplicativePlus[X]): X[A]

def collapse3[G[_], H[_], X[_], A](x: F[G[H[A]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], A: ApplicativePlus[X]): X[A]

def collapse4[G[_], H[_], I[_], X[_], A](x: F[G[H[I[A]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], A: ApplicativePlus[X]): X[A]

def collapse5[G[_], H[_], I[_], J[_], X[_], A](x: F[G[H[I[J[A]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], A: ApplicativePlus[X]): X[A]

def collapse6[G[_], H[_], I[_], J[_], K[_], X[_], A](x: F[G[H[I[J[K[A]]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], K: Foldable[K], A: ApplicativePlus[X]): X[A]

def collapse7[G[_], H[_], I[_], J[_], K[_], L[_], X[_], A](x: F[G[H[I[J[K[L[A]]]]]]])(implicit F: Foldable[F], G: Foldable[G], H: Foldable[H], I: Foldable[I], J: Foldable[J], K: Foldable[K], L: Foldable[L], A: ApplicativePlus[X]): X[A]

def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]

The composition of Foldables F and G, [x]F[G[x]], is a Foldable

final def count[A](fa: F[A]): Int

Alias for length.

def element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean

Whether a is an element of fa.

def empty[A](fa: F[A]): Boolean

Deforested alias for toStream(fa).isEmpty.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

Combine the elements of a structure using a monoid.

def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): B

Left-associative fold of a structure.

def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]

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.

def foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]

As foldMap but returning None if the foldable is empty and Some otherwise

def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]

def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]

def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]

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.

def foldableLaw: FoldableLaw

val foldableSyntax: FoldableSyntax[F]

final def foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

Curried version of foldLeft

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 foldLeftM

final def foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B

Curried version of foldRight

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 foldRightM

final def getClass(): Class[_]

def hashCode(): Int

def index[A](fa: F[A], i: Int): Option[A]

def indexOr[A](fa: F[A], default: ⇒ A, i: Int): A

def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A

Insert an A between every A, yielding the sum.

final def isInstanceOf[T0]: Boolean

def length[A](fa: F[A]): Int

Deforested alias for toStream(fa).size.

def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long

def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The greatest element of fa, or None if fa is empty.

def maximumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

The element a of fa which yields the greatest value of f(a), or None if fa is empty.

def maximumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

The greatest value of f(a) for each element a of fa, or None if fa is empty.

def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The smallest element of fa, or None if fa is empty.

def minimumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

The element a of fa which yields the smallest value of f(a), or None if fa is empty.

def minimumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

The smallest value of f(a) for each element a of fa, or None if fa is empty.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]

The product of Foldables F and G, [x](F[x], G[x]]), is a Foldable

def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]

The product of Foldable F and Foldable1 G, [x](F[x], G[x]]), is a Foldable1

def selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

Selects groups of elements that satisfy p and discards others.

def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

sequence_ specialized to State *

def sequence_[M[_], A](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]

Strict sequencing in an applicative functor M that ignores the value in fa.

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.

final def synchronized[T0](arg0: ⇒ T0): T0

def to[A, G[_]](fa: F[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]

def toIndexedSeq[A](fa: F[A]): IndexedSeq[A]

def toList[A](fa: F[A]): List[A]

def toSet[A](fa: F[A]): Set[A]

def toStream[A](fa: F[A]): Stream[A]

def toString(): String

def traverseS_[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, Unit]

traverse_ specialized to State *

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 constructor M.

def traverse_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Applicative[M]): M[Unit]

Strict traversal in an applicative functor M that ignores the result of f.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def foldMapIdentity[A](fa: F[A])(implicit F: Monoid[A]): A

Unbiased sum of monoidal values.