Getter

abstract def get(s: S): A

get the target of a Getter

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]): Getter[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]): Getter[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 asFold: Fold[S, A]

view a Getter with a Fold

final def asInstanceOf[T0]: T0

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

join two Getter with the same target

def clone(): AnyRef

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

compose a Getter with a Fold

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

compose a Getter with a Getter

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

compose a Getter with a PIso

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

compose a Getter with a PLens

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

compose a Getter with a POptional

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

compose a Getter with a PPrism

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

compose a Getter with a PTraversal

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

check if the target satisfies the predicate

def finalize(): Unit

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

find if the target satisfies the predicate

final def first[B]: Getter[(S, B), (A, B)]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

final def second[B]: Getter[(B, S), (B, A)]

final def split[S1, A1](other: Getter[S1, A1]): Getter[(S, S1), (A, A1)]

pair two disjoint Getter

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 product[S1, A1](other: Getter[S1, A1]): Getter[(S, S1), (A, A1)]

final def sum[S1](other: Getter[S1, A]): Getter[\/[S, S1], A]