CompositeFoldable

implicit abstract def F: Foldable[F]

implicit abstract def G: Foldable[G]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

Compose this Foldable[F] with a Foldable[G] to create a Foldable[F[G]] instance.

def dropWhile_[A](fa: F[G[A]])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], dropping all initial elements which match p.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

Check whether at least one element satisfies the predicate.

def filter_[A](fa: F[G[A]])(p: (A) ⇒ Boolean): List[A]

Convert F[A] to a List[A], only including elements which match p.

def finalize(): Unit

def find[A](fa: F[G[A]])(f: (A) ⇒ Boolean): Option[A]

Find the first element matching the predicate, if one exists.

def fold[A](fa: F[G[A]])(implicit A: Monoid[A]): A

Fold implemented using the given Monoid[A] instance.

def foldK[G[_], A](fga: F[G[G[A]]])(implicit G: MonoidK[G]): G[A]

Fold implemented using the given MonoidK[G] instance.

val F = Foldable[List]
F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil))
// List(1, 2, 3, 4, 5)

def foldLeft[A, B](fga: F[G[A]], b: B)(f: (B, A) ⇒ B): B

Left assocative fold on F[G[A]] using 'f'

def foldMap[A, B](fa: F[G[A]])(f: (A) ⇒ B)(implicit B: Monoid[B]): B

Fold implemented by mapping A values into B and then combining them using the given Monoid[B] instance.

def foldRight[A, B](fga: F[G[A]], lb: Eval[B])(f: (A, Eval[B]) ⇒ Eval[B]): Eval[B]

Right associative lazy fold on F using the folding function 'f'.

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

Check whether all elements satisfy the predicate.

final def getClass(): Class[_]

def hashCode(): Int

def isEmpty[A](fa: F[G[A]]): Boolean

Returns true if there are no elements.

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def nonEmpty[A](fa: F[G[A]]): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduceLeftToOption[A, B](fa: F[G[A]])(f: (A) ⇒ B)(g: (B, A) ⇒ B): Option[B]

def reduceRightToOption[A, B](fa: F[G[A]])(f: (A) ⇒ B)(g: (A, Eval[B]) ⇒ Eval[B]): Eval[Option[B]]

def sequence_[G[_], A, B](fga: F[G[G[A]]])(implicit arg0: Applicative[G]): G[Unit]

Sequence F[G[A]] using Applicative[G].

val F = Foldable[List]
F.sequence_(List(Option(1), Option(2), Option(3))) // Some(())
F.sequence_(List(Option(1), None, Option(3)))      // None

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

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

Convert F[A] to a List[A].

def toString(): String

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

Traverse F[A] using Applicative[G].

def parseInt(s: String): Option[Int] = ...
val F = Foldable[List]
F.traverse_(List("333", "444"))(parseInt) // Some(())
F.traverse_(List("333", "zzz"))(parseInt) // None

final def wait(): Unit

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

final def wait(arg0: Long): Unit