scalaz-core/scalaz.syntax/FoldableOps

FoldableOps

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

Wraps a value self and provides methods related to Foldable

trait Ops[F[A]]
class Object
trait Matchable
class Any

Value members

Concrete methods

final
def all(p: A => Boolean): Boolean
final
def allM[G[_] : Monad](p: A => G[Boolean]): G[Boolean]
final
def any(p: A => Boolean): Boolean
final
def anyM[G[_] : Monad](p: A => G[Boolean]): G[Boolean]
final
def asum[G[_], B](implicit ev: A === G[B], G: PlusEmpty[G]): G[B]
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 : Equal](f: A => 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 extrema(implicit A: Order[A]): Option[(A, A)]
final
def extremaBy[B : Order](f: A => B): Option[(A, A)]
final
def extremaOf[B : Order](f: A => B): Option[(B, B)]
final
def filterLength(p: A => Boolean): Int
final
def findLeft(f: A => Boolean): Option[A]
final
def findMapM[G[_] : Monad, B](f: A => G[Option[B]]): 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 : Monoid](f: A => B): B
final
def foldMap1Opt[B : Semigroup](f: A => B): Option[B]
final
def foldMapLeft1Opt[B](z: A => B)(f: (B, A) => B): Option[B]
final
def foldMapM[G[_] : Monad, B : Monoid](f: A => G[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 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 length: Int
final
def longDigits(implicit d: A <:< Digit): Long
final
def maximum(implicit A: Order[A]): Option[A]
final
def maximumBy[B : Order](f: A => B): Option[A]
final
def maximumOf[B : Order](f: A => B): Option[B]
final
def minimum(implicit A: Order[A]): Option[A]
final
def minimumBy[B : Order](f: A => B): Option[A]
final
def minimumOf[B : Order](f: A => B): Option[B]
final
def psum[G[_], B](implicit ev: A === G[B], G: PlusEmpty[G]): G[B]
final
def psumMap[G[_], B](f: A => G[B])(implicit G: PlusEmpty[G]): G[B]
final
def selectSplit(p: A => Boolean): List[NonEmptyList[A]]
def sequenceF_[M[_], B](implicit ev: Liskov[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 : Equal](f: A => 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 toIList: IList[A]
final
def toList: List[A]
final
def toSet: Set[A]
final
def toStream: Stream[A]
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[[F[_]] =>> Applicative[F], GB]): M[Unit]
final
def traverse_[M[_] : Applicative](f: A => M[Unit]): M[Unit]
final
def ∀(p: A => Boolean): Boolean
final
def ∃(p: A => Boolean): Boolean

Deprecated methods

@deprecated("use psum", "7.3.0")
final
def msuml[G[_], B](implicit ev: A === G[B], G: PlusEmpty[G]): G[B]
Deprecated
@deprecated("use psum", "7.3.0")
final
def msumlU(implicit G: Unapply[[F[_]] =>> PlusEmpty[F], A]): M[A]
Deprecated

Concrete fields

val self: F[A]

Implicits

Implicits

implicit
val F: Foldable[F]