Fold

abstract def foldMap[M](f: (A) ⇒ M)(s: S)(implicit arg0: Monoid[M]): M

map each target to a Monoid and combine the results underlying representation of Fold, all Fold methods are defined in terms of foldMap

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def ^<->[B, C, D](other: PIso[A, B, C, D]): Fold[S, C]

alias to composeIso

final def ^<-?[B, C, D](other: PPrism[A, B, C, D]): Fold[S, C]

alias to composePrism

final def ^|->[B, C, D](other: PLens[A, B, C, D]): Fold[S, C]

alias to composeLens

final def ^|->>[B, C, D](other: PTraversal[A, B, C, D]): Fold[S, C]

alias to composeTraversal

final def ^|-?[B, C, D](other: POptional[A, B, C, D]): Fold[S, C]

alias to composeOptional

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

check if all targets satisfy the predicate

final def asInstanceOf[T0]: T0

final def choice[S1](other: Fold[S1, A]): Fold[\/[S, S1], A]

join two Fold with the same target

def clone(): AnyRef

final def composeFold[B](other: Fold[A, B]): Fold[S, B]

compose a Fold with a Fold

final def composeGetter[C](other: Getter[A, C]): Fold[S, C]

compose a Fold with a Getter

final def composeIso[B, C, D](other: PIso[A, B, C, D]): Fold[S, C]

compose a Fold with a PIso

final def composeLens[B, C, D](other: PLens[A, B, C, D]): Fold[S, C]

compose a Fold with a PLens

final def composeOptional[B, C, D](other: POptional[A, B, C, D]): Fold[S, C]

compose a Fold with a POptional

final def composePrism[B, C, D](other: PPrism[A, B, C, D]): Fold[S, C]

compose a Fold with a PPrism

final def composeTraversal[B, C, D](other: PTraversal[A, B, C, D]): Fold[S, C]

compose a Fold with a PTraversal

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def exist(p: (A) ⇒ Boolean): (S) ⇒ Boolean

check if at least one target satisfies the predicate

def finalize(): Unit

final def find(p: (A) ⇒ Boolean): (S) ⇒ Option[A]

find the first target matching the predicate

final def fold(s: S)(implicit ev: Monoid[A]): A

combine all targets using a target's Monoid

final def getAll(s: S): List[A]

get all the targets of a Fold

final def getClass(): Class[_]

def hashCode(): Int

final def headOption(s: S): Option[A]

get the first target

final def isEmpty(s: S): Boolean

check if there is no target

final def isInstanceOf[T0]: Boolean

final def lastOption(s: S): Option[A]

get the last target

final def left[C]: Fold[\/[S, C], \/[A, C]]

final def length(s: S): Int

calculate the number of targets

final def ne(arg0: AnyRef): Boolean

final def nonEmpty(s: S): Boolean

check if there is at least one target

final def notify(): Unit

final def notifyAll(): Unit

final def right[C]: Fold[\/[C, S], \/[C, A]]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit