@typed/fx 1.6.2 → 1.8.0

package/src/switchMap.ts

@@ -0,0 +1,67 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Fiber, RefS } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { fromEffect } from './fromEffect.js'
+
+export function switchMap<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* $(RefS.make<Fiber.RuntimeFiber<never, void> | null>(null))
+        const reset = RefS.set(ref, null)
+
+        const switchEvent = (a: A) =>
+          RefS.updateEffect(ref, (currentFiber) =>
+            pipe(
+              currentFiber ? Fiber.interruptFork(currentFiber) : Effect.unit(),
+              Effect.flatMap(() =>
+                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* $(fx.run(Sink(switchEvent, sink.error)))
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(RefS.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}
+
+export function switchMapEffect<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 switchMap(fx, (a) => fromEffect(f(a)))
+}
+
+export function switchLatest<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
+  return switchMap(fx, (a) => a)
+}
+
+export function switchLatestEffect<R, E, R2, E2, B>(
+  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
+): Fx<R | R2, E | E2, B> {
+  return switchMapEffect(fx, (a) => a)
+}

package/src/switchMapCause.test.ts

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

package/src/switchMapCause.ts

@@ -0,0 +1,74 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Either, Fiber, RefS } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { failCause } from './failCause.js'
+import { fromEffect } from './fromEffect.js'
+
+export function switchMapCause<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* $(RefS.make<Fiber.RuntimeFiber<never, void> | null>(null))
+        const reset = RefS.set(ref, null)
+
+        const switchError = (cause: Cause.Cause<E>) =>
+          RefS.updateEffect(ref, (currentFiber) =>
+            pipe(
+              currentFiber ? Fiber.interruptFork(currentFiber) : Effect.unit(),
+              Effect.flatMap(() =>
+                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* $(fx.run(Sink(sink.event, switchError)))
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(RefS.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}
+
+export function switchMapCauseEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return switchMapCause(fx, (a) => fromEffect(f(a)))
+}
+
+export function switchMapError<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 switchMapCause(fx, (cause) =>
+    pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+  )
+}
+
+export function switchMapErrorEffect<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 switchMapError(fx, (a) => fromEffect(f(a)))
+}

package/src/switchMatch.test.ts

@@ -0,0 +1,26 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { Duration } from './externals.js'
+import { fail } from './failCause.js'
+import { fromArray } from './fromArray.js'
+import { mergeAll } from './mergeAll.js'
+import { succeed } from './succeed.js'
+import { switchMatch } from './switchMatch.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(switchMatch.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together, handling errors and successes, favoring the latest',
+      switchMatch(
+        mergeAll(succeed(array[0]), fail(array[1]), succeed(array[2])),
+        (x) => delay(fromArray([x]), Duration.millis(10)),
+        (x) => delay(fromArray([x]), Duration.millis(10)),
+      ),
+      [array[2]],
+    )
+  })
+})

package/src/switchMatch.ts

@@ -0,0 +1,95 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Either, Fiber, RefS } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { failCause } from './failCause.js'
+import { fromEffect } from './fromEffect.js'
+
+export function switchMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  g: (a: A) => Fx<R3, E3, C>,
+): Fx<R | R2 | R3, E2 | E3, B | C> {
+  return Fx((sink) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(RefS.make<Fiber.RuntimeFiber<never, void> | null>(null))
+        const reset = RefS.set(ref, null)
+
+        const switchWith = (f: () => Fx<R2 | R3, E2 | E3, B | C>) =>
+          RefS.updateEffect(ref, (currentFiber) =>
+            pipe(
+              currentFiber ? Fiber.interruptFork(currentFiber) : Effect.unit(),
+              Effect.flatMap(() =>
+                pipe(
+                  f().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* $(
+          fx.run(
+            Sink(
+              (a) => switchWith(() => g(a)),
+              (cause) => switchWith(() => f(cause)),
+            ),
+          ),
+        )
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(RefS.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}
+
+export function switchMatch<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  f: (error: E) => Fx<R2, E2, B>,
+  g: (a: A) => Fx<R3, E3, C>,
+): Fx<R | R2 | R3, E2 | E3, B | C> {
+  return switchMatchCause(
+    fx,
+    (cause) => pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+    g,
+  )
+}
+
+export function switchMatchCauseEffect<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+  g: (a: A) => Effect.Effect<R3, E3, C>,
+): Fx<R | R2 | R3, E2 | E3, B | C> {
+  return switchMatchCause(
+    fx,
+    (a) => fromEffect(f(a)),
+    (b) => fromEffect(g(b)),
+  )
+}
+
+export function switchMatchEffect<R, E, A, R2, E2, B, R3, E3, C>(
+  fx: Fx<R, E, A>,
+  f: (error: E) => Effect.Effect<R2, E2, B>,
+  g: (a: A) => Effect.Effect<R3, E3, C>,
+): Fx<R | R2 | R3, E2 | E3, B | C> {
+  return switchMatch(
+    fx,
+    (a) => fromEffect(f(a)),
+    (b) => fromEffect(g(b)),
+  )
+}

package/src/takeWhile.test.ts

@@ -0,0 +1,27 @@
+import { describe } from 'vitest'
+
+import { fromArray } from './fromArray.js'
+import { takeUntil, takeWhile } from './takeWhile.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(takeWhile.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'takes values until the predicate returns false',
+      takeWhile(fromArray(array), (x) => x !== array[2]),
+      [array[0], array[1]],
+    )
+  })
+
+  describe(takeUntil.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'takes values while the predicate returns true',
+      takeUntil(fromArray(array), (x) => x === array[2]),
+      [array[0], array[1]],
+    )
+  })
+})

package/src/takeWhile.ts

@@ -0,0 +1,34 @@
+import type { Predicate } from '@effect/data/Predicate'
+import { not } from '@effect/data/Predicate'
+
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function takeWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx(<R2>(sink: Sink<R2, E, A>) =>
+    Effect.asyncEffect<never, never, void, R | R2, never, void>((cb) => {
+      const exit = Effect.sync(() => cb(Effect.unit()))
+
+      return Effect.tap(
+        fx.run(
+          Sink(
+            (a) =>
+              Effect.suspend(() => {
+                if (predicate(a)) {
+                  return sink.event(a)
+                }
+
+                return exit
+              }),
+            sink.error,
+          ),
+        ),
+        () => exit,
+      )
+    }),
+  )
+}
+
+export function takeUntil<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return takeWhile(fx, not(predicate))
+}

package/src/tap.ts

@@ -0,0 +1,17 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function tap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return Fx(<R3>(sink: Sink<R3, E | E2, A>) =>
+    fx.run<R2 | R3>(
+      Sink((a: A) => Effect.matchCauseEffect(f(a), sink.error, () => sink.event(a)), sink.error),
+    ),
+  )
+}
+
+export function tapSync<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, A> {
+  return tap(fx, (a) => Effect.sync(() => f(a)))
+}

package/src/tapCause.ts

@@ -0,0 +1,41 @@
+import { pipe } from '@effect/data/Function'
+
+import { Fx, Sink } from './Fx.js'
+import { Cause, Effect } from './externals.js'
+
+export function tapCause<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return Fx((sink) =>
+    fx.run(
+      Sink(sink.event, (cause) =>
+        Effect.matchCauseEffect(
+          f(cause),
+          (cause2) => sink.error(Cause.sequential(cause, cause2)),
+          () => sink.error(cause),
+        ),
+      ),
+    ),
+  )
+}
+
+export function tapCauseSync<R, E, A, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => B,
+): Fx<R, E, A> {
+  return tapCause(fx, (cause) => Effect.sync(() => f(cause)))
+}
+
+export function tapError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (error: E) => Effect.Effect<R, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return tapCause(fx, (cause) =>
+    pipe(Cause.failureOrCause(cause), Effect.fromEither, Effect.matchEffect(f, Effect.failCause)),
+  )
+}
+
+export function tapErrorSync<R, E, A, B>(fx: Fx<R, E, A>, f: (error: E) => B): Fx<R, E, A> {
+  return tapError(fx, (e) => Effect.sync(() => f(e)))
+}

