@typed/fx 0.0.35 → 1.0.2

package/src/operator/filterMapEffect.ts

@@ -0,0 +1,44 @@
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Option from '@fp-ts/data/Option'
+
+import { Fx } from '../Fx.js'
+
+export function filterMapEffect<A, R2, E2, B>(
+  predicate: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> => new FilterMapEffectFx(fx, predicate)
+}
+
+class FilterMapEffectFx<R, E, A, R2, E2, B>
+  extends Fx.Variance<R | R2, E | E2, B>
+  implements Fx<R | R2, E | E2, B>
+{
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly predicate: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+  ) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E | E2, B>) {
+    return this.fx.run(new FilterMapEffectSink(sink, this.predicate))
+  }
+}
+
+class FilterMapEffectSink<R, E, A, R2, E2, B> implements Fx.Sink<R | R2, E, A> {
+  constructor(
+    readonly sink: Fx.Sink<R, E | E2, B>,
+    readonly predicate: (a: A) => Effect.Effect<R2, E2, Option.Option<B>>,
+  ) {}
+
+  event = (a: A) => {
+    return pipe(
+      this.predicate(a),
+      Effect.matchCauseEffect(this.sink.error, Option.match(Effect.unit, this.sink.event)),
+    )
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}

package/src/operator/flatMap.test.ts

@@ -0,0 +1,38 @@
+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 { fromArray } from '../constructor/fromArray.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { flatMap } from './flatMap.js'
+
+describe(import.meta.url, () => {
+  describe(flatMap.name, () => {
+    it('allows mapping to other Fx', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3]),
+        flatMap((n) => fromArray([n * 2, n + 1])),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [2, 2, 4, 3, 6, 4])
+    })
+
+    it('allows mapping to other asynchronous Fx', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3]),
+        flatMap((n) => at(millis(10), n * 2)),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [2, 4, 6])
+    })
+  })
+})

package/src/operator/flatMap.ts

@@ -0,0 +1,45 @@
+import * as Effect from '@effect/io/Effect'
+import { identity, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { withRefCounter } from '../_internal/RefCounter.js'
+
+export function flatMap<A, R2, E2, B>(
+  f: (a: A) => Fx<R2, E2, B>,
+): <R, E>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, B> {
+  return (fx) => new FlatMapFx(fx, f)
+}
+
+export const flatten: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
+  flatMap(identity)
+
+class FlatMapFx<R, E, A, R2, E2, B>
+  extends Fx.Variance<R | R2, E | E2, B>
+  implements Fx<R | R2, E | E2, B>
+{
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => Fx<R2, E2, B>) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, B>) {
+    return withRefCounter(
+      1,
+      (counter) =>
+        this.fx.run(
+          Fx.Sink(
+            (a) =>
+              pipe(
+                counter.increment,
+                Effect.flatMap(() =>
+                  this.f(a).run(Fx.Sink(sink.event, sink.error, counter.decrement)),
+                ),
+                Effect.forkScoped,
+              ),
+            sink.error,
+            counter.decrement,
+          ),
+        ),
+      sink.end,
+    )
+  }
+}

package/src/operator/flatMapCause.ts

@@ -0,0 +1,43 @@
+import { Cause } from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { withRefCounter } from '../_internal/RefCounter.js'
+
+export function flatMapCause<E, R2, E2, B>(
+  f: (cause: Cause<E>) => Fx<R2, E2, B>,
+): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B> {
+  return (fx) => new FlatMapCauseFx(fx, f)
+}
+
+class FlatMapCauseFx<R, E, A, R2, E2, B>
+  extends Fx.Variance<R | R2, E | E2, B>
+  implements Fx<R | R2, E | E2, A | B>
+{
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (cause: Cause<E>) => Fx<R2, E2, B>) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, A | B>) {
+    return withRefCounter(
+      1,
+      (counter) =>
+        this.fx.run(
+          Fx.Sink(
+            sink.event,
+            (cause) =>
+              pipe(
+                counter.increment,
+                Effect.flatMap(() =>
+                  this.f(cause).run(Fx.Sink(sink.event, sink.error, counter.decrement)),
+                ),
+                Effect.forkScoped,
+              ),
+            counter.decrement,
+          ),
+        ),
+      sink.end,
+    )
+  }
+}

