@typed/fx 0.0.35 → 1.0.2

package/src/hold.ts

@@ -1,142 +0,0 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as FiberId from '@effect/core/io/FiberId'
-import { Scope } from '@effect/core/io/Scope'
-import { pipe } from '@fp-ts/data/Function'
-import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Emitter, Fx } from './Fx.js'
-import { Multicast, MulticastObserver } from './multicast.js'
-
-export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return new Hold(fx)
-}
-
-export class Hold<R, E, A> extends Multicast<R, E, A> {
-  readonly value: AtomicReference<Maybe.Maybe<A>> = new AtomicReference(Maybe.none)
-  protected _pendingEmitters: Array<readonly [Emitter<unknown, E, A>, A[]]> = []
-  protected _scheduledFiber: Fiber.RealFiber<any, any> | undefined
-
-  constructor(readonly fx: Fx<R, E, A>) {
-    super(fx)
-  }
-
-  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown> {
-    if (this.shouldScheduleFlush()) {
-      return pipe(
-        this.scheduleFlush(emitter),
-        Effect.flatMap(() => super.run(emitter)),
-      )
-    }
-
-    const current = this.value.get
-
-    if (Maybe.isSome(current) && this.observers.length === 0) {
-      return pipe(
-        emitter.emit(current.value),
-        Effect.flatMap(() => super.run(emitter)),
-      )
-    }
-
-    return super.run(emitter)
-  }
-
-  emit(value: A) {
-    return Effect.suspendSucceed(() => {
-      this.addValue(value)
-
-      return pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.emit(value)),
-      )
-    })
-  }
-
-  failCause(cause: Cause<E>) {
-    return Effect.suspendSucceed(() =>
-      pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.failCause(cause)),
-      ),
-    )
-  }
-
-  get end() {
-    return Effect.suspendSucceed(() =>
-      pipe(
-        this.flushPending(),
-        Effect.flatMap(() => super.end),
-      ),
-    )
-  }
-
-  protected shouldScheduleFlush() {
-    return Maybe.isSome(this.value.get) && this.observers.length > 0
-  }
-
-  protected scheduleFlush<R>(observer: Emitter<R, E, A>) {
-    this._pendingEmitters.push([
-      observer,
-      pipe(
-        this.value.get,
-        Maybe.fold(
-          () => [],
-          (a) => [a],
-        ),
-      ),
-    ])
-
-    const interrupt = this._scheduledFiber
-      ? this._scheduledFiber.interruptAsFork(new FiberId.None())
-      : Effect.unit
-
-    this._scheduledFiber = undefined
-
-    return pipe(
-      interrupt,
-      Effect.flatMap(() => this.flushPending()),
-      Effect.delay(Duration.millis(0)),
-      Effect.forkScoped,
-      Effect.tap((fiber: Fiber.RealFiber<any, any>) =>
-        Effect.sync(() => (this._scheduledFiber = fiber)),
-      ),
-    )
-  }
-
-  protected flushPending() {
-    if (this._pendingEmitters.length === 0) {
-      return Effect.unit
-    }
-
-    const pendingEmitters = this._pendingEmitters
-    this._pendingEmitters = []
-
-    return Effect.forEachDiscard(pendingEmitters, (pending) =>
-      Effect.suspendSucceed(() => {
-        const [emitter, values] = pending
-        const observer = this.findObserver(emitter)
-
-        if (!observer) {
-          return Effect.unit
-        }
-
-        return Effect.forEachDiscard(values, (value) => this.runEvent(value, observer))
-      }),
-    )
-  }
-
-  protected addValue(value: A) {
-    this.value.set(Maybe.some(value))
-
-    this._pendingEmitters.forEach(([, values]) => {
-      values.push(value)
-    })
-  }
-
-  protected findObserver(emitter: Emitter<unknown, E, A>): MulticastObserver<E, A> | undefined {
-    return this.observers.find((o) => o.emitter === emitter)
-  }
-}

package/src/mapCause.test.ts

@@ -1,34 +0,0 @@
-import { deepEqual } from 'assert'
-
-import * as Cause from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.mapCause.name, () => {
-    it('maps the cause', async () => {
-      const value = Math.random()
-      const cause = Cause.fail(value)
-      const test = pipe(Fx.failCause(cause), Fx.mapCause(Cause.map((x) => x + 1)), Fx.runDrain)
-
-      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
-    })
-  })
-
-  describe(Fx.mapError.name, () => {
-    it('maps the error', async () => {
-      const value = Math.random()
-      const cause = Cause.fail(value)
-      const test = pipe(
-        Fx.failCause(cause),
-        Fx.mapError((x) => x + 1),
-        Fx.runDrain,
-      )
-
-      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
-    })
-  })
-})

package/src/mapCause.ts

@@ -1,19 +0,0 @@
-import * as Cause from '@effect/core/io/Cause'
-import { flow } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function mapCause<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, f)
-}
-
-export function mapError<E, E2>(f: (error: E) => E2) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, Cause.map(f))
-}
-
-function mapCause_<R, E, A, E2>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Cause.Cause<E2>,
-): Fx<R, E2, A> {
-  return Fx((emitter) => fx.run(Emitter(emitter.emit, flow(f, emitter.failCause), emitter.end)))
-}

package/src/mapEffect.test.ts

@@ -1,21 +0,0 @@
-import { deepEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.mapEffect.name, () => {
-    it('applies an Effect to the output value of a Fx', async () => {
-      const value = Math.random()
-      const test = pipe(
-        Fx.succeed(value),
-        Fx.mapEffect((a) => Effect.succeed(a + 1)),
-        Fx.runCollect,
-      )
-
-      deepEqual(await Effect.unsafeRunPromise(test), [value + 1])
-    })
-  })
-})

package/src/mapEffect.ts

@@ -1,17 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { flow } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-
-export const mapEffect =
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) =>
-  <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
-    Fx((emitter) =>
-      fx.run(
-        Emitter(
-          flow(f, Effect.foldCauseEffect(emitter.failCause, emitter.emit)),
-          emitter.failCause,
-          emitter.end,
-        ),
-      ),
-    )

package/src/merge.test.ts

@@ -1,21 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.mergeAll.name, () => {
-    it('merges together emits', async () => {
-      const result = await pipe(
-        Fx.mergeAll([Fx.fromIterable([1, 2, 3]), Fx.fromIterable([4, 5, 6])]),
-        Fx.runCollect,
-
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 2, 3, 4, 5, 6])
-    })
-  })
-})

package/src/merge.ts

@@ -1,33 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-
-import { Emitter, Fx } from './Fx.js'
-import { withDynamicCountdownLatch } from './_internal.js'
-
-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> => mergeAll([first, second])
-}
-
-export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
-  fx: readonly [...FX],
-): Fx<Fx.ResourcesOf<FX[number]>, Fx.ErrorsOf<FX[number]>, Fx.OutputOf<FX[number]>>
-
-export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A>
-
-export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A> {
-  return Fx((emitter) => {
-    const array = Array.from(iterable)
-
-    if (array.length === 0) {
-      return emitter.end
-    }
-
-    return withDynamicCountdownLatch(
-      array.length,
-      ({ latch }) =>
-        Effect.forEachDiscard(array, (fx) =>
-          Effect.forkScoped(fx.run(Emitter(emitter.emit, emitter.failCause, latch.countDown))),
-        ),
-      emitter.end,
-    )
-  })
-}

package/src/multicast.test.ts

@@ -1,52 +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('multicast', () => {
-    it('should not change the underlying stream', async () => {
-      const values = [1, 2, 3]
-      let started = 0
-      const test = pipe(
-        Fx.suspendSucceed(() => {
-          started++
-          return pipe(
-            Fx.fromIterable(values),
-            Fx.flatMap((a) =>
-              pipe(
-                Fx.fromIterable([a, a + 1]),
-                Fx.merge(pipe(Fx.fromIterable([a * a, a ** a]), Fx.delay(Duration.millis(50)))),
-              ),
-            ),
-          )
-        }),
-        Fx.multicast,
-      )
-      const events = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-      const events2 = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
-
-      deepStrictEqual(await events, [
-        1,
-        1 + 1,
-        2,
-        2 + 1,
-        3,
-        3 + 1,
-        1 * 1,
-        2 * 2,
-        3 * 3,
-        1 ** 1,
-        2 ** 2,
-        3 ** 3,
-      ])
-
-      deepStrictEqual(await events, await events2)
-
-      deepStrictEqual(started, 1)
-    })
-  })
-})

package/src/multicast.ts