package/src/test-utils.ts

@@ -0,0 +1,36 @@
+import { ok } from 'assert'
+
+import { it, expect } from 'vitest'
+
+import type { Fx } from './Fx.js'
+import { Cause, Effect, Exit } from './externals.js'
+import { observe } from './observe.js'
+
+export function testCollectAll<E = never, A = never>(
+  name: string,
+  fx: Fx<never, E, A>,
+  expected: ReadonlyArray<A>,
+) {
+  it(name, async () => {
+    const test = Effect.scoped(
+      Effect.gen(function* ($) {
+        const values: Array<A> = []
+
+        yield* $(observe(fx, (a) => Effect.sync(() => values.push(a))))
+
+        return values
+      }),
+    )
+
+    expect(await Effect.runPromise(test)).toEqual(expected)
+  })
+}
+
+export function testCause<E, A>(name: string, fx: Fx<never, E, A>, expected: Cause.Cause<E>) {
+  it(name, async () => {
+    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit())))
+
+    ok(Exit.isFailure(exit))
+    expect(Cause.unannotate(exit.cause)).toEqual(expected)
+  })
+}

package/src/throttle.test.ts

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

package/src/throttle.ts

@@ -0,0 +1,40 @@
+import { pipe } from '@effect/data/Function'
+
+import { Fx, Sink } from './Fx.js'
+import type { Duration } from './externals.js'
+import { Effect, Fiber, Ref } from './externals.js'
+
+export function throttle<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
+  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 throttleEvent = (a: A) =>
+          Effect.gen(function* ($) {
+            const currentFiber = yield* $(Ref.get(ref))
+
+            if (currentFiber) {
+              return
+            }
+
+            const fiber = yield* $(
+              pipe(sink.event(a), Effect.zipLeft(Effect.delay(reset, duration)), Effect.forkScoped),
+            )
+
+            yield* $(Ref.set(ref, fiber))
+          })
+
+        yield* $(fx.run(Sink(throttleEvent, sink.error)))
+
+        // Wait for the last fiber to finish
+        const fiber = yield* $(Ref.get(ref))
+
+        if (fiber) {
+          yield* $(Fiber.join(fiber))
+        }
+      }),
+    ),
+  )
+}

package/src/toArray.ts

@@ -0,0 +1,15 @@
+import type { Scope } from '@effect/io/Scope'
+
+import type { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+import { observe } from './observe.js'
+
+export function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Array<A>> {
+  return Effect.gen(function* ($) {
+    const array: Array<A> = []
+
+    yield* $(observe(fx, (a) => Effect.sync(() => array.push(a))))
+
+    return array
+  })
+}

package/src/toChunk.ts

@@ -0,0 +1,15 @@
+import type { Scope } from '@effect/io/Scope'
+
+import type { Fx } from './Fx.js'
+import { Chunk, Effect } from './externals.js'
+import { observe } from './observe.js'
+
+export function toChunk<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Chunk.Chunk<A>> {
+  return Effect.gen(function* ($) {
+    let chunk = Chunk.empty<A>()
+
+    yield* $(observe(fx, (a) => Effect.sync(() => (chunk = Chunk.append(chunk, a)))))
+
+    return chunk
+  })
+}

package/src/toReadonlyArray.ts

@@ -0,0 +1,17 @@
+import type { Scope } from '@effect/io/Scope'
+
+import type { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+import { observe } from './observe.js'
+
+export function toReadonlyArray<R, E, A>(
+  fx: Fx<R, E, A>,
+): Effect.Effect<R | Scope, E, ReadonlyArray<A>> {
+  return Effect.gen(function* ($) {
+    const array: Array<A> = []
+
+    yield* $(observe(fx, (a) => Effect.sync(() => array.push(a))))
+
+    return array
+  })
+}

package/tsconfig.build.json

@@ -1,4 +1,7 @@
 {
   "extends": "./tsconfig.json",
-  "exclude": ["src/**/*.test.ts"]
-}
+  "exclude": [
+    "src/**/*.test.ts",
+    "dist"
+  ]
+}