scalaz-core/scalaz/PLensFamily

PLensFamily

sealed abstract
class PLensFamily[A1, A2, B1, B2]

Partial Lens Families, offering a purely functional means to access and retrieve an optional field transitioning from type B1 to type B2 in a record that is simultaneously transitioning from type A1 to type A2. scalaz.PLens 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 partial lens family can address the nth element of a List.

Type Params
A1

The initial type of the record

A2

The final type of the record

B1

The initial type of the optional field

B2

The final type of the optional field

See also
Companion
object
class Object
trait Matchable
class Any

Value members

Abstract methods

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

Concrete methods

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

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

alias for compose

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

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.

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

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

Partial Lenses can be composed

Partial Lenses can be composed

def exists(p: B1 => Boolean, a: A1): Boolean
def forall(p: B1 => Boolean, a: A1): Boolean
def get(a: A1): Option[B1]
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.

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

def getOrZ(a: A1)(implicit M: Monoid[B1]): B1
def is(a: A1): 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

Modify the potential value viewed through the partial lens

def modg(f: B1 => B2, a: A1): Option[A2]
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

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

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

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
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

Alias for sum