@typed/fx 1.17.4 → 1.18.0

package/src/keyed.test.ts

@@ -1,47 +0,0 @@
-import { millis } from '@effect/data/Duration'
-import * as Effect from '@effect/io/Effect'
-import { describe, it, expect } from 'vitest'
-
-import { at } from './at.js'
-import { keyed } from './keyed.js'
-import { mergeAll } from './mergeAll.js'
-import { succeed } from './succeed.js'
-import { toReadonlyArray } from './toReadonlyArray.js'
-
-describe(__filename, () => {
-  describe(keyed.name, () => {
-    it('allow keeping a reference to a running stream', async () => {
-      const test = Effect.gen(function* ($) {
-        const inputs = mergeAll(
-          succeed([1, 2, 3]),
-          at([3, 2, 1], millis(200)),
-          at([4, 5, 6, 1], millis(400)),
-        )
-
-        let calls = 0
-
-        const fx = keyed(
-          inputs,
-          (source) => {
-            calls++
-            return source
-          },
-          (x) => x,
-        )
-
-        const events = yield* $(toReadonlyArray(fx))
-
-        expect(events).toEqual([
-          [1, 2, 3],
-          [3, 2, 1],
-          [4, 5, 6, 1],
-        ])
-
-        // Should only be called once for each unique value
-        expect(calls).toEqual(6)
-      })
-
-      await Effect.runPromise(Effect.scoped(test))
-    })
-  })
-})

package/src/keyed.ts

@@ -1,278 +0,0 @@
-import * as MutableHashMap from '@effect/data/MutableHashMap'
-import * as Option from '@effect/data/Option'
-import * as ReadonlyArray from '@effect/data/ReadonlyArray'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Scope from '@effect/io/Scope'
-
-import { Fx, Sink } from './Fx.js'
-import { RefSubject, makeRef } from './RefSubject.js'
-import { Subject, makeHoldSubject } from './Subject.js'
-import { ScopedFork, withScopedFork } from './helpers.js'
-import { skipRepeats } from './skipRepeats.js'
-
-export function keyed<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, readonly A[]>,
-  f: (fx: RefSubject<never, A>, key: C) => Fx<R2, E2, B>,
-  getKey: (a: A) => C,
-): Fx<R | R2, E | E2, readonly B[]> {
-  return Fx(<R3>(sink: Sink<R3, E | E2, readonly B[]>) =>
-    withScopedFork((fork, scope) =>
-      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(skipRepeats(state.output).run(sink)))
-
-        // Listen to the input and update the state
-        yield* $(
-          fx.run(
-            Sink(
-              (as) =>
-                updateState({
-                  state,
-                  updated: as,
-                  getKey,
-                  f,
-                  fork,
-                  scope,
-                  emit,
-                  error: sink.error,
-                }),
-              sink.error,
-            ),
-          ),
-        )
-
-        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: readonly A[]
-  previousKeys: ReadonlySet<C>
-
-  readonly subjects: MutableHashMap.MutableHashMap<C, RefSubject<never, A>>
-  readonly initialValues: MutableHashMap.MutableHashMap<C, A>
-  readonly fibers: MutableHashMap.MutableHashMap<C, Fiber.RuntimeFiber<never, void>>
-  readonly values: MutableHashMap.MutableHashMap<C, B>
-  readonly output: Subject<never, readonly B[]>
-}
-
-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, readonly B[]>(),
-  }
-}
-
-function updateState<A, B, C, R2, E2, R3>({
-  state,
-  updated,
-  f,
-  fork,
-  scope,
-  emit,
-  error,
-  getKey,
-}: {
-  state: KeyedState<A, B, C>
-  updated: readonly A[]
-  f: (fx: RefSubject<never, A>, key: C) => Fx<R2, E2, B>
-  fork: ScopedFork
-  scope: Scope.Scope
-  emit: Effect.Effect<never, never, void>
-  error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
-  getKey: (a: A) => C
-}) {
-  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) => C,
-) {
-  const added: A[] = []
-  const unchanged: A[] = []
-  const removed: C[] = []
-  const previousKeys = state.previousKeys
-  const keys = new Set<C>(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: C) {
-  return Effect.gen(function* ($) {
-    const subject = MutableHashMap.get(state.subjects, key)
-
-    if (Option.isSome(subject)) yield* $(Effect.fork(subject.value.end()))
-
-    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>({
-  state,
-  value,
-  f,
-  fork,
-  emit,
-  error,
-  getKey,
-}: {
-  state: KeyedState<A, B, C>
-  value: A
-  f: (fx: RefSubject<never, A>, key: C) => Fx<R2, E2, B>
-  fork: ScopedFork
-  emit: Effect.Effect<never, never, void>
-  error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
-  getKey: (a: A) => C
-}) {
-  return Effect.gen(function* ($) {
-    const key = getKey(value)
-
-    // Set the initial value
-    MutableHashMap.set(state.initialValues, key, value)
-
-    const subject = yield* $(
-      makeRef<never, never, A>(
-        Effect.sync(() =>
-          // Default to the initial value
-          MutableHashMap.get(state.initialValues, key).pipe(Option.getOrElse(() => value)),
-        ),
-      ),
-    )
-    const fx = f(subject, key)
-    const fiber = yield* $(
-      fork(
-        fx.run(
-          Sink(
-            (b: B) =>
-              Effect.suspend(() => {
-                MutableHashMap.set(state.values, key, b)
-                return emit
-              }),
-            error,
-          ),
-        ),
-      ),
-    )
-
-    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) => C) {
-  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) => C) {
-  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.event(values)
-    }
-
-    return Effect.unit
-  })
-}
-
-function endAll<A, B, C>(state: KeyedState<A, B, C>) {
-  return Effect.forEach(state.subjects, ([, subject]) => subject.end(), {
-    concurrency: 'unbounded',
-  })
-}

package/src/map.test.ts

@@ -1,17 +0,0 @@
-import { describe } from 'vitest'
-
-import { fromArray } from './fromArray.js'
-import { map } from './map.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(map.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'transforms the values of the stream',
-      map(fromArray(array), (x) => x + 1),
-      array.map((x) => x + 1),
-    )
-  })
-})