package/src/operator/flatMapConcurrently.test.ts

@@ -0,0 +1,28 @@
+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 { fromArray } from '../constructor/fromArray.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+import { mergeAll } from './merge.js'
+
+describe(import.meta.url, () => {
+  describe(flatMapConcurrently.name, () => {
+    it('merges inner streams with specified concurrency', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3, 4]),
+        flatMapConcurrently(2, (n) => mergeAll(at(millis(50), n), at(millis(100), n * n))),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 1, 4, 3, 4, 9, 16])
+    })
+  })
+})

package/src/operator/flatMapConcurrently.ts

@@ -0,0 +1,17 @@
+import * as TSemaphore from '@effect/stm/TSemaphore'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { suspend } from '../constructor/suspend.js'
+
+import { flatMap } from './flatMap.js'
+import { withPermit } from './withPermit.js'
+
+export function flatMapConcurrently<A, R2, E2, B>(concurrency: number, f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(stream: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    suspend(() => {
+      const semaphore = TSemaphore.unsafeMake(concurrency)
+
+      return pipe(stream, flatMap(flow(f, withPermit(semaphore))))
+    })
+}

package/src/operator/flatMapEffect.ts

@@ -0,0 +1,13 @@
+import { Effect } from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { fromEffect } from '../constructor/fromEffect.js'
+
+import { flatMap } from './flatMap.js'
+
+export function flatMapEffect<A, R2, E2, B>(
+  f: (a: A) => Effect<R2, E2, B>,
+): <R, E>(stream: Fx<R, E, A>) => Fx<R | R2, E | E2, B> {
+  return flatMap(flow(f, fromEffect))
+}

package/src/operator/flatMapEffectConcurrently.ts

@@ -0,0 +1,14 @@
+import { Effect } from '@effect/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { fromEffect } from '../constructor/fromEffect.js'
+
+import { flatMapConcurrently } from './flatMapConcurrently.js'
+
+export function flatMapEffectConcurrently<A, R2, E2, B>(
+  concurrency: number,
+  f: (a: A) => Effect<R2, E2, B>,
+): <R, E>(stream: Fx<R, E, A>) => Fx<R | R2, E | E2, B> {
+  return flatMapConcurrently(concurrency, flow(f, fromEffect))
+}

package/src/operator/hold.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 { millis } from '@fp-ts/data/Duration'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { hold } from './hold.js'
+import { mergeAll } from './merge.js'
+
+describe(import.meta.url, () => {
+  describe(hold.name, () => {
+    it('allows replaying latest events to late subscribers', async () => {
+      const test = Effect.gen(function* ($) {
+        const stream = hold(
+          mergeAll(
+            at(millis(0), 1),
+            at(millis(100), 2),
+            at(millis(200), 3),
+            at(millis(300), 4),
+            at(millis(400), 5),
+            at(millis(500), 6),
+          ),
+        )
+
+        const fiber1 = yield* $(Effect.fork(collectAll(stream)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber2 = yield* $(Effect.fork(collectAll(stream)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber3 = yield* $(Effect.fork(collectAll(stream)))
+
+        deepStrictEqual(yield* $(Fiber.join(fiber1)), [1, 2, 3, 4, 5, 6], '1')
+        deepStrictEqual(yield* $(Fiber.join(fiber2)), [1, 2, 3, 4, 5, 6], '2')
+        deepStrictEqual(yield* $(Fiber.join(fiber3)), [2, 3, 4, 5, 6], '3')
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/operator/hold.ts

@@ -0,0 +1,143 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { Scope } from '@effect/io/Scope'
+import { pipe } from '@fp-ts/data/Function'
+import * as MutableRef from '@fp-ts/data/MutableRef'
+import * as Option from '@fp-ts/data/Option'
+
+import { Fx } from '../Fx.js'
+import { asap } from '../_internal/RefCounter.js'
+
+import { MulticastFx } from './multicast.js'
+
+export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new HoldFx(fx, MutableRef.make(Option.none))
+}
+
+export function hold_<R, E, A>(fx: Fx<R, E, A>, value: MutableRef.MutableRef<Option.Option<A>>) {
+  return new HoldFx(fx, value)
+}
+
+export class HoldFx<R, E, A> extends MulticastFx<R, E, A> implements Fx<R, E, A> {
+  protected pendingSinks: Array<readonly [Fx.Sink<any, E, A>, A[]]> = []
+  protected scheduledFiber: Fiber.RuntimeFiber<any, any> | undefined = undefined
+
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    protected current: MutableRef.MutableRef<Option.Option<A>>,
+  ) {
+    super(fx)
+
+    this.event = this.event.bind(this)
+    this.error = this.error.bind(this)
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>): Effect.Effect<Scope | R | R2, never, void> {
+    return Effect.suspendSucceed(() => {
+      if (Option.isSome(this.current.get())) {
+        return pipe(
+          this.scheduleFlush(sink),
+          Effect.flatMap(() => super.run(sink)),
+        )
+      }
+
+      return super.run(sink)
+    })
+  }
+
+  event(a: A) {
+    return Effect.suspendSucceed(() => {
+      this.addValue(a)
+
+      return pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.event(a)),
+      )
+    })
+  }
+
+  error(cause: Cause.Cause<E>) {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.error(cause)),
+      ),
+    )
+  }
+
+  get end() {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.end),
+      ),
+    )
+  }
+
+  protected scheduleFlush(sink: Fx.Sink<any, E, A>) {
+    return Effect.suspendSucceed(() => {
+      this.pendingSinks.push([
+        sink,
+        pipe(
+          this.current.get(),
+          Option.match(
+            () => [],
+            (a) => [a],
+          ),
+        ),
+      ])
+
+      const interrupt = this.scheduledFiber
+        ? Fiber.interruptFork(this.scheduledFiber)
+        : Effect.unit()
+
+      this.scheduledFiber = undefined
+
+      return pipe(
+        interrupt,
+        Effect.flatMap(() => this.flushPending()),
+        Effect.scheduleForked(asap),
+        Effect.tap((f) =>
+          Effect.sync(() => {
+            this.scheduledFiber = f
+          }),
+        ),
+      )
+    })
+  }
+
+  protected flushPending() {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+
+    if (this.pendingSinks.length === 0) {
+      return Effect.unit()
+    }
+
+    const pendingSinks = this.pendingSinks
+
+    this.pendingSinks = []
+
+    return Effect.gen(function* ($) {
+      for (const [sink, events] of pendingSinks) {
+        const observer = that.findObserver(sink)
+
+        if (!observer) continue
+
+        for (const event of events) {
+          yield* $(that.runEvent(event, observer))
+        }
+      }
+    })
+  }
+
+  protected findObserver(sink: Fx.Sink<any, E, A>) {
+    return this.observers.find((x) => x.sink === sink)
+  }
+
+  protected addValue(a: A) {
+    this.current.set(Option.some(a))
+    this.pendingSinks.forEach(([, events]) => events.push(a))
+  }
+}

package/src/operator/index.ts

@@ -0,0 +1,83 @@
+export * from './as.js'
+export * from './asUnit.js'
+export * from './catchAll.js'
+export * from './catchAllCause.js'
+export * from './catchAllDefect.js'
+export * from './combine.js'
+export * from './compact.js'
+export * from './concatMap.js'
+export * from './continueWith.js'
+export * from './debounce.js'
+export * from './delay.js'
+export * from './during.js'
+export * from './exhaustMap.js'
+export * from './exhaustMapEffect.js'
+export * from './exhaustMapLatest.js'
+export * from './exhaustMapLatestEffect.js'
+export * from './filter.js'
+export * from './filterEffect.js'
+export * from './filterMap.js'
+export * from './filterMapEffect.js'
+export * from './flatMap.js'
+export * from './flatMapCause.js'
+export * from './flatMapConcurrently.js'
+export * from './flatMapEffect.js'
+export * from './flatMapEffectConcurrently.js'
+export * from './hold.js'
+export * from './interruptible.js'
+export * from './loop.js'
+export * from './map.js'
+export * from './mapCause.js'
+export * from './mapError.js'
+export * from './merge.js'
+export * from './multicast.js'
+export * from './onDone.js'
+export * from './onDoneCause.js'
+export * from './onError.js'
+export * from './onExit.js'
+export * from './onInterrupt.js'
+export * from './orElse.js'
+export * from './provideEnvironment.js'
+export * from './provideLayer.js'
+export * from './provideService.js'
+export * from './provideServiceEffect.js'
+export * from './provideSomeEnvironment.js'
+export * from './provideSomeLayer.js'
+export * from './race.js'
+export * from './sample.js'
+export * from './sandbox.js'
+export * from './scan.js'
+export * from './scanEffect.js'
+export * from './separate.js'
+export * from './since.js'
+export * from './skip.js'
+export * from './skipAfter.js'
+export * from './skipRepeats.js'
+export * from './skipUntil.js'
+export * from './skipWhile.js'
+export * from './slice.js'
+export * from './snapshot.js'
+export * from './snapshotEffect.js'
+export * from './startWith.js'
+export * from './startWithEffect.js'
+export * from './struct.js'
+export * from './switchMap.js'
+export * from './switchMapCause.js'
+export * from './switchMapEffect.js'
+export * from './switchMapError.js'
+export * from './switchMatch.js'
+export * from './take.js'
+export * from './takeUntil.js'
+export * from './takeWhile.js'
+export * from './tap.js'
+export * from './tapCause.js'
+export * from './tapError.js'
+export * from './throttle.js'
+export * from './tuple.js'
+export * from './uninterruptible.js'
+export * from './until.js'
+export * from './withItems.js'
+export * from './withPermit.js'
+export * from './withRuntimeFlags.js'
+export * from './zip.js'
+export * from './zipItems.js'

package/src/operator/interruptible.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 interruptible<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new InterruptibleFx(fx)
+}
+
+class InterruptibleFx<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.interruptible)
+  }
+}

