LensFamily

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

def %=[B <: B2](f: (B1) ⇒ B): IndexedState[A1, A2, B]

Modify the portion of the state viewed through the lens and return its new value.

def %==(f: (B1) ⇒ B2): IndexedState[A1, A2, Unit]

Modify the portion of the state viewed through the lens, but do not return its new value.

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

alias for product

def ->>-[C, X1 <: A1, X2 >: A2](f: ⇒ IndexedState[X1, X2, C]): IndexedState[X1, X2, C]

Sequence the monadic action of looking through the lens to occur before the state action f.

def :=[B <: B2](b: ⇒ B): IndexedState[A1, A2, B]

Set the portion of the state viewed through the lens and return its new value.

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

alias for compose

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def =>=(f: (B1) ⇒ B2): (A1) ⇒ A2

def =>>=[X[+_]](f: (B1) ⇒ X[B2])(implicit XF: Functor[X]): (A1) ⇒ X[A2]

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

Map the function f over the value under the lens, as a state action.

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

alias for andThen

def >>-[C, X1 <: A1, X2 >: A2](f: (B1) ⇒ IndexedState[X1, X2, C]): IndexedState[X1, X2, C]

Bind the function f over the value under the lens, as a state action.

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

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

final def asInstanceOf[T0]: T0

def assign[B <: B2](b: ⇒ B): IndexedState[A1, A2, B]

Set the portion of the state viewed through the lens and return its new value.

def clone(): AnyRef

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

Lenses can be composed

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatMap[C, X1 <: A1, X2 >: A2](f: (B1) ⇒ IndexedState[X1, X2, C]): IndexedState[X1, X2, C]

Bind the function f over the value under the lens, as a state action.

def get(a: A1): B1

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lensLaw: LensLaw

def lifts[C](s: IndexedState[B1, B2, C]): IndexedState[A1, A2, C]

Contravariantly map a state action through a lens.

def liftsNT: ~>[[+x]IndexedStateT[[+X]X, B1, B2, x], [+x]IndexedStateT[[+X]X, A1, A2, x]]

Contravariantly mapping the state of a state monad through a lens is a natural transformation

def map[C, A <: A1](f: (B1) ⇒ C): State[A, C]

Map the function f over the lens as a state action.

def mod(f: (B1) ⇒ B2, a: A1): A2

Modify the value viewed through the lens

def modf[X[+_]](f: (B1) ⇒ X[B2], a: A1)(implicit XF: Functor[X]): X[A2]

Modify the value viewed through the lens, returning a functor X full of results.

def modp[C](f: (B1) ⇒ (B2, C), a: A1): (A2, C)

Modify the value viewed through the lens, returning a C on the side.

def mods[B <: B2](f: (B1) ⇒ B): IndexedState[A1, A2, B]

Modify the portion of the state viewed through the lens and return its new value.

def mods_(f: (B1) ⇒ B2): IndexedState[A1, A2, Unit]

Modify the portion of the state viewed through the lens, but do not return its new value.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def partial: PLensFamily[A1, A2, B1, B2]

A homomorphism of lens categories

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

Two disjoint lenses can be paired

def set(a: A1, b: B2): A2

def st[A <: A1]: State[A, B1]

def sum[C1, C2, B1m >: B1, B2m <: B2](that: ⇒ LensFamily[C1, C2, B1m, B2m]): LensFamily[\/[A1, C1], \/[A2, C2], B1m, B2m]

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

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

def toString(): String

def unary_~: PLensFamily[A1, A2, B1, B2]

alias for partial

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): LensFamily[X1, X2, B1, B2]

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

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

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

def |||[C1, C2, A1m <: A1, A2m >: A2, B1m >: B1, B2m <: B2](that: ⇒ LensFamily[C1, C2, B1m, B2m]): LensFamily[\/[A1, C1], \/[A2, C2], B1m, B2m]

Alias for sum