@typed/fx 1.17.4 → 1.18.0

package/src/filter.ts

@@ -1,23 +0,0 @@
-import type { Predicate, Refinement } from '@effect/data/Predicate'
-import { not } from '@effect/data/Predicate'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function filter<R, E, A, B extends A>(
-  fx: Fx<R, E, A>,
-  refinement: Refinement<A, B>,
-): Fx<R, E, B>
-export function filter<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-export function filter<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
-  return Fx((sink) => fx.run(Sink((a) => (predicate(a) ? sink.event(a) : Effect.unit), sink.error)))
-}
-
-export function remove<R, E, A, B extends A>(
-  fx: Fx<R, E, A>,
-  refinement: Refinement<A, B>,
-): Fx<R, E, Exclude<A, B>>
-export function remove<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
-export function remove<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
-  return filter(fx, not(predicate))
-}

package/src/filterMap.ts

@@ -1,19 +0,0 @@
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function filterMap<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> {
-  return Fx((sink) =>
-    fx.run(
-      Sink(
-        (a) => Option.match(f(a), { onNone: () => Effect.unit, onSome: sink.event }),
-        sink.error,
-      ),
-    ),
-  )
-}
-
-export function compact<R, E, A>(fx: Fx<R, E, Option.Option<A>>): Fx<R, E, A> {
-  return filterMap(fx, (a) => a)
-}

package/src/flatMap.test.ts

@@ -1,19 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { delay } from './delay.js'
-import { flatMap } from './flatMap.js'
-import { fromArray } from './fromArray.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(flatMap.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'merges multiple streams together, infinite concurrency',
-      flatMap(fromArray(array), (x) => delay(fromArray([x]), Duration.millis(10))),
-      array,
-    )
-  })
-})

package/src/flatMap.ts

@@ -1,31 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { fromEffect } from './fromEffect.js'
-import { withUnboundedConcurrency } from './helpers.js'
-
-export function flatMap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Fx<R2, E2, B>,
-): Fx<R | R2, E | E2, B> {
-  return Fx(<R3>(sink: Sink<R3, E | E2, B>) =>
-    withUnboundedConcurrency((fork) => fx.run(Sink((a) => fork(f(a).run(sink)), sink.error))),
-  )
-}
-
-export function flatMapEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E | E2, B> {
-  return flatMap(fx, (a) => fromEffect(f(a)))
-}
-
-export function flatten<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
-  return flatMap(fx, (a) => a)
-}
-
-export function flattenEffect<R, E, R2, E2, B>(
-  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
-): Fx<R | R2, E | E2, B> {
-  return flatMapEffect(fx, (a) => a)
-}

package/src/fromArray.test.ts

@@ -1,11 +0,0 @@
-import { describe } from 'vitest'
-
-import { fromArray } from './fromArray.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(fromArray.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-    testCollectAll('returns each the array', fromArray(array), array)
-  })
-})

package/src/fromArray.ts

@@ -1,21 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from './Fx.js'
-
-export function fromArray<A>(array: ReadonlyArray<A>): Fx<never, never, A> {
-  return Fx((sink) =>
-    Effect.suspend(() => {
-      if (array.length === 0) {
-        return Effect.unit
-      }
-
-      let eff = sink.event(array[0])
-
-      for (let i = 1; i < array.length; i++) {
-        eff = Effect.flatMap(eff, () => sink.event(array[i]))
-      }
-
-      return eff
-    }),
-  )
-}

package/src/fromDequeue.ts

