@typed/fx 1.12.6 → 1.14.0

package/src/keyed.ts

@@ -1,14 +1,16 @@
 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 } from './RefSubject.js'
+import { RefSubject, makeRef } from './RefSubject.js'
 import { Subject, makeHoldSubject } from './Subject.js'
-import { Cause } from './externals.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[]>,
@@ -16,42 +18,38 @@ export function keyed<R, E, A, R2, E2, B, C>(
   getKey: (a: A) => C,
 ): Fx<R | R2, E | E2, readonly B[]> {
   return Fx(<R3>(sink: Sink<R3, E | E2, readonly B[]>) =>
-    withScopedFork((fork) =>
+    withScopedFork((fork, scope) =>
       Effect.gen(function* ($) {
         const state = createKeyedState<A, B, C>()
         const emit = emitWhenReady(state, getKey)
 
-        // Let output emit to the sink
-        yield* $(fork(state.output.run(sink)))
-
-        const params: Omit<UpdateStateParams<A, B, C, R2, E2, R3>, 'updated'> = {
-          state,
-          getKey,
-          f,
-          fork,
-          emit,
-          error: sink.error,
-        }
+        // 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(
-              (updated) =>
+              (as) =>
                 updateState({
-                  ...params,
-                  updated,
+                  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])))
-
-        // Send end signals to all Fx listening to subjects to allow finalization
-        yield* $(endAll(state))
       }),
     ),
   )
@@ -78,42 +76,56 @@ function createKeyedState<A, B, C>(): KeyedState<A, B, C> {
   }
 }
 
-type UpdateStateParams<A, B, C, R2, E2, R3> = {
+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>) => Fx<R2, E2, B>
-  getKey: (a: A) => C
   fork: ScopedFork
-  error: (e: Cause.Cause<E2>) => Effect.Effect<R3, never, void>
+  scope: Scope.Scope
   emit: Effect.Effect<never, never, void>
-}
-
-function updateState<A, B, C, R2, E2, R3>(params: UpdateStateParams<A, B, C, R2, E2, R3>) {
-  const { state, updated, emit, getKey } = params
-
-  return Effect.gen(function* ($) {
-    const { added, removed, unchanged } = diffValues(state, updated, getKey)
-
-    // Remove values that are no longer in the stream
-    if (removed.length > 0) {
-      yield* $(Effect.forEachDiscard(removed, (key) => removeValue(state, key)))
-    }
-
-    // Add values that are new to the stream
-    if (added.length > 0) {
-      yield* $(Effect.forEachDiscard(added, (value) => addValue({ ...params, value })))
-    }
-
-    // Update values that are still in the stream
-    if (unchanged.length > 0) {
-      yield* $(Effect.forEachDiscard(unchanged, (value) => updateValue(state, value, getKey)))
-    }
-
-    // If nothing was added, emit the current values
-    if (added.length === 0) {
-      yield* $(emit)
-    }
-  })
+  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>(
@@ -121,23 +133,11 @@ function diffValues<A, B, C>(
   updated: ReadonlyArray<A>,
   getKey: (a: A) => C,
 ) {
-  const previousKeys = state.previousKeys
-  const keys = new Set<C>(updated.map(getKey))
-
-  state.previous = updated
-  state.previousKeys = keys
-
-  if (previousKeys.size === 0) {
-    return {
-      added: updated,
-      unchanged: [],
-      removed: [],
-    }
-  }
-
   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]
@@ -156,6 +156,9 @@ function diffValues<A, B, C>(
     }
   })
 
+  state.previous = updated
+  state.previousKeys = keys
+
   return {
     added,
     unchanged,
@@ -179,16 +182,6 @@ function removeValue<A, B, C>(state: KeyedState<A, B, C>, key: C) {
   })
 }
 
