@typed/fx 1.6.2 → 1.8.0

package/src/map.test.ts

@@ -0,0 +1,17 @@
+import { describe } from 'vitest'
+
+import { fromArray } from './fromArray.js'
+import { map } from './map.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(map.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'transforms the values of the stream',
+      map(fromArray(array), (x) => x + 1),
+      array.map((x) => x + 1),
+    )
+  })
+})

package/src/map.ts

@@ -0,0 +1,10 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function map<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, B> {
+  return Fx((sink) => fx.run(Sink((a) => Effect.suspend(() => sink.event(f(a))), sink.error)))
+}
+
+export function as<R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, B> {
+  return map(fx, () => value)
+}

package/src/mergeAll.test.ts

@@ -0,0 +1,17 @@
+import { describe } from 'vitest'
+
+import { fromArray } from './fromArray.js'
+import { mergeAll } from './mergeAll.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(mergeAll.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together',
+      mergeAll(fromArray(array), fromArray(array)),
+      [...array, ...array],
+    )
+  })
+})

package/src/mergeAll.ts

@@ -0,0 +1,23 @@
+import { Fx, Sink } from './Fx.js'
+import { Cause, Effect } from './externals.js'
+
+export function mergeAll<FXS extends ReadonlyArray<Fx<any, any, any>>>(
+  ...fxs: FXS
+): Fx<Fx.ResourcesOf<FXS[number]>, Fx.ErrorsOf<FXS[number]>, Fx.OutputOf<FXS[number]>> {
+  return Fx((sink) =>
+    Effect.forEachParDiscard(fxs, (fx) =>
+      fx.run(
+        Sink(sink.event, (cause) =>
+          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+        ),
+      ),
+    ),
+  )
+}
+
+export function merge<R, E, A, R2, E2, B>(
+  self: Fx<R, E, A>,
+  other: Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return mergeAll(self, other)
+}

package/src/multicast.test.ts

