LensFamily

Type Members

type ArrayLens[S, A] = ArrayLensFamily[S, S, A]

Definition Classes
LensInstances
case class ArrayLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Array[A], Array[A]]) extends Product with Serializable

Provide an imperative-seeming API for arrays viewed through a lens
Provide an imperative-seeming API for arrays viewed through a lens

Definition Classes
LensInstances
type FractionalLens[S, F] = FractionalLensFamily[S, S, F]

Definition Classes
LensInstances
case class FractionalLensFamily[S1, S2, F](lens: LensFamily[S1, S2, F, F], frac: Fractional[F]) extends Product with Serializable

Allow the illusion of imperative updates to numbers viewed through a lens
Allow the illusion of imperative updates to numbers viewed through a lens

Definition Classes
LensInstances
type IntegralLens[S, I] = IntegralLensFamily[S, S, I]

Definition Classes
LensInstances
case class IntegralLensFamily[S1, S2, I](lens: LensFamily[S1, S2, I, I], ig: Integral[I]) extends Product with Serializable

Allow the illusion of imperative updates to numbers viewed through a lens
Allow the illusion of imperative updates to numbers viewed through a lens

Definition Classes
LensInstances
type MapLens[S, K, V] = MapLensFamily[S, S, K, V]

Definition Classes
LensInstances
case class MapLensFamily[S1, S2, K, V](lens: LensFamily[S1, S2, Map[K, V], Map[K, V]]) extends Product with Serializable

A lens that views an immutable Map type can provide a mutable.Map-like API via State
A lens that views an immutable Map type can provide a mutable.Map-like API via State

Definition Classes
LensInstances
type NumericLens[S, N] = NumericLensFamily[S, S, N]

Definition Classes
LensInstances
case class NumericLensFamily[S1, S2, N](lens: LensFamily[S1, S2, N, N], num: Numeric[N]) extends Product with Serializable

Allow the illusion of imperative updates to numbers viewed through a lens
Allow the illusion of imperative updates to numbers viewed through a lens

Definition Classes
LensInstances
type QueueLens[S, A] = QueueLensFamily[S, S, A]

Definition Classes
LensInstances
case class QueueLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Queue[A], Queue[A]]) extends Product with Serializable

Provide an imperative-seeming API for queues viewed through a lens
Provide an imperative-seeming API for queues viewed through a lens

Definition Classes
LensInstances
type SeqLikeLens[S, A, Repr <: SeqLike[A, Repr]] = SeqLikeLensFamily[S, S, A, Repr]

Definition Classes
LensInstances
case class SeqLikeLensFamily[S1, S2, A, Repr <: SeqLike[A, Repr]](lens: LensFamily[S1, S2, Repr, Repr]) extends Product with Serializable

Provide the appearance of a mutable-like API for sorting sequences through a lens
Provide the appearance of a mutable-like API for sorting sequences through a lens

Definition Classes
LensInstances
type SetLens[S, K] = SetLensFamily[S, S, K]

Definition Classes
LensInstances
case class SetLensFamily[S1, S2, K](lens: LensFamily[S1, S2, Set[K], Set[K]]) extends Product with Serializable

Definition Classes
LensInstances

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
val ArrayLens: ArrayLensFamily.type

Definition Classes
LensInstances
val FractionalLens: FractionalLensFamily.type

Definition Classes
LensInstances
val IntegralLens: IntegralLensFamily.type

Definition Classes
LensInstances
implicit def LensFamilyState[A, B](lens: LensFamily[A, _, B, _]): State[A, B]

Lenses may be used implicitly as State monadic actions that get the viewed portion of the state
Lenses may be used implicitly as State monadic actions that get the viewed portion of the state

Definition Classes
LensInstances
implicit def LensFamilyUnzip[S, R]: Unzip[[α]LensFamily[S, R, α, α]]

Definition Classes
LensInstances
val MapLens: MapLensFamily.type

Definition Classes
LensInstances
val NumericLens: NumericLensFamily.type

Definition Classes
LensInstances
val QueueLens: QueueLensFamily.type

Definition Classes
LensInstances
val SeqLikeLens: SeqLikeLensFamily.type

Definition Classes
LensInstances
val SetLens: SetLensFamily.type