-type AddValueParams<A, B, C, R2, E2, R3> = {
-  state: KeyedState<A, B, C>
-  value: A
-  f: (fx: RefSubject<never, A>) => 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
-}
-
 function addValue<A, B, C, R2, E2, R3>({
   state,
   value,
@@ -197,10 +190,18 @@ function addValue<A, B, C, R2, E2, R3>({
   emit,
   error,
   getKey,
-}: AddValueParams<A, B, C, R2, E2, R3>) {
+}: {
+  state: KeyedState<A, B, C>
+  value: A
+  f: (fx: RefSubject<never, A>) => 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)
-    const subject = RefSubject.unsafeMake<never, A>(Effect.succeed(value))
+    const subject = yield* $(makeRef<never, never, A>(Effect.succeed(value)))
     const fx = f(subject)
     const fiber = yield* $(
       fork(
@@ -237,7 +238,7 @@ 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()
+      return Effect.unit
     }
 
     const values = ReadonlyArray.filterMap(state.previous, (value) =>
@@ -249,12 +250,12 @@ function emitWhenReady<A, B, C>(state: KeyedState<A, B, C>, getKey: (a: A) => C)
       return state.output.event(values)
     }
 
-    return Effect.unit()
+    return Effect.unit
   })
 }
 
 function endAll<A, B, C>(state: KeyedState<A, B, C>) {
-  return Effect.gen(function* ($) {
-    yield* $(Effect.forEachParDiscard(state.subjects, ([, subject]) => subject.end()))
+  return Effect.forEach(state.subjects, ([, subject]) => subject.end(), {
+    concurrency: 'unbounded',
   })
 }

package/src/map.ts

@@ -1,5 +1,6 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx, Sink } from './Fx.js'
-import { Effect } from './externals.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)))

package/src/mergeAll.ts

@@ -1,5 +1,8 @@
+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 { Cause, Effect, Option } from './externals.js'
 import { compact } from './filterMap.js'
 import { map } from './map.js'
 
@@ -7,12 +10,15 @@ export function mergeAll<FXS extends ReadonlyArray<Fx<any, any, any>>>(
   ...fxs: FXS
 ): Fx<Fx.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
   return Fx((sink) =>
-    Effect.forEachParDiscard(fxs, (fx) =>
-      fx.run(
-        Sink(sink.event, (cause) =>
-          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+    Effect.forEach(
+      fxs,
+      (fx) =>
+        fx.run(
+          Sink(sink.event, (cause) =>
+            Cause.isInterruptedOnly(cause) ? Effect.unit : sink.error(cause),
+          ),
         ),
-      ),
+      { concurrency: 'unbounded', discard: true },
     ),
   )
 }

package/src/mergeBufferConcurrently.test.ts

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

@@ -0,0 +1,105 @@
+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.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
+  if (fxs.length === 0) return empty()
+  if (fxs.length === 1) return fxs[0]
+
+  return Fx(<R2>(sink: Sink<R2, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>>) =>
+    Effect.suspend(() => {
+      type O = Fx.OutputOf<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> {
+        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.asUnit(
+        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) {
+                            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()
+                            // Fast-path for remaining values
+                            isEmitting = true
+
+                            // Emit the values
+                            return Effect.all(Chunk.map(toEmit, sink.event))
+                          }
+
+                          // Otherwise, buffer the value
+                          buffer = Chunk.append(buffer, o)
+
+                          return Effect.unit
+                        }),
+                      ),
+                    sink.error,
+                  ),
+                ),
+                () => (isEmitting ? next(index) : onFinished(index, buffer)),
+              )
+            }),
+          ),
+          { concurrency: 'unbounded' },
+        ),
+      )
+    }),
+  )
+}

package/src/mergeConcurrently.test.ts

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

@@ -0,0 +1,57 @@
+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.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
+  if (fxs.length === 0) return empty()
+  if (fxs.length === 1) return fxs[0]
+
+  return Fx(<R2>(sink: Sink<R2, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>>) =>
+    Effect.gen(function* ($) {
+      let currentIndex = 0
+      const values = new Map<number, Fx.OutputOf<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.OutputOf<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.OutputOf<FXS[number]>) {
+        return Effect.suspend(() => {
+          values.set(index, value)
+
+          return emit(index)
+        })
+      }
+
+      yield* $(Fiber.joinAll(fibers))
+    }),
+  )
+}

package/src/multicast.test.ts

