@typed/fx 1.6.2 → 1.8.0

package/src/catchAllCause.ts

@@ -0,0 +1,84 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { failCause } from './failCause.js'
+import { fromEffect } from './fromEffect.js'
+
+export function catchAllCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return Fx((sink) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<Set<Fiber.RuntimeFiber<never, void>>>(new Set()))
+
+        yield* $(
+          fx.run(
+            Sink(sink.event, (cause: Cause.Cause<E>) =>
+              Effect.gen(function* ($) {
+                const fiber = yield* $(
+                  Effect.forkScoped(
+                    f(cause).run(
+                      Sink(sink.event, (cause) =>
+                        Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                      ),
+                    ),
+                  ),
+                )
+
+                // Add Fiber to fibers
+                yield* $(Ref.update(ref, (fs) => fs.add(fiber)))
+
+                // When the fiber ends, we need to remove it from the list of fibers
+                yield* $(
+                  pipe(
+                    Fiber.join(fiber),
+                    Effect.flatMap(() =>
+                      Ref.update(ref, (fs) => {
+                        fs.delete(fiber)
+                        return fs
+                      }),
+                    ),
+                    // but don't allow this to be blocking
+                    Effect.forkScoped,
+                  ),
+                )
+              }),
+            ),
+          ),
+        )
+
+        // Wait for the last fibers to finish
+        const fibers = yield* $(Ref.get(ref))
+
+        if (fibers.size > 0) {
+          yield* $(Fiber.joinAll(fibers))
+        }
+      }),
+    ),
+  )
+}
+
+export function catchAll<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return catchAllCause(fx, (cause) => pipe(cause, Cause.failureOrCause, Either.match(f, failCause)))
+}
+
+export function catchAllCauseEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return catchAllCause(fx, (e) => fromEffect(f(e)))
+}
+
+export function catchAllEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return catchAll(fx, (e) => fromEffect(f(e)))
+}

package/src/combineAll.ts

@@ -0,0 +1,63 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+import { map } from './map.js'
+import { succeed } from './succeed.js'
+
+export function combineAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  ...fx: FX
+): Fx<
+  Fx.ResourcesOf<FX[number]>,
+  Fx.ErrorsOf<FX[number]>,
+  {
+    [k in keyof FX]: Fx.OutputOf<FX[k]>
+  }
+> {
+  if (fx.length === 0) {
+    return succeed([]) as any
+  }
+
+  if (fx.length === 1) {
+    return map(fx[0], (x) => [x]) as any
+  }
+
+  return Fx((sink) =>
+    Effect.gen(function* ($) {
+      const length = fx.length
+      const values = new Map<number, any>()
+
+      const emitIfReady = Effect.suspend(() =>
+        values.size === length
+          ? sink.event(
+              Array.from(values)
+                .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+                .map((x) => x[1]) as {
+                [k in keyof FX]: Fx.OutputOf<FX[k]>
+              },
+            )
+          : Effect.unit(),
+      )
+
+      yield* $(
+        Effect.forEachParWithIndex(fx, (f, i) =>
+          f.run(
+            Sink(
+              (a) =>
+                Effect.suspend(() => {
+                  values.set(i, a)
+                  return emitIfReady
+                }),
+              sink.error,
+            ),
+          ),
+        ),
+      )
+    }),
+  )
+}
+
+export function combine<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  other: Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, readonly [A, B]> {
+  return combineAll(fx, other)
+}

package/src/continueWith.test.ts

@@ -0,0 +1,17 @@
+import { describe } from 'vitest'
+
+import { continueWith } from './continueWith.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(continueWith.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'appends one stream after another',
+      continueWith(fromArray(array), () => fromArray(array)),
+      [...array, ...array],
+    )
+  })
+})

package/src/continueWith.ts

