@typed/fx 0.0.35 → 1.0.2

package/src/operator/mapCause.test.ts

@@ -0,0 +1,30 @@
+import { deepStrictEqual, ok } from 'assert'
+
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+import * as Option from '@fp-ts/data/Option'
+import { describe, it } from 'vitest'
+
+import { fail } from '../constructor/fail.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { mapCause } from './mapCause.js'
+
+describe(import.meta.url, () => {
+  describe(mapCause.name, () => {
+    it('transforms an Fx error', async () => {
+      const test = pipe(fail(1), mapCause(Cause.map((x) => x + 1)), collectAll)
+      const exit = await Effect.unsafeRunPromiseExit(test)
+
+      ok(Exit.isFailure(exit))
+
+      const option = Cause.failureOption(exit.cause)
+
+      ok(Option.isSome(option))
+
+      deepStrictEqual(option.value, 2)
+    })
+  })
+})

package/src/operator/mapCause.ts

@@ -0,0 +1,23 @@
+import { Cause } from '@effect/io/Cause'
+import { flow } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function mapCause<E, E2>(
+  f: (e: Cause<E>) => Cause<E2>,
+): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A> {
+  return (fx) => new MapCauseFx(fx, f)
+}
+
+class MapCauseFx<R, E, A, E2> extends Fx.Variance<R, E2, A> implements Fx<R, E2, A> {
+  constructor(readonly fx: Fx<R, E, A>, readonly f: (e: Cause<E>) => Cause<E2>) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E2, A>) {
+    return this.fx.run({
+      ...sink,
+      error: flow(this.f, sink.error),
+    })
+  }
+}

package/src/operator/mapError.ts

@@ -0,0 +1,9 @@
+import { map } from '@effect/io/Cause'
+
+import { Fx } from '../Fx.js'
+
+import { mapCause } from './mapCause.js'
+
+export function mapError<E, E2>(f: (e: E) => E2): <R, A>(fx: Fx<R, E, A>) => Fx<R, E2, A> {
+  return mapCause(map(f))
+}

package/src/operator/merge.test.ts

@@ -0,0 +1,31 @@
+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'
+
+describe(import.meta.url, () => {
+  describe(mergeAll.name, () => {
+    it('allows merging multiple streams together', async () => {
+      const test = pipe(
+        mergeAll(
+          at(millis(0), 1),
+          at(millis(200), 2),
+          at(millis(100), 3),
+          at(millis(150), 4),
+          at(millis(250), 5),
+        ),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 3, 4, 2, 5])
+    })
+  })
+})

package/src/operator/merge.ts

@@ -0,0 +1,43 @@
+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 mergeAll<Streams extends readonly Fx<any, any, any>[]>(
+  ...streams: Streams
+): Fx<Fx.ResourcesOf<Streams[number]>, Fx.ErrorsOf<Streams[number]>, Fx.OutputOf<Streams[number]>> {
+  return new MergeAllFx(streams)
+}
+
+export function merge<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> => new MergeAllFx([first, second])
+}
+
+class MergeAllFx<Streams extends readonly Fx<any, any, any>[]>
+  extends Fx.Variance<
+    Fx.ResourcesOf<Streams[number]>,
+    Fx.ErrorsOf<Streams[number]>,
+    Fx.OutputOf<Streams[number]>
+  >
+  implements
+    Fx<Fx.ResourcesOf<Streams[number]>, Fx.ErrorsOf<Streams[number]>, Fx.OutputOf<Streams[number]>>
+{
+  constructor(readonly streams: Streams) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, Fx.ErrorsOf<Streams[number]>, Fx.OutputOf<Streams[number]>>) {
+    return withRefCounter(
+      this.streams.length,
+      (counter) =>
+        pipe(
+          this.streams,
+          Effect.forEachParDiscard((s) =>
+            s.run(Fx.Sink(sink.event, sink.error, counter.decrement)),
+          ),
+        ),
+      sink.end,
+    )
+  }
+}

package/src/operator/multicast.test.ts

