@typed/fx 0.0.9 → 0.0.10

package/perf/runFullSuite.ts

@@ -0,0 +1,37 @@
+import { spawnSync } from 'node:child_process'
+import * as fs from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const currentDir = dirname(fileURLToPath(import.meta.url))
+const casesDir = join(currentDir, '/cases')
+
+export const runPerfTestPath = join(currentDir, 'runPerfTest.ts')
+export const readmeBasePath = join(currentDir, 'readme-base.md')
+export const readmePath = join(currentDir, 'readme.md')
+export const fileNames = fs.readdirSync(casesDir).map((x) => basename(x))
+
+let readmeContent = fs.readFileSync(readmeBasePath, 'utf-8').toString()
+
+for (const fileName of fileNames) {
+  console.log('Running', 'cases/' + basename(fileName), '\n')
+
+  const { stdout } = spawnSync(`node`, [
+    `--loader`,
+    `@esbuild-kit/esm-loader`,
+    `${runPerfTestPath}`,
+    `${fileName}`,
+  ])
+
+  const output = stdout.toString()
+
+  console.log(output)
+
+  readmeContent += output
+}
+
+if (fs.existsSync(readmePath)) {
+  fs.unlinkSync(readmePath)
+}
+
+fs.writeFileSync(readmePath, readmeContent)

package/perf/runPerfTest.ts

@@ -0,0 +1,18 @@
+import process from 'node:process'
+
+import { runPerformanceTest } from './_internal.js'
+
+const fileName = process.argv.slice(2).filter((x) => x.trim() !== '--')[0]
+
+async function main() {
+  const { name, cases } = await import(
+    `./cases/${fileName}${fileName.endsWith('.ts') ? '' : '.ts'}`
+  )
+
+  runPerformanceTest({ name, cases }, () => process.exit(0))
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/perf/tsconfig.json

@@ -2,6 +2,6 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "../tsconfig.base.json",
   "include": [
-    "./*.ts"
+    "."
   ]
 }

package/src/Fx.ts

@@ -1,18 +1,50 @@
+import { Cause } from '@effect/core/io/Cause'
 import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
 
-import { Sink } from './Sink.js'
+/**
+ * TODOS:
+ * until
+ * since
+ * during
+ */
 
