Type Members
- abstract type TypeClassType <: Foldable[F]
Abstract Value Members
- abstract def self: F[A]
- abstract val typeClassInstance: TypeClassType
Concrete Value Members
- final def !=(arg0: Any): Boolean
- final def ##: Int
- final def ==(arg0: Any): Boolean
- final def asInstanceOf[T0]: T0
- def clone(): AnyRef
- def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
- def collectFirstSome[B](f: (A) => Option[B]): Option[B]
- def collectFoldSome[B](f: (A) => Option[B])(implicit B: Monoid[B]): B
- def combineAll(implicit arg0: Monoid[A]): A
- def combineAllOption(implicit ev: Semigroup[A]): Option[A]
- def dropWhile_(p: (A) => Boolean): List[A]
- final def eq(arg0: AnyRef): Boolean
- def equals(arg0: AnyRef): Boolean
- def exists(p: (A) => Boolean): Boolean
- def existsM[G[_]](p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
- def filter_(p: (A) => Boolean): List[A]
- def finalize(): Unit
- def find(f: (A) => Boolean): Option[A]
- def fold(implicit A: Monoid[A]): A
- def foldK[G[_], B](implicit arg0: <:<[A, G[B]], G: MonoidK[G]): G[B]
- def foldLeft[B](b: B)(f: (B, A) => B): B
- final def foldLeftM[G[_], B](z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
- def foldM[G[_], B](z: B)(f: (B, A) => G[B])(implicit G: Monad[G]): G[B]
- def foldMap[B](f: (A) => B)(implicit B: Monoid[B]): B
- def foldMapA[G[_], B](f: (A) => G[B])(implicit G: Applicative[G], B: Monoid[B]): G[B]
- def foldMapM[G[_], B](f: (A) => G[B])(implicit G: Monad[G], B: Monoid[B]): G[B]
- def foldRight[B](lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B]
- def foldRightDefer[G[_], B](gb: G[B])(fn: (A, G[B]) => G[B])(implicit arg0: Defer[G]): G[B]
- def forall(p: (A) => Boolean): Boolean
- def forallM[G[_]](p: (A) => G[Boolean])(implicit G: Monad[G]): G[Boolean]
- def get(idx: Long): Option[A]
- final def getClass(): Class[_ <: AnyRef]
- def hashCode(): Int
- def intercalate(a: A)(implicit A: Monoid[A]): A
- def isEmpty: Boolean
- final def isInstanceOf[T0]: Boolean
- def maximumByList[B](f: (A) => B)(implicit arg0: Order[B]): List[A]
- def maximumByOption[B](f: (A) => B)(implicit arg0: Order[B]): Option[A]
- def maximumList(implicit A: Order[A]): List[A]
- def maximumOption(implicit A: Order[A]): Option[A]
- def minimumByList[B](f: (A) => B)(implicit arg0: Order[B]): List[A]
- def minimumByOption[B](f: (A) => B)(implicit arg0: Order[B]): Option[A]
- def minimumList(implicit A: Order[A]): List[A]
- def minimumOption(implicit A: Order[A]): Option[A]
- final def ne(arg0: AnyRef): Boolean
- def nonEmpty: Boolean
- final def notify(): Unit
- final def notifyAll(): Unit
- def partitionEither[B, C](f: (A) => Either[B, C])(implicit A: Alternative[F]): (F[B], F[C])
- def productAll(implicit A: Numeric[A]): A
- def reduceLeftOption(f: (A, A) => A): Option[A]
- def reduceLeftToOption[B](f: (A) => B)(g: (B, A) => B): Option[B]
- def reduceRightOption(f: (A, Eval[A]) => Eval[A]): Eval[Option[A]]
- def reduceRightToOption[B](f: (A) => B)(g: (A, Eval[B]) => Eval[B]): Eval[Option[B]]
- def sequence_[G[_], B](implicit arg0: <:<[A, G[B]], arg1: Applicative[G]): G[Unit]
- def size: Long
- def sumAll(implicit A: Numeric[A]): A
- final def synchronized[T0](arg0: => T0): T0
- def takeWhile_(p: (A) => Boolean): List[A]
- def toIterable: Iterable[A]
- def toList: List[A]
- def toString(): String
- def traverse_[G[_], B](f: (A) => G[B])(implicit G: Applicative[G]): G[Unit]
- def unorderedFold(implicit arg0: CommutativeMonoid[A]): A
- def unorderedFoldMap[B](f: (A) => B)(implicit arg0: CommutativeMonoid[B]): B
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit