sealed abstract class LensFamily[A1, A2, B1, B2] extends AnyRef
A Lens Family, offering a purely functional means to access and retrieve
a field transitioning from type B1 to type B2 in a record simultaneously
transitioning from type A1 to type A2. scalaz.Lens is a convenient
alias for when A1 === A2, and B1 === B2.
The term field should not be interpreted restrictively to mean a member of a class. For example, a lens
family can address membership of a Set.
- A1
The initial type of the record
- A2
The final type of the record
- B1
The initial type of the field
- B2
The final type of the field
- Source
- Lens.scala
- See also
- Alphabetic
- By Inheritance
- LensFamily
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def run(a: A1): IndexedStore[B1, B2, A2]
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- 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.
Modify the portion of the state viewed through the lens and return its old value. alias for
modo- Since
7.0.2
- def <:=(b: => B2): IndexedState[A1, A2, B1]
Set the portion of the state viewed through the lens and return its old value.
Set the portion of the state viewed through the lens and return its old value. alias for
assigno- Since
7.0.2
- def <=<[C1, C2](that: LensFamily[C1, C2, A1, A2]): LensFamily[C1, C2, B1, B2]
alias for
compose - final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- 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
fover 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
fover 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
- Definition Classes
- Any
- 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.
Set the portion of the state viewed through the lens and return its old value.
- Since
7.0.2
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- 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
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMap[C](f: (B1) => IndexedState[A1, A2, C]): IndexedState[A1, A2, C]
Bind the function
fover the value under the lens, as a state action. - def get(a: A1): B1
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- 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[B1, B2, [X]X, γ$0$], [γ$1$]IndexedStateT[A1, A2, [X]X, γ$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
fover 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
Xfull 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.
Modify the portion of the state viewed through the lens and return its old value.
- Since
7.0.2
- def modp[C](f: (B1) => (B2, C), a: A1): (A2, C)
Modify the value viewed through the lens, returning a
Con 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
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- 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
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unary_~: PLensFamily[A1, A2, B1, B2]
alias for
partial - final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- 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