@typed/fx 0.0.9 → 0.0.12

package/src/filterLoop.ts

@@ -0,0 +1,143 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
+import { pipe } from '@tsplus/stdlib/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Emitter, Fx } from './Fx.js'
+import { startWith } from './continueWith.js'
+import { FilterMap, Map } from './filterMap.js'
+
+export function loop<A, B, C>(seed: A, f: (a: A, b: B) => readonly [A, C]) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => Loop.make(fx, seed, f)
+}
+
+export function scan<A, B>(seed: A, f: (a: A, b: B) => A) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
+    pipe(
+      fx,
+      loop(seed, (a, b) => {
+        const c = f(a, b)
+        return [c, c]
+      }),
+      startWith(seed),
+    )
+}
+
+export function filterLoop<A, B, C>(seed: A, f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => FilterLoop.make(fx, seed, f)
+}
+
+export function filterScan<A, B>(seed: A, f: (a: A, b: B) => Maybe.Maybe<A>) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
+    pipe(
+      fx,
+      filterLoop(seed, (a, b) =>
+        pipe(
+          f(a, b),
+          Maybe.map((c) => [c, c]),
+        ),
+      ),
+      startWith(seed),
+    )
+}
+
+export class Loop<R, E, A, B, C> implements Fx<R, E, C> {
+  constructor(
+    readonly fx: Fx<R, E, B>,
+    readonly seed: A,
+    readonly f: (a: A, b: B) => readonly [A, C],
+  ) {}
+
+  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return Effect.suspendSucceed(() => {
+      let acc = this.seed
+
+      return this.fx.run(
+        Emitter(
+          (b: B) => {
+            const [a, c] = this.f(acc, b)
+
+            acc = a
+
+            return emitter.emit(c)
+          },
+          emitter.failCause,
+          emitter.end,
+        ),
+      )
+    })
+  }
+
+  static make<R, E, A, B, C>(
+    fx: Fx<R, E, B>,
+    seed: A,
+    f: (a: A, b: B) => readonly [A, C],
+  ): Fx<R, E, C> {
+    if (fx instanceof FilterMap) {
+      return FilterLoop.make(fx.fx, seed, (a, x) =>
+        pipe(
+          x,
+          fx.f,
+          Maybe.map((b) => f(a, b)),
+        ),
+      )
+    }
+
+    if (fx instanceof Map) {
+      return Loop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
+    }
+
+    return new Loop(fx, seed, f)
+  }
+}
+
+export class FilterLoop<R, E, A, B, C> implements Fx<R, E, C> {
+  constructor(
+    readonly fx: Fx<R, E, B>,
+    readonly seed: A,
+    readonly f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
+  ) {}
+
+  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return Effect.suspendSucceed(() => {
+      let acc = this.seed
+
+      return this.fx.run(
+        Emitter(
+          (b: B) =>
+            pipe(
+              this.f(acc, b),
+              Maybe.fold(
+                () => Effect.unit,
+                ([a, c]) => ((acc = a), emitter.emit(c)),
+              ),
+            ),
+          emitter.failCause,
+          emitter.end,
+        ),
+      )
+    })
+  }
+
+  static make<R, E, A, B, C>(
+    fx: Fx<R, E, B>,
+    seed: A,
+    f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
+  ): Fx<R, E, C> {
+    if (fx instanceof FilterMap) {
+      return FilterLoop.make(fx.fx, seed, (a, x) =>
+        pipe(
+          x,
+          fx.f,
+          Maybe.flatMap((b) => f(a, b)),
+        ),
+      )
+    }
+
+    if (fx instanceof Map) {
+      return FilterLoop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
+    }
+
+    return new FilterLoop(fx, seed, f)
+  }
+}

package/src/filterMap.test.ts

@@ -0,0 +1,33 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.map.name, () => {
+    it('transform the values of a Fx', async () => {
+      const test = pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.map((x) => x ** x),
+        Fx.runCollect,
+      )
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 4, 27])
+    })
+  })
+
+  describe(Fx.filterMap.name, () => {
+    it('transform the values and filters using Maybe of a Fx', async () => {
+      const test = pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.filterMap((x) => (x % 2 === 0 ? Maybe.none : Maybe.some(x ** x))),
+        Fx.runCollect,
+      )
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 27])
+    })
+  })
+})