Definition Classes
LensInstances
def apply[A1, A2, B1, B2](r: (A1) ⇒ IndexedStore[B1, B2, A2]): LensFamily[A1, A2, B1, B2]
def applyLens[A, B](k: (B) ⇒ A)(implicit e: Equal[A]): @>[Store[A, B], B]

Definition Classes
LensFunctions
implicit def arrayLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Array[A], Array[A]]): ArrayLensFamily[S1, S2, A]

Definition Classes
LensInstances
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def codiagLens[A]: Lens[\/[A, A], A]

A lens that discards the choice of right or left from disjunction
A lens that discards the choice of right or left from disjunction

Definition Classes
LensFunctions
def codiagLensFamily[A1, A2]: LensFamily[\/[A1, A1], \/[A2, A2], A1, A2]

A lens family that discards the choice of right or left from disjunction
A lens family that discards the choice of right or left from disjunction

Definition Classes
LensFamilyFunctions
def distributeLens[A, B, C]: @>[(A, \/[B, C]), \/[(A, B), (A, C)]]

Definition Classes
LensFunctions
def distributeLensFamily[A1, A2, B1, B2, C1, C2]: LensFamily[(A1, \/[B1, C1]), (A2, \/[B2, C2]), \/[(A1, B1), (A1, C1)], \/[(A2, B2), (A2, C2)]]

Definition Classes
LensFamilyFunctions
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def factorLens[A, B, C]: @>[\/[(A, B), (A, C)], (A, \/[B, C])]

Definition Classes
LensFunctions
def factorLensFamily[A1, A2, B1, B2, C1, C2]: LensFamily[\/[(A1, B1), (A1, C1)], \/[(A2, B2), (A2, C2)], (A1, \/[B1, C1]), (A2, \/[B2, C2])]

Definition Classes
LensFamilyFunctions
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def firstLens[A, B]: @>[(A, B), A]

Access the first field of a tuple
Access the first field of a tuple

Definition Classes
LensFunctions
def firstLensFamily[A1, A2, B]: LensFamily[(A1, B), (A2, B), A1, A2]

Polymorphically access the first field of a tuple
Polymorphically access the first field of a tuple

Definition Classes
LensFamilyFunctions
implicit def fractionalLensFamily[S1, S2, F](lens: LensFamily[S1, S2, F, F])(implicit arg0: Fractional[F]): FractionalLensFamily[S1, S2, F]

Definition Classes
LensInstances
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def integralLensFamily[S1, S2, I](lens: LensFamily[S1, S2, I, I])(implicit arg0: Integral[I]): IntegralLensFamily[S1, S2, I]

Definition Classes
LensInstances
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lazyFirstLens[A, B]: @>[LazyTuple2[A, B], A]

Access the first field of a tuple
Access the first field of a tuple

Definition Classes
LensFunctions
def lazyFirstLensFamily[A1, A2, B]: LensFamily[LazyTuple2[A1, B], LazyTuple2[A2, B], A1, A2]

Polymorphically access the first field of a tuple
Polymorphically access the first field of a tuple

Definition Classes
LensFamilyFunctions
def lazySecondLens[A, B]: @>[LazyTuple2[A, B], B]

Access the second field of a tuple
Access the second field of a tuple

Definition Classes
LensFunctions
def lazySecondLensFamily[A, B1, B2]: LensFamily[LazyTuple2[A, B1], LazyTuple2[A, B2], B1, B2]

Polymorphically access the second field of a tuple
Polymorphically access the second field of a tuple

Definition Classes
LensFamilyFunctions
def lens[A, B](r: (A) ⇒ Store[B, A]): Lens[A, B]

Definition Classes
LensFunctions
implicit val lensCategory: LensCategory

Definition Classes
LensInstances
def lensFamily[A1, A2, B1, B2](r: (A1) ⇒ IndexedStore[B1, B2, A2]): LensFamily[A1, A2, B1, B2]

Definition Classes
LensFamilyFunctions
def lensFamilyId[A1, A2]: LensFamily[A1, A2, A1, A2]

The identity lens family for a given pair of objects
The identity lens family for a given pair of objects

Definition Classes
LensFamilyFunctions
def lensFamilyg[A1, A2, B1, B2](set: (A1) ⇒ (B2) ⇒ A2, get: (A1) ⇒ B1): LensFamily[A1, A2, B1, B2]

