FoldableOps

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit val F: Foldable[F]
final def all(p: (A) ⇒ Boolean): Boolean
final def allM[G[_]](p: (A) ⇒ G[Boolean])(implicit arg0: Monad[G]): G[Boolean]
final def any(p: (A) ⇒ Boolean): Boolean
final def anyM[G[_]](p: (A) ⇒ G[Boolean])(implicit arg0: Monad[G]): G[Boolean]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def collapse[X[_]](implicit A: ApplicativePlus[X]): X[A]
final def concatenate(implicit A: Monoid[A]): A
final def count: Int
final def distinct(implicit A: Order[A]): IList[A]
final def distinctBy[B](f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]
final def distinctE(implicit A: Equal[A]): IList[A]
final def element(a: A)(implicit A: Equal[A]): Boolean
final def empty: Boolean
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def extrema(implicit A: Order[A]): Option[(A, A)]
def extremaBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(A, A)]
def extremaOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(B, B)]
final def filterLength(p: (A) ⇒ Boolean): Int
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def findLeft(f: (A) ⇒ Boolean): Option[A]
final def findMapM[G[_], B](f: (A) ⇒ G[Option[B]])(implicit arg0: Monad[G]): G[Option[B]]
final def findRight(f: (A) ⇒ Boolean): Option[A]
final def fold(implicit A: Monoid[A]): A
final def fold1Opt(implicit A: Semigroup[A]): Option[A]
final def foldLeft[B](z: B)(f: (B, A) ⇒ B): B
final def foldLeft1Opt(f: (A, A) ⇒ A): Option[A]
final def foldLeftM[G[_], B](z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]
final def foldMap[B](f: (A) ⇒ B = (a: A) => a)(implicit arg0: Monoid[B]): B
final def foldMap1Opt[B](f: (A) ⇒ B = (a: A) => a)(implicit arg0: Semigroup[B]): Option[B]
final def foldMapLeft1Opt[B](z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
final def foldMapM[G[_], B](f: (A) ⇒ G[B])(implicit arg0: Monad[G], arg1: Monoid[B]): G[B]
final def foldMapRight1Opt[B](z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]
final def foldRight[B](z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B
final def foldRight1Opt(f: (A, ⇒ A) ⇒ A): Option[A]
final def foldRightM[G[_], B](z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]
final def foldl[B](z: B)(f: (B) ⇒ (A) ⇒ B): B
final def foldl1Opt(f: (A) ⇒ (A) ⇒ A): Option[A]
final def foldlM[G[_], B](z: B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]
final def foldr[B](z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B
final def foldr1Opt(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
final def foldrM[G[_], B](z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def index(n: Int): Option[A]
final def indexOr(default: ⇒ A, n: Int): A
final def intercalate(a: A)(implicit A: Monoid[A]): A
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def length: Int
final def longDigits(implicit d: <:<[A, Digit]): Long
final def maximum(implicit A: Order[A]): Option[A]
final def maximumBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]
final def maximumOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]
final def minimum(implicit A: Order[A]): Option[A]
final def minimumBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]
final def minimumOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]
final def msuml[G[_], B](implicit ev: ===[A, G[B]], G: PlusEmpty[G]): G[B]
final def msumlU(implicit G: Unapply[PlusEmpty, A]): M[A]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def selectSplit(p: (A) ⇒ Boolean): List[NonEmptyList[A]]
val self: F[A]

Definition Classes
FoldableOps → Ops
def sequenceF_[M[_], B](implicit ev: <~<[F[A], F[Free[M, B]]]): Free[M, Unit]
final def sequenceS_[S, B](implicit ev: ===[A, State[S, B]]): State[S, Unit]
final def sequence_[G[_], B](implicit ev: ===[A, G[B]], G: Applicative[G]): G[Unit]
final def splitBy[B](f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]
final def splitByRelation(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]
final def splitWith(p: (A) ⇒ Boolean): List[NonEmptyList[A]]
final def suml(implicit A: Monoid[A]): A
final def suml1Opt(implicit A: Semigroup[A]): Option[A]
final def sumr(implicit A: Monoid[A]): A
final def sumr1Opt(implicit A: Semigroup[A]): Option[A]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def toEphemeralStream: EphemeralStream[A]
final def toIList: IList[A]
final def toList: List[A]
final def toSet: Set[A]
final def toStream: Stream[A]
def toString(): String

Definition Classes
AnyRef → Any
final def toVector: Vector[A]
final def traverseS_[S, B](f: (A) ⇒ State[S, B]): State[S, Unit]
final def traverseU_[GB](f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Unit]
final def traverse_[M[_]](f: (A) ⇒ M[Unit])(implicit arg0: Applicative[M]): M[Unit]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def ∀(p: (A) ⇒ Boolean): Boolean
final def ∃(p: (A) ⇒ Boolean): Boolean

Deprecated Value Members

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

Annotations
@deprecated
Deprecated
(Since version 7.2.22) removed in scalaz 7.3
Exceptions thrown
NoSuchMethodException if Scala 2.13 or later

Related Doc: package syntax

final class FoldableOps[F[_], A] extends Ops[F[A]]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val F: Foldable[F]

final def all(p: (A) ⇒ Boolean): Boolean

final def allM[G[_]](p: (A) ⇒ G[Boolean])(implicit arg0: Monad[G]): G[Boolean]

final def any(p: (A) ⇒ Boolean): Boolean

final def anyM[G[_]](p: (A) ⇒ G[Boolean])(implicit arg0: Monad[G]): G[Boolean]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def collapse[X[_]](implicit A: ApplicativePlus[X]): X[A]

final def concatenate(implicit A: Monoid[A]): A

final def count: Int

final def distinct(implicit A: Order[A]): IList[A]

final def distinctBy[B](f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]

final def distinctE(implicit A: Equal[A]): IList[A]

final def element(a: A)(implicit A: Equal[A]): Boolean

final def empty: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def extrema(implicit A: Order[A]): Option[(A, A)]

def extremaBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(A, A)]

def extremaOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(B, B)]

final def filterLength(p: (A) ⇒ Boolean): Int

def finalize(): Unit

final def findLeft(f: (A) ⇒ Boolean): Option[A]

final def findMapM[G[_], B](f: (A) ⇒ G[Option[B]])(implicit arg0: Monad[G]): G[Option[B]]

final def findRight(f: (A) ⇒ Boolean): Option[A]

final def fold(implicit A: Monoid[A]): A

final def fold1Opt(implicit A: Semigroup[A]): Option[A]

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

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

final def foldLeftM[G[_], B](z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]

final def foldMap[B](f: (A) ⇒ B = (a: A) => a)(implicit arg0: Monoid[B]): B

final def foldMap1Opt[B](f: (A) ⇒ B = (a: A) => a)(implicit arg0: Semigroup[B]): Option[B]

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

final def foldMapM[G[_], B](f: (A) ⇒ G[B])(implicit arg0: Monad[G], arg1: Monoid[B]): G[B]

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

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

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

final def foldRightM[G[_], B](z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

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

final def foldl1Opt(f: (A) ⇒ (A) ⇒ A): Option[A]

final def foldlM[G[_], B](z: B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]

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

final def foldr1Opt(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]

final def foldrM[G[_], B](z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

final def getClass(): Class[_]

def hashCode(): Int

final def index(n: Int): Option[A]

final def indexOr(default: ⇒ A, n: Int): A

final def intercalate(a: A)(implicit A: Monoid[A]): A

final def isInstanceOf[T0]: Boolean

final def length: Int

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

final def maximum(implicit A: Order[A]): Option[A]

final def maximumBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

final def maximumOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

final def minimum(implicit A: Order[A]): Option[A]

final def minimumBy[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

final def minimumOf[B](f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

final def msuml[G[_], B](implicit ev: ===[A, G[B]], G: PlusEmpty[G]): G[B]

final def msumlU(implicit G: Unapply[PlusEmpty, A]): M[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

val self: F[A]

def sequenceF_[M[_], B](implicit ev: <~<[F[A], F[Free[M, B]]]): Free[M, Unit]

final def sequenceS_[S, B](implicit ev: ===[A, State[S, B]]): State[S, Unit]

final def sequence_[G[_], B](implicit ev: ===[A, G[B]], G: Applicative[G]): G[Unit]

final def splitBy[B](f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]

final def splitByRelation(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]

final def splitWith(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

final def suml(implicit A: Monoid[A]): A

final def suml1Opt(implicit A: Semigroup[A]): Option[A]