-export interface Fx<R, E, A, E1 = never> {
-  readonly run: <R2, E2, B>(sink: Sink<E, A, R2, E2, B>) => Effect.Effect<R | R2, E1 | E2, B>
+export interface Fx<R, E, A> {
+  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown>
 }
 
-export function Fx<R, E, A, E1 = never>(run: Fx<R, E, A, E1>['run']): Fx<R, E, A, E1> {
-  return { run }
+export function Fx<R, E, A>(run: Fx<R, E, A>['run']): Fx<R, E, A> {
+  return {
+    run,
+  }
 }
 
 export namespace Fx {
-  export type ResourcesOf<T> = T extends Fx<infer R, any, any, any> ? R : never
-  export type ErrorsOf<T> = T extends Fx<any, infer E, any, any> ? E : never
-  export type OutputOf<T> = T extends Fx<any, any, infer A, any> ? A : never
-  export type ReturnErrorsOf<T> = T extends Fx<any, any, any, infer E1> ? E1 : never
+  export type ResourcesOf<T> = T extends Fx<infer R, any, any> ? R : never
+  export type ErrorsOf<T> = T extends Fx<any, infer E, any> ? E : never
+  export type OutputOf<T> = T extends Fx<any, any, infer A> ? A : never
+}
+
+export interface Emitter<R, E, A> {
+  readonly emit: (a: A) => Effect.Effect<R, never, unknown>
+  readonly failCause: (e: Cause<E>) => Effect.Effect<R, never, unknown>
+  readonly end: Effect.Effect<R, never, unknown>
+}
+
+export function Emitter<R, E, A>(
+  emit: Emitter<R, E, A>['emit'],
+  failCause: Emitter<R, E, A>['failCause'],
+  end: Emitter<R, E, A>['end'],
+): Emitter<R, E, A> {
+  return {
+    emit,
+    failCause,
+    end,
+  }
+}
+
+export namespace Emitter {
+  export type ResourcesOf<T> = T extends Emitter<infer R, any, any> ? R : never
+  export type ErrorsOf<T> = T extends Emitter<any, infer E, any> ? E : never
+  export type OutputOf<T> = T extends Emitter<any, any, infer A> ? A : never
 }

package/src/_internal.ts

@@ -1,129 +1,74 @@
+import {
+  CountdownLatch,
+  CountdownLatchInternal,
+} from '@effect/core/concurrent/CountdownLatch/definition'
+import * as Cause from '@effect/core/io/Cause'
 import * as Deferred from '@effect/core/io/Deferred'
 import * as Effect from '@effect/core/io/Effect'
-import { Exit } from '@effect/core/io/Exit'
-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 { pipe } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { isSome } from '@tsplus/stdlib/data/Maybe'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-export const asap = Schedule.delayed(() => Duration.millis(0))(Schedule.once)
-
-export function refCountDeferred<E, A>(initialEnded = false, initialCount = 0) {
-  return Effect.gen(function* ($) {
-    const ended = yield* $(Ref.makeRef<boolean>(() => initialEnded))
-    const ref = yield* $(Ref.makeSynchronized(() => initialCount))
-    const deferred = yield* $(Deferred.make<E, A>())
-    const increment = ref.update((a) => a + 1)
-    const decrement = ref.update((a) => Math.max(0, a - 1))
-    const refCount = ref.get
+export const EARLY_EXIT_FAILURE = Symbol('EarlyExitFailure')
+export interface EarlyExitFailure {
+  readonly sym: typeof EARLY_EXIT_FAILURE
+}
+export const EarlyExitFailure: EarlyExitFailure = { sym: EARLY_EXIT_FAILURE }
 
-    return {
-      await: deferred.await,
-      endIfComplete: <R>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, void> =>
-        Effect.gen(function* ($) {
-          if ((yield* $(ended.get)) && (yield* $(refCount)) === 0) {
-            yield* $(pipe(effect, Effect.intoDeferred(deferred)))
-          }
-        }),
-      error: <R>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, never, void> =>
-        Effect.gen(function* ($) {
-          yield* $(ended.set(true))
-          yield* $(pipe(effect, Effect.intoDeferred(deferred)))
-        }),
-      increment,
-      decrement,
-      refCount,
-      ended: ended.get,
-      end: ended.set(true),
-    }
-  })
+export function isEarlyExitFailure(u: unknown): u is EarlyExitFailure {
+  return typeof u === 'object' && u !== null && (u as any).sym === EARLY_EXIT_FAILURE
 }
 
-export function deferredCallback<E, A, R2, E2>(
-  f: (cb: (exit: Exit<E, A>) => Effect.Effect<never, never, never>) => Effect.Effect<R2, E2, A>,
-): Effect.Effect<R2, E | E2, A> {
-  return Effect.scoped(
-    Effect.gen(function* ($) {
-      const deferred = yield* $(Deferred.make<E, A>())
-      const fiber = yield* $(
-        Effect.forkScoped(
-          f((exit) => {
-            deferred.unsafeDone(Effect.done(exit))
+export const exitEarly = Effect.die(EarlyExitFailure)
 
-            return Effect.never
-          }),
-        ),
-      )
+export const onEarlyExitFailure =
+  <R2, E2, B>(handler: Effect.Effect<R2, E2, B>) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R | R2, E | E2, A | B> =>
+    pipe(
+      effect,
+      Effect.foldCauseEffect<E, A, R | R2, E | E2, A | B, R | R2, E | E2, A | B>(
+        (e) =>
+          pipe(
+            e,
+            Cause.dieMaybe,
+            Maybe.fold(
+              () => Effect.failCause(e),
+              (d) => (isEarlyExitFailure(d) ? handler : Effect.failCause(e)),
+            ),
+          ),
+        Effect.succeed,
+      ),
+    )
 
-      yield* $(Effect.addFinalizer(Fiber.interrupt(fiber)))
+/**
+ * A small wrapper around CountdownLatch which enables incrementing
+ * the latch count dynamically
+ */
+export type DynamicCountdownLatch = {
+  readonly increment: Effect.Effect<never, never, void>
+  readonly latch: CountdownLatch
+}
 
-      return yield* $(Effect.race(deferred.await)(Fiber.join(fiber)))
-    }),
+export function makeDynamicCountdownLatch(
+  initialCount: number,
+): Effect.Effect<never, never, DynamicCountdownLatch> {
+  return pipe(
+    Ref.makeRef<number>(() => initialCount),
+    Effect.zipWith(Deferred.make<never, void>(), (ref, deferred) => ({
+      increment: ref.update((x) => x + 1),
+      latch: new CountdownLatchInternal(ref, deferred),
+    })),
   )
 }
 
-type RefOutput<T> = T extends Ref.Ref<infer R> ? R : never
-
-export function tupleRef<Refs extends ReadonlyArray<Ref.Ref<any>>>(
-  refs: readonly [...Refs],
-): Ref.Ref<{ readonly [K in keyof Refs]: RefOutput<Refs[K]> }> {
-  const get = Effect.gen(function* ($) {
-    const result: any[] = []
-
-    for (const ref of refs) {
-      result.push(yield* $(ref.get))
-    }
-
-    return result as unknown as { readonly [K in keyof Refs]: RefOutput<Refs[K]> }
-  })
-
-  const set = (a: { readonly [K in keyof Refs]: RefOutput<Refs[K]> }) =>
-    Effect.gen(function* ($) {
-      let i = 0
-      for (const ref of refs) {
-        yield* $(ref.set(a[i++]))
-      }
-    })
-
-  const tupledRef = {
-    [Ref.RefSym]: Ref.RefSym,
-    get,
-    set,
-    update: (f) =>
-      pipe(
-        get,
-        Effect.flatMap((a) => set(f(a))),
-      ),
-    updateSome: (f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap((a) => (isSome(a) ? set(a.value) : Effect.unit)),
-      ),
-    modify: (f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap(([b, a]) => pipe(a, set, Effect.as(b))),
-      ),
-    modifySome: (fallback, f) =>
-      pipe(
-        get,
-        Effect.map(f),
-        Effect.flatMap((maybe) =>
-          isSome(maybe)
-            ? pipe(maybe.value[1], set, Effect.as(maybe.value[0]))
-            : Effect.succeed(fallback),
-        ),
-      ),
-    getAndSet: (a) => pipe(get, Effect.zipLeft(set(a))),
-    getAndUpdate: (f) => pipe(get, Effect.zipLeft(tupledRef.update(f))),
-    getAndUpdateSome: (f) => pipe(get, Effect.zipLeft(tupledRef.updateSome(f))),
-    updateAndGet: (f) => pipe(tupledRef.update(f), Effect.zipRight(get)),
-    updateSomeAndGet: (f) => pipe(tupledRef.updateSome(f), Effect.zipRight(get)),
-  } as Ref.Ref<{ readonly [K in keyof Refs]: RefOutput<Refs[K]> }>
-
-  return tupledRef
+export function withDynamicCountdownLatch<R, E, A, R2, E2, B>(
+  initialCount: number,
+  f: (latch: DynamicCountdownLatch) => Effect.Effect<R, E, A>,
+  onEnd: Effect.Effect<R2, E2, B>,
+): Effect.Effect<R | R2, E | E2, B> {
+  return pipe(
+    makeDynamicCountdownLatch(initialCount),
+    Effect.tap(f),
+    Effect.flatMap(({ latch }) => pipe(latch.await, Effect.zipRight(onEnd))),
+  )
 }

package/src/combine.test.ts

@@ -1,34 +1,33 @@
 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 { combine } from './combine.js'
-import { delay } from './delay.js'
-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('combine', () => {
     it('combines 2 fx together', async () => {
       const values = [1, 2, 3]
       const test = pipe(
-        from(values),
-        flatMap((a) =>
-          pipe(from([a, a + 1]), combine(pipe(from([a * a, a ** a]), delay(Duration.millis(10))))),
+        Fx.fromIterable(values),
+        Fx.flatMap((a) =>
+          pipe(
+            Fx.fromIterable([a, a + 1]),
+            Fx.combine(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]],
-        [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],
+        [1 + 1, 1 ** 1],
+        [2 + 1, 2 ** 2],
+        [3 + 1, 3 ** 3],
       ])
     })
   })

package/src/combine.ts

@@ -1,66 +1,62 @@
 import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import { pipe } from '@fp-ts/data/Function'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred, tupleRef } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
 
-export function combine<R2, E2, B, E3>(other: Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, readonly [A, B], E1 | E3> =>
-    combineAll([self, other])
+export function combine<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
+    combineAll([first, second])
 }
 
-export function combineAll<FX extends ReadonlyArray<Fx<any, any, any, any>>>(
+export function combineAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: readonly [...FX],
 ): Fx<
   Fx.ResourcesOf<FX[number]>,
   Fx.ErrorsOf<FX[number]>,
-  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> },
-  Fx.ReturnErrorsOf<FX[number]>
+  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> }
 >
 
-export function combineAll<R2, E2, B, E3>(
-  fx: Iterable<Fx<R2, E2, B, E3>>,
-): Fx<R2, E2, ReadonlyArray<B>, E3>
-
-export function combineAll<R2, E2, B, E3>(
-  fx: Iterable<Fx<R2, E2, B, E3>>,
-): Fx<R2, E2, ReadonlyArray<B>, E3> {
-  return Fx(<R4, E4, C>(sink: Sink<E2, ReadonlyArray<B>, R4, E4, C>) =>
-    Effect.gen(function* ($) {
-      const array = Array.from(fx)
-      const deferred = yield* $(refCountDeferred<E3 | E4, C>(true, array.length))
-      const refs = Array.from(
-        yield* $(Effect.forEach(array, () => Ref.makeRef<Maybe.Maybe<B>>(() => Maybe.none))),
-      )
-      const ref = tupleRef(refs)
-
-      const emitIfReady = pipe(
-        ref.get,
-        Effect.map((as) => as.filter(Maybe.isSome).map((x) => x.value)),
-        Effect.flatMap((bs) => (bs.length === array.length ? sink.event(bs) : Effect.unit)),
-      )
-
-      yield* $(
-        Effect.forEachParWithIndex(array, (fx, i) =>
-          Effect.fork(
-            fx.run(
-              Sink(
-                (a) => pipe(refs[i].set(Maybe.some(a)), Effect.zipRight(emitIfReady)),
-                flow(sink.error, deferred.error),
-                pipe(
-                  deferred.decrement,
-                  Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+export function combineAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>>
+
+export function combineAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>> {
+  return Fx((emitter) =>
+    Effect.suspendSucceed(() => {
+      const array = Array.from(iterable)
+
+      return pipe(
+        Effect.sync<Maybe.Maybe<A>[]>(() => Array(array.length)),
+        Effect.flatMap((ref) =>
+          Effect.suspendSucceed(() => {
+            const emitIfReady = pipe(
+              Effect.sync(() => ref.filter(Maybe.isSome).map((x) => x.value)),
+              Effect.flatMap((bs) => (bs.length === array.length ? emitter.emit(bs) : Effect.unit)),
+            )
+
+            return withDynamicCountdownLatch(
+              array.length,
+              ({ latch }) =>
+                Effect.forEachWithIndex(array, (fx, i) =>
+                  Effect.forkScoped(
+                    fx.run(
+                      Emitter(
+                        (a) =>
+                          pipe(
+                            Effect.sync(() => (ref[i] = Maybe.some(a))),
+                            Effect.zipRight(emitIfReady),
+                          ),
+                        emitter.failCause,
+                        latch.countDown,
+                      ),
+                    ),
+                  ),
                 ),
-              ),
-            ),
-          ),
+              emitter.end,
+            )
+          }),
         ),
       )
-
-      return yield* $(deferred.await)
     }),
   )
 }

package/src/continueWith.test.ts

@@ -0,0 +1,26 @@
+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.continueWith.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2]),
+            Fx.continueWith(() => Fx.fromIterable([3, 4])),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3, 4])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/continueWith.ts

@@ -1,23 +1,21 @@
 import * as Effect from '@effect/core/io/Effect'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 import { succeed } from './fromEffect.js'
 
-export function continueWith<R2, E2, B, E3>(continueWith: () => Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
-    Fx((sink) =>
+export function continueWith<R2, E2, B>(f: () => Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    Fx((emitter) =>
       fx.run(
-        Sink(
-          sink.event,
-          sink.error,
-          Effect.suspendSucceed(() => continueWith().run(sink)),
+        Emitter(
+          emitter.emit,
+          emitter.failCause,
+          Effect.suspendSucceed(() => f().run(emitter)),
         ),
       ),
     )
 }
 
 export function startWith<B>(value: B) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A | B, E1> =>
-    continueWith(() => fx)(succeed(value))
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B | A> => continueWith(() => fx)(succeed(value))
 }

package/src/debounce.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 { debounce } from './debounce.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('debounce', () => {
     it('favors the latest overlapping event', async () => {
-      const test = pipe(from([1, 2, 3]), debounce(millis(100)), collectAll)
+      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.debounce(millis(100)), Fx.runCollect)
 
-      deepStrictEqual(await unsafeRunPromise(test), [3])
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [3])
     })
   })
 })

package/src/debounce.ts

@@ -1,68 +1,49 @@
 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 debounce(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 debounce(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => debounce_(fx, duration)
+}
 
-          return yield* $(
+function debounce_<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((previous) =>
-                    Effect.gen(function* (_) {
-                      if (previous) {
-                        yield* _(Fiber.interrupt(previous))
-                      } else {
-                        yield* $(deferred.increment)
-                      }
-
-                      return yield* _(
+                    pipe(
+                      previous ? Fiber.interrupt(previous) : increment,
+                      Effect.flatMap(() =>
                         pipe(
-                          sink.event(a),
-                          Effect.schedule(Schedule.delayed(() => duration)(Schedule.once)),
+                          emitter.emit(a),
+                          Effect.delay(duration),
                           Effect.interruptible,
-                          Effect.tap(() =>
-                            pipe(
-                              deferred.decrement,
-                              Effect.zipRight(deferred.endIfComplete(sink.end)),
-                            ),
-                          ),
+                          Effect.tap(() => latch.countDown),
                           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,
               ),
             ),
-          )
-        }),
-    )
-}
-
-/**
- *     pipe(
-        Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
-        Effect.flatMap((ref) =>
-          ,
+          emitter.end,
         ),
-        Effect.scoped,
       ),
- */
+    ),
+  )
+}