@typed/fx 0.0.9 → 0.0.12

package/src/switchMap.test.ts

@@ -1,25 +1,35 @@
 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 { delay } from './delay.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
-import { switchMap } from './switchMap.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('switchMap', () => {
-    it('chains the latest inner fx', async () => {
-      const values = [1, 2, 3]
-      const test = pipe(
-        from(values),
-        switchMap((x) => delay(Duration.millis(100))(from([x + 1, x + 2]))),
+  describe(Fx.switchMap.name, () => {
+    it('allows chaining multiple synchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.switchMap((n) => Fx.fromIterable([n, n, n])),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
+      )
+
+      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.switchMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
       )
-      const events = await pipe(test, collectAll, unsafeRunPromise)
 
-      deepStrictEqual(events, [4, 5])
+      deepStrictEqual(result, [3, 3, 3])
     })
   })
 })

package/src/switchMap.ts

@@ -1,64 +1,46 @@
 import * as Effect from '@effect/core/io/Effect'
-import { Fiber, interrupt } from '@effect/core/io/Fiber'
-import { makeSynchronized } from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import * as Fiber from '@effect/core/io/Fiber'
+import * as Ref from '@effect/core/io/Ref'
+import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
 
-export function switchMap<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 SwitchMapFx(self, f)
-}
-
-export class SwitchMapFx<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
-
-    return pipe(
-      refCountDeferred<E1 | E3 | E4, C>(),
-      Effect.map((deferred) => ({ deferred } as const)),
-      Effect.bind('ref', () => makeSynchronized<Fiber<E1 | E3 | E4, any> | null>(() => null)),
-      Effect.flatMap(({ deferred, ref }) =>
-        self.run(
-          Sink(
-            (a) =>
-              ref.updateEffect((current) =>
-                pipe(
-                  current ? interrupt(current) : Effect.unit,
-                  Effect.zipRight(deferred.increment),
-                  Effect.zipRight(
-                    pipe(
-                      f(a).run(
-                        Sink(
-                          sink.event,
-                          flow(sink.error, deferred.error),
-                          pipe(
-                            deferred.decrement,
-                            Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+export function switchMap<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(<R3>(emitter: Emitter<R3, E | E2, B>) =>
+      pipe(
+        Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
+        Effect.flatMap((ref) =>
+          withDynamicCountdownLatch(
+            1,
+            ({ increment, latch }) =>
+              fx.run(
+                Emitter(
+                  (a) =>
+                    ref.updateEffect((fiber) =>
+                      pipe(
+                        fiber ? Fiber.interrupt(fiber) : increment,
+                        Effect.flatMap(() =>
+                          Effect.forkScoped(
+                            f(a).run(
+                              Emitter(
+                                emitter.emit,
+                                (e) => pipe(ref.set(null), Effect.zipRight(emitter.failCause(e))),
+                                pipe(ref.set(null), Effect.zipRight(latch.countDown)),
+                              ),
+                            ),
                           ),
                         ),
                       ),
-                      Effect.onInterrupt(() => deferred.decrement),
-                      Effect.fork,
                     ),
-                  ),
+                  emitter.failCause,
+                  latch.countDown,
                 ),
               ),
-            flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
-            Effect.suspendSucceed(() =>
-              pipe(
-                deferred.end,
-                Effect.flatMap(() => deferred.endIfComplete(sink.end)),
-                Effect.zipRight(deferred.await),
-              ),
-            ),
+            emitter.end,
           ),
         ),
       ),
     )
-  }
 }

package/src/takeWhile.test.ts

@@ -0,0 +1,44 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.takeWhile.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3, 4, 5, 6, 7]),
+            Fx.takeWhile((x) => x < 4),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+
+  describe(Fx.takeUntil.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2, 3, 4, 5, 6, 7]),
+            Fx.takeUntil((x) => x > 3),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/takeWhile.ts

@@ -1,33 +1,28 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
 import { pipe } from '@fp-ts/data/Function'
-import { Predicate, not } from '@fp-ts/data/Predicate'
+import { Predicate, not } from '@tsplus/stdlib/data/Predicate'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { deferredCallback } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
 
 export function takeWhile<A>(predicate: Predicate<A>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx(<R2, E2, B>(sink: Sink<E, A, R2, E2, B>) =>
-      deferredCallback<E1 | E2, B, R | R2, E1 | E2>((cb) => {
-        return fx.run({
-          ...sink,
-          event: (a) => {
-            if (predicate(a)) {
-              return sink.event(a)
-            }
-
-            return pipe(
-              sink.end,
-              Effect.tap((b) => cb(Exit.succeed(b))),
-            )
-          },
-        })
-      }),
-    )
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => takeWhile_(fx, predicate)
 }
 
 export function takeUntil<A>(predicate: Predicate<A>) {
-  return <R, E, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> => pipe(fx, takeWhile(not(predicate)))
+  return takeWhile(not(predicate))
+}
+
+function takeWhile_<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      fx.run(
+        Emitter(
+          (a) => (predicate(a) ? emitter.emit(a) : exitEarly),
+          emitter.failCause,
+          emitter.end,
+        ),
+      ),
+      onEarlyExitFailure(emitter.end),
+    ),
+  )
 }

package/src/tapEffect.ts

@@ -0,0 +1,24 @@
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export const tapEffect =
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
+    Fx((emitter) =>
+      fx.run(
+        Emitter(
+          (a) =>
+            pipe(
+              a,
+              f,
+              Effect.foldCauseEffect(emitter.failCause, () => emitter.emit(a)),
+            ),
+          emitter.failCause,
+          emitter.end,
+        ),
+      ),
+    )
+
+export const tap = <A>(f: (a: A) => unknown) => tapEffect((a: A) => Effect.sync(() => f(a)))

package/src/throttle.test.ts

@@ -1,19 +1,17 @@
 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 { millis } from '@tsplus/stdlib/data/Duration'
 
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
-import { throttle } from './throttle.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('throttle', () => {
+  describe(Fx.throttle.name, () => {
     it('favors the first overlapping event', async () => {
-      const test = pipe(from([1, 2, 3]), throttle(millis(100)), collectAll)
+      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.throttle(millis(100)), Fx.runCollect)
 
-      deepStrictEqual(await unsafeRunPromise(test), [1])
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1])
     })
   })
 })

package/src/throttle.ts

@@ -1,58 +1,53 @@
 import * as Effect from '@effect/core/io/Effect'
 import * as Fiber from '@effect/core/io/Fiber'
 import * as Ref from '@effect/core/io/Ref'
-import * as Schedule from '@effect/core/io/Schedule'
-import { flow, pipe } from '@fp-ts/data/Function'
-import { Duration } from '@tsplus/stdlib/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
 
-export function throttle(duration: Duration) {
-  return <R, E, A, E1>(fx: Fx<R, E, A>): Fx<R, E, A, E1> =>
-    Fx(
-      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> =>
-        Effect.gen(function* ($) {
-          const ref = yield* $(
-            Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
-          )
-          const deferred = yield* $(refCountDeferred<E1 | E2, B>(true))
+export function throttle(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => throttle_(fx, duration)
+}
 
-          return yield* $(
+function throttle_<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
+      Effect.flatMap((ref) =>
+        withDynamicCountdownLatch(
+          1,
+          ({ increment, latch }) =>
             fx.run(
-              Sink<E, A, R | R2, E1 | E2, B>(
+              Emitter(
                 (a) =>
-                  ref.updateEffect((current) =>
-                    Effect.gen(function* (_) {
-                      if (current) {
-                        return current
-                      }
-
-                      yield* $(deferred.increment)
-
-                      return yield* _(
-                        pipe(
-                          sink.event(a),
-                          Effect.schedule(Schedule.delayed(() => duration)(Schedule.once)),
-                          Effect.tap(() =>
+                  ref.updateEffect((previous) =>
+                    previous
+                      ? Effect.succeed(previous)
+                      : pipe(
+                          increment,
+                          Effect.flatMap(() =>
                             pipe(
-                              ref.set(null),
-                              Effect.zipRight(deferred.decrement),
-                              Effect.zipRight(deferred.endIfComplete(sink.end)),
+                              emitter.emit(a),
+                              Effect.delay(duration),
+                              Effect.interruptible,
+                              Effect.tap(() =>
+                                pipe(ref.set(null), Effect.zipRight(latch.countDown)),
+                              ),
+                              Effect.uninterruptible,
+                              Effect.fork,
                             ),
                           ),
-                          Effect.uninterruptible,
-                          Effect.fork,
                         ),
-                      )
-                    }),
                   ),
-                flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
-                pipe(sink.end, deferred.endIfComplete, Effect.zipRight(deferred.await)),
+                emitter.failCause,
+                latch.countDown,
               ),
             ),
-          )
-        }),
-    )
+          emitter.end,
+        ),
+      ),
+    ),
+  )
 }

package/src/transform.ts

@@ -3,14 +3,14 @@ import * as Effect from '@effect/core/io/Effect'
 import { Exit } from '@effect/core/io/Exit'
 import { RuntimeFlagsPatch } from '@effect/core/io/RuntimeFlags/patch'
 import { Scope } from '@effect/core/io/Scope'
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
 
 import { Fx } from './Fx.js'
 
-export function transform<R2 = never, E2 = never>(
-  f: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A>,
+export function transform<R2 = never>(
+  f: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E, A>,
 ) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E, A, E1 | E2> =>
-    Fx((sink) => f(fx.run(sink)))
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E, A> => Fx((emitter) => f(fx.run(emitter)))
 }
 
 export function withParallelism(parallelism: number) {
@@ -20,11 +20,11 @@ export function withParallelism(parallelism: number) {
 export const withParallelismUnbounded = transform(Effect.withParallelismUnbounded)
 
 export const withFinalizer = <R2, X>(finalizer: Effect.Effect<R2, never, X>) =>
-  transform<R2 | Scope, never>(Effect.withFinalizer(finalizer))
+  transform<R2 | Scope>(Effect.withFinalizer(finalizer))
 
 export const withFinalizerExit = <R2, X>(
   finalizer: <E, A>(exit: Exit<E, A>) => Effect.Effect<R2, never, X>,
-) => transform<R2 | Scope, never>(Effect.withFinalizerExit(finalizer))
+) => transform<R2 | Scope>(Effect.withFinalizerExit(finalizer))
 
 export const withRuntimeFlags = (updated: RuntimeFlagsPatch) =>
   transform(Effect.withRuntimeFlags(updated))
@@ -32,3 +32,11 @@ export const withRuntimeFlags = (updated: RuntimeFlagsPatch) =>
 export const scoped = transform(Effect.scoped)
 
 export const withClock = (clock: Clock) => transform(Effect.withClock(clock))
+
+export const uninterruptible = transform(Effect.uninterruptible)
+export const interruptible = transform(Effect.interruptible)
+
+export const withPermit = (self: TSemaphore.TSemaphore) => transform(TSemaphore.withPermit(self))
+
+export const withPermits = (permits: number) => (self: TSemaphore.TSemaphore) =>
+  transform(TSemaphore.withPermits(permits)(self))

package/src/until.test.ts

@@ -1,24 +1,18 @@
 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 { millis } from '@tsplus/stdlib/data/Duration'
 
-import { at } from './delay.js'
-import { periodic } from './periodic.js'
-import { collectAll } from './reduce.js'
-import { until } from './until.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('until', () => {
-    it('adds a delay to an event', async () => {
-      const value = Math.random()
-      const end = at(Duration.millis(200))(value)
-      const stream = periodic(Duration.millis(50))
-      const test = until(end)(stream)
-      const events = await pipe(test, collectAll, unsafeRunPromise)
+  describe(Fx.until.name, () => {
+    it('runs a stream until a signal is emitted to stop', async () => {
+      const test = pipe(Fx.periodic(millis(20)), Fx.until(Fx.at(millis(200))(null)), Fx.runCollect)
+      const events = await Effect.unsafeRunPromise(test)
 
-      deepStrictEqual(events.length, 3)
+      deepStrictEqual(events.length, 9)
     })
   })
 })

package/src/until.ts

@@ -1,37 +1,27 @@
 import * as Effect from '@effect/core/io/Effect'
-import { flow } from '@fp-ts/data/Function'
+import { joinAll } from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
 
-export function until<R2, E2, B, E3>(signal: Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E, A, E1 | E2 | E3> =>
-    Fx(<R4, E4, C>(sink: Sink<E, A, R4, E4, C>) =>
-      Effect.gen(function* ($) {
-        const deferred = yield* $(refCountDeferred<E1 | E2 | E3 | E4, C>(true))
-
-        yield* $(
-          Effect.fork(
-            signal.run(
-              Sink(
-                () => deferred.endIfComplete(sink.end),
-                flow(Effect.failCause, deferred.error),
-                deferred.endIfComplete(sink.end),
-              ),
-            ),
-          ),
-        )
-
-        yield* $(
-          Effect.fork(
-            fx.run(
-              Sink(sink.event, flow(sink.error, deferred.error), deferred.endIfComplete(sink.end)),
-            ),
-          ),
-        )
+export function until<R2, E2, B>(signal: Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => until_(fx, signal)
+}
 
-        return yield* $(deferred.await)
-      }),
-    )
+function until_<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, signal: Fx<R2, E2, B>): Fx<R | R2, E | E2, A> {
+  return Fx((emitter) =>
+    pipe(
+      signal.run(Emitter(() => exitEarly, emitter.failCause, exitEarly)),
+      Effect.forkScoped,
+      Effect.flatMap((fiber) =>
+        pipe(
+          fx.run(emitter),
+          Effect.forkScoped,
+          Effect.flatMap((fiber2) => joinAll([fiber, fiber2])),
+        ),
+      ),
+      onEarlyExitFailure(emitter.end),
+    ),
+  )
 }

package/src/withEmitter.test.ts

@@ -0,0 +1,28 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.withEmitter.name, () => {
+    it('should allow converting sync callbacks into an Fx', async () => {
+      const test = pipe(
+        Fx.withEmitter((emitter) => {
+          emitter.emit(1)
+          emitter.emit(2)
+          emitter.emit(3)
+          emitter.end()
+
+          return Effect.unit
+        }),
+        Fx.runCollect,
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})

package/src/withEmitter.ts

@@ -0,0 +1,49 @@
+import { Cause } from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { unsafeForkUnstarted } from '@effect/core/io/Fiber/_internal/runtime'
+import { Scope } from '@effect/core/io/Scope'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function withEmitter<R, E, A>(
+  f: (sink: {
+    readonly emit: (a: A) => void
+    readonly failCause: (cause: Cause<E>) => void
+    readonly end: () => void
+  }) => Effect.Canceler<R>,
+): Fx<R, E, A> {
+  return Fx<R, E, A>(<R2>(sink: Emitter<R2, E, A>) => {
+    return Effect.withFiberRuntime<R | R2 | Scope, never, unknown>((fiber, status) => {
+      const unsafeRun = <R, E, A>(
+        eff: Effect.Effect<R, E, A>,
+        observer: (exit: Exit.Exit<E, A>) => void,
+      ) => {
+        const f = unsafeForkUnstarted(eff, fiber, status.runtimeFlags)
+        f.addObserver(observer)
+        f.start(eff)
+      }
+
+      let canceler: Effect.Canceler<R> = Effect.unit
+
+      return pipe(
+        Effect.addFinalizer(Effect.suspendSucceed(() => canceler)),
+        Effect.zipRight(
+          Effect.asyncEffect<R | R2, never, unknown, R | R2, never, any>((cb) => {
+            canceler = f({
+              emit: (a) =>
+                unsafeRun(sink.emit(a), (exit) =>
+                  Exit.isFailure(exit) ? cb(Effect.failCause(exit.cause)) : undefined,
+                ),
+              failCause: (e) => unsafeRun(sink.failCause(e), flow(Effect.done, cb)),
+              end: () => unsafeRun(sink.end, flow(Effect.done, cb)),
+            })
+
+            return canceler
+          }),
+        ),
+      )
+    })
+  })
+}

package/src/zip.test.ts

@@ -1,31 +1,30 @@
 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 { delay } from './delay.js'
-import { flatMap } from './flatMap.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
-import { zip } from './zip.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('zip', () => {
     it('zips 2 fx together', async () => {
       const values = [1, 2, 3]
       const test = pipe(
-        from(values),
-        flatMap((a) =>
-          pipe(from([a, a + 1]), zip(pipe(from([a * a, a ** a]), delay(Duration.millis(10))))),
+        Fx.fromIterable(values),
+        Fx.flatMap((a) =>
+          pipe(
+            Fx.fromIterable([a, a + 1]),
+            Fx.zip(pipe(Fx.fromIterable([a * a, a ** a]), Fx.delay(Duration.millis(10)))),
+          ),
         ),
       )
-      const events = await pipe(test, collectAll, unsafeRunPromise)
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
 
       deepStrictEqual(events, [
-        [values[0] + 1, values[0] * values[0]],
-        [values[1] + 1, values[1] * values[1]],
-        [values[2] + 1, values[2] * values[2]],
+        [1 + 1, 1 * 1],
+        [2 + 1, 2 * 2],
+        [3 + 1, 3 * 3],
       ])
     })
   })