package/src/operator/loop.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 { loop } from './loop.js'
+
+describe(import.meta.url, () => {
+  describe(loop.name, () => {
+    it('allows tracking state and computed a value from that state', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3]),
+        loop(0, (acc, n) => [(acc + n).toString(), acc + n]),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, ['1', '3', '6'])
+    })
+  })
+})

package/src/operator/loop.ts

@@ -0,0 +1,43 @@
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from '../Fx.js'
+
+export function loop<B, A, C>(seed: B, f: (b: B, a: A) => readonly [C, B]) {
+  return <R, E>(stream: Fx<R, E, A>): Fx<R, E, C> => new LoopFx(stream, seed, f)
+}
+
+class LoopFx<R, E, A, B, C> extends Fx.Variance<R, E, C> implements Fx<R, E, C> {
+  constructor(
+    readonly stream: Fx<R, E, A>,
+    readonly seed: B,
+    readonly f: (b: B, a: A) => readonly [C, B],
+  ) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, C>) {
+    return this.stream.run(new LoopSink(sink, this.seed, this.f))
+  }
+}
+
+class LoopSink<R, E, A, B, C> implements Fx.Sink<R, E, A> {
+  protected acc: B = this.seed
+
+  constructor(
+    readonly sink: Fx.Sink<R, E, C>,
+    readonly seed: B,
+    readonly f: (b: B, a: A) => readonly [C, B],
+  ) {}
+
+  readonly event = (a: A) =>
+    Effect.suspendSucceed(() => {
+      const [c, b] = this.f(this.acc, a)
+
+      this.acc = b
+
+      return this.sink.event(c)
+    })
+
+  readonly error = this.sink.error
+  readonly end = this.sink.end
+}

package/src/operator/map.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 { map } from './map.js'
+
+describe(import.meta.url, () => {
+  describe(map.name, () => {
+    it('transforms an Fx', async () => {
+      const test = pipe(
+        fromArray([1, 2, 3]),
+        map((x) => x + 1),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [2, 3, 4])
+    })
+  })
+})

package/src/operator/map.ts

@@ -0,0 +1,26 @@
+import { Fx } from '../Fx.js'
+
+export function map<A, B>(f: (a: A) => B) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, B> => new MapFx(fx, f)
+}
+
+class MapFx<R, E, A, B> extends Fx.Variance<R, E, B> implements Fx<R, E, B> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, B>) {
+    return this.fx.run(new MapSink(sink, this.f))
+  }
+}
+
+class MapSink<R, E, A, B> implements Fx.Sink<R, E, A> {
+  constructor(readonly sink: Fx.Sink<R, E, B>, readonly f: (a: A) => B) {}
+
+  event = (a: A) => {
+    return this.sink.event(this.f(a))
+  }
+
+  error = this.sink.error
+  end = this.sink.end
+}