@@ -1,116 +0,0 @@
-import * as Cause from '@effect/core/io/Cause'
-import * as Deferred from '@effect/core/io/Deferred'
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import { Scope } from '@effect/core/io/Scope'
-import { pipe } from '@fp-ts/data/Function'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { Env } from '@tsplus/stdlib/service/Env'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return new Multicast(fx)
-}
-
-export interface MulticastObserver<E, A> {
-  readonly emitter: Emitter<any, E, A>
-  readonly env: Env<any>
-  readonly deferred: Deferred.Deferred<never, void>
-}
-
-export class Multicast<R, E, A> implements Fx<R, E, A>, Emitter<never, E, A> {
-  readonly _R!: () => R
-  readonly _E!: () => E
-  readonly _A!: () => A
-
-  protected observers: MulticastObserver<E, A>[] = []
-  protected fiber: Fiber.Fiber<never, unknown> | undefined
-
-  constructor(readonly fx: Fx<R, E, A>) {
-    this.emit = this.emit.bind(this)
-    this.failCause = this.failCause.bind(this)
-  }
-
-  run<RO>(emitter: Emitter<RO, E, A>): Effect.Effect<R | RO | Scope, never, unknown> {
-    return pipe(
-      Effect.environment<RO>(),
-      Effect.zip(Deferred.make<never, void>()),
-      Effect.tap(([env, deferred]) => {
-        this.observers.push({ emitter, env, deferred })
-
-        return this.fiber
-          ? Effect.unit
-          : pipe(
-              this.fx.run(this),
-              Effect.delay(Duration.millis(0)),
-              Effect.forkScoped,
-              Effect.tap((fiber) => Effect.sync(() => (this.fiber = fiber))),
-            )
-      }),
-
-      Effect.flatMap(([, deferred]) => deferred.await),
-    )
-  }
-
-  emit(a: A) {
-    return Effect.suspendSucceed(() =>
-      Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEvent(a, observer)),
-    )
-  }
-
-  failCause(e: Cause.Cause<E>) {
-    return pipe(
-      Effect.suspendSucceed(() =>
-        Effect.forEachDiscard(this.observers.slice(), (observer) => this.runFailCause(e, observer)),
-      ),
-      Effect.flatMap(() => this.cleanup()),
-    )
-  }
-
-  get end() {
-    return pipe(
-      Effect.suspendSucceed(() =>
-        Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEnd(observer)),
-      ),
-      Effect.flatMap(() => this.cleanup()),
-    )
-  }
-
-  protected runEvent(a: A, observer: MulticastObserver<E, A>) {
-    return pipe(
-      observer.emitter.emit(a),
-      Effect.onError((c) => this.runFailCause(c, observer)),
-      Effect.provideEnvironment(observer.env),
-    )
-  }
-
-  protected runFailCause(e: Cause.Cause<E>, observer: MulticastObserver<E, A>) {
-    this.observers.splice(this.observers.indexOf(observer), 1)
-
-    return pipe(
-      observer.emitter.failCause(e),
-      Effect.intoDeferred(observer.deferred),
-      Effect.provideEnvironment(observer.env),
-    )
-  }
-
-  protected runEnd(observer: MulticastObserver<E, A>) {
-    this.observers.splice(this.observers.indexOf(observer), 1)
-
-    return pipe(
-      observer.emitter.end,
-      Effect.intoDeferred(observer.deferred),
-      Effect.provideEnvironment(observer.env),
-    )
-  }
-
-  protected cleanup() {
-    return this.fiber
-      ? pipe(
-          Fiber.interrupt(this.fiber),
-          Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
-        )
-      : Effect.unit
-  }
-}

package/src/on.ts

@@ -1,33 +0,0 @@
-import { Cause } from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import { FiberId } from '@effect/core/io/FiberId'
-import { pipe } from '@fp-ts/data/Function'
-import { HashSet } from '@tsplus/stdlib/collections/HashSet'
-
-import { Fx } from './Fx.js'
-
-export const onDone =
-  <E, R1, X1, R2, X2>(
-    error: (e: E) => Effect.Effect<R1, never, X1>,
-    success: (a: unknown) => Effect.Effect<R2, never, X2>,
-  ) =>
-  <R, A>(fx: Fx<R, E, A>): Fx<R | R1 | R2, E, A> =>
-    Fx((emitter) => pipe(fx.run(emitter), Effect.onDone(error, success)))
-
-export const onDoneCause =
-  <E, R1, X1, R2, X2>(
-    error: (e: Cause<E>) => Effect.Effect<R1, never, X1>,
-    success: (a: unknown) => Effect.Effect<R2, never, X2>,
-  ) =>
-  <R, A>(fx: Fx<R, E, A>): Fx<R | R1 | R2, E, A> =>
-    Fx((emitter) => pipe(fx.run(emitter), Effect.onDoneCause(error, success)))
-
-export const onTermination =
-  <R1, X1>(error: (e: Cause<never>) => Effect.Effect<R1, never, X1>) =>
-  <R, E, A>(fx: Fx<R, E, A>): Fx<R | R1, E, A> =>
-    Fx((emitter) => pipe(fx.run(emitter), Effect.onTermination(error)))
-
-export const onInterrupt =
-  <R2, X>(cleanup: (fiberIds: HashSet<FiberId>) => Effect.Effect<R2, never, X>) =>
-  <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E, A> =>
-    Fx((emitter) => pipe(fx.run(emitter), Effect.onInterrupt(cleanup)))

