Differ

A Differ[Value, Patch] knows how to compare an old value and new value of type Value to produce a patch of type Patch that describes the differences between those values. A Differ also knows how to apply a patch to an old value to produce a new value that represents the old value updated with the changes described by the patch.

A Differ can be used to construct a FiberRef supporting compositional updates using the FiberRef.makePatch constructor.

The Differ companion object contains constructors for Differ values for common data types such as Chunk, Map, and Set. In addition, Differvalues can be transformed using thetransformoperator and combined using theorElseEither and zip operators. This allows creating Differvalues for arbitrarily complex data types compositionally.

Self Type: Differ[Value, Patch]

Linear Supertypes

Serializable, Serializable, AnyRef, Any

Abstract Value Members

abstract def combine(first: Patch, second: Patch): Patch

Combines two patches to produce a new patch that describes the updates of the first patch and then the updates of the second patch.
Combines two patches to produce a new patch that describes the updates of the first patch and then the updates of the second patch. The combine operation should be associative. In addition, if the combine operation is commutative then joining multiple fibers concurrently will result in deterministic FiberRef values.
abstract def diff(oldValue: Value, newValue: Value): Patch

Constructs a patch describing the updates to a value from an old value and a new value.
abstract def empty: Patch

An empty patch that describes no changes.
abstract def patch(patch: Patch)(oldValue: Value): Value

Applies a patch to an old value to produce a new value that is equal to the old value with the updates described by the patch.

Concrete Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
final def <*>[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[(Value, Value2), (Patch, Patch2)]

A symbolic alias for zip.
final def <+>[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[Either[Value, Value2], OrPatch[Value, Value2, Patch, Patch2]]

A symbolic alias for orElseEither.
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
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 finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def orElseEither[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[Either[Value, Value2], OrPatch[Value, Value2, Patch, Patch2]]

Combines this differ and the specified differ to produce a differ that knows how to diff the sum of their values.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def transform[Value2](f: (Value) ⇒ Value2, g: (Value2) ⇒ Value): Differ[Value2, Patch]

Transforms the type of values that this differ knows how to differ using the specified functions that map the new and old value types to each other.
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 def zip[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[(Value, Value2), (Patch, Patch2)]

Combines this differ and the specified differ to produce a new differ that knows how to diff the product of their values.

Related Docs: object Differ | package zio

trait Differ[Value, Patch] extends Serializable

Abstract Value Members

abstract def combine(first: Patch, second: Patch): Patch

abstract def diff(oldValue: Value, newValue: Value): Patch

abstract def empty: Patch

abstract def patch(patch: Patch)(oldValue: Value): Value

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def <*>[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[(Value, Value2), (Patch, Patch2)]

final def <+>[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[Either[Value, Value2], OrPatch[Value, Value2, Patch, Patch2]]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def orElseEither[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[Either[Value, Value2], OrPatch[Value, Value2, Patch, Patch2]]

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

def toString(): String

final def transform[Value2](f: (Value) ⇒ Value2, g: (Value2) ⇒ Value): Differ[Value2, Patch]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def zip[Value2, Patch2](that: Differ[Value2, Patch2]): Differ[(Value, Value2), (Patch, Patch2)]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped