Lens

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def *** [C, D] (that: Lens[C, D]): Lens[(A, C), (B, D)]

Two disjoint lenses can be paired

def := (b: B): State[A, Unit]

Set the value viewed through the lens to a given value

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

def andThen [C] (that: Lens[B, C]): Lens[A, C]

def apply (whole: A): B

A Lens[A,B] can be used as a function from A => B, or implicitly via Lens.

def asInstanceOf [T0] : T0

def canEqual (arg0: Any): Boolean

def clone (): AnyRef

def compose [C] (that: Lens[C, A]): Lens[C, B]

Lenses can be composed

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

def finalize (): Unit

def flatMap [C] (f: (B) ⇒ State[A, C]): State[A, C]

flatMapping a lens yields a state action to avoid ambiguity

val get : (A) ⇒ B

def getClass (): java.lang.Class[_]

def hashCode (): Int

def isInstanceOf [T0] : Boolean

def lifts [C] (s: State[B, C]): State[A, C]

We can contravariantly map the state of a state monad through a lens

def liftsNT : ~>[[X]State[B, X], [X]State[A, X]]

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

def map [C] (f: (B) ⇒ C): State[A, C]

Mapping a lens yields a state action to avoid ambiguity

def mod (a: A, f: (B) ⇒ B): A

Modify the value viewed through the lens

def modf [F[_]] (a: A, f: (B) ⇒ F[B])(implicit arg0: Functor[F]): F[A]

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

def modp [C] (a: A, f: (B) ⇒ (B, C)): (A, C)

modp[C] = modf[PartialApply1Of2[Tuple,C]#Flip], but is more convenient to think about

def modps [C] (f: (B) ⇒ (B, C)): State[A, C]

modify the state, and return a derived value as a state monadic action.

def mods [C] (f: (B) ⇒ B): State[A, B]

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

def mods_ [C] (f: (B) ⇒ B): State[A, Unit]

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

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def productArity : Int

def productElement (arg0: Int): Any

def productIterator : Iterator[Any]

def productPrefix : String

val set : (A, B) ⇒ A

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

implicit def toState : State[A, B]

A Lens[A,B] can be used directly as a State[A,B] that retrieves the value viewed from the state

def toString (): String

def wait (): Unit

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

def wait (arg0: Long): Unit

def xmap [C] (f: (B) ⇒ C)(g: (C) ⇒ B): Lens[A, C]

You can apply an isomorphism to the value viewed through the lens to obtain a new lens.

def ||| [C] (that: Lens[C, B]): Lens[Either[A, C], B]

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

def productElements : Iterator[Any]