@@ -1,39 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Q from '@effect/io/Queue'
-
-import { Fx } from './Fx.js'
-
-export function fromDequeue<A>(queue: Q.Dequeue<A>): Fx<never, never, A> {
-  return Fx((sink) =>
-    Effect.catchAllCause(
-      Effect.gen(function* ($) {
-        let isShutdown = yield* $(queue.isShutdown())
-
-        while (!isShutdown) {
-          yield* $(queue.take(), Effect.flatMap(sink.event))
-          isShutdown = yield* $(queue.isShutdown())
-        }
-      }),
-      sink.error,
-    ),
-  )
-}
-
-export function fromDequeueWithShutdown<A>(queue: Q.Dequeue<A>): Fx<never, never, A> {
-  return Fx((sink) =>
-    Effect.onExit(
-      Effect.catchAllCause(
-        Effect.gen(function* ($) {
-          let isShutdown = yield* $(queue.isShutdown())
-
-          while (!isShutdown) {
-            yield* $(queue.take(), Effect.flatMap(sink.event))
-            isShutdown = yield* $(queue.isShutdown())
-          }
-        }),
-        sink.error,
-      ),
-      queue.shutdown,
-    ),
-  )
-}

package/src/fromEffect.test.ts

@@ -1,16 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import { describe } from 'vitest'
-
-import { fromEffect } from './fromEffect.js'
-import { testCause, testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(fromEffect.name, (): void => {
-    const value = Math.random()
-
-    testCollectAll('returns the output', fromEffect(Effect.succeed(value)), [value])
-
-    testCause('fails with the given Cause', fromEffect(Effect.fail(value)), Cause.fail(value))
-  })
-})

package/src/fromEffect.ts

@@ -1,23 +0,0 @@
-import { pipeArguments } from '@effect/data/Pipeable'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, FxTypeId, Sink } from './Fx.js'
-
-export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
-  return new FromEffect(effect)
-}
-
-class FromEffect<R, E, A> implements Fx<R, E, A> {
-  readonly [FxTypeId]!: Fx<R, E, A>[FxTypeId]
-
-  constructor(readonly effect: Effect.Effect<R, E, A>) {}
-
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, void> {
-    return Effect.matchCauseEffect(this.effect, { onFailure: sink.error, onSuccess: sink.event })
-  }
-
-  pipe() {
-    // eslint-disable-next-line prefer-rest-params
-    return pipeArguments(this, arguments)
-  }
-}

package/src/fromEmitter.test.ts

@@ -1,33 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import { describe } from 'vitest'
-
-import { fromEmitter } from './fromEmitter.js'
-import { testCause, testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(fromEmitter.name, () => {
-    testCollectAll(
-      'returns each value emitted',
-      fromEmitter((emitter) =>
-        Effect.sync(() => {
-          emitter.event(1)
-          emitter.event(2)
-          emitter.event(3)
-          emitter.end()
-        }),
-      ),
-      [1, 2, 3],
-    )
-
-    testCause(
-      'fails with the given Cause',
-      fromEmitter((emitter) =>
-        Effect.sync(() => {
-          emitter.error(Cause.fail(1))
-        }),
-      ),
-      Cause.fail(1),
-    )
-  })
-})

package/src/fromEmitter.ts

@@ -1,46 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Deferred from '@effect/io/Deferred'
-import * as Effect from '@effect/io/Effect'
-import * as Runtime from '@effect/io/Runtime'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Sink } from './Fx.js'
-import { Fx } from './Fx.js'
-
-export function fromEmitter<E, A, R, E2>(
-  f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope, E2, void>,
-): Fx<Exclude<R, Scope>, E | E2, A> {
-  return Fx(
-    <R2>(sink: Sink<R2, E | E2, A>): Effect.Effect<Exclude<R, Scope> | R2, never, void> =>
-      Effect.scoped(
-        Effect.gen(function* ($) {
-          // Use to signal this emitter has completed.
-          const deferred = yield* $(Deferred.make<never, void>())
-
-          // Construct an Emitter which uses the current runtime and scope
-          // to run the effects it emits while exposing itself to external APIs
-          // like DOM event listeners and other imperative APIs.
-          const forkIn = Effect.forkIn(yield* $(Effect.scope))
-          const run = Runtime.runCallback(yield* $(Effect.runtime<R | R2>()))
-          const emitter: Emitter<E, A> = {
-            event: (a) => run(forkIn(sink.event(a))),
-            error: (cause) => run(forkIn(Effect.intoDeferred(sink.error(cause), deferred))),
-            end: () => run(Deferred.succeed(deferred, undefined)),
-          }
-
-          // Run your Effect with this emitter using the same scope as all
-          // of the emitted effects.
-          yield* $(forkIn(Effect.catchAllCause(f(emitter), sink.error)))
-
-          // Wait for this Stream to end before returning
-          return yield* $(Deferred.await(deferred))
-        }),
-      ),
-  )
-}
-
-export interface Emitter<E, A> {
-  readonly event: (a: A) => void
-  readonly error: (cause: Cause.Cause<E>) => void
-  readonly end: () => void
-}

package/src/fromFxEffect.test.ts

@@ -1,17 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import { describe } from 'vitest'
-
-import { fromFxEffect } from './fromFxEffect.js'
-import { succeed } from './succeed.js'
-import { testCause, testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(fromFxEffect.name, (): void => {
-    const value = Math.random()
-
-    testCollectAll('returns the output', fromFxEffect(Effect.succeed(succeed(value))), [value])
-
-    testCause('fails with the given Cause', fromFxEffect(Effect.fail(value)), Cause.fail(value))
-  })
-})

package/src/fromFxEffect.ts

@@ -1,11 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from './Fx.js'
-
-export function fromFxEffect<R, E, R2, E2, B>(
-  effect: Effect.Effect<R, E, Fx<R2, E2, B>>,
-): Fx<R | R2, E | E2, B> {
-  return Fx((sink) =>
-    Effect.matchCauseEffect(effect, { onFailure: sink.error, onSuccess: (fx) => fx.run(sink) }),
-  )
-}

package/src/fromHub.ts

@@ -1,10 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Hub from '@effect/io/Hub'
-import * as Scope from '@effect/io/Scope'
-
-import { Fx } from './Fx.js'
-import { fromDequeueWithShutdown } from './fromDequeue.js'
-
-export function fromHub<A>(hub: Hub.Hub<A>): Fx<Scope.Scope, never, A> {
-  return Fx((sink) => Effect.flatMap(hub.subscribe(), (q) => fromDequeueWithShutdown(q).run(sink)))
-}

package/src/fromIterable.test.ts

@@ -1,11 +0,0 @@
-import { describe } from 'vitest'
-
-import { fromIterable } from './fromIterable.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(fromIterable.name, () => {
-    const set = new Set([Math.random(), Math.random(), Math.random()])
-    testCollectAll('returns each the array', fromIterable(set), Array.from(set))
-  })
-})

package/src/fromIterable.ts

@@ -1,27 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from './Fx.js'
-
-export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
-  return Fx((sink) =>
-    Effect.suspend(() => {
-      const iterator = iterable[Symbol.iterator]()
-      let result = iterator.next()
-
-      if (result.done) {
-        return Effect.unit
-      }
-
-      let eff = sink.event(result.value)
-      result = iterator.next()
-
-      while (!result.done) {
-        const value = result.value
-        eff = Effect.flatMap(eff, () => sink.event(value))
-        result = iterator.next()
-      }
-
-      return eff
-    }),
-  )
-}

package/src/gen.test.ts

@@ -1,30 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import { describe } from 'vitest'
-
-import { gen } from './gen.js'
-import { succeed } from './succeed.js'
-import { testCause, testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(gen.name, () => {
-    const value = Math.random()
-
-    testCollectAll(
-      'returns the output',
-      // eslint-disable-next-line require-yield
-      gen(function* () {
-        return succeed(value)
-      }),
-      [value],
-    )
-
-    testCause(
-      'fails with the given Cause',
-      gen(function* ($) {
-        return yield* $(Effect.fail(value))
-      }),
-      Cause.fail(value),
-    )
-  })
-})

package/src/gen.ts

@@ -1,28 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from './Fx.js'
-import { fromFxEffect } from './fromFxEffect.js'
-
-export type EffectGenResources<T> = [T] extends [never]
-  ? never
-  : T extends Effect.EffectGen<infer R, any, any>
-  ? R
-  : never
-
-export type EffectGenErrors<T> = [T] extends [never]
-  ? never
-  : T extends Effect.EffectGen<any, infer E, any>
-  ? E
-  : never
-
-export type EffectGenOutput<T> = [T] extends [never]
-  ? never
-  : T extends Effect.EffectGen<any, any, infer A>
-  ? A
-  : never
-
-export function gen<Y extends Effect.EffectGen<any, any, any>, R, E, A>(
-  f: (adapter: Effect.Adapter) => Generator<Y, Fx<R, E, A>>,
-): Fx<R | EffectGenResources<Y>, E | EffectGenErrors<Y>, A> {
-  return fromFxEffect(Effect.gen(f)) as Fx<R | EffectGenResources<Y>, E | EffectGenErrors<Y>, A>
-}

package/src/helpers.ts

@@ -1,142 +0,0 @@
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Ref from '@effect/io/Ref'
-import * as RefS from '@effect/io/Ref/Synchronized'
-import * as Scope from '@effect/io/Scope'
-
-export type ScopedFork = <R2, E2, B>(
-  effect: Effect.Effect<R2, E2, B>,
-) => Effect.Effect<R2, never, Fiber.RuntimeFiber<E2, B>>
-
-export function withScopedFork<R, E, A>(
-  f: (fork: ScopedFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
-) {
-  return Effect.acquireUseRelease(
-    Scope.make(),
-    (scope) => f(Effect.forkIn(scope), scope),
-    (scope, exit) => Scope.close(scope, exit),
-  )
-}
-
-export type ForkFxFiber = <R2>(
-  effect: Effect.Effect<R2, never, void>,
-) => Effect.Effect<R2, never, Fiber.RuntimeFiber<never, void>>
-
-export function withUnboundedConcurrency<R, E, A>(
-  f: (fork: ForkFxFiber) => Effect.Effect<R, E, A>,
-) {
-  return withScopedFork((fork) =>
-    Effect.suspend(() => {
-      const fibers = new Set<Fiber.RuntimeFiber<never, void>>()
-
-      return Effect.flatMap(
-        f((effect) =>
-          Effect.flatMap(fork(effect), (fiber) => {
-            fibers.add(fiber)
-            return Effect.as(
-              fork(
-                Effect.ensuring(
-                  Fiber.join(fiber),
-                  Effect.sync(() => fibers.delete(fiber)),
-                ),
-              ),
-              fiber,
-            )
-          }),
-        ),
-        () => (fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.unit),
-      )
-    }),
-  )
-}
-
-export type ForkFx = <R2>(eff: Effect.Effect<R2, never, void>) => Effect.Effect<R2, never, void>
-
-export function withSwitch<R, E, A>(f: (switchFork: ForkFx) => Effect.Effect<R, E, A>) {
-  return withScopedFork((fork) =>
-    Effect.flatMap(RefS.make<Fiber.Fiber<never, void> | undefined>(undefined), (ref) => {
-      const switchFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
-        RefS.updateEffect(ref, (currentFiber) =>
-          currentFiber ? Effect.zipRight(Fiber.interruptFork(currentFiber), fork(eff)) : fork(eff),
-        )
-
-      return Effect.flatMap(
-        Effect.flatMap(f(switchFork), () => RefS.get(ref)),
-        (fiber) => (fiber ? Fiber.join(fiber) : Effect.unit),
-      )
-    }),
-  )
-}
-
-export function withExhaust<R, E, A>(f: (exhaustFork: ForkFx) => Effect.Effect<R, E, A>) {
-  return withScopedFork((fork) =>
-    Effect.flatMap(Ref.make<Fiber.Fiber<never, void> | void>(undefined), (ref) => {
-      const reset = Ref.set(ref, undefined)
-
-      const exhaustFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
-        Effect.flatMap(Ref.get(ref), (currentFiber) =>
-          currentFiber
-            ? Effect.unit
-            : Effect.flatMap(fork(Effect.ensuring(eff, reset)), (fiber) => Ref.set(ref, fiber)),
-        )
-
-      return Effect.flatMap(
-        Effect.flatMap(f(exhaustFork), () => Ref.get(ref)),
-        (fiber) => (fiber ? Fiber.join(fiber) : Effect.unit),
-      )
-    }),
-  )
-}
-
-export function withExhaustLatest<R, E, A>(
-  f: (exhaustLatestFork: ForkFx) => Effect.Effect<R, E, A>,
-) {
-  return withScopedFork((fork) =>
-    Effect.flatMap(
-      Effect.zip(
-        Ref.make<Fiber.Fiber<never, void> | void>(undefined),
-        Ref.make<Option.Option<Effect.Effect<any, never, void>>>(Option.none()),
-      ),
-      ([ref, nextEffect]) => {
-        const reset = Ref.set(ref, undefined)
-
-        // Wait for the current fiber to finish
-        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) =>
-          fiber ? Fiber.join(fiber) : Effect.unit,
-        )
-
-        // Run the next value that's be saved for replay if it exists
-
-        const runNext: Effect.Effect<any, never, void> = Effect.flatMap(
-          Ref.get(nextEffect),
-          (next) => {
-            if (Option.isNone(next)) {
-              return Effect.unit
-            }
-
-            return Effect.all([
-              // Clear the next A to be replayed
-              Ref.set(nextEffect, Option.none()),
-              // Replay the next A
-              exhaustLatestFork(next.value),
-              // Ensure we don't close the scope until the last fiber completes
-              awaitNext,
-            ])
-          },
-        )
-
-        const exhaustLatestFork = <R2>(eff: Effect.Effect<R2, never, void>) =>
-          Effect.flatMap(Ref.get(ref), (currentFiber) =>
-            currentFiber
-              ? Ref.set(nextEffect, Option.some(eff))
-              : Effect.flatMap(fork(Effect.ensuring(eff, Effect.zip(reset, runNext))), (fiber) =>
-                  RefS.set(ref, fiber),
-                ),
-          )
-
-        return Effect.zip(f(exhaustLatestFork), awaitNext)
-      },
-    ),
-  )
-}

package/src/hold.test.ts

@@ -1,37 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import { millis } from '@effect/data/Duration'
-import { range } from '@effect/data/ReadonlyArray'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import { describe, it, expect } from 'vitest'
-
-import { at } from './at.js'
-import { hold } from './hold.js'
-import { mergeAll } from './mergeAll.js'
-import { toChunk } from './toChunk.js'
-
-describe(__filename, () => {
-  describe(hold.name, () => {
-    it('allows replaying latest events to late subscribers', async () => {
-      const test = Effect.gen(function* ($) {
-        const stream = hold(mergeAll(...range(0, 5).map((n) => at(n + 1, millis(n * 100)))))
-
-        const fiber1 = yield* $(Effect.fork(toChunk(stream)))
-
-        yield* $(Effect.sleep(millis(75)))
-
-        const fiber2 = yield* $(Effect.fork(toChunk(stream)))
-
-        yield* $(Effect.sleep(millis(75)))
-
-        const fiber3 = yield* $(Effect.fork(toChunk(stream)))
-
-        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber1)))).toEqual([1, 2, 3, 4, 5, 6])
-        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber2)))).toEqual([1, 2, 3, 4, 5, 6])
-        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber3)))).toEqual([2, 3, 4, 5, 6])
-      })
-
-      await Effect.runPromise(Effect.scoped(test))
-    })
-  })
-})

package/src/hold.ts

@@ -1,36 +0,0 @@
-import * as MutableRef from '@effect/data/MutableRef'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx, Sink } from './Fx.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)
-}
-
-export class HoldFx<R, E, A> extends MulticastFx<R, E, A> {
-  readonly current = MutableRef.make(Option.none<A>())
-
-  constructor(public fx: Fx<R, E, A>) {
-    super(fx)
-  }
-
-  run<R2>(sink: Sink<R2, E, A>) {
-    const current = MutableRef.get(this.current)
-
-    if (Option.isSome(current)) {
-      return Effect.flatMap(sink.event(current.value), () => super.run(sink))
-    }
-
-    return super.run(sink)
-  }
-
-  event(a: A) {
-    return Effect.suspend(() => {
-      MutableRef.set(this.current, Option.some(a))
-
-      return super.event(a)
-    })
-  }
-}