PTraversal

abstract def modifyF[F[_]](f: (A) ⇒ F[B])(s: S)(implicit arg0: Applicative[F]): F[T]

modify polymorphically the target of a PTraversal with an Applicative function all traversal methods are written in terms of modifyF

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

alias to composeIso

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

alias to composePrism

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

alias to composeLens

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

alias to composeTraversal

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

alias to composeOptional

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

check if all targets satisfy the predicate

final def asFold: Fold[S, A]

view a PTraversal as a Fold

final def asInstanceOf[T0]: T0

final def asSetter: PSetter[S, T, A, B]

view a PTraversal as a PSetter

final def choice[S1, T1](other: PTraversal[S1, T1, A, B]): PTraversal[\/[S, S1], \/[T, T1], A, B]

join two PTraversal with the same target

def clone(): AnyRef

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

compose a PTraversal with a Fold

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

compose a PTraversal with a Getter

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

compose a PTraversal with a PIso

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

compose a PTraversal with a PLens

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

compose a PTraversal with a POptional

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

compose a PTraversal with a PPrism

final def composeSetter[C, D](other: PSetter[A, B, C, D]): PSetter[S, T, C, D]

compose a PTraversal with a PSetter

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

compose a PTraversal 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 foldMap[M](f: (A) ⇒ M)(s: S)(implicit arg0: Monoid[M]): M

map each target to a Monoid and combine the results

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

get all the targets of a PTraversal

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 length(s: S): Int

calculate the number of targets

final def modify(f: (A) ⇒ B): (S) ⇒ T

modify polymorphically the target of a PTraversal with a function

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 set(b: B): (S) ⇒ T

set polymorphically the target of a PTraversal with a value

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

final def sum[S1, T1](other: PTraversal[S1, T1, A, B]): PTraversal[\/[S, S1], \/[T, T1], A, B]