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

package/src/internal/differ/orPatch.ts

@@ -0,0 +1,311 @@
+import * as Chunk from "../../Chunk.js"
+import type { Differ } from "../../Differ.js"
+import type { Either } from "../../Either.js"
+import * as E from "../../Either.js"
+import * as Equal from "../../Equal.js"
+import * as Dual from "../../Function.js"
+import { Structural } from "../data.js"
+
+/** @internal */
+export const OrPatchTypeId: Differ.Or.TypeId = Symbol.for("effect/DifferOrPatch") as Differ.Or.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [OrPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+}
+
+/** @internal */
+export interface Empty<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/** @internal */
+export const empty = <Value, Value2, Patch, Patch2>(): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => _empty
+
+/** @internal */
+export interface AndThen<in out Value, in out Value2, in out Patch, Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "AndThen"
+  readonly first: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+  readonly second: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+/** @internal */
+export const makeAndThen = <Value, Value2, Patch, Patch2>(
+  first: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
+  second: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+/** @internal */
+export interface SetLeft<in out Value, in out Value2, in out Patch, Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "SetLeft"
+  readonly value: Value
+}
+
+const SetLeftProto = Object.assign(Object.create(PatchProto), {
+  _tag: "SetLeft"
+})
+
+/** @internal */
+export const makeSetLeft = <Value, Value2, Patch, Patch2>(
+  value: Value
+): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => {
+  const o = Object.create(SetLeftProto)
+  o.value = value
+  return o
+}
+
+/** @internal */
+export interface SetRight<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "SetRight"
+  readonly value: Value2
+}
+
+const SetRightProto = Object.assign(Object.create(PatchProto), {
+  _tag: "SetRight"
+})
+
+/** @internal */
+export const makeSetRight = <Value, Value2, Patch, Patch2>(
+  value: Value2
+): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => {
+  const o = Object.create(SetRightProto)
+  o.value = value
+  return o
+}
+
+/** @internal */
+export interface UpdateLeft<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "UpdateLeft"
+  readonly patch: Patch
+}
+
+const UpdateLeftProto = Object.assign(Object.create(PatchProto), {
+  _tag: "UpdateLeft"
+})
+
+/** @internal */
+export const makeUpdateLeft = <Value, Value2, Patch, Patch2>(
+  patch: Patch
+): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => {
+  const o = Object.create(UpdateLeftProto)
+  o.patch = patch
+  return o
+}
+
+/** @internal */
+export interface UpdateRight<in out Value, in out Value2, in out Patch, in out Patch2>
+  extends Differ.Or.Patch<Value, Value2, Patch, Patch2>
+{
+  readonly _tag: "UpdateRight"
+  readonly patch: Patch2
+}
+
+const UpdateRightProto = Object.assign(Object.create(PatchProto), {
+  _tag: "UpdateRight"
+})
+
+/** @internal */
+export const makeUpdateRight = <Value, Value2, Patch, Patch2>(
+  patch: Patch2
+): Differ.Or.Patch<
+  Value,
+  Value2,
+  Patch,
+  Patch2
+> => {
+  const o = Object.create(UpdateRightProto)
+  o.patch = patch
+  return o
+}
+
+type Instruction =
+  | AndThen<any, any, any, any>
+  | Empty<any, any, any, any>
+  | SetLeft<any, any, any, any>
+  | SetRight<any, any, any, any>
+  | UpdateLeft<any, any, any, any>
+  | UpdateRight<any, any, any, any>
+
+/** @internal */
+export const diff = <Value, Value2, Patch, Patch2>(
+  options: {
+    readonly oldValue: Either<Value2, Value>
+    readonly newValue: Either<Value2, Value>
+    readonly left: Differ<Value, Patch>
+    readonly right: Differ<Value2, Patch2>
+  }
+): Differ.Or.Patch<Value, Value2, Patch, Patch2> => {
+  switch (options.oldValue._tag) {
+    case "Left": {
+      switch (options.newValue._tag) {
+        case "Left": {
+          const valuePatch = options.left.diff(options.oldValue.left, options.newValue.left)
+          if (Equal.equals(valuePatch, options.left.empty)) {
+            return empty()
+          }
+          return makeUpdateLeft(valuePatch)
+        }
+        case "Right": {
+          return makeSetRight(options.newValue.right)
+        }
+      }
+    }
+    case "Right": {
+      switch (options.newValue._tag) {
+        case "Left": {
+          return makeSetLeft(options.newValue.left)
+        }
+        case "Right": {
+          const valuePatch = options.right.diff(options.oldValue.right, options.newValue.right)
+          if (Equal.equals(valuePatch, options.right.empty)) {
+            return empty()
+          }
+          return makeUpdateRight(valuePatch)
+        }
+      }
+    }
+  }
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Value, Value2, Patch, Patch2>(
+    that: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+  ) => (
+    self: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+  ) => Differ.Or.Patch<Value, Value2, Patch, Patch2>,
+  <Value, Value2, Patch, Patch2>(
+    self: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
+    that: Differ.Or.Patch<Value, Value2, Patch, Patch2>
+  ) => Differ.Or.Patch<Value, Value2, Patch, Patch2>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Value, Value2, Patch, Patch2>(
+    options: {
+      readonly oldValue: Either<Value2, Value>
+      readonly left: Differ<Value, Patch>
+      readonly right: Differ<Value2, Patch2>
+    }
+  ) => (self: Differ.Or.Patch<Value, Value2, Patch, Patch2>) => Either<Value2, Value>,
+  <Value, Value2, Patch, Patch2>(
+    self: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
+    options: {
+      readonly oldValue: Either<Value2, Value>
+      readonly left: Differ<Value, Patch>
+      readonly right: Differ<Value2, Patch2>
+    }
+  ) => Either<Value2, Value>
+>(2, <Value, Value2, Patch, Patch2>(
+  self: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
+  { left, oldValue, right }: {
+    oldValue: Either<Value2, Value>
+    left: Differ<Value, Patch>
+    right: Differ<Value2, Patch2>
+  }
+) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
+  let patches: Chunk.Chunk<Differ.Or.Patch<Value, Value2, Patch, Patch2>> = Chunk.of(self)
+  let result = oldValue
+  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 "UpdateLeft": {
+        if (result._tag === "Left") {
+          result = E.left(left.patch(head.patch, result.left))
+        }
+        patches = tail
+        break
+      }
+      case "UpdateRight": {
+        if (result._tag === "Right") {
+          result = E.right(right.patch(head.patch, result.right))
+        }
+        patches = tail
+        break
+      }
+      case "SetLeft": {
+        result = E.left(head.value)
+        patches = tail
+        break
+      }
+      case "SetRight": {
+        result = E.right(head.value)
+        patches = tail
+        break
+      }
+    }
+  }
+  return result
+})