Definition Classes
LensFamilyFunctions
def lensFamilyu[A1, A2, B1, B2](set: (A1, B2) ⇒ A2, get: (A1) ⇒ B1): LensFamily[A1, A2, B1, B2]

Definition Classes
LensFamilyFunctions
def lensId[A]: Lens[A, A]

The identity lens for a given object
The identity lens for a given object

Definition Classes
LensFunctions
def lensg[A, B](set: (A) ⇒ (B) ⇒ A, get: (A) ⇒ B): Lens[A, B]

Definition Classes
LensFunctions
def lensu[A, B](set: (A, B) ⇒ A, get: (A) ⇒ B): Lens[A, B]

Definition Classes
LensFunctions
implicit def mapLensFamily[S1, S2, K, V](lens: LensFamily[S1, S2, Map[K, V], Map[K, V]]): MapLensFamily[S1, S2, K, V]

Definition Classes
LensInstances
def mapVLens[K, V](k: K): @>[Map[K, V], Option[V]]

Access the value at a particular key of a Map *
Access the value at a particular key of a Map *

Definition Classes
LensFunctions
def mapWithDefaultLens[K, V](k: K): @>[WithDefault[K, V], V]

Access the value at a particular key of a Map.WithDefault
Access the value at a particular key of a Map.WithDefault

Definition Classes
LensFunctions
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nelHeadLens[A]: @>[NonEmptyList[A], A]

Definition Classes
LensFunctions
def nelTailLens[A]: @>[NonEmptyList[A], List[A]]

Definition Classes
LensFunctions
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def numericLensFamily[S1, S2, N](lens: LensFamily[S1, S2, N, N])(implicit arg0: Numeric[N]): NumericLensFamily[S1, S2, N]

Definition Classes
LensInstances
def predicateLens[A]: @>[Store[A, Boolean], \/[A, A]]

Definition Classes
LensFunctions
def predicateLensFamily[A1, A2]: LensFamily[Store[A1, Boolean], Store[A2, Boolean], \/[A1, A1], \/[A2, A2]]

Definition Classes
LensFamilyFunctions
implicit def queueLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Queue[A], Queue[A]]): QueueLensFamily[S1, S2, A]

Definition Classes
LensInstances
def secondLens[A, B]: @>[(A, B), B]

Access the second field of a tuple
Access the second field of a tuple

Definition Classes
LensFunctions
def secondLensFamily[A, B1, B2]: LensFamily[(A, B1), (A, B2), B1, B2]

Polymorphically access the second field of a tuple
Polymorphically access the second field of a tuple

Definition Classes
LensFamilyFunctions
implicit def seqLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Seq[A], Seq[A]]): SeqLikeLensFamily[S1, S2, A, Seq[A]]

Definition Classes
LensInstances
implicit def seqLikeLensFamily[S1, S2, A, Repr <: SeqLike[A, Repr]](lens: LensFamily[S1, S2, Repr, Repr]): SeqLikeLensFamily[S1, S2, A, Repr]

Definition Classes
LensInstances0
implicit def setLensFamily[S1, S2, K](lens: LensFamily[S1, S2, Set[K], Set[K]]): SetLensFamily[S1, S2, K]

A lens that views a Set can provide the appearance of in place mutation
A lens that views a Set can provide the appearance of in place mutation

Definition Classes
LensInstances
def setMembershipLens[A](a: A): @>[Set[A], Boolean]

Specify whether a value is in a Set
Specify whether a value is in a Set

Definition Classes
LensFunctions
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trivialLens[A]: Lens[A, Unit]

The trivial lens that can retrieve Unit from anything
The trivial lens that can retrieve Unit from anything

Definition Classes
LensFunctions
implicit def tuple2LensFamily[S1, S2, A, B](lens: LensFamily[S1, S2, (A, B), (A, B)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B])

Definition Classes
LensInstances
implicit def tuple3LensFamily[S1, S2, A, B, C](lens: LensFamily[S1, S2, (A, B, C), (A, B, C)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B], LensFamily[S1, S2, C, C])

