@typed/fx 1.20.0 → 1.20.2

package/src/internal/diff.ts

@@ -2,45 +2,55 @@ import type { Equivalence } from "effect"
 import * as Equal from "effect/Equal"
 import { identity } from "effect/Function"
 
-export type DiffResult<A> = ReadonlyArray<Diff<A>>
+export type DiffResult<A, B> = ReadonlyArray<Diff<A, B>>
 
-export type Diff<A> = Add<A> | Remove<A> | Update<A> | Moved<A>
+export type Diff<A, B> = Add<A, B> | Remove<A, B> | Update<A, B> | Moved<A, B>
 
-export interface Add<A> {
+export interface Add<A, B> {
   readonly _tag: "Add"
   readonly index: number
   readonly value: A
+  readonly key: B
 }
 
-export const add = <A>(value: A, index: number): Add<A> => ({ _tag: "Add", index, value })
+export const add = <A, B>(value: A, index: number, key: B): Add<A, B> => ({ _tag: "Add", index, value, key })
 
-export interface Remove<A> {
+export interface Remove<A, B> {
   readonly _tag: "Remove"
   readonly index: number
   readonly value: A
+  readonly key: B
 }
 
-export const remove = <A>(value: A, index: number): Remove<A> => ({ _tag: "Remove", index, value })
+export const remove = <A, B>(value: A, index: number, key: B): Remove<A, B> => ({ _tag: "Remove", index, value, key })
 
-export interface Update<A> {
+export interface Update<A, B> {
   readonly _tag: "Update"
   readonly index: number
   readonly value: A
+  readonly key: B
 }
 
-export const update = <A>(value: A, index: number): Update<A> => ({ _tag: "Update", index, value })
+export const update = <A, B>(value: A, index: number, key: B): Update<A, B> => ({ _tag: "Update", index, value, key })
 
-export interface Moved<A> {
+export interface Moved<A, B> {
   readonly _tag: "Moved"
   readonly index: number
   readonly to: number
   readonly value: A
+  readonly key: B
 }
 
-export const moved = <A>(value: A, from: number, to: number): Moved<A> => ({ _tag: "Moved", index: from, to, value })
+export const moved = <A, B>(value: A, from: number, to: number, key: B): Moved<A, B> => ({
+  _tag: "Moved",
+  index: from,
+  to,
+  value,
+  key
+})
 
-export type DiffOptions<A> = {
-  readonly getKey: (a: A) => PropertyKey
+export type DiffOptions<A, B extends PropertyKey> = {
+  readonly getKey: (a: A) => B
   readonly eq?: Equivalence.Equivalence<A>
   readonly keyMap?: Map<PropertyKey, number>
 }
@@ -48,43 +58,45 @@ export type DiffOptions<A> = {
 export function diff<A extends PropertyKey>(
   oldValue: ReadonlyArray<A>,
   newValue: ReadonlyArray<A>,
-  options?: Omit<DiffOptions<A>, "getKey">
-): DiffResult<A>
+  options?: Omit<DiffOptions<A, A>, "getKey">
+): DiffResult<A, A>
 
-export function diff<A>(
+export function diff<A, B extends PropertyKey>(
   oldValue: ReadonlyArray<A>,
   newValue: ReadonlyArray<A>,
-  options: DiffOptions<A>
-): DiffResult<A>
+  options: DiffOptions<A, B>
+): DiffResult<A, B>
 
-export function diff<A>(
+export function diff<A, B extends PropertyKey>(
   a: ReadonlyArray<A>,
   b: ReadonlyArray<A>,
-  options: Partial<DiffOptions<A>> = {}
-): DiffResult<A> {
+  options: Partial<DiffOptions<A, B>> = {}
+): DiffResult<A, B> {
   const { eq = Equal.equals, getKey = identity as any } = options
-  const diff: Array<Diff<A>> = []
+  const diff: Array<Diff<A, B>> = []
   const oldKeyMap = options.keyMap ?? getKeyMap(a, getKey)
   const keyMap = getKeyMap(b, getKey)
 
   for (let i = 0; i < a.length; ++i) {
     const aValue = a[i]
-    const bIndex = keyMap.get(getKey(aValue))
+    const key = getKey(aValue)
+    const bIndex = keyMap.get(key)
     if (bIndex === undefined) {
-      diff.push(remove(aValue, i))
+      diff.push(remove(aValue, i, key))
     }
   }
 
   for (let i = 0; i < b.length; ++i) {
     const bValue = b[i]
-    const aIndex = oldKeyMap.get(getKey(bValue))
+    const key = getKey(bValue)
+    const aIndex = oldKeyMap.get(key)
     if (aIndex === undefined) {
-      diff.push(add(bValue, i))
+      diff.push(add(bValue, i, key))
     } else {
       if (aIndex !== i) {
-        diff.push(moved(bValue, aIndex, i))
+        diff.push(moved(bValue, aIndex, i, key))
       } else if (!eq(a[aIndex], bValue)) {
-        diff.push(update(bValue, i))
+        diff.push(update(bValue, i, key))
       }
     }
   }
@@ -95,48 +107,50 @@ export function diff<A>(
 export function diffIterator<A extends PropertyKey>(
   oldValue: ReadonlyArray<A>,
   newValue: ReadonlyArray<A>,
-  options?: Omit<DiffOptions<A>, "getKey">
-): Generator<Diff<A>>
+  options?: Omit<DiffOptions<A, A>, "getKey">
+): Generator<Diff<A, A>>
 
-export function diffIterator<A>(
+export function diffIterator<A, B extends PropertyKey>(
   oldValue: ReadonlyArray<A>,
   newValue: ReadonlyArray<A>,
-  options: DiffOptions<A>
-): Generator<Diff<A>>
+  options: DiffOptions<A, B>
+): Generator<Diff<A, B>>
 
-export function* diffIterator<A>(
+export function* diffIterator<A, B extends PropertyKey>(
   a: ReadonlyArray<A>,
   b: ReadonlyArray<A>,
-  options: Partial<DiffOptions<A>> = {}
-): Generator<Diff<A>> {
+  options: Partial<DiffOptions<A, B>> = {}
+): Generator<Diff<A, B>> {
   const { eq = Equal.equals, getKey = identity as any } = options
   const oldKeyMap = options.keyMap ?? getKeyMap(a, getKey)
   const keyMap = getKeyMap(b, getKey)
 
   for (let i = 0; i < a.length; ++i) {
     const aValue = a[i]
-    const bIndex = keyMap.get(getKey(aValue))
+    const key = getKey(aValue)
+    const bIndex = keyMap.get(key)
     if (bIndex === undefined) {
-      yield remove(aValue, i)
+      yield remove(aValue, i, key)
     }
   }
 
   for (let i = 0; i < b.length; ++i) {
     const bValue = b[i]
-    const aIndex = oldKeyMap.get(getKey(bValue))
+    const key = getKey(bValue)
+    const aIndex = oldKeyMap.get(key)
     if (aIndex === undefined) {
-      yield add(bValue, i)
+      yield add(bValue, i, key)
     } else {
       if (aIndex !== i) {
-        yield moved(bValue, aIndex, i)
+        yield moved(bValue, aIndex, i, key)
       } else if (!eq(a[aIndex], bValue)) {
-        yield update(bValue, i)
+        yield update(bValue, i, key)
       }
     }
   }
 }
 
-function sortDiff<A>(a: Diff<A>, b: Diff<A>): number {
+function sortDiff<A, B>(a: Diff<A, B>, b: Diff<A, B>): number {
   if (a._tag === "Remove" && b._tag !== "Remove") return -1
   if (b._tag === "Remove") return 1
   return a.index - b.index

package/src/internal/helpers.ts

@@ -85,7 +85,7 @@ export function withScopedFork<R, E, A>(
 
 export function makeForkInScope(scope: Scope.Scope) {
   return <R, E, A>(effect: Effect.Effect<R, E, A>) =>
-    matchEffectPrimitive<R, E, A, Effect.Effect<Exclude<R, Scope.Scope>, never, Fiber.Fiber<E, A>>>(effect, {
+    matchEffectPrimitive<R, E, A, Effect.Effect<R, never, Fiber.Fiber<E, A>>>(effect, {
       Success: (a) => Effect.succeed(Fiber.succeed(a)),
       Failure: (cause) => Effect.succeed(Fiber.failCause(cause)),
       Sync: (f) =>
@@ -100,7 +100,7 @@ export function makeForkInScope(scope: Scope.Scope) {
       Right: (a) => Effect.succeed(Fiber.succeed(a)),
       Some: (a) => Effect.succeed(Fiber.succeed(a)),
       None: (e) => Effect.succeed(Fiber.fail(e)),
-      Otherwise: (eff) => Effect.forkIn(Effect.provideService(eff, Scope.Scope, scope), scope)
+      Otherwise: (eff) => Effect.forkIn(eff, scope)
     })
 }
 
@@ -454,6 +454,11 @@ export class RingBuffer<A> {
         )
     }
   }
+
+  clear() {
+    this._buffer = Array(this.capacity)
+    this._size = 0
+  }
 }
 
 export function awaitScopeClose(scope: Scope.Scope) {

package/src/internal/keyed.ts

@@ -1,5 +1,5 @@
 import type { FiberId } from "effect"
-import { Context, Effect, ExecutionStrategy, Option, Scope } from "effect"
+import { Context, Effect, ExecutionStrategy, Exit, Option, Scope } from "effect"
 import type { Fx, KeyedOptions } from "../Fx.js"
 import * as RefSubject from "../RefSubject.js"
 import * as Sink from "../Sink.js"
@@ -40,14 +40,14 @@ class Keyed<R, E, A, B extends PropertyKey, R2, E2, C> extends FxBase<R | R2 | S
 interface KeyedState<A, B extends PropertyKey, C> {
   readonly entries: Map<B, KeyedEntry<A, C>>
   readonly indices: Map<number, B>
-  previousKeys: ReadonlyArray<B>
+  previousValues: ReadonlyArray<A>
 }
 
 function emptyKeyedState<A, B extends PropertyKey, C>(): KeyedState<A, B, C> {
   return {
     entries: new Map(),
     indices: new Map(),
-    previousKeys: []
+    previousValues: []
   }
 }
 
@@ -65,15 +65,14 @@ function runKeyed<R, E, A, B extends PropertyKey, R2, E2, C, R3>(
 
       function diffAndPatch(values: ReadonlyArray<A>) {
         return Effect.gen(function*(_) {
-          const previous = state.previousKeys
-          const keys = values.map(options.getKey)
-          state.previousKeys = keys
+          const previous = state.previousValues
+          state.previousValues = values
 
           let added = false
           let done = false
           let scheduled = false
 
-          for (const patch of diffIterator(previous, keys)) {
+          for (const patch of diffIterator(previous, values, options)) {
             if (patch._tag === "Remove") {
               yield* _(removeValue(state, patch))
             } else if (patch._tag === "Add") {
@@ -133,11 +132,11 @@ class KeyedEntry<A, C> {
 }
 
 function getReadyIndices<A, B extends PropertyKey, C>(
-  { entries, indices, previousKeys }: KeyedState<A, B, C>
+  { entries, indices, previousValues }: KeyedState<A, B, C>
 ): ReadonlyArray<C> {
   const output: Array<C> = []
 
-  for (let i = 0; i < previousKeys.length; ++i) {
+  for (let i = 0; i < previousValues.length; ++i) {
     const key = indices.get(i)
 
     if (key === undefined) break
@@ -156,7 +155,7 @@ function getReadyIndices<A, B extends PropertyKey, C>(
 function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
   { entries, indices }: KeyedState<A, B, C>,
   values: ReadonlyArray<A>,
-  patch: Add<B>,
+  patch: Add<A, B>,
   id: FiberId.FiberId,
   parentScope: Scope.Scope,
   options: KeyedOptions<A, B, R2, E2, C>,
@@ -172,23 +171,22 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
       scope: childScope,
       id
     }))
+    yield* _(Scope.addFinalizer(childScope, ref.interrupt))
 
     const entry = new KeyedEntry<A, C>(
       value,
       patch.index,
       Option.none(),
       ref,
-      ref.interrupt
+      Scope.close(childScope, Exit.interrupt(id))
     )
 
-    entries.set(patch.value, entry)
-    indices.set(patch.index, patch.value)
-
-    yield* _(Scope.addFinalizer(childScope, ref.interrupt))
+    entries.set(patch.key, entry)
+    indices.set(patch.index, patch.key)
 
     yield* _(
       Effect.forkIn(
-        options.onValue(ref, patch.value).run(Sink.make(
+        options.onValue(ref, patch.key).run(Sink.make(
           (cause) => sink.onFailure(cause),
           (output) => {
             entry.output = Option.some(output)
@@ -202,9 +200,9 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
   })
 }
 
-function removeValue<A, B extends PropertyKey, C>({ entries, indices }: KeyedState<A, B, C>, patch: Remove<B>) {
-  const interrupt = entries.get(patch.value)!.interrupt
-  entries.delete(patch.value)
+function removeValue<A, B extends PropertyKey, C>({ entries, indices }: KeyedState<A, B, C>, patch: Remove<A, B>) {
+  const interrupt = entries.get(patch.key)!.interrupt
+  entries.delete(patch.key)
   indices.delete(patch.index)
   return interrupt
 }
@@ -212,9 +210,9 @@ function removeValue<A, B extends PropertyKey, C>({ entries, indices }: KeyedSta
 function updateValue<A, B extends PropertyKey, C>(
   { entries, indices }: KeyedState<A, B, C>,
   values: ReadonlyArray<A>,
-  patch: Update<B> | Moved<B>
+  patch: Update<A, B> | Moved<A, B>
 ) {
-  const key = patch.value
+  const key = patch.key
   const entry = entries.get(key)!
 
   if (patch._tag === "Moved") {

package/src/internal/share.ts

@@ -57,7 +57,12 @@ export class Share<R, E, A, R2> extends FxBase<R | R2 | Scope.Scope, E, A> {
     return Effect.suspend(() => {
       if (this._RefCount.increment() === 1) {
         return this.i0.run(this.i1).pipe(
-          Effect.onExit(() => Effect.sync(() => MutableRef.set(this._FxFiber, Option.none()))),
+          Effect.onExit(() =>
+            Effect.suspend(() => {
+              MutableRef.set(this._FxFiber, Option.none())
+              return this.i1.interrupt
+            })
+          ),
           Effect.interruptible,
           Effect.forkDaemon,
           Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this._FxFiber, Option.some(fiber)))),