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 combineAll[A](fa: F[G[A]])(implicit arg0: Monoid[A]): A

Alias for fold.

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.

scala> import cats.std.list._
scala> val F = Foldable[List]
scala> F.foldK(List(1 :: 2 :: Nil, 3 :: 4 :: 5 :: Nil))
res0: List[Int] = List(1, 2, 3, 4, 5)

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

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

def foldM[G[_], A, B](fa: F[G[A]], z: B)(f: (B, A) ⇒ G[B])(implicit G: Monad[G]): G[B]

Left associative monadic folding on 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 sequenceU_[GA](fa: F[G[GA]])(implicit U: Unapply[Applicative, GA]): M[Unit]

Behaves like sequence_, but uses Unapply to find the Applicative instance for G - used when G is a type constructor with two or more parameters such as cats.data.Xor

scala> import cats.data.Xor
scala> import cats.std.list._
scala> val F = Foldable[List]
scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Right(444)))
res0: Xor[String, Unit] = Right(())
scala> F.sequenceU_(List(Xor.right[String, Int](333), Xor.Left("boo")))
res1: Xor[String, Unit] = Left(boo)

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

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

scala> import cats.std.list._
scala> import cats.std.option._
scala> val F = Foldable[List]
scala> F.sequence_(List(Option(1), Option(2), Option(3)))
res0: Option[Unit] = Some(())
scala> F.sequence_(List(Option(1), None, Option(3)))
res1: Option[Unit] = None

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

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

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

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

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

def toString(): String

def traverseU_[A, GB](fa: F[G[A]])(f: (A) ⇒ GB)(implicit U: Unapply[Applicative, GB]): M[Unit]

Behaves like traverse_, but uses Unapply to find the Applicative instance for G - used when G is a type constructor with two or more parameters such as cats.data.Xor

scala> import cats.data.Xor
scala> import cats.std.list._
scala> def parseInt(s: String): Xor[String, Int] =
     |   try { Xor.Right(s.toInt) }
     |   catch { case _: NumberFormatException => Xor.Left("boo") }
scala> val F = Foldable[List]
scala> F.traverseU_(List("333", "444"))(parseInt)
res0: Xor[String, Unit] = Right(())
scala> F.traverseU_(List("333", "zzz"))(parseInt)
res1: Xor[String, Unit] = Left(boo)

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

scala> import cats.data.Xor
scala> import cats.std.list._
scala> import cats.std.option._
scala> def parseInt(s: String): Option[Int] = Xor.catchOnly[NumberFormatException](s.toInt).toOption
scala> val F = Foldable[List]
scala> F.traverse_(List("333", "444"))(parseInt)
res0: Option[Unit] = Some(())
scala> F.traverse_(List("333", "zzz"))(parseInt)
res1: Option[Unit] = None

final def wait(): Unit

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

final def wait(arg0: Long): Unit