Definition Classes
LensInstances
implicit def tuple4LensFamily[S1, S2, A, B, C, D](lens: LensFamily[S1, S2, (A, B, C, D), (A, B, C, D)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B], LensFamily[S1, S2, C, C], LensFamily[S1, S2, D, D])

Definition Classes
LensInstances
implicit def tuple5LensFamily[S1, S2, A, B, C, D, E](lens: LensFamily[S1, S2, (A, B, C, D, E), (A, B, C, D, E)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B], LensFamily[S1, S2, C, C], LensFamily[S1, S2, D, D], LensFamily[S1, S2, E, E])

Definition Classes
LensInstances
implicit def tuple6LensFamily[S1, S2, A, B, C, D, E, H](lens: LensFamily[S1, S2, (A, B, C, D, E, H), (A, B, C, D, E, H)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B], LensFamily[S1, S2, C, C], LensFamily[S1, S2, D, D], LensFamily[S1, S2, E, E], LensFamily[S1, S2, H, H])

Definition Classes
LensInstances
implicit def tuple7LensFamily[S1, S2, A, B, C, D, E, H, I](lens: LensFamily[S1, S2, (A, B, C, D, E, H, I), (A, B, C, D, E, H, I)]): (LensFamily[S1, S2, A, A], LensFamily[S1, S2, B, B], LensFamily[S1, S2, C, C], LensFamily[S1, S2, D, D], LensFamily[S1, S2, E, E], LensFamily[S1, S2, H, H], LensFamily[S1, S2, I, I])

Definition Classes
LensInstances
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( ... )

Related Docs: class LensFamily | package scalaz

object LensFamily extends LensInstances with LensFunctions

Type Members

type ArrayLens[S, A] = ArrayLensFamily[S, S, A]

case class ArrayLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Array[A], Array[A]]) extends Product with Serializable

type FractionalLens[S, F] = FractionalLensFamily[S, S, F]

case class FractionalLensFamily[S1, S2, F](lens: LensFamily[S1, S2, F, F], frac: Fractional[F]) extends Product with Serializable

type IntegralLens[S, I] = IntegralLensFamily[S, S, I]

case class IntegralLensFamily[S1, S2, I](lens: LensFamily[S1, S2, I, I], ig: Integral[I]) extends Product with Serializable

type MapLens[S, K, V] = MapLensFamily[S, S, K, V]

case class MapLensFamily[S1, S2, K, V](lens: LensFamily[S1, S2, Map[K, V], Map[K, V]]) extends Product with Serializable

type NumericLens[S, N] = NumericLensFamily[S, S, N]

case class NumericLensFamily[S1, S2, N](lens: LensFamily[S1, S2, N, N], num: Numeric[N]) extends Product with Serializable

type QueueLens[S, A] = QueueLensFamily[S, S, A]

case class QueueLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Queue[A], Queue[A]]) extends Product with Serializable

type SeqLikeLens[S, A, Repr <: SeqLike[A, Repr]] = SeqLikeLensFamily[S, S, A, Repr]

case class SeqLikeLensFamily[S1, S2, A, Repr <: SeqLike[A, Repr]](lens: LensFamily[S1, S2, Repr, Repr]) extends Product with Serializable

type SetLens[S, K] = SetLensFamily[S, S, K]

case class SetLensFamily[S1, S2, K](lens: LensFamily[S1, S2, Set[K], Set[K]]) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ArrayLens: ArrayLensFamily.type

val FractionalLens: FractionalLensFamily.type

val IntegralLens: IntegralLensFamily.type

implicit def LensFamilyState[A, B](lens: LensFamily[A, _, B, _]): State[A, B]

implicit def LensFamilyUnzip[S, R]: Unzip[[α]LensFamily[S, R, α, α]]

val MapLens: MapLensFamily.type

val NumericLens: NumericLensFamily.type

val QueueLens: QueueLensFamily.type

val SeqLikeLens: SeqLikeLensFamily.type

val SetLens: SetLensFamily.type

def apply[A1, A2, B1, B2](r: (A1) ⇒ IndexedStore[B1, B2, A2]): LensFamily[A1, A2, B1, B2]

def applyLens[A, B](k: (B) ⇒ A)(implicit e: Equal[A]): @>[Store[A, B], B]

