@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/differ/contextPatch.ts

@@ -0,0 +1,232 @@
+import * as Chunk from "../../Chunk.js"
+import type { Context } from "../../Context.js"
+import type { Differ } from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import * as Dual from "../../Function.js"
+import { makeContext } from "../context.js"
+import { Structural } from "../data.js"
+
+/** @internal */
+export const ContextPatchTypeId: Differ.Context.TypeId = Symbol.for(
+  "effect/DifferContextPatch"
+) as Differ.Context.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [ContextPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+}
+
+interface Empty<Input, Output> extends Differ.Context.Patch<Input, Output> {
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/**
+ * @internal
+ */
+export const empty = <Input, Output>(): Differ.Context.Patch<Input, Output> => _empty
+
+/** @internal */
+export interface AndThen<in out Input, in out Output, in out Output2> extends Differ.Context.Patch<Input, Output2> {
+  readonly _tag: "AndThen"
+  readonly first: Differ.Context.Patch<Input, Output>
+  readonly second: Differ.Context.Patch<Output, Output2>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+const makeAndThen = <Input, Output, Output2>(
+  first: Differ.Context.Patch<Input, Output>,
+  second: Differ.Context.Patch<Output, Output2>
+): Differ.Context.Patch<Input, Output2> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+/** @internal */
+export interface AddService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env, Env | I> {
+  readonly _tag: "AddService"
+  readonly key: string
+  readonly service: T
+}
+
+const AddServiceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AddService"
+})
+
+const makeAddService = <Env, I, T>(
+  key: string,
+  service: T
+): Differ.Context.Patch<Env, Env | I> => {
+  const o = Object.create(AddServiceProto)
+  o.key = key
+  o.service = service
+  return o
+}
+
+/** @internal */
+export interface RemoveService<in out Env, in out I> extends Differ.Context.Patch<Env, Exclude<Env, I>> {
+  readonly _tag: "RemoveService"
+  readonly key: string
+}
+
+const RemoveServiceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "RemoveService"
+})
+
+const makeRemoveService = <Env, I>(
+  key: string
+): Differ.Context.Patch<Env, Exclude<Env, I>> => {
+  const o = Object.create(RemoveServiceProto)
+  o.key = key
+  return o
+}
+
+/** @internal */
+export interface UpdateService<in out Env, in out T, in out I> extends Differ.Context.Patch<Env | I, Env | I> {
+  readonly _tag: "UpdateService"
+  readonly key: string
+  update(service: T): T
+}
+
+const UpdateServiceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "UpdateService"
+})
+
+const makeUpdateService = <Env, I, T>(
+  key: string,
+  update: (service: T) => T
+): Differ.Context.Patch<Env | I, Env | I> => {
+  const o = Object.create(UpdateServiceProto)
+  o.key = key
+  o.update = update
+  return o
+}
+
+type Instruction =
+  | Empty<any, any>
+  | AndThen<any, any, any>
+  | AddService<any, any, any>
+  | RemoveService<any, any>
+  | UpdateService<any, any, any>
+
+/** @internal */
+export const diff = <Input, Output>(
+  oldValue: Context<Input>,
+  newValue: Context<Output>
+): Differ.Context.Patch<Input, Output> => {
+  const missingServices = new Map(oldValue.unsafeMap)
+  let patch = empty<any, any>()
+  for (const [tag, newService] of newValue.unsafeMap.entries()) {
+    if (missingServices.has(tag)) {
+      const old = missingServices.get(tag)!
+      missingServices.delete(tag)
+      if (!Equal.equals(old, newService)) {
+        patch = combine(makeUpdateService(tag, () => newService))(patch)
+      }
+    } else {
+      missingServices.delete(tag)
+      patch = combine(makeAddService(tag, newService))(patch)
+    }
+  }
+  for (const [tag] of missingServices.entries()) {
+    patch = combine(makeRemoveService(tag))(patch)
+  }
+  return patch
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Output, Output2>(
+    that: Differ.Context.Patch<Output, Output2>
+  ) => <Input>(
+    self: Differ.Context.Patch<Input, Output>
+  ) => Differ.Context.Patch<Input, Output2>,
+  <Input, Output, Output2>(
+    self: Differ.Context.Patch<Input, Output>,
+    that: Differ.Context.Patch<Output, Output2>
+  ) => Differ.Context.Patch<Input, Output2>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Input>(
+    context: Context<Input>
+  ) => <Output>(
+    self: Differ.Context.Patch<Input, Output>
+  ) => Context<Output>,
+  <Input, Output>(
+    self: Differ.Context.Patch<Input, Output>,
+    context: Context<Input>
+  ) => Context<Output>
+>(2, <Input, Output>(self: Differ.Context.Patch<Input, Output>, context: Context<Input>) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return context as any
+  }
+  let wasServiceUpdated = false
+  let patches: Chunk.Chunk<Differ.Context.Patch<unknown, unknown>> = Chunk.of(
+    self as Differ.Context.Patch<unknown, unknown>
+  )
+  const updatedContext: Map<string, unknown> = new Map(context.unsafeMap)
+  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 "AddService": {
+        updatedContext.set(head.key, head.service)
+        patches = tail
+        break
+      }
+      case "AndThen": {
+        patches = Chunk.prepend(Chunk.prepend(tail, head.second), head.first)
+        break
+      }
+      case "RemoveService": {
+        updatedContext.delete(head.key)
+        patches = tail
+        break
+      }
+      case "UpdateService": {
+        updatedContext.set(head.key, head.update(updatedContext.get(head.key)))
+        wasServiceUpdated = true
+        patches = tail
+        break
+      }
+    }
+  }
+  if (!wasServiceUpdated) {
+    return makeContext(updatedContext) as Context<Output>
+  }
+  const map = new Map()
+  for (const [tag] of context.unsafeMap) {
+    if (updatedContext.has(tag)) {
+      map.set(tag, updatedContext.get(tag))
+      updatedContext.delete(tag)
+    }
+  }
+  for (const [tag, s] of updatedContext) {
+    map.set(tag, s)
+  }
+  return makeContext(map) as Context<Output>
+})