@@ -0,0 +1,69 @@
+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 { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { fromIterable } from '../constructor/fromIterable.js'
+import { suspend } from '../constructor/suspend.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { delay } from './delay.js'
+import { flatMap } from './flatMap.js'
+import { merge } from './merge.js'
+import { multicast } from './multicast.js'
+
+describe(import.meta.url, () => {
+  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 pipe(
+              fromIterable(values),
+              flatMap((a) =>
+                pipe(
+                  fromIterable([a, a + 1]),
+                  merge(pipe(fromIterable([a * a, a ** a]), delay(millis(50)))),
+                ),
+              ),
+            )
+          }),
+        )
+
+        const fiber1 = yield* $(Effect.fork(collectAll(stream)))
+        const fiber2 = yield* $(Effect.fork(collectAll(stream)))
+
+        const events1 = yield* $(Fiber.join(fiber1))
+        const events2 = yield* $(Fiber.join(fiber2))
+
+        deepStrictEqual(events1, [
+          1,
+          1 + 1,
+          2,
+          2 + 1,
+          3,
+          3 + 1,
+          1 * 1,
+          2 * 2,
+          3 * 3,
+          1 ** 1,
+          2 ** 2,
+          3 ** 3,
+        ])
+
+        deepStrictEqual(events1, events2)
+
+        deepStrictEqual(started, 1)
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/operator/multicast.ts

@@ -0,0 +1,131 @@
+import { Cause } from '@effect/io/Cause'
+import * as Deferred from '@effect/io/Deferred'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { RuntimeFiber } from '@effect/io/Fiber'
+import { Scope } from '@effect/io/Scope'
+import { Context } from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+import { asap } from '../_internal/RefCounter.js'
+
+export const multicast = <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => new MulticastFx(fx)
+
+export class MulticastFx<R, E, A>
+  extends Fx.Variance<R, E, A>
+  implements Fx<R, E, A>, Fx.Sink<never, E, A>
+{
+  protected observers: Array<MulticastObserver<any, E, A>> = []
+  protected fiber: RuntimeFiber<never, unknown> | undefined
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    super()
+
+    this.event = this.event.bind(this)
+    this.error = this.error.bind(this)
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>): Effect.Effect<R | R2 | Scope, never, void> {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const { fx, observers } = this
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const that = this
+
+    return Effect.gen(function* ($) {
+      const deferred = yield* $(Deferred.make<never, void>())
+      const context = yield* $(Effect.environment<R | R2>())
+      const observer: MulticastObserver<R2, E, A> = {
+        sink,
+        context,
+        deferred,
+      }
+
+      if (observers.push(observer) === 1) {
+        that.fiber = yield* $(pipe(fx.run(that), Effect.scheduleForked(asap)))
+      }
+
+      yield* $(Deferred.await(deferred))
+
+      if (observers.length === 0) {
+        yield* $(that.cleanup())
+      }
+    })
+  }
+
+  event(a: A) {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.observers.slice(),
+        Effect.forEachDiscard((observer) => this.runEvent(a, observer)),
+      ),
+    )
+  }
+
+  error(cause: Cause<E>) {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.observers.slice(),
+        Effect.forEachDiscard((observer) => this.runError(cause, observer)),
+        Effect.tap(() => this.cleanup()),
+      ),
+    )
+  }
+
+  get end(): Effect.Effect<never, never, void> {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.observers.slice(),
+        Effect.forEachDiscard((observer) => this.runEnd(observer)),
+        Effect.tap(() => this.cleanup()),
+      ),
+    )
+  }
+
+  protected runEvent(a: A, observer: MulticastObserver<any, E, A>) {
+    return pipe(observer.sink.event(a), Effect.provideEnvironment(observer.context))
+  }
+
+  protected runError(cause: Cause<E>, observer: MulticastObserver<any, E, A>) {
+    return pipe(
+      observer.sink.error(cause),
+      Effect.provideEnvironment(observer.context),
+      Effect.tap(() => Effect.sync(() => this.removeObserver(observer))),
+      Effect.intoDeferred(observer.deferred),
+    )
+  }
+
+  protected runEnd(observer: MulticastObserver<any, E, A>) {
+    return pipe(
+      observer.sink.end,
+      Effect.provideEnvironment(observer.context),
+      Effect.tap(() => Effect.sync(() => this.removeObserver(observer))),
+      Effect.intoDeferred(observer.deferred),
+    )
+  }
+
+  protected removeObserver(observer: MulticastObserver<any, E, A>) {
+    const { observers } = this
+    const index = observers.indexOf(observer)
+
+    if (index > -1) {
+      observers.splice(index, 1)
+    }
+  }
+
+  protected cleanup() {
+    return this.fiber
+      ? pipe(
+          Fiber.interrupt(this.fiber),
+          Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+        )
+      : Effect.unit()
+  }
+}
+
+export interface MulticastObserver<R, E, A> {
+  readonly sink: Fx.Sink<R, E, A>
+  readonly context: Context<R>
+  readonly deferred: Deferred.Deferred<never, unknown>
+}

package/src/operator/onDone.ts

