@typed/fx 1.17.4 → 1.18.0

package/src/internal/helpers.ts

@@ -0,0 +1,428 @@
+import { getOption, unsafeGet } from "@typed/context"
+import { Effectable, Exit, TestClock } from "effect"
+import { type Cause, NoSuchElementException } from "effect/Cause"
+import type * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
+import * as Runtime from "effect/Runtime"
+import * as Scope from "effect/Scope"
+import * as SynchronizedRef from "effect/SynchronizedRef"
+import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx"
+import type * as Sink from "../Sink"
+import type { InternalEffect } from "./effect-primitive"
+import { matchEffectPrimitive } from "./effect-primitive"
+
+export function withScopedFork<R, E, A>(
+  f: (fork: ScopedFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+): Effect.Effect<R, E, A> {
+  return Effect.acquireUseRelease(
+    Scope.make(),
+    (scope) => {
+      const fork = makeScopedFork(scope)
+
+      return f((effect) => fork(Effect.interruptible(effect)), scope)
+    },
+    Scope.close
+  )
+}
+
+function makeScopedFork(scope: Scope.Scope): ScopedFork {
+  const forkIn = Effect.forkIn(scope)
+
+  return <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, Fiber.Fiber<E, A>> => {
+    // Convert simple Effects directly into synthetic Fibers to avoid the overhead of constructing a fiber.
+    return matchEffectPrimitive(effect as Effect.Effect<R, E, A> & InternalEffect, {
+      Success: (e): Effect.Effect<R, never, Fiber.Fiber<E, A>> => Effect.succeed(Fiber.succeed(e.i0 as A)),
+      Failure: (e) => Effect.succeed(Fiber.failCause(e.i0 as Cause<E>)),
+      Sync: (e) => Effect.sync(() => Fiber.succeed(e.i0() as A)),
+      Left: (e) => Effect.succeed(Fiber.fail(e.left as E)),
+      Right: (e) => Effect.succeed(Fiber.succeed(e.right as A)),
+      None: () => Effect.succeed(Fiber.fail(new NoSuchElementException() as E)),
+      Some: (e) => Effect.succeed(Fiber.succeed(e.value)),
+      Otherwise: (e) => forkIn(e as Effect.Effect<R, E, A>)
+    })
+  }
+}
+
+export function withSwitchFork<R, E, A>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+) {
+  return withScopedFork((_, scope) =>
+    Effect.flatMap(
+      SynchronizedRef.make<Fiber.Fiber<never, void>>(Fiber.unit),
+      (ref) => runSwitchFork(ref, scope, f)
+    )
+  )
+}
+
+export function runSwitchFork<R, E, A>(
+  ref: SynchronizedRef.SynchronizedRef<Fiber.Fiber<never, void>>,
+  scope: Scope.Scope,
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+) {
+  return Effect.flatMap(
+    f((effect) =>
+      SynchronizedRef.updateAndGetEffect(
+        ref,
+        (fiber) => Effect.flatMap(Fiber.interrupt(fiber), () => Effect.forkIn(effect, scope))
+      ), scope),
+    () => Effect.flatMap(SynchronizedRef.get(ref), Fiber.join)
+  )
+}
+
+export function withExhaustFork<R, E, A>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+) {
+  return withScopedFork((fork, scope) =>
+    Effect.flatMap(
+      SynchronizedRef.make<Fiber.Fiber<never, void> | null>(null),
+      (ref) =>
+        Effect.flatMap(
+          f((effect) =>
+            SynchronizedRef.updateEffect(
+              ref,
+              (fiber) => fiber ? Effect.succeed(fiber) : fork(Effect.onExit(effect, () => Ref.set(ref, null)))
+            ), scope),
+          () => Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+        )
+    )
+  )
+}
+
+export function withExhaustLatestFork<R, E, A>(
+  f: (exhaustLatestFork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+) {
+  return withScopedFork((fork, scope) =>
+    Effect.flatMap(
+      Effect.zip(
+        Ref.make<Fiber.Fiber<never, void> | void>(undefined),
+        Ref.make<Option.Option<Effect.Effect<any, never, void>>>(Option.none())
+      ),
+      ([ref, nextEffect]) => {
+        const reset = Ref.set(ref, undefined)
+
+        // Wait for the current fiber to finish
+        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+
+        // Run the next value that's be saved for replay if it exists
+
+        const runNext: Effect.Effect<any, never, void> = Effect.flatMap(
+          Ref.get(nextEffect),
+          (next) => {
+            if (Option.isNone(next)) {
+              return Effect.unit
+            }
+
+            return Effect.all([
+              // Clear the next A to be replayed
+              Ref.set(nextEffect, Option.none()),
+              // Replay the next A
+              exhaustLatestFork(next.value),
+              // Ensure we don't close the scope until the last fiber completes
+              awaitNext
+            ])
+          }
+        )
+
+        const exhaustLatestFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
+          Effect.flatMap(Ref.get(ref), (currentFiber) =>
+            currentFiber
+              ? Ref.set(nextEffect, Option.some(eff))
+              : Effect.flatMap(fork(Effect.ensuring(eff, Effect.zip(reset, runNext))), (fiber) => Ref.set(ref, fiber)))
+
+        return Effect.zip(f(exhaustLatestFork, scope), awaitNext)
+      }
+    )
+  )
+}
+
+export function withUnboundedFork<R, E, A>(
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+) {
+  return withScopedFork((fork, scope) =>
+    Effect.flatMap(
+      Ref.make<Set<Fiber.Fiber<never, void>>>(new Set()),
+      (ref) =>
+        Effect.flatMap(
+          f((effect) =>
+            fork(effect).pipe(
+              Effect.tap((fiber) => Ref.update(ref, (set) => set.add(fiber))),
+              Effect.tap((fiber) =>
+                Scope.addFinalizer(
+                  scope,
+                  Ref.update(ref, (set) => {
+                    set.delete(fiber)
+                    return set
+                  })
+                )
+              )
+            ), scope),
+          () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.unit)
+        )
+    )
+  )
+}
+
+export function withBoundedFork(capacity: number) {
+  return <R, E, A>(
+    f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
+  ) => {
+    return withScopedFork((fork, scope) =>
+      Effect.flatMap(
+        Ref.make<Set<Fiber.Fiber<never, void>>>(new Set()).pipe(Effect.zip(Effect.makeSemaphore(capacity))),
+        ([ref, semaphore]) =>
+          Effect.flatMap(
+            f((effect) =>
+              fork(semaphore.withPermits(1)(effect)).pipe(
+                Effect.tap((fiber) => Ref.update(ref, (set) => set.add(fiber))),
+                Effect.tap((fiber) =>
+                  Scope.addFinalizer(
+                    scope,
+                    Ref.update(ref, (set) => {
+                      set.delete(fiber)
+                      return set
+                    })
+                  )
+                )
+              ), scope),
+            () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.unit)
+          )
+      )
+    )
+  }
+}
+
+export function withFlattenStrategy(
+  strategy: FlattenStrategy
+): <R, E, A>(f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>) => Effect.Effect<R, E, void> {
+  switch (strategy._tag) {
+    case "Bounded":
+      return withBoundedFork(strategy.capacity)
+    case "Exhaust":
+      return withExhaustFork
+    case "ExhaustLatest":
+      return withExhaustLatestFork
+    case "Switch":
+      return withSwitchFork
+    case "Unbounded":
+      return withUnboundedFork
+  }
+}
+
+export class RingBuffer<A> {
+  constructor(
+    readonly capacity: number
+  ) {
+    this._buffer = Array(this.capacity)
+  }
+
+  private _buffer: Array<A>
+  private _size = 0
+
+  get size() {
+    return this._size
+  }
+
+  push(a: A) {
+    if (this._size < this.capacity) {
+      this._buffer[this._size++] = a
+    } else {
+      this._buffer.shift()
+      this._buffer.push(a)
+    }
+  }
+
+  forEach<R2, E2, B>(
+    f: (a: A, i: number) => Effect.Effect<R2, E2, B>
+  ) {
+    switch (this._size) {
+      case 0:
+        return Effect.unit
+      case 1:
+        return f(this._buffer[0], 0)
+      case 2:
+        return Effect.zipRight(f(this._buffer[0], 0), f(this._buffer[1], 1))
+      case 3:
+        return Effect.zipRight(
+          f(this._buffer[0], 0),
+          Effect.zipRight(f(this._buffer[1], 1), f(this._buffer[2], 2))
+        )
+      default:
+        return Effect.forEach(
+          Array.from({ length: this._size }, (_, i) => this._buffer[i]),
+          f,
+          {
+            discard: true
+          }
+        )
+    }
+  }
+}
+
+export function withEarlyExit<R, E, A, R2, B>(
+  sink: Sink.Sink<E, A>,
+  f: (sink: Sink.WithEarlyExit<E, A>) => Effect.Effect<R2, E, B>
+): Effect.Effect<R | R2, never, void> {
+  return Effect.asyncEffect<never, never, void, R | R2, never, void>((resume) => {
+    const earlyExit: Sink.WithEarlyExit<E, A> = {
+      ...sink,
+      earlyExit: Effect.sync(() => resume(Effect.unit))
+    }
+
+    return Effect.matchCauseEffect(f(earlyExit), {
+      onFailure: sink.onFailure,
+      onSuccess: () => earlyExit.earlyExit
+    })
+  })
+}
+
+export function withBuffers<R, E, A>(size: number, sink: Sink.WithContext<R, E, A>) {
+  return Effect.sync(() => {
+    const buffers: Array<Array<A>> = Array.from({ length: size }, () => [])
+    const finished = new Set<number>()
+    let currentIndex = 0
+
+    const drainBuffer = (index: number): Effect.Effect<R, never, void> => {
+      const effect = Effect.forEach(buffers[index], sink.onSuccess)
+      buffers[index] = []
+
+      return Effect.flatMap(effect, () => finished.has(index) ? onEnd(index) : Effect.unit)
+    }
+
+    const onSuccess = (index: number, value: A) => {
+      if (index === currentIndex) {
+        const buffer = buffers[index]
+
+        if (buffer.length === 0) {
+          return sink.onSuccess(value)
+        } else {
+          buffer.push(value)
+
+          return drainBuffer(index)
+        }
+      } else {
+        buffers[index].push(value)
+
+        return Effect.unit
+      }
+    }
+
+    const onEnd = (index: number) => {
+      finished.add(index)
+
+      if (index === currentIndex && ++currentIndex < size) {
+        return drainBuffer(currentIndex)
+      } else {
+        return Effect.unit
+      }
+    }
+
+    return {
+      onSuccess,
+      onEnd
+    }
+  })
+}
+
+export type ScopedRuntime<R> = {
+  readonly runtime: Runtime.Runtime<R | Scope.Scope>
+  readonly scope: Scope.Scope
+  readonly run: <E, A>(effect: Effect.Effect<R | Scope.Scope, E, A>) => Fiber.RuntimeFiber<E, A>
+  readonly runPromise: <E, A>(effect: Effect.Effect<R | Scope.Scope, E, A>) => Promise<A>
+}
+
+export function scopedRuntime<R>(): Effect.Effect<
+  R | Scope.Scope,
+  never,
+  ScopedRuntime<R>
+> {
+  return Effect.gen(function*(_) {
+    const runtime = yield* _(Effect.runtime<R | Scope.Scope>())
+    const scope = unsafeGet(runtime.context, Scope.Scope)
+    const runFork = Runtime.runFork(runtime)
+
+    const run = <E, A>(effect: Effect.Effect<R | Scope.Scope, E, A>): Fiber.RuntimeFiber<E, A> => {
+      const fiber: Fiber.RuntimeFiber<E, A> = Scope.addFinalizer(
+        scope,
+        Effect.suspend(() => Fiber.interrupt(fiber))
+      ).pipe(
+        Effect.zipRight(effect),
+        runFork
+      )
+
+      return fiber
+    }
+
+    const runPromise = <E, A>(effect: Effect.Effect<R | Scope.Scope, E, A>): Promise<A> =>
+      new Promise((resolve, reject) => {
+        const fiber = run(effect)
+        fiber.addObserver(Exit.match({
+          onFailure: (cause) => reject(Runtime.makeFiberFailure(cause)),
+          onSuccess: resolve
+        }))
+      })
+
+    return {
+      runtime,
+      scope,
+      run,
+      runPromise
+    } as const
+  })
+}
+
+export function awaitScopeClose(scope: Scope.Scope) {
+  return Effect.asyncEffect<never, never, unknown, never, never, void>((cb) =>
+    Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.unit)))
+  )
+}
+
+export class MulticastEffect<R, E, A> extends Effectable.Class<R, E, A> {
+  private _fiber: Fiber.Fiber<E, A> | null = null
+
+  constructor(
+    readonly effect: Effect.Effect<R, E, A>
+  ) {
+    super()
+  }
+
+  commit() {
+    return Effect.suspend(() => {
+      if (this._fiber) {
+        return Fiber.join(this._fiber)
+      } else {
+        return Effect.forkDaemon(this.effect).pipe(
+          Effect.tap((fiber) => Effect.sync(() => this._fiber = fiber)),
+          Effect.flatMap((fiber) =>
+            Effect.ensuring(Fiber.join(fiber), Effect.sync(() => this._fiber === fiber ? this._fiber = null : null))
+          )
+        )
+      }
+    })
+  }
+
+  interrupt() {
+    return Effect.suspend(() => {
+      if (this._fiber) {
+        return Fiber.interruptFork(this._fiber)
+      } else {
+        return Effect.unit
+      }
+    })
+  }
+}
+
+export function adjustTime(input?: Duration.DurationInput) {
+  return Effect.gen(function*(_) {
+    const ctx = yield* _(Effect.context<never>())
+    const testClock = getOption(ctx, TestClock.TestClock)
+
+    if (Option.isSome(testClock)) {
+      yield* _(testClock.value.adjust(input ?? 1))
+    } else if (input) {
+      yield* _(Effect.sleep(input))
+    }
+  })
+}