package/src/filterMap.ts

@@ -0,0 +1,71 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
+import { flow } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+import { Predicate } from '@tsplus/stdlib/data/Predicate'
+
+import { Emitter, Fx } from './Fx.js'
+
+export const map =
+  <A, B>(f: (a: A) => B) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> =>
+    Map.make(fx, f)
+
+export const as = <B>(value: B): (<R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B>) => map(() => value)
+
+export class Map<R, E, A, B> implements Fx<R, E, B> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B) {}
+
+  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return this.fx.run(Emitter(flow(this.f, emitter.emit), emitter.failCause, emitter.end))
+  }
+
+  static make = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> => {
+    if (fx instanceof Map) {
+      return Map.make(fx.fx, flow(fx.f, f))
+    }
+
+    if (fx instanceof FilterMap) {
+      return FilterMap.make(fx.fx, flow(fx.f, Maybe.map(f)))
+    }
+
+    return new Map(fx, f)
+  }
+}
+
+export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> => FilterMap.make(fx, f)
+}
+
+export function filter<A>(predicate: Predicate<A>) {
+  return filterMap((a: A) => Maybe.fromPredicate(a, predicate))
+}
+
+export class FilterMap<R, E, A, B> implements Fx<R, E, B> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => Maybe.Maybe<B>) {}
+
+  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return this.fx.run(
+      Emitter(
+        flow(
+          this.f,
+          Maybe.fold(() => Effect.unit, emitter.emit),
+        ),
+        emitter.failCause,
+        emitter.end,
+      ),
+    )
+  }
+
+  static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Maybe.Maybe<B>): Fx<R, E, B> {
+    if (fx instanceof Map) {
+      return FilterMap.make(fx.fx, flow(fx.f, f))
+    }
+
+    if (fx instanceof FilterMap) {
+      return FilterMap.make(fx.fx, flow(fx.f, Maybe.flatMap(f)))
+    }
+
+    return new FilterMap(fx, f)
+  }
+}

package/src/flatMap.test.ts

@@ -1,23 +1,50 @@
 import { deepStrictEqual } from 'assert'
 
-import { unsafeRunPromise } from '@effect/core/io/Effect'
+import * as Effect from '@effect/core/io/Effect'
 import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { flatMap } from './flatMap.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('flatMap', () => {
-    it('chains fx together', async () => {
-      const values = [1, 2, 3]
-      const test = pipe(
-        from(values),
-        flatMap((x) => from([x + 1, x + 2])),
+  describe(Fx.flatMap.name, () => {
+    it('allows chaining multiple synchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) => Fx.fromIterable([n, n, n])),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
       )
-      const events = await pipe(test, collectAll, unsafeRunPromise)
 
-      deepStrictEqual(events, [2, 3, 3, 4, 4, 5])
+      deepStrictEqual(result, [1, 1, 1, 2, 2, 2, 3, 3, 3])
+    })
+
+    it('allows chaining multiple asynchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 2, 3, 1, 2, 3, 1, 2, 3])
+    })
+
+    it('interrupts inner fibers when they emit their end signal', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) =>
+          n === 1
+            ? Fx.take(4)(
+                Fx.fromIterable([n, n + 10, n + 20, n + 30, n + 40, n + 50, n + 60, n + 70]),
+              )
+            : Fx.fromIterable([n, n, n]),
+        ),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 11, 21, 31, 2, 2, 2, 3, 3, 3])
     })
   })
 })

package/src/flatMap.ts

@@ -1,66 +1,40 @@
 import * as Effect from '@effect/core/io/Effect'
 import { flow, pipe } from '@fp-ts/data/Function'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
-import { MapFx } from './map.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
+import { Map } from './filterMap.js'
 
