@typed/fx 0.0.35 → 1.0.2

package/perf/helpers.ts

@@ -1,60 +0,0 @@
-import * as url from 'node:url'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as MC from '@most/core'
-import * as MS from '@most/scheduler'
-import { asap } from '@most/scheduler'
-import * as MT from '@most/types'
-import * as rxjs from 'rxjs'
-
-import * as Fx from '../src/index'
-import { PerformanceTestCase } from '../tools/benchmark.js'
-
-export function effectTest<E, A>(init: () => Effect.Effect<never, E, A>) {
-  return PerformanceTestCase('effect/Stream', init, Effect.unsafeRunPromise)
-}
-
-export function rxjsTest<A>(init: () => rxjs.Observable<A>) {
-  return PerformanceTestCase('rxjs @7', init, (o) => new Promise((resolve) => o.subscribe(resolve)))
-}
-
-export function mostTest<A>(init: (fromArray: typeof mostFromArray) => MT.Stream<A>) {
-  const scheduler = MS.newDefaultScheduler()
-
-  return PerformanceTestCase(
-    '@most/core',
-    () => init(mostFromArray),
-    (o) => MC.runEffects(o, scheduler),
-  )
-}
-
-export function mostFromArray<A>(array: readonly A[]): MT.Stream<A> {
-  const l = array.length
-  return MC.newStream((sink, scheduler) =>
-    asap(
-      {
-        run(t) {
-          for (let i = 0; i < l; ++i) {
-            sink.event(t, array[i])
-          }
-          sink.end(t)
-        },
-        error(t, e) {
-          sink.error(t, e)
-        },
-        dispose() {
-          // Nothing to dispose
-        },
-      },
-      scheduler,
-    ),
-  )
-}
-
-export function fxTest<E, A>(init: () => Fx.Fx<never, E, A>) {
-  return PerformanceTestCase('@typed/fx', () => Fx.runDrain(init()), Effect.unsafeRunPromise)
-}
-
-export function isMain(meta: ImportMeta) {
-  return meta.url.startsWith('file:') && process.argv[1] === url.fileURLToPath(meta.url)
-}

package/perf/readme.md

@@ -1,29 +0,0 @@
-## filter -> map -> reduce 100000 integers
-
-| Library       | Average  | Min     | Max      | Time to init | Overhead |
-| :------------ | :------- | :------ | :------- | :----------- | :------- |
-| @most/core    | 0.2568   | 0.1631  | 0.3892   | 0.3249       | 1        |
-| @typed/fx     | 18.8323  | 16.4398 | 20.9216  | 2.6015       | 73.3345  |
-| rxjs @7       | 57.6014  | 44.5954 | 112.446  | 0.3096       | 224.3045 |
-| effect/Stream | 123.0393 | 93.0288 | 655.9159 | 0.6783       | 479.125  |
-
-
-
-## flatMap 1000 * 1000 integers
-
-| Library       | Average   | Min       | Max       | Time to init | Overhead |
-| :------------ | :-------- | :-------- | :-------- | :----------- | :------- |
-| @most/core    | 15.4904   | 12.6532   | 16.4449   | 0.1212       | 1        |
-| @typed/fx     | 234.3654  | 220.5097  | 230.1482  | 0.6584       | 15.1297  |
-| effect/Stream | 1120.986  | 721.7412  | 1270.016  | 0.4573       | 72.3665  |
-| rxjs @7       | 1202.6763 | 1092.9419 | 1538.5066 | 0.1441       | 77.6401  |
-
-
-
-## switchMap 1000 * 1000 integers
-
-| Library    | Average  | Min      | Max       | Time to init | Overhead |
-| :--------- | :------- | :------- | :-------- | :----------- | :------- |
-| @most/core | 2.0085   | 0.9466   | 4.1761    | 0.2004       | 1        |
-| @typed/fx  | 186.2795 | 156.3581 | 180.712   | 0.5469       | 92.7456  |
-| rxjs @7    | 943.8542 | 876.9877 | 1019.2166 | 0.4218       | 469.9299 |

package/perf/runPerfTest.ts