package/src/internal/keyed.ts

@@ -0,0 +1,281 @@
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import { equals } from "effect/Equal"
+import * as Fiber from "effect/Fiber"
+import * as MutableHashMap from "effect/MutableHashMap"
+import * as Option from "effect/Option"
+import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as Scope from "effect/Scope"
+import type * as Fx from "../Fx"
+import { fromEffect, type RefSubject } from "../RefSubject"
+import { WithContext } from "../Sink"
+import type { Subject } from "../Subject"
+import { from, skipRepeatsWith, withScopedFork } from "./core"
+import { makeHoldSubject } from "./core-subject"
+import { adjustTime } from "./helpers"
+import { run } from "./run"
+
+export function keyed<R, E, A, B, R2, E2, C>(
+  fx: Fx.Fx<R, E, ReadonlyArray<A>>,
+  getKey: (a: A) => B,
+  f: (fx: RefSubject<never, never, A>, key: B) => Fx.FxInput<R2, E2, C>
+): Fx.Fx<R | R2, E | E2, ReadonlyArray<C>> {
+  return withScopedFork(({ fork, scope, sink }) =>
+    Effect.gen(function*($) {
+      const state = createKeyedState<A, B, C>()
+      const emit = emitWhenReady(state, getKey)
+
+      // Let output emit to the sink, it is closes by the surrounding scope
+      yield* $(fork(run(skipRepeatsWith(state.output, ReadonlyArray.getEquivalence(equals)), sink)))
+
+      yield* $(adjustTime(1))
+
+      // Listen to the input and update the state
+      yield* $(
+        run(
+          fx,
+          WithContext(
+            sink.onFailure,
+            (as) =>
+              updateState({
+                state,
+                updated: as,
+                getKey,
+                f: (ref, key) => from(f(ref, key)),
+                fork,
+                scope,
+                emit,
+                error: sink.onFailure
+              })
+          )
+        )
+      )
+
+      yield* $(endAll(state))
+
+      // When the source stream ends we wait for the remaining fibers to end
+      yield* $(Fiber.joinAll(Array.from(state.fibers).map((x) => x[1])))
+    })
+  )
+}
+
+type KeyedState<A, B, C> = {
+  previous: ReadonlyArray<A>
+  previousKeys: ReadonlySet<B>
+
+  readonly subjects: MutableHashMap.MutableHashMap<B, RefSubject<never, never, A>>
+  readonly initialValues: MutableHashMap.MutableHashMap<B, A>
+  readonly fibers: MutableHashMap.MutableHashMap<B, Fiber.RuntimeFiber<never, void>>
+  readonly values: MutableHashMap.MutableHashMap<B, C>
+  readonly output: Subject<never, never, ReadonlyArray<C>>
+}
+
+function createKeyedState<A, B, C>(): KeyedState<A, B, C> {
+  return {
+    previous: [],
+    previousKeys: new Set(),
+    subjects: MutableHashMap.empty(),
+    initialValues: MutableHashMap.empty(),
+    fibers: MutableHashMap.empty(),
+    values: MutableHashMap.empty(),
+    output: makeHoldSubject<never, ReadonlyArray<C>>()
+  }
+}
+
+function updateState<A, B, C, R2, E2, R3>({
+  emit,
+  error,
+  f,
+  fork,
+  getKey,
+  scope,
+  state,
+  updated
+}: {
+  state: KeyedState<A, B, C>
+  updated: ReadonlyArray<A>
+  f: (fx: RefSubject<never, never, A>, key: B) => Fx.Fx<R2, E2, C>
+  fork: Fx.ScopedFork
+  scope: Scope.Scope
+  emit: Effect.Effect<never, never, void>
+  error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
+  getKey: (a: A) => B
+}): Effect.Effect<Exclude<R2 | R3, Scope.Scope>, never, void> {
+  return Effect.provideService(
+    Effect.gen(function*($) {
+      const { added, removed, unchanged } = diffValues(state, updated, getKey)
+
+      // Remove values that are no longer in the stream
+      yield* $(Effect.forEach(removed, (key) => removeValue(state, key), { discard: true }))
+
+      // Update values that are still in the stream
+      yield* $(
+        Effect.forEach(unchanged, (value) => updateValue(state, value, getKey), {
+          concurrency: "unbounded",
+          discard: true
+        })
+      )
+
+      // Add values that are new to the stream
+      yield* $(
+        Effect.forEach(added, (value) => addValue({ state, value, f, fork, emit, error, getKey }), {
+          concurrency: "unbounded",
+          discard: true
+        })
+      )
+
+      // If nothing was added, emit the current values
+      if (added.length === 0) {
+        yield* $(emit)
+      }
+    }),
+    Scope.Scope,
+    scope
+  )
+}
+
+function diffValues<A, B, C>(
+  state: KeyedState<A, B, C>,
+  updated: ReadonlyArray<A>,
+  getKey: (a: A) => B
+) {
+  const added: Array<A> = []
+  const unchanged: Array<A> = []
+  const removed: Array<B> = []
+  const previousKeys = state.previousKeys
+  const keys = new Set<B>(updated.map(getKey))
+
+  for (let i = 0; i < updated.length; ++i) {
+    const value = updated[i]
+    const key = getKey(value)
+
+    if (previousKeys.has(key)) {
+      unchanged.push(value)
+    } else {
+      added.push(value)
+    }
+  }
+
+  previousKeys.forEach((k) => {
+    if (!keys.has(k)) {
+      removed.push(k)
+    }
+  })
+
+  state.previous = updated
+  state.previousKeys = keys
+
+  return {
+    added,
+    unchanged,
+    removed
+  } as const
+}
+
+function removeValue<A, B, C>(state: KeyedState<A, B, C>, key: B) {
+  return Effect.gen(function*($) {
+    const subject = MutableHashMap.get(state.subjects, key)
+
+    if (Option.isSome(subject)) yield* $(Effect.fork(subject.value.interrupt))
+
+    const fiber = MutableHashMap.get(state.fibers, key)
+
+    if (Option.isSome(fiber)) yield* $(Fiber.interruptFork(fiber.value))
+
+    MutableHashMap.remove(state.values, key)
+    MutableHashMap.remove(state.subjects, key)
+    MutableHashMap.remove(state.fibers, key)
+  })
+}
+
+function addValue<A, B, C, R2, E2, R3>({
+  emit,
+  error,
+  f,
+  fork,
+  getKey,
+  state,
+  value
+}: {
+  state: KeyedState<A, B, C>
+  value: A
+  f: (fx: RefSubject<never, never, A>, key: B) => Fx.Fx<R2, E2, C>
+  fork: Fx.ScopedFork
+  emit: Effect.Effect<never, never, void>
+  error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
+  getKey: (a: A) => B
+}) {
+  return Effect.uninterruptible(Effect.suspend(() => {
+    const key = getKey(value)
+
+    // Set the initial value
+    MutableHashMap.set(state.initialValues, key, value)
+
+    return fromEffect<never, never, A>(
+      Effect.sync(() =>
+        // Default to the initial value
+        MutableHashMap.get(state.initialValues, key).pipe(Option.getOrElse(() => value))
+      )
+    ).pipe(
+      Effect.flatMap((subject) =>
+        fork(
+          run(
+            f(subject, key),
+            WithContext(
+              error,
+              (c: C) =>
+                Effect.suspend(() => {
+                  MutableHashMap.set(state.values, key, c)
+                  return emit
+                })
+            )
+          )
+        ).pipe(
+          Effect.tap((fiber) =>
+            Effect.sync(() => {
+              MutableHashMap.set(state.subjects, key, subject)
+              MutableHashMap.set(state.fibers, key, fiber)
+            })
+          )
+        )
+      )
+    )
+  }))
+}
+
+function updateValue<A, B, C>(state: KeyedState<A, B, C>, value: A, getKey: (a: A) => B) {
+  return Effect.gen(function*($) {
+    const key = getKey(value)
+    const subject = MutableHashMap.get(state.subjects, key)
+
+    // External updates reset the initial value
+    MutableHashMap.set(state.initialValues, key, value)
+
+    // Send the current value
+    if (Option.isSome(subject)) {
+      yield* $(subject.value.set(value))
+    }
+  })
+}
+
+function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => B) {
+  return Effect.suspend(() => {
+    // Fast path: if we don't have enough values, don't emit
+    if (MutableHashMap.size(state.values) !== state.previous.length) {
+      return Effect.unit
+    }
+
+    const values = ReadonlyArray.filterMap(state.previous, (value) => MutableHashMap.get(state.values, getKey(value)))
+
+    // When all of the values have resolved at least once, emit the output
+    if (values.length === state.previous.length) {
+      return state.output.onSuccess(values)
+    }
+
+    return Effect.unit
+  })
+}
+
+function endAll<A, B, C>(state: KeyedState<A, B, C>) {
+  return Effect.forEach(state.subjects, ([, subject]) => subject.interrupt, { concurrency: "unbounded" })
+}