@@ -0,0 +1,19 @@
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Either from '@fp-ts/data/Either'
+import { flow, pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { onDoneCause } from './onDoneCause.js'
+
+export function onDone<E, R2, E2, B, A, R3, E3, C>(
+  onCause: (cause: E) => Effect.Effect<R2, E2, B>,
+  onDone: Effect.Effect<R3, E3, C>,
+) {
+  return <R>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, A> =>
+    pipe(
+      fx,
+      onDoneCause(flow(Cause.failureOrCause, Either.match(onCause, Effect.failCause)), onDone),
+    )
+}

package/src/operator/onDoneCause.ts

@@ -0,0 +1,46 @@
+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 onDoneCause<E, R2, E2, B, R3, E3, C>(
+  onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+  onDone: Effect.Effect<R3, E3, C>,
+) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, A> =>
+    new OnDoneCauseFx(fx, onCause, onDone)
+}
+
+class OnDoneCauseFx<R, E, A, R2, E2, B, R3, E3, C>
+  extends Fx.Variance<R | R2 | R3, E | E2 | E3, A>
+  implements Fx<R | R2 | R3, E | E2 | E3, A>
+{
+  constructor(
+    readonly fx: Fx<R, E, A>,
+    readonly onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    readonly onDone: Effect.Effect<R3, E3, C>,
+  ) {
+    super()
+  }
+
+  run<R4>(sink: Fx.Sink<R4, E | E2 | E3, A>) {
+    return this.fx.run(
+      Fx.Sink(
+        sink.event,
+        (cause) =>
+          pipe(
+            this.onCause(cause),
+            Effect.matchCauseEffect(
+              (cause2) => sink.error(Cause.sequential(cause, cause2)),
+              () => sink.error(cause),
+            ),
+          ),
+        pipe(
+          this.onDone,
+          Effect.matchCauseEffect(sink.error, () => sink.end),
+        ),
+      ),
+    )
+  }
+}

package/src/operator/onError.ts

@@ -0,0 +1,11 @@
+import * as Effect from '@effect/io/Effect'
+
+import { Fx } from '../Fx.js'
+
+import { onDone } from './onDone.js'
+
+export function onError<E, R2, E2, B>(
+  f: (e: E) => Effect.Effect<R2, E2, B>,
+): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A> {
+  return onDone(f, Effect.unit())
+}

package/src/operator/onExit.ts

@@ -0,0 +1,17 @@
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { onDoneCause } from './onDoneCause.js'
+
+export function onExit<E, R2, E2, B>(
+  onExit: (exit: Exit.Exit<E, void>) => Effect.Effect<R2, E2, B>,
+) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> =>
+    pipe(
+      fx,
+      onDoneCause((cause) => onExit(Exit.failCause(cause)), onExit(Exit.unit())),
+    )
+}

package/src/operator/onInterrupt.ts

@@ -0,0 +1,31 @@
+import * as Effect from '@effect/io/Effect'
+import { FiberId } from '@effect/io/Fiber/Id'
+import { flow, pipe } from '@fp-ts/data/Function'
+import { HashSet } from '@fp-ts/data/HashSet'
+
+import { Fx } from '../Fx.js'
+
+export function onInterrupt<R2, E2, B>(
+  f: (interruptors: HashSet<FiberId>) => Effect.Effect<R2, E2, B>,
+) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => new OnInterruptFx(fx, f)
+}
+
+class OnInterruptFx<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: (interruptors: HashSet<FiberId>) => Effect.Effect<R2, E2, B>,
+  ) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
+    return pipe(
+      this.fx.run(sink),
+      Effect.onInterrupt(flow(this.f, Effect.matchCauseEffect(sink.error, Effect.unit))),
+    )
+  }
+}

package/src/operator/orElse.ts

@@ -0,0 +1,9 @@
+import { Fx } from '../Fx.js'
+
+import { catchAll } from './catchAll.js'
+
+export function orElse<R2, E2, B>(
+  second: Fx<R2, E2, B>,
+): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B> {
+  return catchAll(() => second)
+}

package/src/operator/provideEnvironment.ts

@@ -0,0 +1,23 @@
+import * as Effect from '@effect/io/Effect'
+import { Scope } from '@effect/io/Scope'
+import * as Context from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function provideEnvironment<R>(context: Context.Context<R>) {
+  return <E, A>(self: Fx<R, E, A>): Fx<never, E, A> => new ProvideEnvironmentFx(self, context)
+}
+
+class ProvideEnvironmentFx<R, E, A> extends Fx.Variance<never, E, A> implements Fx<never, E, A> {
+  constructor(readonly self: Fx<R, E, A>, readonly context: Context.Context<R>) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>) {
+    return pipe(
+      this.self.run(sink),
+      Effect.provideSomeEnvironment<R2 | Scope, R | R2 | Scope>(Context.merge(this.context)),
+    )
+  }
+}

