@typed/fx 0.0.8 → 0.0.9

package/perf/_internal.ts

@@ -0,0 +1,149 @@
+import { performance } from 'node:perf_hooks'
+
+import * as EffectStream from '@effect/core/Stream/Stream'
+import * as Effect from '@effect/core/io/Effect'
+import * as M from '@most/core'
+import * as MS from '@most/scheduler'
+import * as MT from '@most/types'
+import benchmark, { Suite } from 'benchmark'
+import * as RxJS from 'rxjs'
+
+import * as Fx from '@/index.js'
+
+export function parseIterations() {
+  const i = parseInt(process.argv[2], 10)
+
+  return Number.isNaN(i) ? 10000 : i
+}
+
+export const iterations = parseIterations()
+export const array = Array.from({ length: iterations }, (_, i) => i)
+
+export function runSuite(suite: Suite) {
+  suite.on('start', logStart).on('cycle', logResults).on('complete', logComplete).run()
+}
+
+function logResults(e: any) {
+  const t = e.target
+
+  if (t.failure) {
+    console.error(padl(10, t.name) + 'FAILED: ' + e.target.failure)
+  } else {
+    const result =
+      padl(18, t.name) +
+      padr(13, t.hz.toFixed(2) + ' op/s') +
+      ' \xb1' +
+      padr(7, t.stats.rme.toFixed(2) + '%') +
+      padr(15, ' (' + t.stats.sample.length + ' samples)')
+
+    console.log(result)
+  }
+}
+
+function logStart(this: any) {
+  console.log(this.name)
+  console.log('-------------------------------------------------------')
+}
+
+function logComplete() {
+  console.log('-------------------------------------------------------')
+  process.exit(0)
+}
+
+function padl(n: number, s: string) {
+  while (s.length < n) {
+    s += ' '
+  }
+  return s
+}
+
+function padr(n: number, s: string) {
+  while (s.length < n) {
+    s = ' ' + s
+  }
+  return s
+}
+
+export function timeConstruction(label: string) {
+  const start = performance.now()
+  return () => {
+    const end = performance.now()
+    console.log(label, end - start)
+  }
+}
+
+export interface PerformanceTest {
+  readonly name: string
+  readonly cases: readonly PerformanceTestCase<any>[]
+}
+
+export interface PerformanceTestCase<A> {
+  name: string
+  init: () => A
+  run: (a: A, deferred: benchmark.Deferred) => void
+}
+
+export function PerformanceTestCase<A>(
+  name: string,
+  init: () => A,
+  run: (a: A, deferred: benchmark.Deferred) => void,
+): PerformanceTestCase<A> {
+  return { name, init, run }
+}
+
+export function runPerformanceTest(test: PerformanceTest) {
+  // eslint-disable-next-line import/no-named-as-default-member
+  let suite = new benchmark.Suite(test.name)
+
+  for (const testCase of test.cases) {
+    const end = timeConstruction(testCase.name)
+    const constructed = testCase.init()
+    end()
+
+    suite = suite.add(testCase.name, (deferred: benchmark.Deferred) =>
+      testCase.run(constructed, deferred),
+    )
+  }
+
+  runSuite(suite)
+}
+
+export function fxTest<E, A, E1>(init: () => Fx.Fx<never, E, A, E1>) {
+  return PerformanceTestCase(
+    'Fx',
+    () => Fx.drainNow(init()),
+    (fx, deferred) => Effect.unsafeRunAsyncWith(fx, () => deferred.resolve()),
+  )
+}
+
+export function fxEffectTest<E, A>(init: () => Effect.Effect<never, E, A>) {
+  return PerformanceTestCase('Fx', init, (e, deferred) => {
+    Effect.unsafeRunPromise(e).then(() => deferred.resolve())
+  })
+}
+
+export function mostStreamTest<A>(init: () => MT.Stream<A>) {
+  const mostScheduler = MS.newDefaultScheduler()
+
+  return PerformanceTestCase('@most/core', init, (mostStream, deferred) =>
+    M.runEffects(mostStream, mostScheduler).then(() => deferred.resolve()),
+  )
+}
+
+export function rxjsObservableTest<A>(init: () => RxJS.Observable<A>) {
+  return PerformanceTestCase('RxJS @7', init, (observable, deferred) => {
+    observable.subscribe({
+      complete: () => deferred.resolve(),
+    })
+  })
+}
+
+export function effectTsStreamTest<E, A>(init: () => EffectStream.Stream<never, E, A>) {
+  return PerformanceTestCase(
+    'Effect/Stream',
+    () => EffectStream.runDrain(init()),
+    (e, deferred) => {
+      Effect.unsafeRunPromise(e).then(() => deferred.resolve())
+    },
+  )
+}