@@ -1,25 +0,0 @@
-import { TestSuiteResult, printTestSuiteResult } from '../tools/benchmark.js'
-
-import { isMain } from './helpers.js'
-
-export const results: readonly TestSuiteResult[] = await runSequentially([
-  () => import('./cases/filter-map-reduce.js').then((x) => x.result),
-  () => import('./cases/flatMap.js').then((x) => x.result),
-  () => import('./cases/switchMap.js').then((x) => x.result),
-])
-
-if (isMain(import.meta)) {
-  console.log('\n\n')
-  console.log(results.map(printTestSuiteResult).join('\n\n'))
-}
-
-async function runSequentially<Promises extends ReadonlyArray<() => Promise<any>>>(
-  tasks: Promises,
-): Promise<{ readonly [K in keyof Promises]: Awaited<ReturnType<Promises[K]>> }> {
-  const results: any[] = []
-  for (const task of tasks) {
-    results.push(await task())
-  }
-
-  return results as any
-}

package/readme.md

@@ -1,7 +0,0 @@
-# @typed/fx
-
-`Fx` is a toolkit for composing synchronous, asynchronous, and event-based programs using reactive programming.
-
-It is built directly atop of [Effect-ts](https://github.com/Effect-TS/core) an inherits all of its capabilities
-while being able to be bi-directionally converted `Effect <-> Fx`. `Fx` is intended to be the shorthand for plural form of `Effect` "Effects".
-

package/src/Subject.test.ts

@@ -1,95 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe('Subject', () => {
-    it('creates a stream which can be pushed into imperatively', async () => {
-      const subject = Fx.Subject.unsafeMake<number, number>()
-      const promise = pipe(
-        subject,
-        Fx.map((n) => n * 2),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      subject.unsafeEmit(1)
-      subject.unsafeEmit(2)
-      subject.unsafeEmit(3)
-      subject.unsafeEnd()
-
-      deepStrictEqual(await promise, [2, 4, 6])
-    })
-  })
-
-  describe('RefSubject', () => {
-    it('creates a Ref to sample the current value of the stream', async () => {
-      const test = Effect.gen(function* ($) {
-        const subject = Fx.RefSubject.unsafeMake(() => 1)
-        const fiber = yield* $(
-          pipe(
-            subject,
-            Fx.map((n) => n * 2),
-            Fx.filter((x) => x % 2 === 0),
-            Fx.runCollect,
-            Effect.fork,
-          ),
-        )
-
-        deepStrictEqual(yield* $(subject.get), 1)
-
-        yield* $(subject.emit(1))
-
-        deepStrictEqual(yield* $(subject.get), 1)
-
-        yield* $(subject.emit(2))
-
-        deepStrictEqual(yield* $(subject.get), 2)
-
-        yield* $(subject.emit(3))
-
-        deepStrictEqual(yield* $(subject.get), 3)
-
-        yield* $(subject.end)
-
-        const events = yield* $(Fiber.join(fiber))
-
-        deepStrictEqual(events, [2, 2, 4, 6])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-
-    it('emits values when ref is updated', async () => {
-      const test = Effect.gen(function* ($) {
-        const subject = Fx.RefSubject.unsafeMake(() => 1)
-        const fiber = yield* $(
-          pipe(
-            subject,
-            Fx.map((n) => n * 2),
-            Fx.filter((x) => x % 2 === 0),
-            Fx.runCollect,
-            Effect.fork,
-          ),
-        )
-
-        deepStrictEqual(yield* $(subject.get), 1)
-
-        yield* $(subject.update((x) => x + 1))
-        yield* $(subject.update((x) => x + 1))
-        yield* $(subject.update((x) => x + 1))
-        yield* $(subject.end)
-
-        const events = yield* $(Fiber.join(fiber))
-
-        deepStrictEqual(events, [2, 4, 6, 8])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})

package/src/Subject.ts

@@ -1,230 +0,0 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { AtomicInternal, UnsafeAPI } from '@effect/core/io/Ref/operations/_internal/AtomicInternal'
-import { SynchronizedInternal } from '@effect/core/io/Ref/operations/_internal/SynchronizedInternal'
-import * as TSemaphore from '@effect/core/stm/TSemaphore'
-import { flow } from '@fp-ts/data/Function'
-import { LazyArg, pipe } from '@tsplus/stdlib/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { never } from './fromEffect.js'
-import { Hold } from './hold.js'
-import { Multicast } from './multicast.js'
-
-export function makeSubject<E, A>(): Effect.Effect<never, never, Subject<E, A>> {
-  return Effect.sync(() => Subject.unsafeMake<E, A>())
-}
-
-export function makeHoldSubject<E, A>(): Effect.Effect<never, never, HoldSubject<E, A>> {
-  return Effect.sync(() => HoldSubject.unsafeMake<E, A>())
-}
-
-export function makeRefSubject<A, E = never>(
-  initial: LazyArg<A>,
-): Effect.Effect<never, never, RefSubject<E, A>> {
-  return Effect.sync(() => RefSubject.unsafeMake<A, E>(initial))
-}
-
-export function makeSynchronizedSubject<A, E = never>(
-  initial: LazyArg<A>,
-): Effect.Effect<never, never, SynchronizedSubject<E, A>> {
-  return Effect.sync(() => SynchronizedSubject.unsafeMake<A, E>(initial))
-}
-
-export interface Subject<E, A> extends Fx<never, E, A>, Emitter<never, E, A>, UnsafeEmitter<E, A> {}
-
-export interface UnsafeEmitter<E, A> {
-  readonly unsafeEmit: (a: A) => void
-  readonly unsafeFailCause: (cause: Cause<E>) => void
-  readonly unsafeEnd: () => void
-}
-
-const FX_BRANDING = {
-  _R: () => void 0 as never,
-  _E: () => void 0 as any,
-  _A: () => void 0 as any,
-}
-
-export namespace Subject {
-  export const unsafeMake = <E, A>(): Subject<E, A> => {
-    const m = new Multicast<never, E, A>(never)
-
-    return {
-      ...FX_BRANDING,
-      run: m.run.bind(m),
-      emit: m.emit.bind(m),
-      failCause: m.failCause.bind(m),
-      end: m.end,
-      unsafeEmit: (a) => Effect.unsafeRunAsync(m.emit(a)),
-      unsafeFailCause: (c) => Effect.unsafeRunAsync(m.failCause(c)),
-      unsafeEnd: () => Effect.unsafeRunAsync(m.end),
-    }
-  }
-}
-
-export interface HoldSubject<E, A> extends Subject<E, A> {
-  readonly get: Effect.Effect<never, never, Maybe.Maybe<A>>
-}
-
-export namespace HoldSubject {
-  export const unsafeMake = <E, A>(): HoldSubject<E, A> => {
-    const h = new Hold<never, E, A>(never)
-
-    return {
-      ...FX_BRANDING,
-      get: Effect.sync(() => h.value.get),
-      run: (e) => h.run(e),
-      emit: (a) => h.emit(a),
-      failCause: (e) => h.failCause(e),
-      end: h.end,
-      unsafeEmit: (a) => Effect.unsafeRunAsync(h.emit(a)),
-      unsafeFailCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
-      unsafeEnd: () => Effect.unsafeRunAsync(h.end),
-    }
-  }
-}
-
-export interface RefSubject<E, A> extends Subject<E, A>, Ref.Ref<A> {}
-
-export namespace RefSubject {
-  export const unsafeMake = <A, E = never>(initial: LazyArg<A>): RefSubject<E, A> => {
-    const h = new Hold<never, E, A>(never)
-    const maybeRef: Ref.Ref<Maybe.Maybe<A>> = new AtomicInternal(new UnsafeAPI(h.value))
-    const ref = emitRefChanges(invmapRef(maybeRef, Maybe.getOrElse(initial), Maybe.some), h)
-
-    // Ensure there is always a value in the Ref
-    h.value.set(Maybe.some(initial()))
-
-    return {
-      ...FX_BRANDING,
-      [Ref.RefSym]: Ref.RefSym,
-      [Ref._A]: (_) => _,
-      get: ref.get,
-      modify: (f) => ref.modify(f),
-      set: (a) => ref.set(a),
-      getAndSet: (a) => ref.getAndSet(a),
-      getAndUpdate: (f) => ref.getAndUpdate(f),
-      getAndUpdateSome: (f) => ref.getAndUpdateSome(f),
-      modifySome: (fallback, f) => ref.modifySome(fallback, f),
-      update: (f) => ref.update(f),
-      updateAndGet: (f) => ref.updateAndGet(f),
-      updateSome: (f) => ref.updateSome(f),
-      updateSomeAndGet: (f) => ref.updateSomeAndGet(f),
-      run: h.run.bind(h),
-      emit: ref.set,
-      failCause: h.failCause.bind(h),
-      end: h.end,
-      unsafeEmit: (a) => Effect.unsafeRunAsync(ref.set(a)),
-      unsafeFailCause: (c) => Effect.unsafeRunAsync(h.failCause(c)),
-      unsafeEnd: () => Effect.unsafeRunAsync(h.end),
-    }
-  }
-}
-
-export interface SynchronizedSubject<E, A> extends RefSubject<E, A>, Ref.Ref.Synchronized<A> {}
-
-export namespace SynchronizedSubject {
-  export const unsafeMake = <A, E = never>(initial: LazyArg<A>): SynchronizedSubject<E, A> => {
-    const subject = RefSubject.unsafeMake<A, E>(initial)
-    const synchronizedRef = new SynchronizedInternal(subject, TSemaphore.unsafeMake(1))
-
-    return {
-      ...subject,
-      [Ref.SynchronizedSym]: Ref.SynchronizedSym,
-      modifyEffect: (f) => synchronizedRef.modifyEffect(f),
-      modifySomeEffect: (fallback, f) => synchronizedRef.modifySomeEffect(fallback, f),
-      getAndUpdateEffect: (f) => synchronizedRef.getAndUpdateEffect(f),
-      getAndUpdateSomeEffect: (f) => synchronizedRef.getAndUpdateSomeEffect(f),
-      updateEffect: (f) => synchronizedRef.updateEffect(f),
-      updateAndGetEffect: (f) => synchronizedRef.updateAndGetEffect(f),
-      updateSomeEffect: (f) => synchronizedRef.updateSomeEffect(f),
-      updateSomeAndGetEffect: (f) => synchronizedRef.updateSomeAndGetEffect(f),
-    }
-  }
-}
-
-function invmapRef<A, B>(ref: Ref.Ref<A>, to: (a: A) => B, from: (b: B) => A): Ref.Ref<B> {
-  const get: Ref.Ref<B>['get'] = pipe(ref.get, Effect.map(to))
-
-  const modify: Ref.Ref<B>['modify'] = (f) =>
-    ref.modify((a) => {
-      const [b, c] = f(to(a))
-      return [b, from(c)]
-    })
-
-  const set: Ref.Ref<B>['set'] = flow(from, ref.set)
-
-  const getAndSet: Ref.Ref<B>['getAndSet'] = flow(from, ref.getAndSet, Effect.map(to))
-
-  const getAndUpdate: Ref.Ref<B>['getAndUpdate'] = (f) =>
-    pipe(ref.getAndUpdate(flow(to, f, from)), Effect.map(to))
-
-  const getAndUpdateSome: Ref.Ref<B>['getAndUpdateSome'] = (f) =>
-    pipe(ref.getAndUpdateSome(flow(to, f, Maybe.map(from))), Effect.map(to))
-
-  const modifySome: Ref.Ref<B>['modifySome'] = (fallback, f) =>
-    ref.modifySome(fallback, (a) =>
-      pipe(
-        a,
-        to,
-        f,
-        Maybe.map(([c, b]) => [c, from(b)]),
-      ),
-    )
-
-  const update: Ref.Ref<B>['update'] = (f) => ref.update(flow(to, f, from))
-
-  const updateAndGet: Ref.Ref<B>['updateAndGet'] = (f) =>
-    pipe(ref.updateAndGet(flow(to, f, from)), Effect.map(to))
-
-  const updateSome: Ref.Ref<B>['updateSome'] = (f) => ref.updateSome(flow(to, f, Maybe.map(from)))
-
-  const updateSomeAndGet: Ref.Ref<B>['updateSomeAndGet'] = (f) =>
-    pipe(ref.updateSomeAndGet(flow(to, f, Maybe.map(from))), Effect.map(to))
-
-  return {
-    [Ref.RefSym]: Ref.RefSym,
-    [Ref._A]: (_) => _,
-    get,
-    modify,
-    set,
-    getAndSet,
-    getAndUpdate,
-    getAndUpdateSome,
-    modifySome,
-    update,
-    updateAndGet,
-    updateSome,
-    updateSomeAndGet,
-  }
-}
-
-function emitRefChanges<A, E>(ref: Ref.Ref<A>, subject: Emitter<never, E, A>): Ref.Ref<A> {
-  const andEmitLatestValue = Effect.zipLeft(pipe(ref.get, Effect.flatMap(subject.emit)))
-
-  return {
-    [Ref.RefSym]: Ref.RefSym,
-    [Ref._A]: (_) => _,
-    get: ref.get,
-    modify: (f) => pipe(ref.modify(f), andEmitLatestValue),
-    set: (a) =>
-      pipe(
-        ref.update(() => a),
-        Effect.zipLeft(subject.emit(a)),
-      ),
-    getAndSet: (a) =>
-      pipe(
-        ref.getAndUpdate(() => a),
-        Effect.zipLeft(subject.emit(a)),
-      ),
-    getAndUpdate: (f) => pipe(ref.getAndUpdate(f), andEmitLatestValue),
-    getAndUpdateSome: (f) => pipe(ref.getAndUpdateSome(f), andEmitLatestValue),
-    modifySome: (fallback, f) => pipe(ref.modifySome(fallback, f), andEmitLatestValue),
-    update: (f) => pipe(ref.update(f), andEmitLatestValue),
-    updateAndGet: (f) => pipe(ref.updateAndGet(f), andEmitLatestValue),
-    updateSome: (f) => pipe(ref.updateSome(f), andEmitLatestValue),
-    updateSomeAndGet: (f) => pipe(ref.updateSomeAndGet(f), andEmitLatestValue),
-  }
-}

package/src/_internal.ts

@@ -1,72 +0,0 @@
-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 * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-
-export const EARLY_EXIT_FAILURE = Symbol('EarlyExitFailure')
-export interface EarlyExitFailure {
-  readonly sym: typeof EARLY_EXIT_FAILURE
-}
-export const EarlyExitFailure: EarlyExitFailure = { sym: EARLY_EXIT_FAILURE }
-
-export function isEarlyExitFailure(u: unknown): u is EarlyExitFailure {
-  return typeof u === 'object' && u !== null && (u as any).sym === EARLY_EXIT_FAILURE
-}
-
-export const exitEarly = Effect.die(EarlyExitFailure)
-
-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) => {
-        const defects = Cause.defects(e)
-
-        for (const defect of defects) {
-          if (isEarlyExitFailure(defect)) {
-            return handler
-          }
-        }
-
-        return Effect.failCause(e)
-      }, Effect.succeed),
-    )
-
-/**
- * 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
-}
-
-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),
-    })),
-  )
-}
-
-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 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-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(
-        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, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, [
-        [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 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-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>>>(
-  fx: readonly [...FX],
-): Fx<
-  Fx.ResourcesOf<FX[number]>,
-  Fx.ErrorsOf<FX[number]>,
-  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> }
->
-
-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)
-
-      if (array.length === 0) {
-        return pipe(emitter.emit([]), Effect.zipRight(emitter.end))
-      }
-
-      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,
-            )
-          }),
-        ),
-      )
-    }),
-  )
-}

package/src/continueWith.test.ts

@@ -1,26 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/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,21 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-
-import { Emitter, Fx } from './Fx.js'
-import { succeed } from './fromEffect.js'
-
-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(
-        Emitter(
-          emitter.emit,
-          emitter.failCause,
-          Effect.suspendSucceed(() => f().run(emitter)),
-        ),
-      ),
-    )
-}
-
-export function startWith<B>(value: B) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B | A> => continueWith(() => fx)(succeed(value))
-}

package/src/debounce.test.ts

@@ -1,17 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { millis } from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe('debounce', () => {
-    it('favors the latest overlapping event', async () => {
-      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.debounce(millis(100)), Fx.runCollect)
-
-      deepStrictEqual(await Effect.unsafeRunPromise(test), [3])
-    })
-  })
-})