@typed/fx 0.0.35 → 1.0.2

package/src/debounce.ts

@@ -1,49 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-export function debounce(duration: Duration.Duration) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => debounce_(fx, duration)
-}
-
-function debounce_<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
-  return Fx((emitter) =>
-    pipe(
-      Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
-      Effect.flatMap((ref) =>
-        withDynamicCountdownLatch(
-          1,
-          ({ increment, latch }) =>
-            fx.run(
-              Emitter(
-                (a) =>
-                  ref.updateEffect((previous) =>
-                    pipe(
-                      previous ? Fiber.interrupt(previous) : increment,
-                      Effect.flatMap(() =>
-                        pipe(
-                          emitter.emit(a),
-                          Effect.delay(duration),
-                          Effect.interruptible,
-                          Effect.tap(() => latch.countDown),
-                          Effect.uninterruptible,
-                          Effect.fork,
-                        ),
-                      ),
-                    ),
-                  ),
-                emitter.failCause,
-                latch.countDown,
-              ),
-            ),
-          emitter.end,
-        ),
-      ),
-    ),
-  )
-}

package/src/delay.test.ts

@@ -1,24 +0,0 @@
-import { deepStrictEqual, ok } 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('delay', () => {
-    it('adds a delay to an event', async () => {
-      const start = performance.now()
-      const value = Math.random()
-      const delayMs = 100
-      const test = Fx.at(Duration.millis(delayMs))(value)
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-      const end = performance.now()
-
-      ok(end - start >= delayMs)
-
-      deepStrictEqual(events, [value])
-    })
-  })
-})

package/src/delay.ts

@@ -1,17 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { flow } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-
-import { Emitter, Fx } from './Fx.js'
-import { succeed } from './fromEffect.js'
-
-export function delay(duration: Duration.Duration) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
-    Fx((emitter) =>
-      fx.run(Emitter(flow(emitter.emit, Effect.delay(duration)), emitter.failCause, emitter.end)),
-    )
-}
-
-export function at(duration: Duration.Duration) {
-  return flow(succeed, delay(duration))
-}

package/src/during.test.ts

@@ -1,39 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as TestClock from '@effect/core/testing/TestClock'
-import { TestEnvironment } from '@effect/core/testing/TestEnvironment'
-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(Fx.during.name, () => {
-    it('runs a stream during a signal is emitted to stop', async () => {
-      const sut = Effect.gen(function* ($) {
-        const fiber = yield* $(
-          pipe(
-            Fx.periodic(millis(10)),
-            Fx.scan(0, (x) => x + 1),
-            Fx.during(Fx.at(millis(50))(Fx.at(millis(50))(null))),
-            Fx.runCollect,
-            Effect.fork,
-          ),
-        )
-
-        for (let i = 0; i < 10; i++) {
-          yield* $(TestClock.adjust(millis(10)))
-        }
-
-        return yield* $(Fiber.join(fiber))
-      })
-
-      const test = pipe(sut, Effect.provideLayer(TestEnvironment))
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [6, 7, 8, 9, 10])
-    })
-  })
-})

package/src/during.ts

@@ -1,54 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { joinAll } from '@effect/core/io/Fiber'
-import { pipe } from '@fp-ts/data/Function'
-import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
-
-import { Emitter, Fx } from './Fx.js'
-import { exitEarly, onEarlyExitFailure } from './_internal.js'
-
-export function during<R2, E2, R3, E3, B>(signal: Fx<R2, E2, Fx<R3, E3, B>>) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, A> => during_(fx, signal)
-}
-
-function during_<R, E, A, R2, E2, R3, E3, B>(
-  fx: Fx<R, E, A>,
-  signal: Fx<R2, E2, Fx<R3, E3, B>>,
-): Fx<R | R2 | R3, E | E2 | E3, A> {
-  return Fx((emitter) =>
-    pipe(
-      Effect.sync(() => new AtomicReference(false)),
-      Effect.flatMap((ref) =>
-        pipe(
-          signal.run(
-            Emitter(
-              (endSignal) =>
-                pipe(
-                  Effect.sync(() => ref.set(true)),
-                  Effect.flatMap(() =>
-                    endSignal.run(Emitter(() => exitEarly, emitter.failCause, Effect.unit)),
-                  ),
-                ),
-              emitter.failCause,
-              Effect.unit,
-            ),
-          ),
-          Effect.forkScoped,
-          Effect.flatMap((fiber) =>
-            pipe(
-              fx.run(
-                Emitter(
-                  (a) => (ref.get ? emitter.emit(a) : Effect.unit),
-                  emitter.failCause,
-                  exitEarly,
-                ),
-              ),
-              Effect.forkScoped,
-              Effect.flatMap((fiber2) => joinAll([fiber, fiber2])),
-              onEarlyExitFailure(emitter.end),
-            ),
-          ),
-        ),
-      ),
-    ),
-  )
-}

package/src/exhaustMap.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(Fx.exhaustMap.name, () => {
-    it('allows chaining multiple synchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.exhaustMap((n) => Fx.fromIterable([n, n, n])),
-        Fx.runCollect,
-
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1])
-    })
-
-    it('allows chaining multiple asynchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.exhaustMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1])
-    })
-  })
-})

package/src/exhaustMap.ts

@@ -1,49 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-export function exhaustMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
-    Fx(<R3>(emitter: Emitter<R3, E | E2, B>) =>
-      pipe(
-        Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
-        Effect.flatMap((ref) =>
-          withDynamicCountdownLatch(
-            1,
-            ({ increment, latch }) =>
-              fx.run(
-                Emitter(
-                  (a) =>
-                    ref.updateEffect((fiber) =>
-                      fiber
-                        ? Effect.succeed(fiber)
-                        : pipe(
-                            increment,
-                            Effect.flatMap(() =>
-                              Effect.forkScoped(
-                                f(a).run(
-                                  Emitter(
-                                    emitter.emit,
-                                    (e) =>
-                                      pipe(ref.set(null), Effect.zipRight(emitter.failCause(e))),
-                                    pipe(ref.set(null), Effect.zipRight(latch.countDown)),
-                                  ),
-                                ),
-                              ),
-                            ),
-                          ),
-                    ),
-                  emitter.failCause,
-                  latch.countDown,
-                ),
-              ),
-            emitter.end,
-          ),
-        ),
-      ),
-    )
-}

package/src/exhaustMapLatest.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(Fx.exhaustMapLatest.name, () => {
-    it('allows chaining multiple synchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.exhaustMapLatest((n) => Fx.fromIterable([n, n, n])),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1, 3, 3, 3])
-    })
-
-    it('allows chaining multiple asynchronous streams', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.exhaustMapLatest((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
-        Fx.runCollect,
-
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1, 3, 3, 3])
-    })
-  })
-})

package/src/exhaustMapLatest.ts

@@ -1,59 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as Ref from '@effect/core/io/Ref'
-import { Scope } from '@effect/core/io/Scope'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-export function exhaustMapLatest<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
-    Fx(<R3>(emitter: Emitter<R3, E | E2, B>) =>
-      pipe(
-        Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
-        Effect.zip(Ref.makeRef<Fx<R2, E2, B> | null>(() => null)),
-        Effect.flatMap(([fiberRef, nextFxRef]) => {
-          return withDynamicCountdownLatch(
-            1,
-            ({ increment, latch }) => {
-              const runNextFx: Effect.Effect<R3 | R2 | Scope, never, void> = pipe(
-                nextFxRef.getAndSet(null),
-                Effect.flatMap((fx) =>
-                  fx ? fiberRef.updateEffect(() => runFx(fx)) : latch.countDown,
-                ),
-              )
-
-              const runFx = (fx: Fx<R2, E2, B>) =>
-                Effect.forkScoped(
-                  fx.run(
-                    Emitter(
-                      emitter.emit,
-                      (e) => pipe(fiberRef.set(null), Effect.zipRight(emitter.failCause(e))),
-                      pipe(fiberRef.set(null), Effect.zipRight(runNextFx)),
-                    ),
-                  ),
-                )
-
-              return fx.run(
-                Emitter(
-                  (a) =>
-                    fiberRef.updateEffect((fiber) =>
-                      fiber
-                        ? pipe(nextFxRef.set(f(a)), Effect.as(fiber))
-                        : pipe(
-                            increment,
-                            Effect.flatMap(() => runFx(f(a))),
-                          ),
-                    ),
-                  emitter.failCause,
-                  latch.countDown,
-                ),
-              )
-            },
-            emitter.end,
-          )
-        }),
-      ),
-    )
-}

package/src/exhaustMapList.test.ts

@@ -1,64 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as TestClock from '@effect/core/testing/TestClock'
-import { TestEnvironment } from '@effect/core/testing/TestEnvironment'
-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(Fx.exhaustMapList.name, () => {
-    it('memoizes the input value its first stream', async () => {
-      let started = 0
-      const fx = pipe(
-        Fx.succeed([1, 2, 3]),
-        Fx.merge(pipe(Fx.succeed([3, 2, 1]), Fx.delay(millis(30)))),
-        Fx.exhaustMapList((a) => {
-          started++
-
-          return pipe(
-            Fx.periodic(millis(10)),
-            Fx.scan(a, (x) => x + a),
-            Fx.take(a * a),
-          )
-        }),
-      )
-
-      const test = pipe(
-        Effect.gen(function* ($) {
-          const fiber = yield* $(pipe(fx, Fx.runCollect, Effect.fork))
-
-          for (let i = 0; i < 20; i++) {
-            yield* $(TestClock.adjust(millis(10)))
-          }
-
-          return yield* $(Fiber.join(fiber))
-        }),
-        Effect.provideLayer(TestEnvironment),
-      )
-
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [
-        [1, 2, 3],
-        [1, 2, 6],
-        [1, 4, 6],
-        [1, 6, 6],
-        [1, 6, 9],
-        [1, 6, 12],
-        [1, 8, 12],
-        [12, 8, 1],
-        [15, 8, 1],
-        [18, 8, 1],
-        [21, 8, 1],
-        [24, 8, 1],
-        [27, 8, 1],
-      ])
-
-      deepStrictEqual(started, 3)
-    })
-  })
-})

package/src/exhaustMapList.ts

@@ -1,144 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import { pipe } from '@fp-ts/data/Function'
-import * as HashSet from '@tsplus/stdlib/collections/HashSet'
-import * as ImmutableMap from '@tsplus/stdlib/collections/ImmutableMap'
-import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
-import { identity } from '@tsplus/stdlib/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-export function exhaustMapList<A, R2, E2, B, A1 = A>(
-  f: (a: A) => Fx<R2, E2, B>,
-  selector: (a: A) => A1 = identity as any,
-) {
-  return <R, E>(fx: Fx<R, E, ReadonlyArray<A>>): Fx<R | R2, E | E2, ReadonlyArray<B>> =>
-    Fx((emitter) =>
-      pipe(
-        Effect.sync(() => new AtomicReference(ImmutableMap.empty<A1, Fiber.Fiber<E2, unknown>>())),
-        Effect.zip(Effect.sync(() => new AtomicReference<ReadonlyArray<A>>([]))), // Must use Array to maintain order
-        Effect.zip(Effect.sync(() => new AtomicReference(ImmutableMap.empty<A1, B>()))),
-        Effect.flatMap(([[fibersMapRef, previousValuesRef], valuesRef]) => {
-          const emitIfReady = pipe(
-            Effect.sync(() => previousValuesRef.get),
-            Effect.zip(Effect.sync(() => valuesRef.get)),
-            Effect.flatMap(([previousValues, values]) => {
-              const vals = previousValues
-                .map((a) => pipe(values, ImmutableMap.get(selector(a))))
-                .filter(Maybe.isSome)
-                .map((x) => x.value)
-
-              if (vals.length === previousValues.length) {
-                return emitter.emit(vals)
-              }
-
-              return Effect.unit
-            }),
-          )
-
-          return withDynamicCountdownLatch(
-            1,
-            ({ latch, increment }) =>
-              pipe(
-                fx.run(
-                  Emitter(
-                    (as) =>
-                      Effect.suspendSucceed(() => {
-                        const fibersMap = fibersMapRef.get
-                        const previous = HashSet.make<readonly A[]>(...previousValuesRef.get)
-                        const current = HashSet.make<readonly A[]>(...as)
-                        const toStart = HashSet.difference(previous)(current)
-                        const toCancel = HashSet.difference(current)(previous)
-
-                        previousValuesRef.set(as)
-
-                        // If the input values were just reordered, go ahead and emit
-                        if (HashSet.size(toStart) === 0 && HashSet.size(toCancel) === 0) {
-                          return emitIfReady
-                        }
-
-                        return pipe(
-                          Effect.forEachParDiscard(toCancel, (a) =>
-                            pipe(
-                              fibersMap,
-                              ImmutableMap.get(selector(a)),
-                              Maybe.fold(
-                                () => Effect.unit,
-                                (fiber) =>
-                                  pipe(
-                                    Fiber.interrupt(fiber),
-                                    Effect.zipRight(
-                                      Effect.sync(() => {
-                                        const a1 = selector(a)
-                                        fibersMapRef.set(ImmutableMap.remove(a1)(fibersMapRef.get))
-                                        valuesRef.set(ImmutableMap.remove(a1)(valuesRef.get))
-                                      }),
-                                    ),
-                                    Effect.zipRight(latch.countDown),
-                                  ),
-                              ),
-                            ),
-                          ),
-                          Effect.zipParRight(
-                            Effect.forEachDiscard(toStart, (a) =>
-                              pipe(
-                                increment,
-                                Effect.flatMap(() =>
-                                  Effect.forkScoped(
-                                    f(a).run(
-                                      Emitter(
-                                        (b) =>
-                                          pipe(
-                                            Effect.sync(() =>
-                                              valuesRef.set(
-                                                ImmutableMap.set(selector(a), b)(valuesRef.get),
-                                              ),
-                                            ),
-                                            Effect.zipRight(emitIfReady),
-                                          ),
-                                        emitter.failCause,
-                                        pipe(
-                                          Effect.sync(() =>
-                                            fibersMapRef.set(
-                                              ImmutableMap.remove(selector(a))(fibersMapRef.get),
-                                            ),
-                                          ),
-                                          Effect.zipRight(latch.countDown),
-                                        ),
-                                      ),
-                                    ),
-                                  ),
-                                ),
-                                Effect.tap((fiber) =>
-                                  Effect.sync(() =>
-                                    fibersMapRef.set(
-                                      pipe(
-                                        fibersMapRef.get,
-                                        ImmutableMap.set<A1, Fiber.Fiber<E2, unknown>>(
-                                          selector(a),
-                                          fiber,
-                                        ),
-                                      ),
-                                    ),
-                                  ),
-                                ),
-                              ),
-                            ),
-                          ),
-                          Effect.forkScoped,
-                          Effect.zipRight(emitIfReady),
-                        )
-                      }),
-                    emitter.failCause,
-                    latch.countDown,
-                  ),
-                ),
-              ),
-            emitter.end,
-          )
-        }),
-      ),
-    )
-}

package/src/filterLoop.test.ts

@@ -1,63 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.loop.name, () => {
-    it('tracks state and atomically computing a value', async () => {
-      const values = ['foo', 'bar', 'baz', 'quux']
-      const test = pipe(
-        Fx.fromIterable(values),
-        Fx.loop(1, (a, b) => [a + b.length, a]),
-      )
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, [1, 4, 7, 10])
-    })
-  })
-
-  describe(Fx.scan.name, () => {
-    it('emits seed value and tracks applies a reducer to events and accumulator', async () => {
-      const values = ['foo', 'bar', 'baz', 'quux']
-      const test = pipe(
-        Fx.fromIterable(values),
-        Fx.scan(1, (a, b) => a + b.length),
-      )
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, [1, 4, 7, 10, 14])
-    })
-  })
-
-  describe(Fx.filterLoop.name, () => {
-    it('tracks state and atomically computing a value, using Maybe for filtering', async () => {
-      const values = ['foo', 'bar', 'baz', 'quux']
-      const test = pipe(
-        Fx.fromIterable(values),
-        Fx.filterLoop(1, (a, b) =>
-          b.startsWith('b') ? Maybe.some([a + b.length, a]) : Maybe.none,
-        ),
-      )
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, [1, 4])
-    })
-  })
-
-  describe(Fx.filterScan.name, () => {
-    it('emits seed value and tracks applies a reducer to events and accumulator, using Maybe for filtering', async () => {
-      const values = ['foo', 'bar', 'baz', 'quux']
-      const test = pipe(
-        Fx.fromIterable(values),
-        Fx.filterScan(1, (a, b) => (b.startsWith('b') ? Maybe.some(a + b.length) : Maybe.none)),
-      )
-      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(events, [1, 4, 7])
-    })
-  })
-})