package/perf/filter-map-reduce.ts

@@ -0,0 +1,49 @@
+import * as EffectStream from '@effect/core/Stream/Stream'
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as Chunk from '@tsplus/stdlib/collections/Chunk'
+import * as rxjs from 'rxjs'
+
+import {
+  array,
+  effectTsStreamTest,
+  fxEffectTest,
+  iterations,
+  mostStreamTest,
+  runPerformanceTest,
+  rxjsObservableTest,
+} from './_internal.js'
+
+import * as Stream from '@/index.js'
+
+const filterEvens = (x: number) => x % 2 === 0
+const addOne = (x: number) => x + 1
+const add = (x: number, y: number): number => x + y
+
+runPerformanceTest({
+  name: 'filter -> map -> reduce ' + iterations + ' integers',
+  cases: [
+    fxEffectTest(() =>
+      pipe(
+        Stream.from(array),
+        Stream.filter(filterEvens),
+        Stream.map(addOne),
+        Stream.reduce(0, add),
+      ),
+    ),
+    mostStreamTest(() =>
+      pipe(M.periodic(0), M.withItems(array), M.filter(filterEvens), M.map(addOne), M.scan(add, 0)),
+    ),
+    rxjsObservableTest(() =>
+      pipe(rxjs.from(array), rxjs.filter(filterEvens), rxjs.map(addOne), rxjs.scan(add, 0)),
+    ),
+    effectTsStreamTest(() =>
+      pipe(
+        EffectStream.fromChunk(Chunk.from(array)),
+        EffectStream.filter(filterEvens),
+        EffectStream.map(addOne),
+        EffectStream.scan(0, add),
+      ),
+    ),
+  ],
+})

package/perf/flatMap.ts

@@ -0,0 +1,48 @@
+import * as EffectStream from '@effect/core/Stream/Stream'
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as Chunk from '@tsplus/stdlib/collections/Chunk'
+import * as rxjs from 'rxjs'
+
+import {
+  array,
+  effectTsStreamTest,
+  fxEffectTest,
+  iterations,
+  mostStreamTest,
+  runPerformanceTest,
+  rxjsObservableTest,
+} from './_internal.js'
+
+import * as Stream from '@/index.js'
+
+const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
+
+const add = (x: number, y: number): number => x + y
+
+runPerformanceTest({
+  name: 'flatMap ' + iterations + ' integers',
+  cases: [
+    fxEffectTest(() =>
+      pipe(Stream.from(nestedArray), Stream.flatMap(Stream.from), Stream.reduce(0, add)),
+    ),
+    mostStreamTest(() =>
+      pipe(
+        M.periodic(0),
+        M.withItems(nestedArray),
+        M.chain((ns) => pipe(M.periodic(0), M.withItems(ns))),
+        M.scan(add, 0),
+      ),
+    ),
+    rxjsObservableTest(() =>
+      pipe(rxjs.from(nestedArray), rxjs.flatMap(rxjs.from), rxjs.scan(add, 0)),
+    ),
+    effectTsStreamTest(() =>
+      pipe(
+        EffectStream.fromChunk(Chunk.from(nestedArray)),
+        EffectStream.flatMap((ns) => EffectStream.fromChunk(Chunk.from(ns))),
+        EffectStream.scan(0, add),
+      ),
+    ),
+  ],
+})

package/perf/switchMap.ts

