ZoomModelRW

Instance Constructors

new ZoomModelRW(root: ModelR[M, M], get: (M) ⇒ S, set: (M, S) ⇒ M)(implicit feq: FastEq[_ >: S])

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def =!=(that: S): Boolean

Definition Classes
ModelR
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===(that: S): Boolean

Checks if that is equal to this using an appropriate equality check
Checks if that is equal to this using an appropriate equality check
that
Value to compare with

Definition Classes
ZoomModelR → ModelR
def apply(): S

Returns the value of the reader
Returns the value of the reader

Definition Classes
ModelR
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def eval(model: M): S

Evaluates the reader against a supplied model
Evaluates the reader against a supplied model

Definition Classes
BaseModelR → ModelR
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[F[_], A, B](f: (A) ⇒ F[B])(implicit ev: =:=[S, F[A]], monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

FlatMaps over current reader into a new value provided by f.
FlatMaps over current reader into a new value provided by f. Reader type S must be of type F[A], for example Option[A].
f
The function to apply, must return a value of type F[B]

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

Definition Classes
AnyRef → Any
def getF(model: M): S

Attributes
protected
Definition Classes
ZoomModelR → BaseModelR
def hashCode(): Int

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

Definition Classes
Any
def map[F[_], A, B](f: (A) ⇒ B)(implicit ev: =:=[S, F[A]], monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

Maps over current reader into a new value provided by f.
Maps over current reader into a new value provided by f. Reader type S must be of type F[A], for example Option[A].
f
The function to apply

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val root: ModelR[M, M]

Attributes
protected
Definition Classes
ZoomModelR → BaseModelR
def setF(model: M, value: S): M

Attributes
protected
Definition Classes
ZoomModelRW → BaseModelRW
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def updated(newValue: S): M

Updatews the model using the value provided and returns the updated model.
Updatews the model using the value provided and returns the updated model.

Definition Classes
BaseModelRW → ModelRW
def value: S

Returns the value of the reader
Returns the value of the reader

Definition Classes
BaseModelR → ModelR
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 zip[SS](that: ModelR[M, SS])(implicit feqS: FastEq[_ >: S], feqSS: FastEq[_ >: SS]): ZipModelR[M, S, SS]

Combines this reader with another reader to provide a new reader returning a tuple of the values of the two original readers.
Combines this reader with another reader to provide a new reader returning a tuple of the values of the two original readers.
that
The other reader

Definition Classes
BaseModelR → ModelR
def zoom[T](get: (S) ⇒ T)(implicit feq: FastEq[_ >: T]): ZoomModelR[M, T]

Zooms into the model using the provided accessor function
Zooms into the model using the provided accessor function
get
Function to go from current reader to a new value

Definition Classes
BaseModelR → ModelR
def zoomFlatMap[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ F[B])(implicit monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

Zooms into the model and flatMaps over the zoomed value, which must be of type F[A]
Zooms into the model and flatMaps over the zoomed value, which must be of type F[A]
fa
Zooming function
f
The function to apply, must return a value of type F[B]

Definition Classes
BaseModelR → ModelR
def zoomFlatMapRW[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ F[B])(set: (S, F[B]) ⇒ S)(implicit monad: Monad[F], feq: FastEq[_ >: B]): FlatMapModelRW[F, M, A, B]

Zooms into the model and flatMaps over the zoomed value, which must be of type F[A].
Zooms into the model and flatMaps over the zoomed value, which must be of type F[A]. The set function is used to update the model with a new value.
fa
Zooming function
f
The function to apply
set
Function to update the model with a new value

Definition Classes
BaseModelRW → ModelRW
def zoomMap[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ B)(implicit monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

Zooms into the model and maps over the zoomed value, which must be of type F[A]
Zooms into the model and maps over the zoomed value, which must be of type F[A]
fa
Zooming function
f
The function to apply

Definition Classes
BaseModelR → ModelR
def zoomMapRW[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ B)(set: (S, F[B]) ⇒ S)(implicit monad: Monad[F], feq: FastEq[_ >: B]): MapModelRW[F, M, A, B]

Zooms into the model and maps over the zoomed value, which must be of type F[A].
Zooms into the model and maps over the zoomed value, which must be of type F[A]. The set function is used to update the model with a new value.
fa
Zooming function
f
The function to apply
set
Function to update the model with a new value

Definition Classes
BaseModelRW → ModelRW
def zoomRW[U](get: (S) ⇒ U)(set: (S, U) ⇒ S)(implicit feq: FastEq[_ >: U]): ZoomModelRW[M, U]

Zooms into the model using the provided get function.
Zooms into the model using the provided get function. The set function is used to update the model with a new value.
get
Function to go from current reader to a new value
set
Function to update the model with a new value

Definition Classes
BaseModelRW → ModelRW

Related Doc: package diode

class ZoomModelRW[M, S] extends ZoomModelR[M, S] with BaseModelRW[M, S]

Instance Constructors

new ZoomModelRW(root: ModelR[M, M], get: (M) ⇒ S, set: (M, S) ⇒ M)(implicit feq: FastEq[_ >: S])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def =!=(that: S): Boolean

final def ==(arg0: Any): Boolean

def ===(that: S): Boolean

def apply(): S

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval(model: M): S

def finalize(): Unit

def flatMap[F[_], A, B](f: (A) ⇒ F[B])(implicit ev: =:=[S, F[A]], monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

final def getClass(): Class[_]

def getF(model: M): S

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[F[_], A, B](f: (A) ⇒ B)(implicit ev: =:=[S, F[A]], monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val root: ModelR[M, M]

def setF(model: M, value: S): M

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

def toString(): String

def updated(newValue: S): M

def value: S

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[SS](that: ModelR[M, SS])(implicit feqS: FastEq[_ >: S], feqSS: FastEq[_ >: SS]): ZipModelR[M, S, SS]

def zoom[T](get: (S) ⇒ T)(implicit feq: FastEq[_ >: T]): ZoomModelR[M, T]

def zoomFlatMap[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ F[B])(implicit monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

def zoomFlatMapRW[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ F[B])(set: (S, F[B]) ⇒ S)(implicit monad: Monad[F], feq: FastEq[_ >: B]): FlatMapModelRW[F, M, A, B]

def zoomMap[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ B)(implicit monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

def zoomMapRW[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ B)(set: (S, F[B]) ⇒ S)(implicit monad: Monad[F], feq: FastEq[_ >: B]): MapModelRW[F, M, A, B]

def zoomRW[U](get: (S) ⇒ U)(set: (S, U) ⇒ S)(implicit feq: FastEq[_ >: U]): ZoomModelRW[M, U]

Inherited from BaseModelRW[M, S]

Inherited from ModelRW[M, S]

Inherited from ZoomModelR[M, S]

Inherited from BaseModelR[M, S]

Inherited from ModelR[M, S]

Inherited from AnyRef

Inherited from Any

Ungrouped