@@ -0,0 +1,62 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { describe, it, expect } from 'vitest'
+
+import { delay } from './delay.js'
+import { Chunk, Duration } from './externals.js'
+import { flatMap } from './flatMap.js'
+import { fromArray } from './fromArray.js'
+import { merge } from './mergeAll.js'
+import { multicast } from './multicast.js'
+import { suspend } from './suspend.js'
+import { toChunk } from './toChunk.js'
+
+describe(__filename, () => {
+  describe(multicast.name, () => {
+    it('allows sharing the underlying producer of a stream', async () => {
+      const values = [1, 2, 3]
+      let started = 0
+
+      const test = Effect.gen(function* ($) {
+        const stream = multicast(
+          suspend(() => {
+            started++
+
+            return flatMap(fromArray(values), (a) =>
+              merge(fromArray([a, a + 1]), delay(fromArray([a * a, a ** a]), Duration.millis(100))),
+            )
+          }),
+        )
+
+        const fiber1 = yield* $(Effect.fork(toChunk(stream)))
+        const fiber2 = yield* $(Effect.fork(toChunk(stream)))
+
+        const events1 = Chunk.toReadonlyArray(yield* $(Fiber.join(fiber1)))
+        const events2 = Chunk.toReadonlyArray(yield* $(Fiber.join(fiber2)))
+
+        const expected = [
+          values[0],
+          values[0] + 1,
+          values[1],
+          values[1] + 1,
+          values[2],
+          values[2] + 1,
+          values[0] * values[0],
+          values[1] * values[1],
+          values[2] * values[2],
+          values[0] ** values[0],
+          values[1] ** values[1],
+          values[2] ** values[2],
+        ]
+
+        expect(events1).toEqual(expected)
+
+        expect(events1).toEqual(events2)
+
+        expect(started).toEqual(1)
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+  })
+})

package/src/multicast.ts

@@ -0,0 +1,104 @@
+import type { Trace } from '@effect/data/Debug'
+import { identity } from '@effect/data/Function'
+
+import type { Fx, Sink } from './Fx.js'
+import { FxTypeId, Traced } from './Fx.js'
+import type { Cause, Context } from './externals.js'
+import { Effect, Fiber } from './externals.js'
+
+export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new MulticastFx(fx)
+}
+
+export interface MulticastObserver<R, E, A> {
+  readonly sink: Sink<R, E, A>
+  readonly context: Context.Context<R>
+}
+
+export class MulticastFx<R, E, A> implements Fx<R, E, A>, Sink<never, E, A> {
+  readonly [FxTypeId] = {
+    _R: identity,
+    _E: identity,
+    _A: identity,
+  }
+
+  protected observers: Array<MulticastObserver<any, E, A>> = []
+  protected fiber: Fiber.RuntimeFiber<never, void> | undefined
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    this.run = this.run.bind(this)
+    this.event = this.event.bind(this)
+    this.error = this.error.bind(this)
+  }
+
+  run<R2>(sink: Sink<R2, E, A>) {
+    const { observers } = this
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+
+    return Effect.catchAllCause(
+      Effect.gen(function* ($) {
+        const context = yield* $(Effect.context<R2>())
+        const observer: MulticastObserver<R2, E, A> = { sink, context }
+
+        if (observers.push(observer) === 1) {
+          that.fiber = yield* $(Effect.forkDaemon(that.fx.run(that)))
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        yield* $(Fiber.join(that.fiber!))
+
+        that.fiber = undefined
+        that.observers = []
+      }),
+      () => this.removeSink(sink),
+    )
+  }
+
+  readonly traced = (trace: Trace): Fx<R, E, A> => {
+    return multicast(Traced<R, E, A>(this.fx, trace))
+  }
+
+  event(a: A) {
+    return Effect.suspend(() =>
+      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
+    )
+  }
+
+  error = (cause: Cause.Cause<E>) =>
+    Effect.suspend(() =>
+      Effect.forEachDiscard(this.observers.slice(0), (observer) => this.runError(observer, cause)),
+    )
+
+  protected runEvent<R>(observer: MulticastObserver<R, E, A>, a: A) {
+    return Effect.catchAllCause(
+      Effect.provideContext(observer.sink.event(a), observer.context),
+      () => this.removeSink(observer.sink),
+    )
+  }
+
+  protected runError<R>(observer: MulticastObserver<R, E, A>, cause: Cause.Cause<E>) {
+    return Effect.catchAllCause(
+      Effect.provideContext(observer.sink.error(cause), observer.context),
+      () => this.removeSink(observer.sink),
+    )
+  }
+
+  protected removeSink(sink: Sink<any, E, A>) {
+    return Effect.suspend(() => {
+      const index = this.observers.findIndex((o) => o.sink === sink)
+
+      if (index > -1) {
+        this.observers.splice(index, 1)
+      }
+
+      if (this.observers.length === 0) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return Fiber.interrupt(this.fiber!)
+      }
+
+      return Effect.unit()
+    })
+  }
+}

package/src/never.ts

@@ -0,0 +1,6 @@
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function never<E = never, A = never>(): Fx<never, E, A> {
+  return Fx<never, E, A>(() => Effect.never())
+}

package/src/observe.ts

@@ -0,0 +1,33 @@
+import type { Scope } from '@effect/io/Scope'
+
+import type { Fx } from './Fx.js'
+import { Sink } from './Fx.js'
+import type { Cause } from './externals.js'
+import { Deferred, Effect, Fiber } from './externals.js'
+
+export function observe<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, void>,
+): Effect.Effect<R | R2 | Scope, E | E2, void> {
+  return Effect.gen(function* ($) {
+    const deferred = yield* $(Deferred.make<E | E2, void>())
+    const error = (cause: Cause.Cause<E | E2>) => Deferred.failCause(deferred, cause)
+    const end = () => Deferred.succeed(deferred, undefined)
+
+    const fiber = yield* $(
+      Effect.forkScoped(
+        Effect.flatMap(fx.run(Sink((a: A) => Effect.catchAllCause(f(a), error), error)), end),
+      ),
+    )
+
+    const a = yield* $(Deferred.await(deferred))
+
+    yield* $(Fiber.interruptFork(fiber))
+
+    return a
+  })
+}
+
+export function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, void> {
+  return observe(fx, () => Effect.unit())
+}

package/src/onInterrupt.ts

@@ -0,0 +1,16 @@
+import type { HashSet } from '@effect/data/HashSet'
+import type { FiberId } from '@effect/io/Fiber/Id'
+
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function onInterrupt<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (interruptors: HashSet<FiberId>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return Fx((sink) =>
+    Effect.onInterrupt(fx.run(sink), (interruptors) =>
+      Effect.catchAllCause(f(interruptors), sink.error),
+    ),
+  )
+}

package/src/promise.ts

@@ -0,0 +1,70 @@
+import type { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+import { fromEffect } from './fromEffect.js'
+import { fromFxEffect } from './fromFxEffect.js'
+
+export function promise<A>(f: () => Promise<A>): Fx<never, never, A> {
+  return fromEffect(Effect.promise(f))
+}
+
+export function promiseInterrupt<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, never, A> {
+  return fromEffect(Effect.promiseInterrupt(f))
+}
+
+export function tryPromise<A>(f: () => Promise<A>): Fx<never, unknown, A> {
+  return fromEffect(Effect.tryPromise(f))
+}
+
+export function tryPromiseInterrupt<A>(
+  f: (signal: AbortSignal) => Promise<A>,
+): Fx<never, unknown, A> {
+  return fromEffect(Effect.tryPromiseInterrupt(f))
+}
+
+export function tryCatchPromise<A, E>(
+  f: () => Promise<A>,
+  g: (error: unknown) => E,
+): Fx<never, E, A> {
+  return fromEffect(Effect.tryCatchPromise(f, g))
+}
+
+export function tryCatchPromiseInterrupt<A, E>(
+  f: (signal: AbortSignal) => Promise<A>,
+  g: (error: unknown) => E,
+): Fx<never, E, A> {
+  return fromEffect(Effect.tryCatchPromiseInterrupt(f, g))
+}
+
+export function promiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, E, A> {
+  return fromFxEffect(Effect.promise(f))
+}
+
+export function promiseInterruptFx<R, E, A>(
+  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
+): Fx<R, E, A> {
+  return fromFxEffect(Effect.promiseInterrupt(f))
+}
+
+export function tryPromiseFx<R, E, A>(f: () => Promise<Fx<R, E, A>>): Fx<R, unknown, A> {
+  return fromFxEffect(Effect.tryPromise(f))
+}
+
+export function tryPromiseInterruptFx<R, E, A>(
+  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
+): Fx<R, unknown, A> {
+  return fromFxEffect(Effect.tryPromiseInterrupt(f))
+}
+
+export function tryCatchPromiseFx<R, E, A, E2>(
+  f: () => Promise<Fx<R, E, A>>,
+  g: (error: unknown) => E2,
+): Fx<R, E | E2, A> {
+  return fromFxEffect(Effect.tryCatchPromise(f, g))
+}
+
+export function tryCatchPromiseInterruptFx<R, E, A, E2>(
+  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
+  g: (error: unknown) => E2,
+): Fx<R, E | E2, A> {
+  return fromFxEffect(Effect.tryCatchPromiseInterrupt(f, g))
+}

package/src/provide.ts

@@ -0,0 +1,72 @@
+import type { Sink } from './Fx.js'
+import { Fx } from './Fx.js'
+import type { Layer } from './externals.js'
+import { Context, Effect } from './externals.js'
+import { switchMap } from './switchMap.js'
+
+export function provideContext<R, E, A>(
+  fx: Fx<R, E, A>,
+  context: Context.Context<R>,
+): Fx<never, E, A> {
+  return Fx(
+    <R2>(sink: Sink<R2, E, A>): Effect.Effect<R2, never, void> =>
+      Effect.contramapContext(fx.run(sink), (ctx) => Context.merge(ctx, context)),
+  )
+}
+
+export function provideSomeContext<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  context: Context.Context<R2>,
+): Fx<Exclude<R, R2>, E, A> {
+  return Fx(
+    <R3>(sink: Sink<R3, E, A>): Effect.Effect<Exclude<R, R2> | R3, never, void> =>
+      Effect.contramapContext(fx.run(sink), (ctx) =>
+        Context.merge(ctx as Context.Context<R | R3>, context),
+      ),
+  )
+}
+
+export function provideLayer<R, E, A, R2, E2>(
+  fx: Fx<R, E, A>,
+  layer: Layer.Layer<R2, E2, R>,
+): Fx<R2, E | E2, A> {
+  return Fx((sink) => Effect.provideSomeLayer(fx.run(sink), layer) as any)
+}
+
+export function provideSomeLayer<R, E, A, R2, E2, S>(
+  fx: Fx<R, E, A>,
+  layer: Layer.Layer<R2, E2, S>,
+): Fx<Exclude<R, S> | R2, E | E2, A> {
+  return Fx((sink) => Effect.provideSomeLayer(fx.run(sink), layer) as any)
+}
+
+export function provideService<R, E, A, I, S>(
+  fx: Fx<R, E, A>,
+  tag: Context.Tag<I, S>,
+  service: S,
+): Fx<Exclude<R, I>, E, A> {
+  return provideSomeContext(fx, Context.make(tag, service))
+}
+
+export function provideServiceEffect<R, E, A, I, S, R2, E2>(
+  fx: Fx<R, E, A>,
+  tag: Context.Tag<I, S>,
+  service: Effect.Effect<R2, E2, S>,
+): Fx<Exclude<R, I> | R2, E | E2, A> {
+  return Fx(
+    <R3>(sink: Sink<R3, E | E2, A>): Effect.Effect<Exclude<R, I> | R2 | R3, never, void> =>
+      Effect.matchCauseEffect(service, sink.error, (s) =>
+        Effect.contramapContext(fx.run(sink), (ctx) =>
+          Context.merge(ctx as Context.Context<R | R2 | R3>, Context.make(tag, s)),
+        ),
+      ),
+  )
+}
+
+export function provideServiceFx<R, E, A, I, S, R2, E2>(
+  fx: Fx<R, E, A>,
+  tag: Context.Tag<I, S>,
+  service: Fx<R2, E2, S>,
+): Fx<Exclude<R, I> | R2, E | E2, A> {
+  return switchMap(service, (s) => provideService(fx, tag, s))
+}

package/src/reduce.ts

@@ -0,0 +1,12 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function reduce<R, E, A, B>(fx: Fx<R, E, A>, b: B, f: (b: B, a: A) => B): Fx<R, E, B> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      let acc = b
+
+      return fx.run(Sink((a) => Effect.sync(() => (acc = f(acc, a))), sink.error))
+    }),
+  )
+}

package/src/scan.ts

@@ -0,0 +1,14 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function scan<R, E, A, B>(fx: Fx<R, E, A>, seed: B, f: (b: B, a: A) => B): Fx<R, E, B> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      let state = seed
+
+      return Effect.flatMap(sink.event(state), () =>
+        fx.run(Sink((a) => Effect.suspend(() => sink.event((state = f(state, a)))), sink.error)),
+      )
+    }),
+  )
+}

package/src/skipRepeats.ts

@@ -0,0 +1,30 @@
+import { equals } from '@effect/data/Equal'
+import type { Equivalence } from '@effect/data/typeclass/Equivalence'
+
+import { Fx, Sink } from './Fx.js'
+import { Effect, Option } from './externals.js'
+
+export function skipRepeatsWith<R, E, A>(fx: Fx<R, E, A>, eq: Equivalence<A>): Fx<R, E, A> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      let previous: Option.Option<A> = Option.none()
+      const isPrevious = Option.contains(eq)
+
+      return fx.run(
+        Sink(
+          (a) =>
+            Effect.suspend(() =>
+              isPrevious(previous, a)
+                ? Effect.unit()
+                : sink.event(((previous = Option.some(a)), a)),
+            ),
+          sink.error,
+        ),
+      )
+    }),
+  )
+}
+
+export function skipRepeats<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return skipRepeatsWith(fx, equals)
+}

