PLens

abstract def run(a: A1): Option[IndexedStore[B1, B2, A2]]

final def !=(arg0: Any): Boolean

final def ##(): Int

def %%=[A >: A2 <: A1, C](s: IndexedState[B1, B2, C]): PState[A, C]

def %=[A >: A2 <: A1](f: (B1) ⇒ B2): PState[A, B2]

def %==[A >: A2 <: A1](f: (B1) ⇒ B2): State[A, Unit]

def ***[C1, C2, D1, D2](that: PLensFamily[C1, C2, D1, D2]): PLensFamily[(A1, C1), (A2, C2), (B1, D1), (B2, D2)]

alias for product

def ->>-[A >: A2 <: A1, C](f: ⇒ State[A, C]): PState[A, C]

def :=[A >: A2 <: A1](b: ⇒ B2): PState[A, B2]

def <=<[C1, C2](that: PLensFamily[C1, C2, A1, A2]): PLensFamily[C1, C2, B1, B2]

alias for compose

final def ==(arg0: Any): Boolean

def =>=[A >: A2 <: A1](f: (B1) ⇒ B2): (A) ⇒ A

def =?>=(f: (B1) ⇒ B2): (A1) ⇒ Option[A2]

def >-[A >: A2 <: A1, C](f: (B1) ⇒ C): PState[A, C]

def >=>[C1, C2](that: PLensFamily[B1, B2, C1, C2]): PLensFamily[A1, A2, C1, C2]

alias for andThen

def >>-[A >: A2 <: A1, C](f: (B1) ⇒ State[A, C]): PState[A, C]

def andThen[C1, C2](that: PLensFamily[B1, B2, C1, C2]): PLensFamily[A1, A2, C1, C2]

def apply(a: A1): Option[IndexedStore[B1, B2, A2]]

def as(f: (B1) ⇒ A1, a: A1): A1

If the Partial Lens is null, then return the target object, otherwise run the function on its projection.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[C1, C2](that: PLensFamily[C1, C2, A1, A2]): PLensFamily[C1, C2, B1, B2]

Partial Lenses can be composed

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (B1) ⇒ Boolean, a: A1): Boolean

def finalize(): Unit

def forall(p: (B1) ⇒ Boolean, a: A1): Boolean

def get(a: A1): Option[B1]

final def getClass(): Class[_]

def getK: Kleisli[Option, A1, B1]

def getOr(a: A1, b: ⇒ B1): B1

If the Partial Lens is null, then return the given default value.

def getOrZ(a: A1)(implicit M: Monoid[B1]): B1

def hashCode(): Int

def is(a: A1): Boolean

final def isInstanceOf[T0]: Boolean

def isNot(a: A1): Boolean

def kleisli: Kleisli[Option, A1, IndexedStore[B1, B2, A2]]

def mod[A >: A2 <: A1](f: (B1) ⇒ B2, a: A): A

Modify the potential value viewed through the partial lens

def modg(f: (B1) ⇒ B2, a: A1): Option[A2]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def product[C1, C2, D1, D2](that: PLensFamily[C1, C2, D1, D2]): PLensFamily[(A1, C1), (A2, C2), (B1, D1), (B2, D2)]

Two disjoint partial lenses can be paired

def set(a: A1, b: B2): Option[A2]

def setK(a: A1): Kleisli[Option, B2, A2]

def setOr(a: A1, b: B2, d: ⇒ A2): A2

def setOrZ(a: A1, b: B2)(implicit M: Monoid[A2]): A2

def st: PState[A1, B1]

def sum[C1, C2](that: ⇒ PLensFamily[C1, C2, B1, B2]): PLensFamily[\/[A1, C1], \/[A2, C2], B1, B2]

Two partial lenses that view a value of the same type can be joined

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

def toString(): String

def trySet(a: A1): Option[(B2) ⇒ A2]

def trySetK: Kleisli[Option, A1, (B2) ⇒ A2]

def trySetOr(a: A1, d: ⇒ (B2) ⇒ A2): (B2) ⇒ A2

def trySetOrZ(a: A1)(implicit M: Monoid[A2]): (B2) ⇒ A2

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xmapA[X1, X2](f: (A2) ⇒ X2)(g: (X1) ⇒ A1): PLensFamily[X1, X2, B1, B2]

def xmapB[X1, X2](f: (B1) ⇒ X1)(g: (X2) ⇒ B2): PLensFamily[A1, A2, X1, X2]

def xmapbA[X, A >: A2 <: A1](b: Bijection[A, X]): PLensFamily[X, X, B1, B2]

def xmapbB[X, B >: B1 <: B2](b: Bijection[B, X]): PLensFamily[A1, A2, X, X]

def |||[C1, C2](that: ⇒ PLensFamily[C1, C2, B1, B2]): PLensFamily[\/[A1, C1], \/[A2, C2], B1, B2]

Alias for sum