Differ
Constructors
Signature
declare const chunk: <Value, Patch>(
differ: Differ<Value, Patch>,
) => Differ<Chunk<Value>, Differ.Chunk.Patch<Value, Patch>>;environment
Constructs a differ that knows how to diff Env values.
Signature
declare const environment: <A>() => Differ<Context<A>, Differ.Context.Patch<A, A>>;Constructs a differ that knows how to diff a HashMap of keys and values given a differ that knows how to diff the values.
Signature
declare const hashMap: <Key, Value, Patch>(
differ: Differ<Value, Patch>,
) => Differ<HashMap<Key, Value>, Differ.HashMap.Patch<Key, Value, Patch>>;Constructs a differ that knows how to diff a HashSet of values.
Signature
declare const hashSet: <Value>() => Differ<HashSet<Value>, Differ.HashSet.Patch<Value>>;Constructs a new Differ.
Signature
declare const make: <Value, Patch>(params: {
readonly combine: (first: Patch, second: Patch) => Patch;
readonly diff: (oldValue: Value, newValue: Value) => Patch;
readonly empty: Patch;
readonly patch: (patch: Patch, oldValue: Value) => Value;
}) => Differ<Value, Patch>;readonlyArray
Constructs a differ that knows how to diff a ReadonlyArray of values.
Signature
declare const readonlyArray: <Value, Patch>(
differ: Differ<Value, Patch>,
) => Differ<ReadonlyArray<Value>, Differ.ReadonlyArray.Patch<Value, Patch>>;Models
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, HashMap, and HashSet. In addition, Differvalues can be transformed using the transform operator and combined using the orElseEither and zip operators. This allows creating Differ` values for arbitrarily complex data types compositionally.
Signature
interface Differ<in out Value, in out Patch> extends Pipeable {
readonly [TypeId]: {
readonly _P: Invariant<Patch>;
readonly _V: Invariant<Value>;
};
readonly empty: Patch;
combine(first: Patch, second: Patch): Patch;
diff(oldValue: Value, newValue: Value): Patch;
patch(patch: Patch, oldValue: Value): Value;
}Other
orElseEither
Combines this differ and the specified differ to produce a differ that knows how to diff the sum of their values.
Signature
declare const orElseEither: {
<Value2, Patch2>(
that: Differ<Value2, Patch2>,
): <Value, Patch>(
self: Differ<Value, Patch>,
) => Differ<Either<Value2, Value>, Patch<Value, Value2, Patch, Patch2>>;
<Value, Patch, Value2, Patch2>(
self: Differ<Value, Patch>,
that: Differ<Value2, Patch2>,
): Differ<Either<Value2, Value>, Patch<Value, Value2, Patch, Patch2>>;
};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.
Signature
declare const transform: {
<Value, Value2>(options: {
readonly toNew: (value: Value) => Value2;
readonly toOld: (value: Value2) => Value;
}): <Patch>(self: Differ<Value, Patch>) => Differ<Value2, Patch>;
<Value, Patch, Value2>(
self: Differ<Value, Patch>,
options: {
readonly toNew: (value: Value) => Value2;
readonly toOld: (value: Value2) => Value;
},
): Differ<Value2, Patch>;
};Constructs a differ that just diffs two values by returning a function that sets the value to the new value. This differ does not support combining multiple updates to the value compositionally and should only be used when there is no compositional way to update them.
Signature
declare const update: <A>() => Differ<A, (a: A) => A>;updateWith
A variant of update that allows specifying the function that will be used to combine old values with new values.
Signature
declare const updateWith: <A>(f: (x: A, y: A) => A) => Differ<A, (a: A) => A>;Combines this differ and the specified differ to produce a new differ that knows how to diff the product of their values.
Signature
declare const zip: {
<Value2, Patch2>(
that: Differ<Value2, Patch2>,
): <Value, Patch>(
self: Differ<Value, Patch>,
) => Differ<readonly [Value, Value2], readonly [Patch, Patch2]>;
<Value, Patch, Value2, Patch2>(
self: Differ<Value, Patch>,
that: Differ<Value2, Patch2>,
): Differ<readonly [Value, Value2], readonly [Patch, Patch2]>;
};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.
Signature
declare const combine: {
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, Patch>) => Patch;
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: Patch): Patch;
};Signature
declare const diff: {
<Value>(oldValue: Value, newValue: Value): <Patch>(self: Differ<Value, Patch>) => Patch;
<Value, Patch>(self: Differ<Value, Patch>, oldValue: Value, newValue: Value): Patch;
};An empty patch that describes no changes.
Signature
declare const empty: <Value, Patch>(self: Differ<Value, Patch>) => Patch;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.
Signature
declare const patch: {
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => Value;
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value): Value;
};
Constructs a differ that knows how to diff a
Chunkof values given a differ that knows how to diff the values.