package/src/internal/differ/hashMapPatch.ts

@@ -0,0 +1,220 @@
+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
+})

package/src/internal/differ/hashSetPatch.ts

@@ -0,0 +1,176 @@
+import * as Chunk from "../../Chunk.js"
+import type { Differ } from "../../Differ.js"
+import * as Dual from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
+import { Structural } from "../data.js"
+
+/** @internal */
+export const HashSetPatchTypeId: Differ.HashSet.TypeId = Symbol.for(
+  "effect/DifferHashSetPatch"
+) as Differ.HashSet.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [HashSetPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+}
+
+interface Empty<Value> extends Differ.HashSet.Patch<Value> {
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/** @internal */
+export const empty = <Value>(): Differ.HashSet.Patch<Value> => _empty
+
+interface AndThen<Value> extends Differ.HashSet.Patch<Value> {
+  readonly _tag: "AndThen"
+  readonly first: Differ.HashSet.Patch<Value>
+  readonly second: Differ.HashSet.Patch<Value>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+/** @internal */
+export const makeAndThen = <Value>(
+  first: Differ.HashSet.Patch<Value>,
+  second: Differ.HashSet.Patch<Value>
+): Differ.HashSet.Patch<Value> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+interface Add<Value> extends Differ.HashSet.Patch<Value> {
+  readonly _tag: "Add"
+  readonly value: Value
+}
+
+const AddProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Add"
+})
+
+/** @internal */
+export const makeAdd = <Value>(
+  value: Value
+): Differ.HashSet.Patch<Value> => {
+  const o = Object.create(AddProto)
+  o.value = value
+  return o
+}
+
+interface Remove<Value> extends Differ.HashSet.Patch<Value> {
+  readonly _tag: "Remove"
+  readonly value: Value
+}
+
+const RemoveProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Remove"
+})
+
+/** @internal */
+export const makeRemove = <Value>(
+  value: Value
+): Differ.HashSet.Patch<Value> => {
+  const o = Object.create(RemoveProto)
+  o.value = value
+  return o
+}
+
+type Instruction =
+  | Add<any>
+  | AndThen<any>
+  | Empty<any>
+  | Remove<any>
+
+/** @internal */
+export const diff = <Value>(
+  oldValue: HashSet.HashSet<Value>,
+  newValue: HashSet.HashSet<Value>
+): Differ.HashSet.Patch<Value> => {
+  const [removed, patch] = HashSet.reduce(
+    [oldValue, empty<Value>()] as const,
+    ([set, patch], value: Value) => {
+      if (HashSet.has(value)(set)) {
+        return [HashSet.remove(value)(set), patch] as const
+      }
+      return [set, combine(makeAdd(value))(patch)] as const
+    }
+  )(newValue)
+  return HashSet.reduce(patch, (patch, value: Value) => combine(makeRemove(value))(patch))(removed)
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Value>(
+    that: Differ.HashSet.Patch<Value>
+  ) => (
+    self: Differ.HashSet.Patch<Value>
+  ) => Differ.HashSet.Patch<Value>,
+  <Value>(
+    self: Differ.HashSet.Patch<Value>,
+    that: Differ.HashSet.Patch<Value>
+  ) => Differ.HashSet.Patch<Value>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Value>(
+    oldValue: HashSet.HashSet<Value>
+  ) => (
+    self: Differ.HashSet.Patch<Value>
+  ) => HashSet.HashSet<Value>,
+  <Value>(
+    self: Differ.HashSet.Patch<Value>,
+    oldValue: HashSet.HashSet<Value>
+  ) => HashSet.HashSet<Value>
+>(2, <Value>(
+  self: Differ.HashSet.Patch<Value>,
+  oldValue: HashSet.HashSet<Value>
+) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
+  let set = oldValue
+  let patches: Chunk.Chunk<Differ.HashSet.Patch<Value>> = 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": {
+        set = HashSet.add(head.value)(set)
+        patches = tail
+        break
+      }
+      case "Remove": {
+        set = HashSet.remove(head.value)(set)
+        patches = tail
+      }
+    }
+  }
+  return set
+})