implicit def arrayLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Array[A], Array[A]]): ArrayLensFamily[S1, S2, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def codiagLens[A]: Lens[\/[A, A], A]

def codiagLensFamily[A1, A2]: LensFamily[\/[A1, A1], \/[A2, A2], A1, A2]

def distributeLens[A, B, C]: @>[(A, \/[B, C]), \/[(A, B), (A, C)]]

def distributeLensFamily[A1, A2, B1, B2, C1, C2]: LensFamily[(A1, \/[B1, C1]), (A2, \/[B2, C2]), \/[(A1, B1), (A1, C1)], \/[(A2, B2), (A2, C2)]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def factorLens[A, B, C]: @>[\/[(A, B), (A, C)], (A, \/[B, C])]

def factorLensFamily[A1, A2, B1, B2, C1, C2]: LensFamily[\/[(A1, B1), (A1, C1)], \/[(A2, B2), (A2, C2)], (A1, \/[B1, C1]), (A2, \/[B2, C2])]

def finalize(): Unit

def firstLens[A, B]: @>[(A, B), A]

def firstLensFamily[A1, A2, B]: LensFamily[(A1, B), (A2, B), A1, A2]

implicit def fractionalLensFamily[S1, S2, F](lens: LensFamily[S1, S2, F, F])(implicit arg0: Fractional[F]): FractionalLensFamily[S1, S2, F]

final def getClass(): Class[_]

def hashCode(): Int

implicit def integralLensFamily[S1, S2, I](lens: LensFamily[S1, S2, I, I])(implicit arg0: Integral[I]): IntegralLensFamily[S1, S2, I]

final def isInstanceOf[T0]: Boolean

def lazyFirstLens[A, B]: @>[LazyTuple2[A, B], A]

def lazyFirstLensFamily[A1, A2, B]: LensFamily[LazyTuple2[A1, B], LazyTuple2[A2, B], A1, A2]

def lazySecondLens[A, B]: @>[LazyTuple2[A, B], B]

def lazySecondLensFamily[A, B1, B2]: LensFamily[LazyTuple2[A, B1], LazyTuple2[A, B2], B1, B2]

def lens[A, B](r: (A) ⇒ Store[B, A]): Lens[A, B]

implicit val lensCategory: LensCategory

def lensFamily[A1, A2, B1, B2](r: (A1) ⇒ IndexedStore[B1, B2, A2]): LensFamily[A1, A2, B1, B2]

def lensFamilyId[A1, A2]: LensFamily[A1, A2, A1, A2]

def lensFamilyg[A1, A2, B1, B2](set: (A1) ⇒ (B2) ⇒ A2, get: (A1) ⇒ B1): LensFamily[A1, A2, B1, B2]

def lensFamilyu[A1, A2, B1, B2](set: (A1, B2) ⇒ A2, get: (A1) ⇒ B1): LensFamily[A1, A2, B1, B2]

def lensId[A]: Lens[A, A]

def lensg[A, B](set: (A) ⇒ (B) ⇒ A, get: (A) ⇒ B): Lens[A, B]

def lensu[A, B](set: (A, B) ⇒ A, get: (A) ⇒ B): Lens[A, B]

implicit def mapLensFamily[S1, S2, K, V](lens: LensFamily[S1, S2, Map[K, V], Map[K, V]]): MapLensFamily[S1, S2, K, V]

def mapVLens[K, V](k: K): @>[Map[K, V], Option[V]]

def mapWithDefaultLens[K, V](k: K): @>[WithDefault[K, V], V]

final def ne(arg0: AnyRef): Boolean

def nelHeadLens[A]: @>[NonEmptyList[A], A]

def nelTailLens[A]: @>[NonEmptyList[A], List[A]]

final def notify(): Unit

final def notifyAll(): Unit

implicit def numericLensFamily[S1, S2, N](lens: LensFamily[S1, S2, N, N])(implicit arg0: Numeric[N]): NumericLensFamily[S1, S2, N]

def predicateLens[A]: @>[Store[A, Boolean], \/[A, A]]

def predicateLensFamily[A1, A2]: LensFamily[Store[A1, Boolean], Store[A2, Boolean], \/[A1, A1], \/[A2, A2]]

implicit def queueLensFamily[S1, S2, A](lens: LensFamily[S1, S2, Queue[A], Queue[A]]): QueueLensFamily[S1, S2, A]