Lens

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

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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](f: ⇒ IndexedState[A1, A2, C]): IndexedState[A1, A2, C]

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

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

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

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

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

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

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

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

alias for compose

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](f: (B1) ⇒ C): State[A1, 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](f: (B1) ⇒ IndexedState[A1, A2, C]): IndexedState[A1, A2, 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): IndexedState[A1, A2, B2]

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

def assigno(b: ⇒ B2): IndexedState[A1, A2, B1]

Set the portion of the state viewed through the lens and return its old 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](f: (B1) ⇒ IndexedState[A1, A2, C]): IndexedState[A1, A2, 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: ~>[[γ$0$]IndexedStateT[[X]X, B1, B2, γ$0$], [γ$1$]IndexedStateT[[X]X, A1, A2, γ$1$]]

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

def map[C](f: (B1) ⇒ C): State[A1, 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 modo(f: (B1) ⇒ B2): IndexedState[A1, A2, B1]

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

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(f: (B1) ⇒ B2): IndexedState[A1, A2, B2]

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 setf[X[_]](a: A1, b: X[B2])(implicit XF: Functor[X]): X[A2]

def st: State[A1, B1]

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

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: Bijection[A, X]): LensFamily[X, X, B1, B2]

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

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

Alias for sum