package/src/map.ts

@@ -1,11 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> {
-  return Fx((sink) => fx.run(Sink((a) => Effect.suspend(() => sink.event(f(a))), sink.error)))
-}
-
-export function as<R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, B> {
-  return map(fx, () => value)
-}

package/src/mapEffect.ts

@@ -1,20 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-/**
- * Synchronously map the result to an Effect.
- */
-export function mapEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E | E2, B> {
-  return Fx((sink) =>
-    fx.run(
-      Sink(
-        (a) => Effect.matchCauseEffect(f(a), { onFailure: sink.error, onSuccess: sink.event }),
-        sink.error,
-      ),
-    ),
-  )
-}

package/src/mergeAll.test.ts

@@ -1,17 +0,0 @@
-import { describe } from 'vitest'
-
-import { fromArray } from './fromArray.js'
-import { mergeAll } from './mergeAll.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(mergeAll.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'merges multiple streams together',
-      mergeAll(fromArray(array), fromArray(array)),
-      [...array, ...array],
-    )
-  })
-})

package/src/mergeAll.ts

@@ -1,38 +0,0 @@
-import * as Option from '@effect/data/Option'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { compact } from './filterMap.js'
-import { map } from './map.js'
-
-export function mergeAll<FXS extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fxs: FXS
-): Fx<Fx.Context<FXS[number]>, Fx.Error<FXS[number]>, Fx.Success<FXS[number]>> {
-  return Fx((sink) =>
-    Effect.forEach(
-      fxs,
-      (fx) =>
-        fx.run(
-          Sink(sink.event, (cause) =>
-            Cause.isInterruptedOnly(cause) ? Effect.unit : sink.error(cause),
-          ),
-        ),
-      { concurrency: 'unbounded', discard: true },
-    ),
-  )
-}
-
-export function merge<R, E, A, R2, E2, B>(
-  self: Fx<R, E, A>,
-  other: Fx<R2, E2, B>,
-): Fx<R | R2, E | E2, A | B> {
-  return mergeAll(self, other)
-}
-
-export function mergeFirst<R, E, A, R2, E2, B>(
-  self: Fx<R, E, A>,
-  other: Fx<R2, E2, B>,
-): Fx<R | R2, E | E2, A> {
-  return compact(mergeAll(map(self, Option.some), map(other, Option.none)))
-}

