PLensFamily

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.

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

Source: PLens.scala
See also: scalaz.Lens

Linear Supertypes

AnyRef, Any

Abstract Value Members

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

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
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
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
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
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
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.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[C1, C2](that: PLensFamily[C1, C2, A1, A2]): PLensFamily[C1, C2, B1, B2]

Partial Lenses can be composed
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(p: (B1) ⇒ Boolean, a: A1): Boolean
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forall(p: (B1) ⇒ Boolean, a: A1): Boolean
def get(a: A1): Option[B1]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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.
def getOrZ(a: A1)(implicit M: Monoid[B1]): B1
def hashCode(): Int

Definition Classes
AnyRef → Any
def is(a: A1): Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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
def modg(f: (B1) ⇒ B2, a: A1): Option[A2]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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
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
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
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

Related Docs: object PLensFamily | package scalaz

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

Abstract Value Members

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

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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]

final def ==(arg0: Any): Boolean

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]

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (B1) ⇒ Boolean, a: A1): Boolean

def finalize(): Unit

def forall(p: (B1) ⇒ Boolean, a: A1): Boolean

def get(a: A1): Option[B1]

final def getClass(): Class[_]

def getK: Kleisli[Option, A1, B1]

def getOr(a: A1, b: ⇒ B1): B1

def getOrZ(a: A1)(implicit M: Monoid[B1]): B1

def hashCode(): Int

def is(a: A1): Boolean

final def isInstanceOf[T0]: 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

def modg(f: (B1) ⇒ B2, a: A1): Option[A2]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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]

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

def toString(): String

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

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): 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]

Inherited from AnyRef

Inherited from Any

Ungrouped