@@ -0,0 +1,40 @@
+import { pipe } from '@fp-ts/data/Function'
+import * as M from '@most/core'
+import * as rxjs from 'rxjs'
+
+import {
+  array,
+  fxEffectTest,
+  iterations,
+  mostStreamTest,
+  runPerformanceTest,
+  rxjsObservableTest,
+} from './_internal.js'
+
+import * as Stream from '@/index.js'
+
+const nestedArray = array.map((x) => Array.from({ length: x }, (_, i) => x * 1000 + i))
+
+const add = (x: number, y: number): number => x + y
+
+runPerformanceTest({
+  name: 'switchMap ' + iterations + ' integers',
+  cases: [
+    fxEffectTest(() =>
+      pipe(Stream.from(nestedArray), Stream.switchMap(Stream.from), Stream.reduce(0, add)),
+    ),
+    mostStreamTest(() =>
+      pipe(
+        M.periodic(0),
+        M.withItems(nestedArray),
+        M.map((ns) => pipe(M.periodic(0), M.withItems(ns))),
+        M.switchLatest,
+        M.scan(add, 0),
+      ),
+    ),
+    rxjsObservableTest(() =>
+      pipe(rxjs.from(nestedArray), rxjs.switchMap(rxjs.from), rxjs.scan(add, 0)),
+    ),
+    // Effect Stream is pull-based and does not offer switchMap
+  ],
+})

package/perf/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../tsconfig.base.json",
+  "include": [
+    "./*.ts"
+  ]
+}

package/readme.md

@@ -1,34 +1,7 @@
 # @typed/fx
 
