ZoomModelR

Instance Constructors

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

Type Members

type NewR[T] = ModelR[M, T]

Type of a new reader returned by functions such as zoom
Type of a new reader returned by functions such as zoom

Definition Classes
ModelR → ModelRO

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
ModelRO
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 → ModelRO
def apply(): S

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

Definition Classes
ModelRO
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
ZoomModelR → 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]): NewR[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
ModelRO
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
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]): NewR[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
ModelRO
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]

Returns the root model reader of this reader
Returns the root model reader of this reader

Definition Classes
ZoomModelR → ModelR
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def value: S

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

Definition Classes
BaseModelR → ModelRO
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 → ModelRO
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 → ModelRO
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 → ModelRO

Related Doc: package diode

class ZoomModelR[M, S] extends BaseModelR[M, S]

Instance Constructors

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

Type Members

type NewR[T] = ModelR[M, T]

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]): NewR[F[B]]

final def getClass(): Class[_]

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]): NewR[F[B]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val root: ModelR[M, M]

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

def toString(): String

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 zoomMap[F[_], A, B](fa: (S) ⇒ F[A])(f: (A) ⇒ B)(implicit monad: Monad[F], feq: FastEq[_ >: B]): ModelR[M, F[B]]

Inherited from BaseModelR[M, S]

Inherited from ModelR[M, S]

Inherited from ModelRO[S]

Inherited from AnyRef

Inherited from Any

Ungrouped