package/src/skipWhile.test.ts

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

package/src/skipWhile.ts

@@ -0,0 +1,31 @@
+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 skipWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      let skipping = true
+
+      return fx.run(
+        Sink(
+          (a) =>
+            Effect.suspend(() => {
+              if (skipping) {
+                return predicate(a) ? Effect.unit() : sink.event(((skipping = false), a))
+              }
+
+              return sink.event(a)
+            }),
+          sink.error,
+        ),
+      )
+    }),
+  )
+}
+
+export function skipUntil<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return skipWhile(fx, not(predicate))
+}

package/src/slice.test.ts

@@ -0,0 +1,26 @@
+import { describe } from 'vitest'
+
+import { flatMap } from './flatMap.js'
+import { fromArray } from './fromArray.js'
+import { slice } from './slice.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(slice.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'skips and takes the specified number of values',
+      slice(fromArray(array), 1, 1),
+      [array[1]],
+    )
+
+    testCollectAll(
+      'works with higher-order streams',
+      flatMap(fromArray([1, 2, 3]), (x) =>
+        slice(fromArray([Math.random(), x, Math.random()]), 1, 1),
+      ),
+      [1, 2, 3],
+    )
+  })
+})

package/src/slice.ts

@@ -0,0 +1,42 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function slice<R, E, A>(fx: Fx<R, E, A>, skip: number, take: number): Fx<R, E, A> {
+  return Fx(
+    <R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, void> =>
+      Effect.asyncEffect((cb) => {
+        let toSkip = skip
+        let toTake = take
+
+        return fx.run(
+          Sink(
+            (a) =>
+              Effect.suspend(() => {
+                if (toSkip > 0) {
+                  toSkip -= 1
+                  return Effect.unit()
+                }
+
+                if (toTake > 0) {
+                  toTake -= 1
+                  return Effect.tap(sink.event(a), () =>
+                    Effect.sync(() => toTake === 0 && cb(Effect.unit())),
+                  )
+                }
+
+                return Effect.sync(() => cb(Effect.unit()))
+              }),
+            sink.error,
+          ),
+        )
+      }),
+  )
+}
+
+export function skip<R, E, A>(fx: Fx<R, E, A>, skip: number): Fx<R, E, A> {
+  return slice(fx, skip, Infinity)
+}
+
+export function take<R, E, A>(fx: Fx<R, E, A>, take: number): Fx<R, E, A> {
+  return slice(fx, 0, take)
+}

package/src/succeed.ts

@@ -0,0 +1,7 @@
+import { Fx } from './Fx.js'
+
+export function succeed<A>(value: A): Fx<never, never, A> {
+  return Fx((sink) => sink.event(value))
+}
+
+export const unit = succeed<void>(undefined)

package/src/suspend.ts

@@ -0,0 +1,5 @@
+import { Fx } from './Fx.js'
+
+export function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
+  return Fx((sink) => f().run(sink))
+}

package/src/switchMap.test.ts

@@ -0,0 +1,19 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { Duration } from './externals.js'
+import { fromArray } from './fromArray.js'
+import { switchMap } from './switchMap.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(switchMap.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together, favoring the latest',
+      switchMap(fromArray(array), (x) => delay(fromArray([x]), Duration.millis(10))),
+      [array[2]],
+    )
+  })
+})