@@ -1,10 +1,11 @@
+import * as Chunk from '@effect/data/Chunk'
+import * as Duration from '@effect/data/Duration'
 import { pipe } from '@effect/data/Function'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
 import { describe, it, expect } from 'vitest'
 
 import { delay } from './delay.js'
-import { Chunk, Duration } from './externals.js'
 import { flatMap } from './flatMap.js'
 import { fromArray } from './fromArray.js'
 import { merge } from './mergeAll.js'

package/src/multicast.ts

@@ -1,10 +1,11 @@
-import type { Trace } from '@effect/data/Debug'
+import type * as Context from '@effect/data/Context'
 import { identity } from '@effect/data/Function'
+import type * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
 
+import { FxTypeId } from './Fx.js'
 import type { Fx, Sink } from './Fx.js'
-import { FxTypeId, Traced } from './Fx.js'
-import type { Cause, Context } from './externals.js'
-import { Effect, Fiber } from './externals.js'
 
 export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
   return new MulticastFx(fx)
@@ -22,8 +23,10 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     _A: identity,
   }
 
-  protected observers: Array<MulticastObserver<any, E, A>> = []
-  protected fiber: Fiber.RuntimeFiber<never, void> | undefined
+  /**@internal */
+  public observers: Array<MulticastObserver<any, E, A>> = []
+  /**@internal */
+  public fiber: Fiber.RuntimeFiber<never, void> | undefined
 
   constructor(readonly fx: Fx<R, E, A>) {
     this.run = this.run.bind(this)
@@ -37,40 +40,47 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const that = this
 
-    return Effect.gen(function* ($) {
-      const context = yield* $(Effect.context<R2>())
-      const observer: MulticastObserver<R2, E, A> = { sink, context }
+    return Effect.flatMap(Effect.context<R2>(), (context) =>
+      Effect.suspend(() => {
+        const observer: MulticastObserver<R2, E, A> = { sink, context }
 
-      if (observers.push(observer) === 1) {
-        that.fiber = yield* $(Effect.forkDaemon(that.fx.run(that)))
-      }
+        const effects: Array<Effect.Effect<R, never, void>> = []
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      yield* $(Effect.ensuring(Fiber.await(that.fiber!), that.removeSink(sink)))
-    })
-  }
+        if (observers.push(observer) === 1) {
+          effects.push(
+            Effect.tap(Effect.forkDaemon(that.fx.run(that)), (fiber) =>
+              Effect.sync(() => (that.fiber = fiber)),
+            ),
+          )
+        }
 
-  readonly addTrace = (trace: Trace): Fx<R, E, A> => {
-    return Traced<R, E, A>(this.fx, trace)
+        effects.push(
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          Effect.suspend(() => Effect.ensuring(Fiber.await(that.fiber!), that.removeSink(sink))),
+        )
+
+        return Effect.all(effects)
+      }),
+    )
   }
 
   event(a: A) {
     if (this.observers.length === 0) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     return Effect.suspend(() =>
-      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
+      Effect.forEach(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
     )
   }
 
   error(cause: Cause.Cause<E>) {
     if (this.observers.length === 0) {
-      return Effect.unit()
+      return Effect.unit
     }
 
     return Effect.suspend(() =>
-      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runError(observer, cause)),
+      Effect.forEach(this.observers.slice(0), (observer) => this.runError(observer, cause)),
     )
   }
 
@@ -92,7 +102,7 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
     return Effect.suspend(() => {
       const { observers } = this
 
-      if (observers.length === 0) return Effect.unit()
+      if (observers.length === 0) return Effect.unit
 
       const index = observers.findIndex((o) => o.sink === sink)
 
@@ -109,7 +119,7 @@ export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
         }
       }
 
-      return Effect.unit()
+      return Effect.unit
     })
   }
 }

package/src/never.ts

@@ -1,6 +1,7 @@
+import * as Effect from '@effect/io/Effect'
+
 import { Fx } from './Fx.js'
-import { Effect } from './externals.js'
 
 export function never<E = never, A = never>(): Fx<never, E, A> {
-  return Fx<never, E, A>(() => Effect.never())
+  return Fx<never, E, A>(() => Effect.never)
 }