@typed/fx 0.0.35 → 1.0.2

package/src/operator/switchMapError.ts

@@ -0,0 +1,26 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { match } from '@fp-ts/data/Either'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { failCause } from '../constructor/failCause.js'
+
+import { switchMapCause } from './switchMapCause.js'
+import { fromEffect } from '../constructor/fromEffect.js'
+
+export function switchMapError<E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
+    pipe(
+      fx,
+      switchMapCause((cause) => pipe(cause, Cause.failureOrCause, match(f, failCause))),
+    )
+}
+
+export function switchMapErrorEffect<E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
+    pipe(
+      fx,
+      switchMapError(flow(f, fromEffect))
+    )
+}

package/src/operator/switchMatch.test.ts

@@ -0,0 +1,37 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { millis } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { mergeAll } from './merge.js'
+import { switchMatchError } from './switchMatch.js'
+import { flatten } from './flatMap.js'
+import { fail } from '../constructor/fail.js'
+
+describe(import.meta.url, () => {
+  describe(switchMatchError.name, () => {
+    it('allows mapping to other Fx while prefering the latest stream', async () => {
+      const test = pipe(
+        mergeAll(
+          at(millis(0), 1),
+          at(millis(20), 2),
+          at(millis(40), 3),
+          pipe(at(millis(60), fail(4)), flatten),
+        ),
+        switchMatchError(
+          (n) => at(millis(60), n * n),
+          (n) => at(millis(60), n * n),
+        ),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [16])
+    })
+  })
+})

package/src/operator/switchMatch.ts

@@ -0,0 +1,96 @@
+import * as Effect from '@effect/io/Effect'
+import * as Cause from '@effect/io/Cause'
+import * as Fiber from '@effect/io/Fiber'
+import * as Ref from '@effect/io/Ref/Synchronized'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { withRefCounter } from '../_internal/RefCounter.js'
+import { either } from '@fp-ts/data'
+import { failCause } from '../constructor/failCause.js'
+
+export function switchMatchCause<E, R2, E2, B, A, R3, E3, C>(
+  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+  g: (a: A) => Fx<R3, E3, C>,
+): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C> {
+  return (fx) => new SwitchMatchFx(fx, f, g)
+}
+
+export function switchMatchError<E, R2, E2, B, A, R3, E3, C>(
+  f: (error: E) => Fx<R2, E2, B>,
+  g: (a: A) => Fx<R3, E3, C>,
+): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C> {
+  return switchMatchCause(flow(Cause.failureOrCause, either.match(f, failCause)), g)
+}
+
+class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
+  extends Fx.Variance<R | R2 | R3, E2 | E3, B | C>
+  implements Fx<R | R2 | R3, E2 | E3, B | C>
+{
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
+    readonly g: (a: A) => Fx<R3, E3, C>,
+  ) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E2 | E3, B | C>) {
+    return withRefCounter(
+      1,
+      (counter) =>
+        pipe(
+          Ref.make(null as Fiber.RuntimeFiber<never, unknown> | null),
+          Effect.flatMap((refFiber) => {
+            const resetRef = pipe(
+              refFiber,
+              Ref.set<Fiber.RuntimeFiber<never, unknown> | null>(null),
+            )
+
+            let firstError = true
+
+            const handleError = Effect.suspendSucceed(() =>
+              firstError ? ((firstError = false), Effect.asUnit(counter.decrement)) : Effect.unit(),
+            )
+
+            const runWith = <R>(fx: Fx<R, E2 | E3, B | C>) =>
+              pipe(
+                refFiber,
+                Ref.updateEffect((fiber) =>
+                  pipe(
+                    fiber
+                      ? Effect.asUnit(Fiber.interrupt(fiber))
+                      : Effect.asUnit(counter.increment),
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    Effect.flatMap((_: unknown) =>
+                      Effect.forkScoped(
+                        fx.run(
+                          Fx.Sink(
+                            sink.event,
+                            flow(sink.error, Effect.zipLeft(resetRef)),
+                            pipe(counter.decrement, Effect.zipLeft(resetRef)),
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              )
+
+            return this.fx.run(
+              Fx.Sink(
+                (a) => runWith(this.g(a)),
+                (a) =>
+                  pipe(
+                    runWith(this.f(a)),
+                    Effect.flatMap(() => handleError),
+                  ),
+                counter.decrement,
+              ),
+            )
+          }),
+        ),
+      sink.end,
+    )
+  }
+}

package/src/operator/take.ts

@@ -0,0 +1,6 @@
+import { Fx } from '../Fx.js'
+
+import { slice } from './slice.js'
+
+export const take: (amount: number) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = (amount) =>
+  slice(0, amount)

package/src/operator/takeUntil.test.ts

@@ -0,0 +1,25 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { fromArray } from '../constructor/fromArray.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { takeUntil } from './takeUntil.js'
+
+describe(import.meta.url, () => {
+  describe(takeUntil.name, () => {
+    it('ends an Fx once a predicate has been matched', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3, 4, 5, 6, 7, 8]),
+        takeUntil((x) => x === 4),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})

package/src/operator/takeUntil.ts

@@ -0,0 +1,41 @@
+import { Effect } from '@effect/io/Effect'
+import { Predicate } from '@fp-ts/data/Predicate'
+
+import { Fx } from '../Fx.js'
+import { withEarlyExit } from '../_internal/earlyExit.js'
+
+export function takeUntil<A>(predicate: Predicate<A>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => new TakeUntilFx(fx, predicate)
+}
+
+class TakeUntilFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly fx: Fx<R, E, A>, readonly predicate: Predicate<A>) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>) {
+    return withEarlyExit(
+      (earlyExit) => this.fx.run(new TakeUntilSink(sink, this.predicate, earlyExit)),
+      sink.end,
+    )
+  }
+}
+
+class TakeUntilSink<R, E, A> implements Fx.Sink<R, E, A> {
+  constructor(
+    readonly sink: Fx.Sink<R, E, A>,
+    readonly predicate: Predicate<A>,
+    readonly earlyExit: Effect<never, never, never>,
+  ) {}
+
+  event = (a: A) => {
+    if (this.predicate(a)) {
+      return this.earlyExit
+    }
+
+    return this.sink.event(a)
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}

package/src/operator/takeWhile.ts

@@ -0,0 +1,10 @@
+import { pipe } from '@fp-ts/data/Function'
+import { Predicate, not } from '@fp-ts/data/Predicate'
+
+import { Fx } from '../Fx.js'
+
+import { takeUntil } from './takeUntil.js'
+
+export function takeWhile<A>(predicate: Predicate<A>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => pipe(fx, takeUntil(not(predicate)))
+}

package/src/operator/tap.ts

@@ -0,0 +1,31 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { fromEffect } from '../constructor/fromEffect.js'
+
+import { flatMap } from './flatMap.js'
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+
+export function tap<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
+    pipe(
+      fx,
+      flatMap((a) => pipe(a, f, Effect.as(a), fromEffect)),
+    )
+}
+
+export function tapConcurrently<A, R2, E2, B>(
+  concurrency: number,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
+    pipe(
+      fx,
+      flatMapConcurrently(concurrency, (a) => pipe(a, f, Effect.as(a), fromEffect)),
+    )
+}
+
+export function tapSeq<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => pipe(fx, tapConcurrently(1, f))
+}

package/src/operator/tapCause.ts

@@ -0,0 +1,38 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function tapCause<E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => new TapCauseFx(fx, f)
+}
+
+class TapCauseFx<R, E, A, R2, E2, B>
+  extends Fx.Variance<R | R2, E | E2, A>
+  implements Fx<R | R2, E | E2, A>
+{
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+  ) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
+    return this.fx.run(
+      Fx.Sink(
+        sink.event,
+        (cause) =>
+          pipe(
+            this.f(cause),
+            Effect.matchCauseEffect(
+              (cause2) => sink.error(Cause.sequential(cause, cause2)),
+              () => sink.error(cause),
+            ),
+          ),
+        sink.end,
+      ),
+    )
+  }
+}

package/src/operator/tapDefect.ts

@@ -0,0 +1,22 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { match } from '@fp-ts/data/Option'
+
+import { Fx } from '../Fx.js'
+
+import { tapCause } from './tapCause.js'
+
+export function tapDefect<R2, E2, B>(f: (defect: unknown) => Effect.Effect<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    pipe(
+      fx,
+      tapCause(
+        (cause): Effect.Effect<R2, E | E2, B> =>
+          pipe(
+            Cause.defects(cause).get(0),
+            match(() => Effect.failCause(cause), f),
+          ),
+      ),
+    )
+}

package/src/operator/tapError.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { match } from '@fp-ts/data/Either'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { tapCause } from './tapCause.js'
+
+export function tapError<E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    pipe(
+      fx,
+      tapCause((cause) => pipe(cause, Cause.failureOrCause, match(f, Effect.failCause))),
+    )
+}

package/src/operator/throttle.test.ts

@@ -0,0 +1,22 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Duration from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { fromArray } from '../constructor/fromArray.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { throttle } from './throttle.js'
+
+describe(import.meta.url, () => {
+  describe(throttle.name, () => {
+    it('filters noisy streams, favoring the initial', async () => {
+      const test = pipe(fromArray([1, 2, 3]), throttle(Duration.millis(10)), collectAll)
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1])
+    })
+  })
+})

package/src/operator/throttle.ts

@@ -0,0 +1,42 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as Duration from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { suspend } from '../constructor/suspend.js'
+
+import { filterEffect } from './filterEffect.js'
+
+export function throttle(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
+    suspend(() => {
+      let scheduledFiber: Fiber.RuntimeFiber<never, unknown> | undefined
+
+      const shouldThrottle = Effect.gen(function* ($) {
+        if (scheduledFiber) {
+          return false
+        }
+
+        scheduledFiber = yield* $(
+          pipe(
+            Effect.unit(),
+            Effect.delay(duration),
+            Effect.tap(() =>
+              Effect.sync(() => {
+                scheduledFiber = undefined
+              }),
+            ),
+            Effect.fork,
+          ),
+        )
+
+        return true
+      })
+
+      return pipe(
+        fx,
+        filterEffect(() => shouldThrottle),
+      )
+    })
+}

package/src/operator/tuple.ts

@@ -0,0 +1,7 @@
+import { Fx } from '../Fx.js'
+
+import { combineAll } from './combine.js'
+
+export const tuple = <Streams extends readonly Fx<any, any, any>[]>(
+  streams: readonly [...Streams],
+) => combineAll(...streams)

package/src/operator/uninterruptible.ts

@@ -0,0 +1,18 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function uninterruptible<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new UninterruptibleFx(fx)
+}
+
+class UninterruptibleFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly fx: Fx<R, E, A>) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E, A>) {
+    return pipe(this.fx.run(sink), Effect.uninterruptible)
+  }
+}

package/src/operator/until.test.ts

@@ -0,0 +1,47 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as TestClock from '@effect/io/internal/testing/testClock'
+import * as TE from '@effect/io/internal/testing/testEnvironment'
+import * as Duration from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { periodic } from '../constructor/periodic.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { until } from './until.js'
+import { withItems } from './withItems.js'
+
+describe(import.meta.url, () => {
+  describe(until.name, () => {
+    it('interrupts a stream when a signal is received', async () => {
+      const delay = 20
+      const expected = 5
+      const fx = pipe(
+        periodic(Duration.millis(delay)),
+        withItems([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+        until(at(Duration.millis(delay * expected), null)),
+      )
+
+      const test = pipe(
+        Effect.gen(function* ($) {
+          const fiber = yield* $(Effect.fork(collectAll(fx)))
+
+          for (let i = 0; i < expected; i++) {
+            yield* $(TestClock.adjust(Duration.millis(delay)))
+          }
+
+          return yield* $(Fiber.join(fiber))
+        }),
+        Effect.provideSomeLayer(TE.TestEnvironment),
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3, 4, 5])
+    })
+  })
+})

package/src/operator/until.ts

@@ -0,0 +1,35 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+
+import { Fx } from '../Fx.js'
+import { withEarlyExit } from '../_internal/earlyExit.js'
+
+export function until<R2, E2, B>(signal: Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => new UntilFx(fx, signal)
+}
+
+class UntilFx<R, E, A, R2, E2, B>
+  extends Fx.Variance<R | R2, E | E2, A>
+  implements Fx<R | R2, E | E2, A>
+{
+  constructor(readonly fx: Fx<R, E, A>, readonly signal: Fx<R2, E2, B>) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
+    const { fx, signal } = this
+
+    return withEarlyExit(
+      (earlyExit) =>
+        Effect.gen(function* ($) {
+          const fiber = yield* $(Effect.forkScoped(fx.run(sink)))
+          const signalFiber = yield* $(
+            Effect.forkScoped(signal.run(Fx.Sink(() => earlyExit, sink.error, earlyExit))),
+          )
+
+          yield* $(Fiber.joinAll([fiber, signalFiber]))
+        }),
+      sink.end,
+    )
+  }
+}

package/src/operator/withItems.ts

@@ -0,0 +1,9 @@
+import { identity } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { zipItems } from './zipItems.js'
+
+export function withItems<B>(items: Iterable<B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B> {
+  return zipItems(items, identity)
+}

package/src/operator/withPermit.ts

@@ -0,0 +1,18 @@
+import * as TSemaphore from '@effect/stm/TSemaphore'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function withPermit(semaphore: TSemaphore.TSemaphore) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => new WithPermitFx(fx, semaphore)
+}
+
+class WithPermitFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly fx: Fx<R, E, A>, readonly semaphore: TSemaphore.TSemaphore) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>) {
+    return pipe(this.fx.run(sink), TSemaphore.withPermit(this.semaphore))
+  }
+}

package/src/operator/withRuntimeFlags.ts

@@ -0,0 +1,19 @@
+import * as Effect from '@effect/io/Effect'
+import { RuntimeFlagsPatch } from '@effect/io/Fiber/Runtime/Flags/Patch'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function withRuntimeFlags(patch: RuntimeFlagsPatch) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => new WithRuntimeFlagsFx(fx, patch)
+}
+
+class WithRuntimeFlagsFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
+  constructor(readonly fx: Fx<R, E, A>, readonly patch: RuntimeFlagsPatch) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>) {
+    return pipe(this.fx.run(sink), Effect.withRuntimeFlags(this.patch))
+  }
+}

package/src/operator/zip.test.ts

@@ -0,0 +1,30 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { millis } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { mergeAll } from './merge.js'
+import { zipAll } from './zip.js'
+
+describe(import.meta.url, () => {
+  describe(zipAll.name, () => {
+    it('allows combining multiple streams together only emmiting when all streams have emitted at least once', async () => {
+      const test = pipe(
+        zipAll(
+          mergeAll(at(millis(0), 1), at(millis(200), 2)),
+          mergeAll(at(millis(100), 3), at(millis(150), 4)),
+          mergeAll(at(millis(250), 5), at(millis(300), 6)),
+        ),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [[2, 4, 5]])
+    })
+  })
+})