package/src/operator/provideLayer.ts

@@ -0,0 +1,10 @@
+import { Layer } from '@effect/io/Layer'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+import { provideSomeLayer } from './provideSomeLayer.js'
+
+export function provideLayer<R2, E2, R>(layer: Layer<R2, E2, R>) {
+  return <E, A>(self: Fx<R, E, A>): Fx<R2, E | E2, A> => pipe(self, provideSomeLayer(layer))
+}

package/src/operator/provideService.test.ts

@@ -0,0 +1,38 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { Tag } from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { serviceWith } from '../constructor/serviceWith.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { provideService } from './provideService.js'
+
+describe(import.meta.url, () => {
+  describe(provideService.name, () => {
+    it('allows merging multiple streams together', async () => {
+      interface Foo {
+        readonly foo: number
+      }
+      const Foo = Object.assign(Tag<Foo>(), {
+        with<A>(f: (foo: Foo) => A) {
+          return serviceWith(Foo)(f)
+        },
+        provide(foo: number) {
+          return provideService(Foo)({ foo })
+        },
+      })
+
+      const test = pipe(
+        Foo.with((f) => f.foo),
+        Foo.provide(42),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [42])
+    })
+  })
+})

package/src/operator/provideService.ts

@@ -0,0 +1,25 @@
+import * as Effect from '@effect/io/Effect'
+import * as Context from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function provideService<S>(tag: Context.Tag<S>) {
+  return (service: S) => {
+    return <R, E, A>(self: Fx<R | S, E, A>): Fx<Exclude<R, S>, E, A> =>
+      new ProvideServiceFx(self, tag, service)
+  }
+}
+
+class ProvideServiceFx<R, E, A, S>
+  extends Fx.Variance<Exclude<R, S>, E, A>
+  implements Fx<Exclude<R, S>, E, A>
+{
+  constructor(readonly self: Fx<R | S, E, A>, readonly tag: Context.Tag<S>, readonly service: S) {
+    super()
+  }
+
+  run<R2>(sink: Fx.Sink<R2, E, A>) {
+    return pipe(this.self.run(sink), Effect.provideService(this.tag)(this.service))
+  }
+}

package/src/operator/provideServiceEffect.test.ts

@@ -0,0 +1,41 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { Tag } from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { serviceWith } from '../constructor/serviceWith.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { provideServiceEffect } from './provideServiceEffect.js'
+
+describe(import.meta.url, () => {
+  describe(provideServiceEffect.name, () => {
+    it('allows merging multiple streams together', async () => {
+      interface Foo {
+        readonly foo: number
+      }
+      const Foo = Object.assign(Tag<Foo>(), {
+        with<A>(f: (foo: Foo) => A) {
+          return serviceWith(Foo)(f)
+        },
+        provide(foo: number) {
+          return provideServiceEffect(
+            Foo,
+            Effect.sync(() => ({ foo })),
+          )
+        },
+      })
+
+      const test = pipe(
+        Foo.with((f) => f.foo),
+        Foo.provide(42),
+        collectAll,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [42])
+    })
+  })
+})

package/src/operator/provideServiceEffect.ts

@@ -0,0 +1,35 @@
+import * as Effect from '@effect/io/Effect'
+import { Scope } from '@effect/io/Scope'
+import * as Context from '@fp-ts/data/Context'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from '../Fx.js'
+
+export function provideServiceEffect<S, R2, E2>(
+  tag: Context.Tag<S>,
+  service: Effect.Effect<R2, E2, S>,
+) {
+  return <R, E, A>(self: Fx<R | S, E, A>): Fx<Exclude<R | R2, S>, E | E2, A> =>
+    new ProvideServiceEffectFx(self, tag, service)
+}
+
+class ProvideServiceEffectFx<R, E, A, R2, E2, S>
+  extends Fx.Variance<Exclude<R | R2, S>, E | E2, A>
+  implements Fx<Exclude<R | R2, S>, E | E2, A>
+{
+  constructor(
+    readonly self: Fx<R | S, E, A>,
+    readonly tag: Context.Tag<S>,
+    readonly service: Effect.Effect<R2, E2, S>,
+  ) {
+    super()
+  }
+
+  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
+    return pipe(
+      this.self.run(sink),
+      Effect.provideServiceEffect(this.tag)(this.service),
+      Effect.matchCauseEffect(sink.error, Effect.succeed),
+    ) as Effect.Effect<Exclude<R | R2 | R3 | Scope, S>, never, unknown>
+  }
+}