@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/differ/contextPatch.ts

@@ -1,232 +0,0 @@
-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

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

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