@@ -0,0 +1,29 @@
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+import { fromEffect } from './fromEffect.js'
+import { succeed } from './succeed.js'
+
+export function continueWith<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: () => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return Fx((sink) => Effect.flatMap(fx.run(sink), () => f().run(sink)))
+}
+
+export function continueWithEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: () => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return continueWith(fx, () => fromEffect(f()))
+}
+
+export function startWith<R, E, A, B>(fx: Fx<R, E, A>, b: B): Fx<R, E, A | B> {
+  return continueWith(succeed(b), () => fx)
+}
+
+export function startWithEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  other: Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return continueWith(fromEffect(other), () => fx)
+}

package/src/data-first.ts

@@ -0,0 +1,50 @@
+export * from './at.js'
+export * from './catchAllCause.js'
+export * from './combineAll.js'
+export * from './continueWith.js'
+export * from './debounce.js'
+export * from './delay.js'
+export * from './empty.js'
+export * from './exhaustMap.js'
+export * from './exhaustMapCause.js'
+export * from './exhaustMapLatest.js'
+export * from './exhaustMapLatestCause.js'
+export * from './failCause.js'
+export * from './filter.js'
+export * from './filterMap.js'
+export * from './flatMap.js'
+export * from './fromArray.js'
+export * from './fromEffect.js'
+export * from './fromEmitter.js'
+export * from './fromFxEffect.js'
+export * from './fromIterable.js'
+export * from './Fx.js'
+export * from './gen.js'
+export * from './hold.js'
+export * from './map.js'
+export * from './mergeAll.js'
+export * from './multicast.js'
+export * from './never.js'
+export * from './observe.js'
+export * from './onInterrupt.js'
+export * from './promise.js'
+export * from './provide.js'
+export * from './reduce.js'
+export * from './RefSubject.js'
+export * from './scan.js'
+export * from './skipRepeats.js'
+export * from './skipWhile.js'
+export * from './slice.js'
+export * from './Subject.js'
+export * from './succeed.js'
+export * from './suspend.js'
+export * from './switchMap.js'
+export * from './switchMapCause.js'
+export * from './switchMatch.js'
+export * from './takeWhile.js'
+export * from './tap.js'
+export * from './tapCause.js'
+export * from './throttle.js'
+export * from './toArray.js'
+export * from './toChunk.js'
+export * from './toReadonlyArray.js'

package/src/debounce.test.ts

@@ -0,0 +1,18 @@
+import { describe } from 'vitest'
+
+import { debounce } from './debounce.js'
+import { Duration } from './externals.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(debounce.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'debounces events, favoring the latest',
+      debounce(fromArray(array), Duration.millis(10)),
+      [array[2]],
+    )
+  })
+})

package/src/debounce.ts

@@ -0,0 +1,8 @@
+import type { Fx } from './Fx.js'
+import type { Duration } from './externals.js'
+import { Effect } from './externals.js'
+import { switchMapEffect } from './switchMap.js'
+
+export function debounce<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
+  return switchMapEffect(fx, (a) => Effect.delay(Effect.succeed(a), duration))
+}

package/src/delay.test.ts

@@ -0,0 +1,13 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { Duration } from './externals.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(delay.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+    testCollectAll('returns each the array', delay(fromArray(array), Duration.millis(0)), array)
+  })
+})

package/src/delay.ts

@@ -0,0 +1,8 @@
+import type { Duration } from '@effect/data/Duration'
+
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function delay<R, E, A>(fx: Fx<R, E, A>, delay: Duration): Fx<R, E, A> {
+  return Fx((sink) => fx.run(Sink((a) => Effect.delay(sink.event(a), delay), sink.error)))
+}

package/src/empty.test.ts

@@ -0,0 +1,10 @@
+import { describe } from 'vitest'
+
+import { empty } from './empty.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(empty.name, () => {
+    testCollectAll('immediately ends', empty(), [])
+  })
+})

package/src/empty.ts