-Fx is a generator-based abstraction for describing applications that run within Fibers. 
-The Fiber runtime interprets these generators into running applications that process side-effects. 
+`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".
 
-## Features
-
-- Concurrency - never encounter a race condition, control the level of concurrency at any level.
-- Resources Safety - release unused resources at just the right time, even in the event of failures.
-- Resilient - type-safe errors that will never be swallowed.
-- Interruptable - Cancel Fx you're no longer interested in, or mark regions as uninterruptible to avoid errors.
-- Dependency injection - Use the type-checker to ensure your programs are properly constructed.
-- Streams - Push-based streams, modeled after [@most/core](https://github.com/mostjs/core), with full Fx integration.
-- Tracing - Use our TypeScript/Vite plugin to use the TypeScript compiler to augment your stack traces with more useful information.
-- Logging - Built-in Loggers w/ configurable backends
-- State Management - Manage and synchronize state effortlessly across all your running processes.
-
-## Target 
-
-This library is primarily designed for front-end applications (including server-side rendering), that is to say,
-bundle size, parse time, memory constraints, etc. are of great concern. There will always be a balancing act between
-these metrics, ergonomics, and feature-set. We'll attempt to tread these lines as best we can, but Fx is highly feature-rich
-as it is, and can be used to build many many more abstractions that are not yet available as 3rd party plugins.
-
-The full library, and its dependencies, are about 30kb minified + gzipped. 
-However, it is provided as ES modules and is highly tree-shakeable. Take only what you need.
-
-## Come Back Soon
-
-There's not a lot else to see here yet, this library is under very active development and will continue to be updated with more docs and 
-information on how to use it. Check back soon! 
-
-If you're interested in chatting about the project come on over and join us on [Discord](https://discord.com/invite/kpPHEvkaAv)!

package/src/Fx.ts

@@ -0,0 +1,18 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Sink } from './Sink.js'
+
+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 function Fx<R, E, A, E1 = never>(run: Fx<R, E, A, E1>['run']): Fx<R, E, A, E1> {
+  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
+}

package/src/Sink.ts

@@ -0,0 +1,84 @@
+import { Cause } from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+export interface Sink<E, A, R2, E2, B> {
+  readonly event: (value: A) => Effect.Effect<R2, E2, unknown>
+  readonly error: (cause: Cause<E>) => Effect.Effect<R2, E2, B>
+  readonly end: Effect.Effect<R2, E2, B>
+}
+
+export function Sink<E, A, R2 = never, E2 = E, B = void>(
+  event: Sink<E, A, R2, E2, B>['event'],
+  error: Sink<E, A, R2, E2, B>['error'] = Effect.failCause as any,
+  end: Sink<E, A, R2, E2, B>['end'] = Effect.unit as any,
+): Sink<E, A, R2, E2, B> {
+  return { event, error, end }
+}
+
+export namespace Sink {
+  export type InputErrorsOf<T> = T extends Sink<infer R, any, any, any, any> ? R : never
+  export type EventOf<T> = T extends Sink<any, infer R, any, any, any> ? R : never
+  export type ResourcesOf<T> = T extends Sink<any, any, infer R, any, any> ? R : never
+  export type OutputErrorsOf<T> = T extends Sink<any, any, any, infer R, any> ? R : never
+  export type OutputOf<T> = T extends Sink<any, any, any, any, infer R> ? R : never
+}
+
+export function mapInputEvent<A, B>(
+  f: (a: A) => B,
+): <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>) => Sink<E, A, R2, E2, C> {
+  return (sink) => Sink(flow(f, sink.event), sink.error, sink.end)
+}
+
+export function mapInputEventEffect<A, R3, E3, B>(
+  f: (a: A) => Effect.Effect<R3, E3, B>,
+): <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>) => Sink<E, A, R2 | R3, E2 | E3, C> {
+  return (sink) => Sink(flow(f, Effect.flatMap(sink.event)), sink.error, sink.end)
+}
+
+export function mapInputCause<E, E2>(
+  f: (e: Cause<E>) => Cause<E2>,
+): <A, R2, E3, B>(sink: Sink<E2, A, R2, E3, B>) => Sink<E, A, R2, E3, B> {
+  return (sink) => Sink(sink.event, flow(f, sink.error), sink.end)
+}
+
+export function mapInputCauseEffect<E, R3, E3, E2>(
+  f: (e: Cause<E>) => Effect.Effect<R3, E3, Cause<E2>>,
+): <A, R2, E4, B>(sink: Sink<E2, A, R2, E4, B>) => Sink<E, A, R2 | R3, E3 | E4, B> {
+  return (sink) => Sink(sink.event, flow(f, Effect.flatMap(sink.error)), sink.end)
+}
+
+export function mapOutput<B, C>(
+  f: (b: B) => C,
+): <E, A, R2, E2>(sink: Sink<E, A, R2, E2, B>) => Sink<E, A, R2, E2, C> {
+  return (sink) => Sink(sink.event, flow(sink.error, Effect.map(f)), pipe(sink.end, Effect.map(f)))
+}
+
+export function mapOutputEffect<B, R3, E3, C>(
+  f: (b: B) => Effect.Effect<R3, E3, C>,
+): <E, A, R2, E2>(sink: Sink<E, A, R2, E2, B>) => Sink<E, A, R2 | R3, E2 | E3, C> {
+  return (sink) =>
+    Sink(sink.event, flow(sink.error, Effect.flatMap(f)), pipe(sink.end, Effect.flatMap(f)))
+}
+
+export function mapOutputCause<E2, E3>(f: (e: Cause<E2>) => Cause<E3>) {
+  return <E, A, R2, B>(sink: Sink<E, A, R2, E2, B>): Sink<E, A, R2, E3, B> =>
+    Sink(
+      flow(sink.event, Effect.mapErrorCause(f)),
+      flow(sink.error, Effect.mapErrorCause(f)),
+      pipe(sink.end, Effect.mapErrorCause(f)),
+    )
+}
+
+export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
+  return <E, R2, E2, C>(sink: Sink<E, B, R2, E2, C>): Sink<E, A, R2, E2, C> =>
+    Sink(
+      flow(
+        f,
+        Maybe.fold(() => Effect.unit, sink.event),
+      ),
+      sink.error,
+      sink.end,
+    )
+}

package/src/TSemaphore.ts

@@ -0,0 +1,8 @@
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
+
+import { transform } from './transform.js'
+
+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/_internal.ts

@@ -0,0 +1,129 @@
+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'
+
+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
+
+    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 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))
+
+            return Effect.never
+          }),
+        ),
+      )
+
+      yield* $(Effect.addFinalizer(Fiber.interrupt(fiber)))
+
+      return yield* $(Effect.race(deferred.await)(Fiber.join(fiber)))
+    }),
+  )
+}
+
+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
+}

package/src/combine.test.ts

@@ -0,0 +1,35 @@
+import { deepStrictEqual } from 'assert'
+
+import { unsafeRunPromise } 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'
+
+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))))),
+        ),
+      )
+      const events = await pipe(test, collectAll, 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]],
+      ])
+    })
+  })
+})

package/src/combine.ts

@@ -0,0 +1,66 @@
+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 * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Fx } from './Fx.js'
+import { Sink } from './Sink.js'
+import { refCountDeferred, tupleRef } 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 combineAll<FX extends ReadonlyArray<Fx<any, 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]>
+>
+
+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)),
+                ),
+              ),
+            ),
+          ),
+        ),
+      )
+
+      return yield* $(deferred.await)
+    }),
+  )
+}