MapModelR

Instance Constructors

new MapModelR(root: ModelR[M, M], get: (M) ⇒ F[A], f: (A) ⇒ B)(implicit monad: Monad[F], ct: ClassTag[B])

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

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

Definition Classes
ModelR
final def asInstanceOf[T0]: T0

Definition Classes
Any
def chooseEq[A](ct: ClassTag[A]): (A, A) ⇒ Boolean

Choose an equality function based on the type (AnyVal vs.
Choose an equality function based on the type (AnyVal vs. AnyRef)
ct
ClassTag for the type

Definition Classes
ValueRefEq
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit val ct: ClassTag[B]

Definition Classes
MapModelR → MappedModelR
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def eval(model: M): F[B]

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: =:=[F[B], F[A]], monad: Monad[F], ct: ClassTag[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): F[B]

Attributes
protected
Definition Classes
MappedModelR
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: =:=[F[B], F[A]], monad: Monad[F], ct: ClassTag[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
def mapValue: F[B]

Attributes
protected
Definition Classes
MapModelR → MappedModelR
implicit val monad: Monad[F]

Definition Classes
MapModelR → MappedModelR
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def refEq[A](v1: A, v2: A): Boolean

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

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

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def value: F[B]

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

Definition Classes
BaseModelR → ModelR
def valueEq[A](v1: A, v2: A): Boolean

Definition Classes
ValueRefEq
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 cts: ClassTag[F[B]], ctss: ClassTag[SS]): ZipModelR[M, F[B], 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: (F[B]) ⇒ 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: (F[B]) ⇒ F[A])(f: (A) ⇒ F[B])(implicit monad: Monad[F], ct: ClassTag[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 zoomMap[F[_], A, B](fa: (F[B]) ⇒ F[A])(f: (A) ⇒ B)(implicit monad: Monad[F], ct: ClassTag[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

Related Doc: package diode

class MapModelR[F[_], M, A, B] extends BaseModelR[M, F[B]] with MappedModelR[F, M, B]

Instance Constructors

new MapModelR(root: ModelR[M, M], get: (M) ⇒ F[A], f: (A) ⇒ B)(implicit monad: Monad[F], ct: ClassTag[B])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(): F[B]

final def asInstanceOf[T0]: T0

def chooseEq[A](ct: ClassTag[A]): (A, A) ⇒ Boolean

def clone(): AnyRef

implicit val ct: ClassTag[B]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval(model: M): F[B]

def finalize(): Unit

def flatMap[F[_], A, B](f: (A) ⇒ F[B])(implicit ev: =:=[F[B], F[A]], monad: Monad[F], ct: ClassTag[B]): ModelR[M, F[B]]

final def getClass(): Class[_]

def getF(model: M): F[B]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[F[_], A, B](f: (A) ⇒ B)(implicit ev: =:=[F[B], F[A]], monad: Monad[F], ct: ClassTag[B]): ModelR[M, F[B]]

def mapValue: F[B]

implicit val monad: Monad[F]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def refEq[A](v1: A, v2: A): Boolean

val root: ModelR[M, M]

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

def toString(): String

def value: F[B]

def valueEq[A](v1: A, v2: A): Boolean

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 cts: ClassTag[F[B]], ctss: ClassTag[SS]): ZipModelR[M, F[B], SS]

def zoom[T](get: (F[B]) ⇒ T): ZoomModelR[M, T]

def zoomFlatMap[F[_], A, B](fa: (F[B]) ⇒ F[A])(f: (A) ⇒ F[B])(implicit monad: Monad[F], ct: ClassTag[B]): ModelR[M, F[B]]

def zoomMap[F[_], A, B](fa: (F[B]) ⇒ F[A])(f: (A) ⇒ B)(implicit monad: Monad[F], ct: ClassTag[B]): ModelR[M, F[B]]

Inherited from MappedModelR[F, M, B]

Inherited from ValueRefEq

Inherited from BaseModelR[M, F[B]]

Inherited from ModelR[M, F[B]]

Inherited from AnyRef

Inherited from Any

Ungrouped