package/src/mergeBufferConcurrently.test.ts

@@ -1,37 +0,0 @@
-import { millis } from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { at } from './at.js'
-import { fromArray } from './fromArray.js'
-import { mergeAll } from './mergeAll.js'
-import { mergeBufferConcurrently } from './mergeBufferConcurrently.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(mergeBufferConcurrently.name, () => {
-    testCollectAll(
-      'buffers values until the previous stream completes',
-      mergeBufferConcurrently(
-        at(1, millis(50)),
-        mergeAll(at(2, millis(0)), at(3, millis(20)), at(4, millis(40))),
-      ),
-      [1, 2, 3, 4],
-    )
-
-    testCollectAll(
-      'emits immediately if previous stream has ended',
-      mergeBufferConcurrently(
-        at(1, millis(0)),
-        mergeAll(at(2, millis(5)), at(3, millis(10)), at(4, millis(20))),
-        mergeAll(at(5, millis(0)), at(6, millis(5)), at(7, millis(10))),
-      ),
-      [1, 2, 3, 4, 5, 6, 7],
-    )
-
-    testCollectAll(
-      'merges multiple synchronous streams',
-      mergeBufferConcurrently(fromArray([1, 2, 3]), fromArray([4, 5, 6])),
-      [1, 2, 3, 4, 5, 6],
-    )
-  })
-})

package/src/mergeBufferConcurrently.ts

@@ -1,106 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { empty } from './empty.js'
-
-/**
- * Merges n Fx concurrently, emitting the values in order of the streams are provided.
- * For example, Fx at index 0 will emit all of its values first, when it completes, Fx at index 1 will emit all of its values, and so on.
- * When there is asynchrony, the indexes which are not yet ready are buffered.
- */
-export function mergeBufferConcurrently<FXS extends Fx.TupleAny>(
-  ...fxs: FXS
-): Fx<Fx.Context<FXS[number]>, Fx.Error<FXS[number]>, Fx.Success<FXS[number]>> {
-  if (fxs.length === 0) return empty()
-  if (fxs.length === 1) return fxs[0]
-
-  return Fx(<R2>(sink: Sink<R2, Fx.Error<FXS[number]>, Fx.Success<FXS[number]>>) =>
-    Effect.suspend(() => {
-      type O = Fx.Success<FXS[number]>
-
-      const finished = new Map<number, Chunk.Chunk<O>>()
-      let currentIndex = 0
-
-      function onFinished(index: number, buffer: Chunk.Chunk<O>): Effect.Effect<R2, never, void> {
-        if (currentIndex < index) {
-          // If the current index is behind, buffer the value
-          return Effect.sync(() => {
-            finished.set(index, buffer)
-          })
-        }
-
-        if (Chunk.size(buffer) === 0) {
-          return next(index)
-        }
-
-        return Effect.flatMap(Effect.all(Chunk.map(buffer, sink.event)), () => next(index))
-      }
-
-      function next(index: number): Effect.Effect<R2, never, void> {
-        return Effect.suspend(() => {
-          finished.delete(index)
-
-          const nextIndex = ++currentIndex
-
-          if (finished.has(nextIndex)) {
-            return onFinished(nextIndex, finished.get(nextIndex) as Chunk.Chunk<O>)
-          }
-
-          return Effect.unit
-        })
-      }
-
-      return Effect.all(
-        fxs.map((fx, index) =>
-          Effect.suspend(() => {
-            if (index === currentIndex) return Effect.flatMap(fx.run(sink), () => next(index))
-
-            let buffer: Chunk.Chunk<O> = Chunk.empty()
-            let isEmitting = false
-
-            return Effect.flatMap(
-              fx.run(
-                Sink(
-                  (o) =>
-                    Effect.suspend(
-                      Effect.unifiedFn(() => {
-                        // The current index is emitting now
-                        if (isEmitting) {
-                          return sink.event(o)
-                        }
-
-                        // This index is ready to emit values
-                        if (index === currentIndex) {
-                          // Fast-path for remaining values
-                          isEmitting = true
-
-                          if (Chunk.size(buffer) === 0) return sink.event(o)
-
-                          // Drain the current buffer first
-                          const toEmit = Chunk.append(buffer, o)
-                          // Clear the buffer
-                          buffer = Chunk.empty()
-
-                          // Emit the values
-                          return Effect.forEach(toEmit, sink.event, { discard: true })
-                        }
-
-                        // Otherwise, buffer the value
-                        buffer = Chunk.append(buffer, o)
-
-                        return Effect.unit
-                      }),
-                    ),
-                  sink.error,
-                ),
-              ),
-              () => (isEmitting ? next(index) : onFinished(index, buffer)),
-            )
-          }),
-        ),
-        { concurrency: 'unbounded', discard: true },
-      )
-    }),
-  )
-}

