IsomorphismFoldable

implicit abstract def G: Foldable[G]

abstract def iso: Isomorphism.<~>[F, G]

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

Deforested alias for toStream(fa).size.

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

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

Unbiased sum of monoidal values.

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

Right-associative fold of a structure.

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.

val foldableSyntax: FoldableSyntax[F]

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

Curred version of foldLeft

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

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 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 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 minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

The smallest element 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 selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[List[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, B](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[List[A]]

Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

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

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 *

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