@@ -0,0 +1,7 @@
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from './Fx.js'
+
+export function empty<A = never>(): Fx<never, never, A> {
+  return Fx(() => Effect.unit())
+}

package/src/exhaustMap.test.ts

@@ -0,0 +1,19 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { exhaustMap } from './exhaustMap.js'
+import { Duration } from './externals.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(exhaustMap.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together, favoring the first',
+      exhaustMap(fromArray(array), (x) => delay(fromArray([x]), Duration.millis(10))),
+      [array[0]],
+    )
+  })
+})

package/src/exhaustMap.ts

@@ -0,0 +1,72 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { fromEffect } from './fromEffect.js'
+
+export function exhaustMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return Fx((sink) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+        const reset = Ref.set(ref, void 0)
+
+        const exhaustMapEvent = (a: A) =>
+          Effect.gen(function* ($) {
+            const currentFiber = yield* $(Ref.get(ref))
+
+            if (currentFiber) {
+              return
+            }
+
+            const fiber = yield* $(
+              pipe(
+                f(a).run(
+                  Sink(sink.event, (cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                  ),
+                ),
+                Effect.zipLeft(reset),
+                Effect.catchAllCause((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
+                Effect.forkScoped,
+              ),
+            )
+
+            yield* $(Ref.set(ref, fiber))
+          })
+
+        yield* $(fx.run(Sink(exhaustMapEvent, sink.error)))
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(Ref.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}
+
+export function exhaustMapEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return exhaustMap(fx, (a) => fromEffect(f(a)))
+}
+
+export function exhaust<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
+  return exhaustMap(fx, (a) => a)
+}
+
+export function exhaustEffect<R, E, R2, E2, B>(
+  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
+): Fx<R | R2, E | E2, B> {
+  return exhaustMapEffect(fx, (a) => a)
+}

package/src/exhaustMapCause.test.ts

@@ -0,0 +1,23 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { exhaustMapCause, exhaustMapError } from './exhaustMapCause.js'
+import { Duration } from './externals.js'
+import { fail } from './failCause.js'
+import { fromArray } from './fromArray.js'
+import { mergeAll } from './mergeAll.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(exhaustMapCause.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together when they error, favoring the first',
+      exhaustMapError(mergeAll(...array.map((n) => fail(n))), (x) =>
+        delay(fromArray([x]), Duration.millis(10)),
+      ),
+      [array[0]],
+    )
+  })
+})

package/src/exhaustMapCause.ts

@@ -0,0 +1,79 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { failCause } from './failCause.js'
+import { fromEffect } from './fromEffect.js'
+
+export function exhaustMapCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return Fx((sink) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+        const reset = Ref.set(ref, void 0)
+
+        const exhaustMapError = (cause: Cause.Cause<E>) =>
+          Effect.gen(function* ($) {
+            const currentFiber = yield* $(Ref.get(ref))
+
+            if (currentFiber) {
+              return
+            }
+
+            const fiber = yield* $(
+              pipe(
+                f(cause).run(
+                  Sink(sink.event, (cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                  ),
+                ),
+                Effect.zipLeft(reset),
+                Effect.catchAllCause((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
+                Effect.forkScoped,
+              ),
+            )
+
+            yield* $(Ref.set(ref, fiber))
+          })
+
+        yield* $(fx.run(Sink(sink.event, exhaustMapError)))
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(Ref.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}
+
+export function exhaustMapCauseEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return exhaustMapCause(fx, (a) => fromEffect(f(a)))
+}
+
+export function exhaustMapError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return exhaustMapCause(fx, (cause) =>
+    pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+  )
+}
+
+export function exhaustMapErrorEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (error: E) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return exhaustMapError(fx, (a) => fromEffect(f(a)))
+}

package/src/exhaustMapLatest.test.ts

@@ -0,0 +1,19 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { exhaustMapLatest } from './exhaustMapLatest.js'
+import { Duration } from './externals.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(exhaustMapLatest.name, () => {
+    const array = [1, 2, 3]
+
+    testCollectAll(
+      'merges multiple streams together, favoring the first and replaying the latest',
+      exhaustMapLatest(fromArray(array), (x) => delay(fromArray([x]), Duration.millis(x * 10))),
+      [1, 3],
+    )
+  })
+})