package/src/mergeConcurrently.test.ts

@@ -1,20 +0,0 @@
-import { millis } from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { at } from './at.js'
-import { mergeAll } from './mergeAll.js'
-import { mergeConcurrently } from './mergeConcurrently.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(mergeConcurrently.name, () => {
-    testCollectAll(
-      'merges multiple streams together taking 1 value from each in order, but always the latest value from each stream',
-      mergeConcurrently(
-        at(1, millis(100)),
-        mergeAll(at(2, millis(0)), at(3, millis(30)), at(4, millis(60))),
-      ),
-      [1, 4],
-    )
-  })
-})

package/src/mergeConcurrently.ts

@@ -1,57 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-
-import { Fx, Sink } from './Fx.js'
-import { empty } from './empty.js'
-
-export function mergeConcurrently<FXS extends ReadonlyArray<Fx<any, any, any>>>(
-  ...fxs: FXS
-): Fx<Fx.Context<FXS[number]>, Fx.Error<FXS[number]>, Fx.Success<FXS[number]>> {
-  if (fxs.length === 0) return empty()
-  if (fxs.length === 1) return fxs[0]
-
-  return Fx(<R2>(sink: Sink<R2, Fx.Error<FXS[number]>, Fx.Success<FXS[number]>>) =>
-    Effect.gen(function* ($) {
-      let currentIndex = 0
-      const values = new Map<number, Fx.Success<FXS[number]>>()
-      const fibers: Fiber.Fiber<never, void>[] = []
-
-      for (let i = 0; i < fxs.length; ++i) {
-        fibers[i] = yield* $(
-          Effect.fork(fxs[i].run(Sink((value) => onValue(i, value), sink.error))),
-        )
-      }
-
-      function emit(index: number): Effect.Effect<R2, never, void> {
-        if (index === currentIndex && values.has(index)) {
-          return Effect.gen(function* ($) {
-            // Send this value to the sink
-            yield* $(sink.event(values.get(index) as Fx.Success<FXS[number]>))
-
-            // Interrupt the underlying Fiber
-            yield* $(Fiber.interruptFork(fibers[index]))
-
-            const next = ++currentIndex
-
-            // If there's a value for the next index, emit it
-            if (values.has(next)) {
-              yield* $(emit(next))
-            }
-          })
-        }
-
-        return Effect.unit
-      }
-
-      function onValue(index: number, value: Fx.Success<FXS[number]>) {
-        return Effect.suspend(() => {
-          values.set(index, value)
-
-          return emit(index)
-        })
-      }
-
-      yield* $(Fiber.joinAll(fibers))
-    }),
-  )
-}