package/src/orElse.test.ts

@@ -1,22 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.orElse.name, () => {
-    it('allows recovering from failures', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3]),
-        Fx.flatMap((n) => Fx.fail(n)),
-        Fx.orElse((n) => Fx.fromIterable([n, n, n])),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [1, 1, 1])
-    })
-  })
-})

package/src/orElse.ts

@@ -1,33 +0,0 @@
-import * as Cause from '@effect/core/io/Cause'
-import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
-import * as Either from '@tsplus/stdlib/data/Either'
-
-import { Fx } from './Fx.js'
-import { failCause } from './fromEffect.js'
-import { runObserve } from './runObserve.js'
-
-export function orElseCause<E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> => orElseCause_(fx, f)
-}
-
-export function orElse<E, R2, E2, B>(f: (error: E) => Fx<R2, E2, B>) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
-    orElseCause_(fx, flow(Cause.failureOrCause, Either.fold(f, failCause)))
-}
-
-function orElseCause_<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-): Fx<R | R2, E2, A | B> {
-  return Fx((emitter) => {
-    return pipe(
-      fx,
-      runObserve(emitter.emit),
-      Effect.foldCauseEffect(
-        (c) => f(c).run(emitter),
-        () => emitter.end,
-      ),
-    )
-  })
-}

package/src/periodic.test.ts

@@ -1,20 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { millis } from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import { periodic } from './periodic.js'
-import { runCollect } from './runCollect.js'
-import { take } from './slice.js'
-
-describe(import.meta.url, () => {
-  describe('periodic', () => {
-    it('emits a value every period', async () => {
-      const test = pipe(periodic(millis(100)), take(3), runCollect, Effect.scoped)
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [undefined, undefined, undefined])
-    })
-  })
-})

package/src/periodic.ts

@@ -1,11 +0,0 @@
-import { unit } from '@effect/core/io/Effect'
-import * as Schedule from '@effect/core/io/Schedule'
-import { pipe } from '@fp-ts/data/Function'
-import { Duration } from '@tsplus/stdlib/data/Duration'
-
-import { Fx } from './Fx.js'
-import { scheduled } from './scheduled.js'
-
-export function periodic(delay: Duration): Fx<never, never, void> {
-  return pipe(unit, scheduled(Schedule.delayed(() => delay)(Schedule.repeatForever)))
-}

package/src/provide.test.ts

@@ -1,56 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Scope from '@effect/core/io/Scope'
-import { pipe } from '@tsplus/stdlib/data/Function'
-import { Tag } from '@tsplus/stdlib/service/Tag'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.provideService.name, () => {
-    it('provides a service to the Fx', async () => {
-      const test = Effect.gen(function* ($) {
-        const scope = yield* $(Scope.make)
-
-        const result = yield* $(
-          pipe(
-            Fx.service(Scope.Scope.Tag),
-            Fx.flatMap((s) => Fx.fromIterable([s, s])),
-            Fx.provideService(Scope.Scope.Tag, scope),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [scope, scope])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-
-  describe(Fx.provideLayer.name, () => {
-    it('provides a layer to the Fx', async () => {
-      const test = Effect.gen(function* ($) {
-        const value = `${Math.random()}`
-        class Foo {
-          static Tag = Tag<Foo>()
-          constructor(readonly foo: string) {}
-        }
-
-        const result = yield* $(
-          pipe(
-            Fx.service(Foo.Tag),
-            Fx.flatMap((s) => Fx.succeed(s.foo)),
-            Fx.provideLayer(Effect.toLayer(Foo.Tag)(Effect.succeed(new Foo(value)))),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [value])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})