-export function flatMap<A, R2, E2, B, E3>(f: (a: A) => Fx<R2, E2, B, E3>) {
-  return <R, E, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> => new FlatMapFx(self, f)
+export function flatMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    fx instanceof Map ? flatMap_(fx.fx, flow(fx.f, f)) : flatMap_(fx, f)
 }
 
-export class FlatMapFx<R, E, A, E1, R2, E2, B, E3> implements Fx<R2 | R, E | E2, B, E1 | E3> {
-  constructor(readonly self: Fx<R, E, A, E1>, readonly f: (a: A) => Fx<R2, E2, B, E3>) {}
-
-  run<R3, E4, C>(sink: Sink<E | E2, B, R3, E4, C>): Effect.Effect<R2 | R | R3, E1 | E3 | E4, C> {
-    const { self, f } = this
+export function join<R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> {
+  return flatMap_(fx, (fx) => fx)
+}
 
-    return pipe(
-      refCountDeferred<E1 | E3 | E4, C>(),
-      Effect.flatMap((deferred) =>
-        self.run(
-          Sink(
+function flatMap_<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) {
+  return Fx((emitter) =>
+    withDynamicCountdownLatch(
+      1,
+      ({ increment, latch }) =>
+        fx.run(
+          Emitter(
             (a) =>
               pipe(
-                deferred.increment, // Increment ref count
-                Effect.zipRight(
-                  Effect.fork(
-                    f(a).run(
-                      Sink(
-                        sink.event,
-                        flow(sink.error, deferred.error),
-                        pipe(
-                          deferred.decrement, // Decrement ref count
-                          Effect.flatMap(() => deferred.endIfComplete(sink.end)),
-                        ),
-                      ),
-                    ),
+                increment,
+                Effect.flatMap(() =>
+                  Effect.forkScoped(
+                    f(a).run(Emitter(emitter.emit, emitter.failCause, latch.countDown)),
                   ),
                 ),
               ),
-            flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
-            Effect.suspendSucceed(() =>
-              pipe(
-                deferred.end, // Track that the "outer" stream has completed
-                Effect.flatMap(() => deferred.endIfComplete(sink.end)),
-                Effect.zipRight(deferred.await),
-              ),
-            ),
+            emitter.failCause,
+            latch.countDown,
           ),
         ),
-      ),
-    )
-  }
-
-  static make<R, E, A, E1, R2, E2, B, E3>(
-    fx: Fx<R, E, A, E1>,
-    f: (a: A) => Fx<R2, E2, B, E3>,
-  ): Fx<R | R2, E | E2, B, E1 | E3> {
-    if (fx instanceof MapFx) {
-      return new FlatMapFx(fx.fx, flow(fx.f, f))
-    }
-
-    return new FlatMapFx(fx, f)
-  }
+      emitter.end,
+    ),
+  )
 }

package/src/flatMapConcurrently.test.ts

@@ -0,0 +1,23 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('flatMapConcurrently', () => {
+    it('should run effects with specified concurrency', async () => {
+      const test = pipe(
+        Fx.mergeAll([Fx.succeed(1), Fx.succeed(2), Fx.succeed(3)]),
+        Fx.concatMap((a) => Fx.mergeAll([Fx.succeed(a), Fx.at(Duration.millis(50))(a * a)])),
+        Fx.runCollect,
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 1, 2, 4, 3, 9])
+    })
+  })
+})

package/src/flatMapConcurrently.ts

@@ -2,21 +2,15 @@ import * as TSemaphore from '@effect/core/stm/TSemaphore'
 import { flow, pipe } from '@fp-ts/data/Function'
 
 import { Fx } from './Fx.js'
-import { withPermit } from './TSemaphore.js'
 import { flatMap } from './flatMap.js'
 import { suspendSucceed } from './suspendSucceed.js'
+import { withPermit } from './transform.js'
 
-export function flatMapConcurrently<A, R2, E2, B, E3>(
-  concurrency: number,
-  f: (a: A) => Fx<R2, E2, B, E3>,
-) {
-  return <R, E, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> =>
-    suspendSucceed(() =>
-      pipe(self, flatMap(flow(f, withPermit(TSemaphore.unsafeMake(concurrency))))),
-    )
+export function flatMapConcurrently<A, R2, E2, B>(concurrency: number, f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    suspendSucceed(() => pipe(fx, flatMap(flow(f, withPermit(TSemaphore.unsafeMake(concurrency))))))
 }
 
-export function concatMap<A, R2, E2, B, E3>(f: (a: A) => Fx<R2, E2, B, E3>) {
-  return <R, E, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, B, E1 | E3> =>
-    pipe(self, flatMapConcurrently(1, f))
+export function concatMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> => pipe(fx, flatMapConcurrently(1, f))
 }

package/src/fromEffect.ts

@@ -1,31 +1,45 @@
 import * as Cause from '@effect/core/io/Cause'
+import { Clock } from '@effect/core/io/Clock'
 import * as Effect from '@effect/core/io/Effect'
 import { Exit } from '@effect/core/io/Exit'
+import { Fiber } from '@effect/core/io/Fiber'
+import { FiberId } from '@effect/core/io/FiberId'
 import { LazyArg, flow, pipe } from '@fp-ts/data/Function'
 import { Either } from '@tsplus/stdlib/data/Either'
 import { Maybe } from '@tsplus/stdlib/data/Maybe'
+import { Env } from '@tsplus/stdlib/service/Env'
+import { Tag } from '@tsplus/stdlib/service/Tag'
 
 import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
 
 export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
-  return new FromEffectFx(effect)
+  return Fx((emitter) =>
+    pipe(
+      effect,
+      Effect.foldCauseEffect(emitter.failCause, flow(emitter.emit, Effect.zipRight(emitter.end))),
+    ),
+  )
 }
 
-export class FromEffectFx<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly effect: Effect.Effect<R, E, A>) {}
+export const succeed = flow(Effect.succeed, fromEffect)
 
