PLens

A PLens can be seen as a pair of functions: get: S => A i.e. from an S, we can extract an A set: (B, S) => T i.e. if we replace an A by a B in a S, we obtain a T

A PLens could also be defined as a weaker PIso where set requires an additional parameter than reverseGet.

PLens stands for Polymorphic Lens as it set and modify methods change a type A to B and S to T. Lens is a type alias for PLens restricted to monomoprhic updates:

type Lens[S, A] = PLens[S, S, A, A]

A PLens is also a valid Getter, Fold, POptional, PTraversal and PSetter

Typically a PLens or Lens can be defined between a Product (e.g. case class, tuple, HList) and one of it is component.

S: the source of a PLens
T: the modified source of a PLens
A: the target of a PLens
B: the modified target of a PLens

Self Type: PLens[S, T, A, B]
See also: LensLaws in monocle-law module

Linear Supertypes

AnyRef, Any

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ^<->[C, D](other: PIso[A, B, C, D]): PLens[S, T, C, D]

alias to composeIso
alias to composeIso

Annotations
@inline()
def ^<-?[C, D](other: PPrism[A, B, C, D]): POptional[S, T, C, D]

alias to composePrism
alias to composePrism

Annotations
@inline()
def ^|->[C, D](other: PLens[A, B, C, D]): PLens[S, T, C, D]

alias to composeLens
alias to composeLens

Annotations
@inline()
def ^|->>[C, D](other: PTraversal[A, B, C, D]): PTraversal[S, T, C, D]

alias to composeTraversal
alias to composeTraversal

Annotations
@inline()
def ^|-?[C, D](other: POptional[A, B, C, D]): POptional[S, T, C, D]

alias to composeOptional
alias to composeOptional

Annotations
@inline()
def asFold: Fold[S, A]

view a PLens as a Fold
view a PLens as a Fold

Annotations
@inline()
def asGetter: Getter[S, A]

view a PLens as a Getter
view a PLens as a Getter

Annotations
@inline()
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asOptional: POptional[S, T, A, B]

view a PLens as an POptional
view a PLens as an POptional

Annotations
@inline()
def asSetter: PSetter[S, T, A, B]

view a PLens as a PSetter
view a PLens as a PSetter

Annotations
@inline()
def asTraversal: PTraversal[S, T, A, B]

view a PLens as a PTraversal
view a PLens as a PTraversal

Annotations
@inline()
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def composeFold[C](other: Fold[A, C]): Fold[S, C]

compose a PLens with a Fold
compose a PLens with a Fold

Annotations
@inline()
def composeGetter[C](other: Getter[A, C]): Getter[S, C]

compose a PLens with a Getter
compose a PLens with a Getter

Annotations
@inline()
def composeIso[C, D](other: PIso[A, B, C, D]): PLens[S, T, C, D]

compose a PLens with an PIso
compose a PLens with an PIso

Annotations
@inline()
def composeLens[C, D](other: PLens[A, B, C, D]): PLens[S, T, C, D]

compose a PLens with a PLens
compose a PLens with a PLens

Annotations
@inline()
def composeOptional[C, D](other: POptional[A, B, C, D]): POptional[S, T, C, D]

compose a PLens with an POptional
compose a PLens with an POptional

Annotations
@inline()
def composePrism[C, D](other: PPrism[A, B, C, D]): POptional[S, T, C, D]

compose a PLens with a PPrism
compose a PLens with a PPrism

Annotations
@inline()
def composeSetter[C, D](other: PSetter[A, B, C, D]): PSetter[S, T, C, D]

compose a PLens with a PSetter
compose a PLens with a PSetter

Annotations
@inline()
def composeTraversal[C, D](other: PTraversal[A, B, C, D]): PTraversal[S, T, C, D]

compose a PLens with a PTraversal
compose a PLens with a PTraversal

Annotations
@inline()
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val get: (S) ⇒ A

get the target of a PLens
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def modify(f: (A) ⇒ B): (S) ⇒ T

modify polymorphically the target of a PLens using a function
modify polymorphically the target of a PLens using a function

Annotations
@inline()
def modifyF[F[_]](f: (A) ⇒ F[B])(s: S)(implicit arg0: Functor[F]): F[T]

modify polymorphically the target of a PLens using Functor function
modify polymorphically the target of a PLens using Functor function

Annotations
@inline()
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val set: (B) ⇒ (S) ⇒ T

set polymorphically the target of a PLens with a value
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

final class PLens[S, T, A, B] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ^<->[C, D](other: PIso[A, B, C, D]): PLens[S, T, C, D]

def ^<-?[C, D](other: PPrism[A, B, C, D]): POptional[S, T, C, D]

def ^|->[C, D](other: PLens[A, B, C, D]): PLens[S, T, C, D]

def ^|->>[C, D](other: PTraversal[A, B, C, D]): PTraversal[S, T, C, D]

def ^|-?[C, D](other: POptional[A, B, C, D]): POptional[S, T, C, D]

def asFold: Fold[S, A]

def asGetter: Getter[S, A]

final def asInstanceOf[T0]: T0

def asOptional: POptional[S, T, A, B]

def asSetter: PSetter[S, T, A, B]

def asTraversal: PTraversal[S, T, A, B]

def clone(): AnyRef

def composeFold[C](other: Fold[A, C]): Fold[S, C]

def composeGetter[C](other: Getter[A, C]): Getter[S, C]

def composeIso[C, D](other: PIso[A, B, C, D]): PLens[S, T, C, D]

def composeLens[C, D](other: PLens[A, B, C, D]): PLens[S, T, C, D]

def composeOptional[C, D](other: POptional[A, B, C, D]): POptional[S, T, C, D]

def composePrism[C, D](other: PPrism[A, B, C, D]): POptional[S, T, C, D]

def composeSetter[C, D](other: PSetter[A, B, C, D]): PSetter[S, T, C, D]

def composeTraversal[C, D](other: PTraversal[A, B, C, D]): PTraversal[S, T, C, D]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

val get: (S) ⇒ A

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def modify(f: (A) ⇒ B): (S) ⇒ T

def modifyF[F[_]](f: (A) ⇒ F[B])(s: S)(implicit arg0: Functor[F]): F[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val set: (B) ⇒ (S) ⇒ T

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped