@typed/fx 0.0.8 → 0.0.10

package/src/continueWith.test.ts

@@ -0,0 +1,26 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.continueWith.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2]),
+            Fx.continueWith(() => Fx.fromIterable([3, 4])),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3, 4])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/continueWith.ts

@@ -0,0 +1,21 @@
+import * as Effect from '@effect/core/io/Effect'
+
+import { Emitter, Fx } from './Fx.js'
+import { succeed } from './fromEffect.js'
+
+export function continueWith<R2, E2, B>(f: () => Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    Fx((emitter) =>
+      fx.run(
+        Emitter(
+          emitter.emit,
+          emitter.failCause,
+          Effect.suspendSucceed(() => f().run(emitter)),
+        ),
+      ),
+    )
+}
+
+export function startWith<B>(value: B) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B | A> => continueWith(() => fx)(succeed(value))
+}

package/src/debounce.test.ts

@@ -0,0 +1,17 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('debounce', () => {
+    it('favors the latest overlapping event', async () => {
+      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.debounce(millis(100)), Fx.runCollect)
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [3])
+    })
+  })
+})

package/src/debounce.ts

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,24 @@
+import { deepStrictEqual, ok } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,30 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+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 test = pipe(
+        Fx.periodic(millis(10)),
+        Fx.scan(0, (x) => x + 1),
+        Fx.during(Fx.at(millis(50))(Fx.at(millis(55))(null))),
+        Fx.runCollect,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      // Effect-ts doesn't have a very deterministic way to deal with ordering of events
+      // so we first test what we actually expect, and if that fails, test that it worked, but
+      // the timing was slightly off.
+      try {
+        deepStrictEqual(events, [5, 6, 7, 8, 9])
+      } catch (e) {
+        deepStrictEqual(events, [5, 6, 7, 8])
+      }
+    })
+  })
+})

package/src/during.ts

@@ -0,0 +1,54 @@
+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/filterLoop.test.ts

@@ -0,0 +1,63 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/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])
+    })
+  })
+})

package/src/filterLoop.ts

@@ -0,0 +1,143 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
+import { pipe } from '@tsplus/stdlib/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Emitter, Fx } from './Fx.js'
+import { startWith } from './continueWith.js'
+import { FilterMap, Map } from './filterMap.js'
+
+export function loop<A, B, C>(seed: A, f: (a: A, b: B) => readonly [A, C]) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => Loop.make(fx, seed, f)
+}
+
+export function scan<A, B>(seed: A, f: (a: A, b: B) => A) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
+    pipe(
+      fx,
+      loop(seed, (a, b) => {
+        const c = f(a, b)
+        return [c, c]
+      }),
+      startWith(seed),
+    )
+}
+
+export function filterLoop<A, B, C>(seed: A, f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, C> => FilterLoop.make(fx, seed, f)
+}
+
+export function filterScan<A, B>(seed: A, f: (a: A, b: B) => Maybe.Maybe<A>) {
+  return <R, E>(fx: Fx<R, E, B>): Fx<R, E, A> =>
+    pipe(
+      fx,
+      filterLoop(seed, (a, b) =>
+        pipe(
+          f(a, b),
+          Maybe.map((c) => [c, c]),
+        ),
+      ),
+      startWith(seed),
+    )
+}
+
+export class Loop<R, E, A, B, C> implements Fx<R, E, C> {
+  constructor(
+    readonly fx: Fx<R, E, B>,
+    readonly seed: A,
+    readonly f: (a: A, b: B) => readonly [A, C],
+  ) {}
+
+  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return Effect.suspendSucceed(() => {
+      let acc = this.seed
+
+      return this.fx.run(
+        Emitter(
+          (b: B) => {
+            const [a, c] = this.f(acc, b)
+
+            acc = a
+
+            return emitter.emit(c)
+          },
+          emitter.failCause,
+          emitter.end,
+        ),
+      )
+    })
+  }
+
+  static make<R, E, A, B, C>(
+    fx: Fx<R, E, B>,
+    seed: A,
+    f: (a: A, b: B) => readonly [A, C],
+  ): Fx<R, E, C> {
+    if (fx instanceof FilterMap) {
+      return FilterLoop.make(fx.fx, seed, (a, x) =>
+        pipe(
+          x,
+          fx.f,
+          Maybe.map((b) => f(a, b)),
+        ),
+      )
+    }
+
+    if (fx instanceof Map) {
+      return Loop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
+    }
+
+    return new Loop(fx, seed, f)
+  }
+}
+
+export class FilterLoop<R, E, A, B, C> implements Fx<R, E, C> {
+  constructor(
+    readonly fx: Fx<R, E, B>,
+    readonly seed: A,
+    readonly f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
+  ) {}
+
+  run<R2>(emitter: Emitter<R2, E, C>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return Effect.suspendSucceed(() => {
+      let acc = this.seed
+
+      return this.fx.run(
+        Emitter(
+          (b: B) =>
+            pipe(
+              this.f(acc, b),
+              Maybe.fold(
+                () => Effect.unit,
+                ([a, c]) => ((acc = a), emitter.emit(c)),
+              ),
+            ),
+          emitter.failCause,
+          emitter.end,
+        ),
+      )
+    })
+  }
+
+  static make<R, E, A, B, C>(
+    fx: Fx<R, E, B>,
+    seed: A,
+    f: (a: A, b: B) => Maybe.Maybe<readonly [A, C]>,
+  ): Fx<R, E, C> {
+    if (fx instanceof FilterMap) {
+      return FilterLoop.make(fx.fx, seed, (a, x) =>
+        pipe(
+          x,
+          fx.f,
+          Maybe.flatMap((b) => f(a, b)),
+        ),
+      )
+    }
+
+    if (fx instanceof Map) {
+      return FilterLoop.make(fx.fx, seed, (a, x) => f(a, fx.f(x)))
+    }
+
+    return new FilterLoop(fx, seed, f)
+  }
+}

package/src/filterMap.test.ts

@@ -0,0 +1,33 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.map.name, () => {
+    it('transform the values of a Fx', async () => {
+      const test = pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.map((x) => x ** x),
+        Fx.runCollect,
+      )
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 4, 27])
+    })
+  })
+
+  describe(Fx.filterMap.name, () => {
+    it('transform the values and filters using Maybe of a Fx', async () => {
+      const test = pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.filterMap((x) => (x % 2 === 0 ? Maybe.none : Maybe.some(x ** x))),
+        Fx.runCollect,
+      )
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1, 27])
+    })
+  })
+})

package/src/filterMap.ts

@@ -0,0 +1,71 @@
+import * as Effect from '@effect/core/io/Effect'
+import { Scope } from '@effect/core/io/Scope'
+import { flow } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+import { Predicate } from '@tsplus/stdlib/data/Predicate'
+
+import { Emitter, Fx } from './Fx.js'
+
+export const map =
+  <A, B>(f: (a: A) => B) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> =>
+    Map.make(fx, f)
+
+export const as = <B>(value: B): (<R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, B>) => map(() => value)
+
+export class Map<R, E, A, B> implements Fx<R, E, B> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B) {}
+
+  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return this.fx.run(Emitter(flow(this.f, emitter.emit), emitter.failCause, emitter.end))
+  }
+
+  static make = <R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> => {
+    if (fx instanceof Map) {
+      return Map.make(fx.fx, flow(fx.f, f))
+    }
+
+    if (fx instanceof FilterMap) {
+      return FilterMap.make(fx.fx, flow(fx.f, Maybe.map(f)))
+    }
+
+    return new Map(fx, f)
+  }
+}
+
+export function filterMap<A, B>(f: (a: A) => Maybe.Maybe<B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> => FilterMap.make(fx, f)
+}
+
+export function filter<A>(predicate: Predicate<A>) {
+  return filterMap((a: A) => Maybe.fromPredicate(a, predicate))
+}
+
+export class FilterMap<R, E, A, B> implements Fx<R, E, B> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => Maybe.Maybe<B>) {}
+
+  run<R2>(emitter: Emitter<R2, E, B>): Effect.Effect<R | R2 | Scope, never, unknown> {
+    return this.fx.run(
+      Emitter(
+        flow(
+          this.f,
+          Maybe.fold(() => Effect.unit, emitter.emit),
+        ),
+        emitter.failCause,
+        emitter.end,
+      ),
+    )
+  }
+
+  static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Maybe.Maybe<B>): Fx<R, E, B> {
+    if (fx instanceof Map) {
+      return FilterMap.make(fx.fx, flow(fx.f, f))
+    }
+
+    if (fx instanceof FilterMap) {
+      return FilterMap.make(fx.fx, flow(fx.f, Maybe.flatMap(f)))
+    }
+
+    return new FilterMap(fx, f)
+  }
+}

package/src/flatMap.test.ts

@@ -0,0 +1,50 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.flatMap.name, () => {
+    it('allows chaining multiple synchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) => Fx.fromIterable([n, n, n])),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 1, 1, 2, 2, 2, 3, 3, 3])
+    })
+
+    it('allows chaining multiple asynchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 2, 3, 1, 2, 3, 1, 2, 3])
+    })
+
+    it('interrupts inner fibers when they emit their end signal', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) =>
+          n === 1
+            ? Fx.take(4)(
+                Fx.fromIterable([n, n + 10, n + 20, n + 30, n + 40, n + 50, n + 60, n + 70]),
+              )
+            : Fx.fromIterable([n, n, n]),
+        ),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 11, 21, 31, 2, 2, 2, 3, 3, 3])
+    })
+  })
+})

package/src/flatMap.ts

@@ -0,0 +1,40 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
+import { Map } from './filterMap.js'
+
+export function flatMap<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 instanceof Map ? flatMap_(fx.fx, flow(fx.f, f)) : flatMap_(fx, f)
+}
+
+export function join<R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>): Fx<R | R2, E | E2, A> {
+  return flatMap_(fx, (fx) => fx)
+}
+
+function flatMap_<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) {
+  return Fx((emitter) =>
+    withDynamicCountdownLatch(
+      1,
+      ({ increment, latch }) =>
+        fx.run(
+          Emitter(
+            (a) =>
+              pipe(
+                increment,
+                Effect.flatMap(() =>
+                  Effect.forkScoped(
+                    f(a).run(Emitter(emitter.emit, emitter.failCause, latch.countDown)),
+                  ),
+                ),
+              ),
+            emitter.failCause,
+            latch.countDown,
+          ),
+        ),
+      emitter.end,
+    ),
+  )
+}

package/src/flatMapConcurrently.test.ts

@@ -0,0 +1,23 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe('flatMapConcurrently', () => {
+    it('should run effects with specified concurrency', async () => {
+      const test = pipe(
+        Fx.mergeAll([Fx.succeed(1), Fx.succeed(2), Fx.succeed(3)]),
+        Fx.concatMap((a) => Fx.mergeAll([Fx.succeed(a), Fx.at(Duration.millis(50))(a * a)])),
+        Fx.runCollect,
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 1, 2, 4, 3, 9])
+    })
+  })
+})