-  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E2, B> {
-    return pipe(
-      this.effect,
-      Effect.foldCauseEffect(sink.error, flow(sink.event, Effect.zipRight(sink.end))),
-    )
-  }
-}
+export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never> = flow(
+  Effect.failCause,
+  fromEffect,
+)
 
-export const succeed = flow(Effect.succeed, fromEffect)
+export const fail: <E>(e: E) => Fx<never, E, never> = flow(Effect.fail, fromEffect)
+
+export const unit: Fx<never, never, void> = fromEffect(Effect.unit)
+
+export const never: Fx<never, never, never> = fromEffect(Effect.never)
+
+export const interrupt = fromEffect(Effect.interrupt)
+export const interruptAs: (fiberId: FiberId) => Fx<never, never, never> = flow(
+  Effect.interruptAs,
+  fromEffect,
+)
 
-export const fail = flow(Effect.fail, fromEffect)
 export const die = flow(Effect.die, fromEffect)
 export const dieMessage = flow(Effect.dieMessage, fromEffect)
 export const dieSync: <A>(f: LazyArg<A>) => Fx<never, never, never> = flow(
@@ -33,32 +47,66 @@ export const dieSync: <A>(f: LazyArg<A>) => Fx<never, never, never> = flow(
   fromEffect,
 )
 
-export const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never, never> = flow(
-  Effect.failCause,
-  fromEffect,
-)
+export const done: <E, A>(exit: Exit<E, A>) => Fx<never, E, A> = flow(Effect.done, fromEffect)
 
 export const fromEither: <E, A>(either: Either<E, A>) => Fx<never, E, A> = flow(
   Effect.fromEither,
   fromEffect,
 )
 
-export const done: <E, A>(exit: Exit<E, A>) => Fx<never, E, A> = flow(Effect.done, fromEffect)
+export const succeedLeft: <A>(value: A) => Fx<never, never, Either<A, never>> = flow(
+  Effect.succeedLeft,
+  fromEffect,
+)
+
+export const succeedRight: <A>(value: A) => Fx<never, never, Either<never, A>> = flow(
+  Effect.succeedRight,
+  fromEffect,
+)
+
+export const yieldNow = fromEffect(Effect.yieldNow)
+
+export const tryPromise: <A>(promise: LazyArg<Promise<A>>) => Fx<never, unknown, A> = flow(
+  Effect.tryPromise,
+  fromEffect,
+)
+
+export const tryCatchPromise: <A, E>(
+  promise: LazyArg<Promise<A>>,
+  onThrow: (u: unknown) => E,
+) => Fx<never, E, A> = flow(Effect.tryPromise, fromEffect)
+
+export const tryCatch: <A, E>(f: LazyArg<A>, onThrow: (u: unknown) => E) => Fx<never, E, A> = flow(
+  Effect.tryCatch,
+  fromEffect,
+)
+
+export const sync: <A>(f: LazyArg<A>) => Fx<never, never, A> = flow(Effect.sync, fromEffect)
 
 export const async = flow(Effect.async, fromEffect)
 
 export const asyncEffect = flow(Effect.asyncEffect, fromEffect)
 
-export const asyncInterrupt: <R, E, A>(
-  register: (
-    callback: (_: Effect.Effect<R, E, A>) => void,
-  ) => Either<Effect.Effect<R, never, void>, Effect.Effect<R, E, A>>,
-) => Fx<R, E, A> = flow(Effect.asyncInterrupt, fromEffect)
+export const asyncInterrupt = flow(Effect.asyncInterrupt, fromEffect)
 
 export const asyncMaybe: <R, E, A>(
   register: (callback: (_: Effect.Effect<R, E, A>) => void) => Maybe<Effect.Effect<R, E, A>>,
 ) => Fx<R, E, A> = flow(Effect.asyncMaybe, fromEffect)
 
-export const suspendSucceedEffect: <R, E, A>(
-  effect: LazyArg<Effect.Effect<R, E, A>>,
-) => Fx<R, E, A> = flow(Effect.suspendSucceed, fromEffect)
+export const clock: Fx<never, never, Clock> = fromEffect(Effect.clock)
+
+export const environment = <R>(): Fx<R, never, Env<R>> => fromEffect(Effect.environment<R>())
+
+export const service = <R>(tag: Tag<R>): Fx<R, never, R> => fromEffect(Effect.service<R>(tag))
+
+export const environmentWith = flow(Effect.environmentWith, fromEffect)
+export const environmentWithEffect = flow(Effect.environmentWithEffect, fromEffect)
+
+export const descriptor: Fx<never, never, Fiber.Descriptor> = fromEffect(Effect.descriptor)
+
+export const descriptorWith = flow(Effect.descriptorWith, fromEffect)
+
+export const fromFiber = flow(Effect.fromFiber, fromEffect)
+export const fromFiberEffect = flow(Effect.fromFiberEffect, fromEffect)
+
+export const fromMaybe = flow(Effect.fromMaybe, fromEffect)

package/src/fromIterable.ts

@@ -0,0 +1,15 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
+  return new FromIterable(iterable)
+}
+
+export class FromIterable<A> implements Fx<never, never, A> {
+  constructor(readonly iterable: Iterable<A>) {}
+
+  run<R2>(emitter: Emitter<R2, never, A>) {
+    return Effect.zipRight(emitter.end)(Effect.forEachDiscard(this.iterable, emitter.emit))
+  }
+}

package/src/hold.test.ts

@@ -26,15 +26,15 @@ describe(import.meta.url, () => {
       )
 
       const test = Effect.gen(function* ($) {
-        const a = yield* $(Effect.fork(Fx.collectAll(fx)))
+        const a = yield* $(Effect.fork(Fx.runCollect(fx)))
 
         yield* $(Effect.sleep(Duration.millis(50)))
 
-        const b = yield* $(Effect.fork(Fx.collectAll(fx)))
+        const b = yield* $(Effect.fork(Fx.runCollect(fx)))
 
         yield* $(Effect.sleep(Duration.millis(100)))
 
-        const c = yield* $(Effect.fork(Fx.collectAll(fx)))
+        const c = yield* $(Effect.fork(Fx.runCollect(fx)))
 
         deepStrictEqual(yield* $(Fiber.join(a)), [value, value + 1, value + 2])
         deepStrictEqual(yield* $(Fiber.join(b)), [value, value + 1, value + 2])