package/src/exhaustMapLatest.ts

@@ -0,0 +1,104 @@
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import type { Scope } from '@effect/io/Scope'
+
+import { Cause, Effect, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { fromEffect } from './fromEffect.js'
+
+export function exhaustMapLatest<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return Fx(<R3>(sink: Sink<R3, E | E2, B>) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+        const nextValue = yield* $(Ref.make<Option.Option<A>>(Option.none()))
+        const reset = Ref.set(ref, void 0)
+
+        // Wait for the current fiber to finish
+        const awaitNext = Effect.gen(function* ($) {
+          // Wait for the last fiber to finish
+          const fiber = yield* $(Ref.get(ref))
+
+          if (fiber) {
+            // Wait for the fiber to end to check to see if we need to run another
+            yield* $(Fiber.join(fiber))
+          }
+        })
+
+        // Run the next value that's be saved for replay if it exists
+        const runNext: Effect.Effect<R2 | R3 | Scope, never, void> = Effect.gen(function* ($) {
+          const next = yield* $(Ref.get(nextValue))
+
+          if (Option.isSome(next)) {
+            // Clear the next A to be replayed
+            yield* $(Ref.set(nextValue, Option.none()))
+
+            // Replay the next A
+            yield* $(exhaustMapLatestEvent(next.value))
+
+            // Ensure we don't close the scope until the last fiber completes
+            yield* $(awaitNext)
+          }
+        })
+
+        const exhaustMapLatestEvent = (a: A) =>
+          Effect.gen(function* ($) {
+            const currentFiber = yield* $(Ref.get(ref))
+
+            // Always allow the current fiber to continue
+            if (currentFiber) {
+              // Track the latest A to be replayed layer
+              return yield* $(Ref.set(nextValue, Option.some(a)))
+            }
+
+            // Run our Fx with the current value
+            const fiber = yield* $(
+              pipe(
+                f(a).run(
+                  Sink(sink.event, (cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                  ),
+                ),
+                // Clear the current fiber when finished
+                Effect.zipRight(reset),
+                // See if there's another value to replay
+                Effect.zipRight(runNext),
+                Effect.catchAllCause((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
+                Effect.forkScoped,
+              ),
+            )
+
+            yield* $(Ref.set(ref, fiber))
+          })
+
+        yield* $(fx.run(Sink(exhaustMapLatestEvent, sink.error)))
+
+        // Wait for the last fiber to finish
+        yield* $(awaitNext)
+      }),
+    ),
+  )
+}
+
+export function exhaustMapLatestEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return exhaustMapLatest(fx, (a) => fromEffect(f(a)))
+}
+
+export function exhaustLatest<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
+  return exhaustMapLatest(fx, (a) => a)
+}
+
+export function exhaustLatestEffect<R, E, R2, E2, B>(
+  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
+): Fx<R | R2, E | E2, B> {
+  return exhaustMapLatestEffect(fx, (a) => a)
+}

package/src/exhaustMapLatestCause.test.ts

@@ -0,0 +1,23 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { exhaustMapLatestCause, exhaustMapLatestError } from './exhaustMapLatestCause.js'
+import { Duration } from './externals.js'
+import { fail } from './failCause.js'
+import { fromArray } from './fromArray.js'
+import { mergeAll } from './mergeAll.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(exhaustMapLatestCause.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together when they error, favoring the first and replaying the latest',
+      exhaustMapLatestError(mergeAll(...array.map((n) => fail(n))), (x) =>
+        delay(fromArray([x]), Duration.millis(10)),
+      ),
+      [array[0], array[2]],
+    )
+  })
+})