420 lines
14 KiB
TypeScript
420 lines
14 KiB
TypeScript
/**
|
|
* @since 2.0.0
|
|
*/
|
|
import type { Chunk } from "./Chunk.js";
|
|
import type { Context } from "./Context.js";
|
|
import type { Either } from "./Either.js";
|
|
import type { Equal } from "./Equal.js";
|
|
import type { HashMap } from "./HashMap.js";
|
|
import type { HashSet } from "./HashSet.js";
|
|
import type { Pipeable } from "./Pipeable.js";
|
|
import type * as Types from "./Types.js";
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
export declare const TypeId: unique symbol;
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
export type TypeId = typeof TypeId;
|
|
/**
|
|
* 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,
|
|
* `Differ`values 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
export interface Differ<in out Value, in out Patch> extends Pipeable {
|
|
readonly [TypeId]: {
|
|
readonly _V: Types.Invariant<Value>;
|
|
readonly _P: Types.Invariant<Patch>;
|
|
};
|
|
readonly empty: Patch;
|
|
diff(oldValue: Value, newValue: Value): Patch;
|
|
combine(first: Patch, second: Patch): Patch;
|
|
patch(patch: Patch, oldValue: Value): Value;
|
|
}
|
|
declare const ChunkPatchTypeId: unique symbol;
|
|
declare const ContextPatchTypeId: unique symbol;
|
|
declare const HashMapPatchTypeId: unique symbol;
|
|
declare const HashSetPatchTypeId: unique symbol;
|
|
declare const OrPatchTypeId: unique symbol;
|
|
declare const ReadonlyArrayPatchTypeId: unique symbol;
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
export declare namespace Differ {
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace Context {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof ContextPatchTypeId;
|
|
/**
|
|
* A `Patch<Input, Output>` describes an update that transforms a `Env<Input>`
|
|
* to a `Env<Output>` as a data structure. This allows combining updates to
|
|
* different services in the environment in a compositional way.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in Input, out Output> extends Equal {
|
|
readonly [ContextPatchTypeId]: {
|
|
readonly _Input: Types.Contravariant<Input>;
|
|
readonly _Output: Types.Covariant<Output>;
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace Chunk {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof ChunkPatchTypeId;
|
|
/**
|
|
* A patch which describes updates to a chunk of values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in out Value, in out Patch> extends Equal {
|
|
readonly [ChunkPatchTypeId]: {
|
|
readonly _Value: Types.Invariant<Value>;
|
|
readonly _Patch: Types.Invariant<Patch>;
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace HashMap {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof HashMapPatchTypeId;
|
|
/**
|
|
* A patch which describes updates to a map of keys and values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in out Key, in out Value, in out Patch> extends Equal {
|
|
readonly [HashMapPatchTypeId]: {
|
|
readonly _Key: Types.Invariant<Key>;
|
|
readonly _Value: Types.Invariant<Value>;
|
|
readonly _Patch: Types.Invariant<Patch>;
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace HashSet {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof HashSetPatchTypeId;
|
|
/**
|
|
* A patch which describes updates to a set of values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in out Value> extends Equal {
|
|
readonly [HashSetPatchTypeId]: {
|
|
readonly _Value: Types.Invariant<Value>;
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace Or {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof OrPatchTypeId;
|
|
/**
|
|
* A patch which describes updates to either one value or another.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in out Value, in out Value2, in out Patch, in out Patch2> extends Equal {
|
|
readonly [OrPatchTypeId]: {
|
|
readonly _Value: Types.Invariant<Value>;
|
|
readonly _Value2: Types.Invariant<Value2>;
|
|
readonly _Patch: Types.Invariant<Patch>;
|
|
readonly _Patch2: Types.Invariant<Patch2>;
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @since 2.0.0
|
|
*/
|
|
namespace ReadonlyArray {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category symbol
|
|
*/
|
|
type TypeId = typeof ReadonlyArrayPatchTypeId;
|
|
/**
|
|
* A patch which describes updates to a ReadonlyArray of values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category models
|
|
*/
|
|
interface Patch<in out Value, in out Patch> extends Equal {
|
|
readonly [ReadonlyArrayPatchTypeId]: {
|
|
readonly _Value: Types.Invariant<Value>;
|
|
readonly _Patch: Types.Invariant<Patch>;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* An empty patch that describes no changes.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
export declare const empty: <Value, Patch>(self: Differ<Value, Patch>) => Patch;
|
|
/**
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
export declare const diff: {
|
|
/**
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Value>(oldValue: Value, newValue: Value): <Patch>(self: Differ<Value, Patch>) => Patch;
|
|
/**
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Value, Patch>(self: Differ<Value, Patch>, oldValue: Value, newValue: Value): 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
export declare const combine: {
|
|
/**
|
|
* 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, 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. 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
export declare const 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category patch
|
|
*/
|
|
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value): Value;
|
|
};
|
|
/**
|
|
* Constructs a new `Differ`.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export declare const make: <Value, Patch>(params: {
|
|
readonly empty: Patch;
|
|
readonly diff: (oldValue: Value, newValue: Value) => Patch;
|
|
readonly combine: (first: Patch, second: Patch) => Patch;
|
|
readonly patch: (patch: Patch, oldValue: Value) => Value;
|
|
}) => Differ<Value, Patch>;
|
|
/**
|
|
* Constructs a differ that knows how to diff `Env` values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export declare const environment: <A>() => Differ<Context<A>, Differ.Context.Patch<A, A>>;
|
|
/**
|
|
* Constructs a differ that knows how to diff a `Chunk` of values given a
|
|
* differ that knows how to diff the values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export declare const chunk: <Value, Patch>(differ: Differ<Value, Patch>) => Differ<Chunk<Value>, Differ.Chunk.Patch<Value, Patch>>;
|
|
/**
|
|
* Constructs a differ that knows how to diff a `HashMap` of keys and values given
|
|
* a differ that knows how to diff the values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export 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.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export declare const hashSet: <Value>() => Differ<HashSet<Value>, Differ.HashSet.Patch<Value>>;
|
|
/**
|
|
* Combines this differ and the specified differ to produce a differ that
|
|
* knows how to diff the sum of their values.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export declare const orElseEither: {
|
|
/**
|
|
* Combines this differ and the specified differ to produce a differ that
|
|
* knows how to diff the sum of their values.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<Either<Value2, Value>, Differ.Or.Patch<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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<Value, Patch, Value2, Patch2>(self: Differ<Value, Patch>, that: Differ<Value2, Patch2>): Differ<Either<Value2, Value>, Differ.Or.Patch<Value, Value2, Patch, Patch2>>;
|
|
};
|
|
/**
|
|
* Constructs a differ that knows how to diff a `ReadonlyArray` of values.
|
|
*
|
|
* @since 2.0.0
|
|
* @category constructors
|
|
*/
|
|
export declare const readonlyArray: <Value, Patch>(differ: Differ<Value, Patch>) => Differ<ReadonlyArray<Value>, Differ.ReadonlyArray.Patch<Value, 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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export declare const transform: {
|
|
/**
|
|
* 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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<Value, Value2>(options: {
|
|
readonly toNew: (value: Value) => Value2;
|
|
readonly toOld: (value: Value2) => Value;
|
|
}): <Patch>(self: Differ<Value, Patch>) => 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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export declare const update: <A>() => Differ<A, (a: A) => A>;
|
|
/**
|
|
* A variant of `update` that allows specifying the function that will be used
|
|
* to combine old values with new values.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export 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.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
export declare const zip: {
|
|
/**
|
|
* Combines this differ and the specified differ to produce a new differ that
|
|
* knows how to diff the product of their values.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<readonly [Value, Value2], // readonly because invariant
|
|
readonly [Patch, Patch2]>;
|
|
/**
|
|
* Combines this differ and the specified differ to produce a new differ that
|
|
* knows how to diff the product of their values.
|
|
*
|
|
* @since 2.0.0
|
|
*/
|
|
<Value, Patch, Value2, Patch2>(self: Differ<Value, Patch>, that: Differ<Value2, Patch2>): Differ<readonly [Value, Value2], // readonly because invariant
|
|
readonly [Patch, Patch2]>;
|
|
};
|
|
export {};
|
|
//# sourceMappingURL=Differ.d.ts.map
|