package/src/internal/differ/readonlyArrayPatch.ts

@@ -0,0 +1,210 @@
+import * as Arr from "../../Array.js"
+import type * as Differ from "../../Differ.js"
+import * as Equal from "../../Equal.js"
+import * as Dual from "../../Function.js"
+import * as Data from "../data.js"
+
+/** @internal */
+export const ReadonlyArrayPatchTypeId: Differ.Differ.ReadonlyArray.TypeId = Symbol.for(
+  "effect/DifferReadonlyArrayPatch"
+) as Differ.Differ.ReadonlyArray.TypeId
+
+function variance<A, B>(a: A): B {
+  return a as unknown as B
+}
+
+const PatchProto = {
+  ...Data.Structural.prototype,
+  [ReadonlyArrayPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+}
+
+interface Empty<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Empty"
+}
+
+const EmptyProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Empty"
+})
+
+const _empty = Object.create(EmptyProto)
+
+/**
+ * @internal
+ */
+export const empty = <Value, Patch>(): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => _empty
+
+interface AndThen<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "AndThen"
+  readonly first: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  readonly second: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+}
+
+const AndThenProto = Object.assign(Object.create(PatchProto), {
+  _tag: "AndThen"
+})
+
+const makeAndThen = <Value, Patch>(
+  first: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  second: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(AndThenProto)
+  o.first = first
+  o.second = second
+  return o
+}
+
+interface Append<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Append"
+  readonly values: ReadonlyArray<Value>
+}
+
+const AppendProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Append"
+})
+
+const makeAppend = <Value, Patch>(values: ReadonlyArray<Value>): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(AppendProto)
+  o.values = values
+  return o
+}
+
+interface Slice<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Slice"
+  readonly from: number
+  readonly until: number
+}
+
+const SliceProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Slice"
+})
+
+const makeSlice = <Value, Patch>(from: number, until: number): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(SliceProto)
+  o.from = from
+  o.until = until
+  return o
+}
+
+interface Update<Value, Patch> extends Differ.Differ.ReadonlyArray.Patch<Value, Patch> {
+  readonly _tag: "Update"
+  readonly index: number
+  readonly patch: Patch
+}
+
+const UpdateProto = Object.assign(Object.create(PatchProto), {
+  _tag: "Update"
+})
+
+const makeUpdate = <Value, Patch>(index: number, patch: Patch): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  const o = Object.create(UpdateProto)
+  o.index = index
+  o.patch = patch
+  return o
+}
+
+type Instruction =
+  | Empty<any, any>
+  | AndThen<any, any>
+  | Append<any, any>
+  | Slice<any, any>
+  | Update<any, any>
+
+/** @internal */
+export const diff = <Value, Patch>(
+  options: {
+    readonly oldValue: ReadonlyArray<Value>
+    readonly newValue: ReadonlyArray<Value>
+    readonly differ: Differ.Differ<Value, Patch>
+  }
+): Differ.Differ.ReadonlyArray.Patch<Value, Patch> => {
+  let i = 0
+  let patch = empty<Value, Patch>()
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = options.oldValue[i]!
+    const newElement = options.newValue[i]!
+    const valuePatch = options.differ.diff(oldElement, newElement)
+    if (!Equal.equals(valuePatch, options.differ.empty)) {
+      patch = combine(patch, makeUpdate(i, valuePatch))
+    }
+    i = i + 1
+  }
+  if (i < options.oldValue.length) {
+    patch = combine(patch, makeSlice(0, i))
+  }
+  if (i < options.newValue.length) {
+    patch = combine(patch, makeAppend(Arr.drop(i)(options.newValue)))
+  }
+  return patch
+}
+
+/** @internal */
+export const combine = Dual.dual<
+  <Value, Patch>(
+    that: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => (
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  <Value, Patch>(
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+    that: Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+  ) => Differ.Differ.ReadonlyArray.Patch<Value, Patch>
+>(2, (self, that) => makeAndThen(self, that))
+
+/** @internal */
+export const patch = Dual.dual<
+  <Value, Patch>(
+    oldValue: ReadonlyArray<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => (self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>) => ReadonlyArray<Value>,
+  <Value, Patch>(
+    self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+    oldValue: ReadonlyArray<Value>,
+    differ: Differ.Differ<Value, Patch>
+  ) => ReadonlyArray<Value>
+>(3, <Value, Patch>(
+  self: Differ.Differ.ReadonlyArray.Patch<Value, Patch>,
+  oldValue: ReadonlyArray<Value>,
+  differ: Differ.Differ<Value, Patch>
+) => {
+  if ((self as Instruction)._tag === "Empty") {
+    return oldValue
+  }
+  let readonlyArray = oldValue.slice()
+  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = Arr.of(self)
+  while (Arr.isNonEmptyArray(patches)) {
+    const head: Instruction = Arr.headNonEmpty(patches) as Instruction
+    const tail = Arr.tailNonEmpty(patches)
+    switch (head._tag) {
+      case "Empty": {
+        patches = tail
+        break
+      }
+      case "AndThen": {
+        tail.unshift(head.first, head.second)
+        patches = tail
+        break
+      }
+      case "Append": {
+        for (const value of head.values) {
+          readonlyArray.push(value)
+        }
+        patches = tail
+        break
+      }
+      case "Slice": {
+        readonlyArray = readonlyArray.slice(head.from, head.until)
+        patches = tail
+        break
+      }
+      case "Update": {
+        readonlyArray[head.index] = differ.patch(head.patch, readonlyArray[head.index]!)
+        patches = tail
+        break
+      }
+    }
+  }
+  return readonlyArray
+})