Lorem Ipsum MCP Server

import * as Chunk from "../../Chunk.js" import type * as Differ from "../../Differ.js" import * as Equal from "../../Equal.js" import * as Dual from "../../Function.js" import * as HashMap from "../../HashMap.js" import { Structural } from "../data.js" /** @internal */ export const HashMapPatchTypeId: Differ.Differ.HashMap.TypeId = Symbol.for( "effect/DifferHashMapPatch" ) as Differ.Differ.HashMap.TypeId function variance<A, B>(a: A): B { return a as unknown as B } /** @internal */ const PatchProto = { ...Structural.prototype, [HashMapPatchTypeId]: { _Value: variance, _Key: variance, _Patch: variance } } interface Empty<Key, Value, Patch> extends Differ.Differ.HashMap.Patch<Key, Value, Patch> { readonly _tag: "Empty" } const EmptyProto = Object.assign(Object.create(PatchProto), { _tag: "Empty" }) const _empty = Object.create(EmptyProto) /** @internal */ export const empty = <Key, Value, Patch>(): Differ.Differ.HashMap.Patch<Key, Value, Patch> => _empty interface AndThen<Key, Value, Patch> extends Differ.Differ.HashMap.Patch<Key, Value, Patch> { readonly _tag: "AndThen" readonly first: Differ.Differ.HashMap.Patch<Key, Value, Patch> readonly second: Differ.Differ.HashMap.Patch<Key, Value, Patch> } const AndThenProto = Object.assign(Object.create(PatchProto), { _tag: "AndThen" }) const makeAndThen = <Key, Value, Patch>( first: Differ.Differ.HashMap.Patch<Key, Value, Patch>, second: Differ.Differ.HashMap.Patch<Key, Value, Patch> ): Differ.Differ.HashMap.Patch<Key, Value, Patch> => { const o = Object.create(AndThenProto) o.first = first o.second = second return o } interface Add<Key, Value, Patch> extends Differ.Differ.HashMap.Patch<Key, Value, Patch> { readonly _tag: "Add" readonly key: Key readonly value: Value } const AddProto = Object.assign(Object.create(PatchProto), { _tag: "Add" }) const makeAdd = <Key, Value, Patch>(key: Key, value: Value): Differ.Differ.HashMap.Patch<Key, Value, Patch> => { const o = Object.create(AddProto) o.key = key o.value = value return o } interface Remove<Key, Value, Patch> extends Differ.Differ.HashMap.Patch<Key, Value, Patch> { readonly _tag: "Remove" readonly key: Key } const RemoveProto = Object.assign(Object.create(PatchProto), { _tag: "Remove" }) const makeRemove = <Key, Value, Patch>(key: Key): Differ.Differ.HashMap.Patch<Key, Value, Patch> => { const o = Object.create(RemoveProto) o.key = key return o } interface Update<Key, Value, Patch> extends Differ.Differ.HashMap.Patch<Key, Value, Patch> { readonly _tag: "Update" readonly key: Key readonly patch: Patch } const UpdateProto = Object.assign(Object.create(PatchProto), { _tag: "Update" }) const makeUpdate = <Key, Value, Patch>(key: Key, patch: Patch): Differ.Differ.HashMap.Patch<Key, Value, Patch> => { const o = Object.create(UpdateProto) o.key = key o.patch = patch return o } type Instruction = | Add<any, any, any> | Remove<any, any, any> | Update<any, any, any> | Empty<any, any, any> | AndThen<any, any, any> /** @internal */ export const diff = <Key, Value, Patch>( options: { readonly oldValue: HashMap.HashMap<Key, Value> readonly newValue: HashMap.HashMap<Key, Value> readonly differ: Differ.Differ<Value, Patch> } ): Differ.Differ.HashMap.Patch<Key, Value, Patch> => { const [removed, patch] = HashMap.reduce( [options.oldValue, empty<Key, Value, Patch>()] as const, ([map, patch], newValue: Value, key: Key) => { const option = HashMap.get(key)(map) switch (option._tag) { case "Some": { const valuePatch = options.differ.diff(option.value, newValue) if (Equal.equals(valuePatch, options.differ.empty)) { return [HashMap.remove(key)(map), patch] as const } return [ HashMap.remove(key)(map), combine<Key, Value, Patch>(makeUpdate(key, valuePatch))(patch) ] as const } case "None": { return [map, combine<Key, Value, Patch>(makeAdd(key, newValue))(patch)] as const } } } )(options.newValue) return HashMap.reduce( patch, (patch, _, key: Key) => combine<Key, Value, Patch>(makeRemove(key))(patch) )(removed) } /** @internal */ export const combine = Dual.dual< <Key, Value, Patch>( that: Differ.Differ.HashMap.Patch<Key, Value, Patch> ) => ( self: Differ.Differ.HashMap.Patch<Key, Value, Patch> ) => Differ.Differ.HashMap.Patch<Key, Value, Patch>, <Key, Value, Patch>( self: Differ.Differ.HashMap.Patch<Key, Value, Patch>, that: Differ.Differ.HashMap.Patch<Key, Value, Patch> ) => Differ.Differ.HashMap.Patch<Key, Value, Patch> >(2, (self, that) => makeAndThen(self, that)) /** @internal */ export const patch = Dual.dual< <Key, Value, Patch>( oldValue: HashMap.HashMap<Key, Value>, differ: Differ.Differ<Value, Patch> ) => ( self: Differ.Differ.HashMap.Patch<Key, Value, Patch> ) => HashMap.HashMap<Key, Value>, <Key, Value, Patch>( self: Differ.Differ.HashMap.Patch<Key, Value, Patch>, oldValue: HashMap.HashMap<Key, Value>, differ: Differ.Differ<Value, Patch> ) => HashMap.HashMap<Key, Value> >(3, <Key, Value, Patch>( self: Differ.Differ.HashMap.Patch<Key, Value, Patch>, oldValue: HashMap.HashMap<Key, Value>, differ: Differ.Differ<Value, Patch> ) => { if ((self as Instruction)._tag === "Empty") { return oldValue } let map = oldValue let patches: Chunk.Chunk<Differ.Differ.HashMap.Patch<Key, Value, Patch>> = Chunk.of(self) while (Chunk.isNonEmpty(patches)) { const head: Instruction = Chunk.headNonEmpty(patches) as Instruction const tail = Chunk.tailNonEmpty(patches) switch (head._tag) { case "Empty": { patches = tail break } case "AndThen": { patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail)) break } case "Add": { map = HashMap.set(head.key, head.value)(map) patches = tail break } case "Remove": { map = HashMap.remove(head.key)(map) patches = tail break } case "Update": { const option = HashMap.get(head.key)(map) if (option._tag === "Some") { map = HashMap.set(head.key, differ.patch(head.patch, option.value))(map) } patches = tail break } } } return map })