@typed/fx 1.5.9 → 1.6.2

package/src/operator/snapshotEffect.ts

@@ -1,72 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Ref from '@effect/io/Ref/Synchronized'
-
-import { Fx } from '../Fx.js'
-import { run } from '../run/run.js'
-
-export function snapshotEffect<R2, E2, B, A, R3, E3, C>(
-  sampled: Fx<R2, E2, B>,
-  f: (b: B, a: A) => Effect.Effect<R3, E3, C>,
-) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, C> =>
-    new SnapshotEffectFx(fx, sampled, f)
-}
-
-class SnapshotEffectFx<R, E, A, R2, E2, B, R3, E3, C>
-  extends Fx.Variance<R | R2 | R3, E | E2 | E3, C>
-  implements Fx<R | R2 | R3, E | E2 | E3, C>
-{
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly sampled: Fx<R2, E2, B>,
-    readonly f: (b: B, a: A) => Effect.Effect<R3, E3, C>,
-  ) {
-    super()
-  }
-
-  run<R4>(sink: Fx.Sink<R4, E | E2 | E3, C>) {
-    const { fx, sampled, f } = this
-
-    return Effect.gen(function* ($) {
-      const ref = yield* $(Ref.make<Option.Option<B>>(Option.none()))
-
-      yield* $(
-        pipe(
-          sampled,
-          run((b) => pipe(ref, Ref.set(Option.some(b))), sink.error, Effect.unit()),
-          Effect.catchAllCause((cause) =>
-            Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-          ),
-          Effect.forkScoped,
-        ),
-      )
-
-      return yield* $(
-        fx.run(
-          Fx.Sink(
-            (a) =>
-              Ref.updateEffect(ref, (option) =>
-                pipe(
-                  option,
-                  Option.match(
-                    () => Effect.sync(Option.none),
-                    (b) =>
-                      pipe(
-                        f(b, a),
-                        Effect.matchCauseEffect(sink.error, sink.event),
-                        Effect.as(Option.some(b)),
-                      ),
-                  ),
-                ),
-              ),
-            sink.error,
-            sink.end,
-          ),
-        ),
-      )
-    })
-  }
-}

package/src/operator/startWith.ts

@@ -1,14 +0,0 @@
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '../Fx.js'
-import { succeed } from '../constructor/succeed.js'
-
-import { continueWith } from './continueWith.js'
-
-export function startWith<B>(value: B) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A | B> =>
-    pipe(
-      succeed(value),
-      continueWith(() => fx),
-    )
-}

package/src/operator/startWithEffect.ts

@@ -1,32 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export function startWithEffect<R, E, A>(
-  effect: Effect.Effect<R, E, A>,
-): <R2, E2, B>(fx: Fx<R2, E2, B>) => Fx<R | R2, E | E2, A | B> {
-  return (fx) => new StartWithEffectFx(fx, effect)
-}
-
-class StartWithEffectFx<R, E, A, R2, E2, B>
-  extends Fx.Variance<R | R2, E | E2, A | B>
-  implements Fx<R | R2, E | E2, A | B>
-{
-  constructor(readonly fx: Fx<R2, E2, B>, readonly effect: Effect.Effect<R, E, A>) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E | E2, A | B>) {
-    return pipe(
-      this.effect,
-      Effect.matchCauseEffect(sink.error, (a) =>
-        pipe(
-          a,
-          sink.event,
-          Effect.flatMap(() => this.fx.run(sink)),
-        ),
-      ),
-    )
-  }
-}

package/src/operator/struct.test.ts

@@ -1,38 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { millis } from '@effect/data/Duration'
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { periodic } from '../constructor/periodic.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { struct } from './struct.js'
-import { withItems } from './withItems.js'
-
-describe(import.meta.url, () => {
-  describe(struct.name, () => {
-    it('combines a struct of streams into a stream of structs', async () => {
-      const test = pipe(
-        struct({
-          a: pipe(periodic(millis(10)), withItems([1, 2, 3])),
-          b: pipe(periodic(millis(10)), withItems(['a', 'b', 'c'])),
-          c: pipe(periodic(millis(10)), withItems([true, false, true])),
-        }),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [
-        { a: 1, b: 'a', c: true },
-        { a: 2, b: 'a', c: true },
-        { a: 2, b: 'b', c: true },
-        { a: 2, b: 'b', c: false },
-        { a: 3, b: 'b', c: false },
-        { a: 3, b: 'c', c: false },
-        { a: 3, b: 'c', c: true },
-      ])
-    })
-  })
-})

package/src/operator/struct.ts

@@ -1,29 +0,0 @@
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '../Fx.js'
-import { entriesOf } from '../_internal/entriesOf.js'
-
-import { combineAll } from './combine.js'
-import { map } from './map.js'
-
-export function struct<Streams extends Readonly<Record<PropertyKey, Fx<any, any, any>>>>(
-  streams: Streams,
-): Fx<
-  Fx.ResourcesOf<Streams[keyof Streams]>,
-  Fx.ErrorsOf<Streams[keyof Streams]>,
-  {
-    readonly [K in keyof Streams]: Fx.OutputOf<Streams[K]>
-  }
-> {
-  return pipe(
-    combineAll(
-      ...entriesOf(streams).map(([k, fx]) =>
-        pipe(
-          fx,
-          map((a) => [k, a]),
-        ),
-      ),
-    ),
-    map(Object.fromEntries),
-  )
-}

package/src/operator/switchMap.test.ts

@@ -1,41 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { millis } from '@effect/data/Duration'
-import * as Either from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { at } from '../constructor/at.js'
-import { fail } from '../constructor/fail.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { mergeAll } from './merge.js'
-import { switchMap } from './switchMap.js'
-
-describe(import.meta.url, () => {
-  describe(switchMap.name, () => {
-    it('allows mapping to other Fx while prefering the latest stream', async () => {
-      const test = pipe(
-        mergeAll(at(millis(0), 1), at(millis(20), 2), at(millis(40), 3)),
-        switchMap((n) => at(millis(40), n * n)),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [9])
-    })
-
-    it('collects inner errors', async () => {
-      const test = pipe(
-        mergeAll(at(millis(0), 1), at(millis(20), 2), at(millis(40), 3)),
-        switchMap((n) => fail(n)),
-        collectAll,
-      )
-
-      const either = await Effect.runPromiseEither(test)
-
-      deepStrictEqual(either, Either.left(1))
-    })
-  })
-})

package/src/operator/switchMap.ts

@@ -1,89 +0,0 @@
-import { flow, pipe, identity, dual } from '@effect/data/Function'
-import type { FlatMap } from '@effect/data/typeclass/FlatMap'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Ref from '@effect/io/Ref/Synchronized'
-
-import { Fx } from '../Fx.js'
-import { withRefCounter } from '../_internal/RefCounter.js'
-import { splitInterrupt } from '../_internal/matchInterruptCause.js'
-import type { FxTypeLambda } from '../typeclass/TypeLambda.js'
-
-export const switchMap: FlatMap<FxTypeLambda>['flatMap'] = dual(
-  2,
-  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, f: (a: A) => Fx<R2, E2, B>) => new SwitchMapFx(fx, f),
-)
-
-export const switchLatest: <R, E, R2, E2, A>(fx: Fx<R, E, Fx<R2, E2, A>>) => Fx<R | R2, E | E2, A> =
-  switchMap(identity)
-
-class SwitchMapFx<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) =>
-        pipe(
-          Ref.make(null as Fiber.RuntimeFiber<never, unknown> | null),
-          Effect.flatMap((refFiber) => {
-            const resetRef = pipe(
-              refFiber,
-              Ref.set<Fiber.RuntimeFiber<never, unknown> | null>(null),
-            )
-
-            return this.fx.run(
-              Fx.Sink(
-                (a) =>
-                  pipe(
-                    refFiber,
-                    Ref.updateEffect((fiber) =>
-                      pipe(
-                        fiber
-                          ? Effect.asUnit(Fiber.interrupt(fiber))
-                          : Effect.asUnit(counter.increment),
-                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        Effect.flatMap((_: unknown) =>
-                          pipe(
-                            this.f(a).run(
-                              Fx.Sink(
-                                sink.event,
-                                flow(
-                                  Effect.unified((cause) =>
-                                    Cause.isInterruptedOnly(cause)
-                                      ? Effect.unit()
-                                      : sink.error(cause),
-                                  ),
-                                  Effect.zipLeft(resetRef),
-                                ),
-                                pipe(counter.decrement, Effect.zipLeft(resetRef)),
-                              ),
-                            ),
-                            Effect.catchAllCause(
-                              splitInterrupt(sink.error, () =>
-                                pipe(resetRef, Effect.zipRight(counter.decrement)),
-                              ),
-                            ),
-                            Effect.forkScoped,
-                          ),
-                        ),
-                      ),
-                    ),
-                  ),
-                sink.error,
-                counter.decrement,
-              ),
-            )
-          }),
-          Effect.catchAllCause(splitInterrupt(sink.error, () => counter.decrement)),
-        ),
-      sink.end,
-    )
-  }
-}

package/src/operator/switchMapCause.test.ts

@@ -1,40 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { millis } from '@effect/data/Duration'
-import * as Either from '@effect/data/Either'
-import { flow, pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { at } from '../constructor/at.js'
-import { fail } from '../constructor/fail.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { flatMap } from './flatMap.js'
-import { mergeAll } from './merge.js'
-import { switchMapCause } from './switchMapCause.js'
-
-describe(import.meta.url, () => {
-  describe(switchMapCause.name, () => {
-    it('allows mapping to other Fx during failures while prefering the latest stream', async () => {
-      const test = pipe(
-        mergeAll(at(millis(0), 1), at(millis(20), 2), at(millis(40), 3)),
-        flatMap((n) => fail(n)),
-        switchMapCause(
-          flow(
-            Cause.failureOrCause,
-            Either.match(
-              (n) => at(millis(40), n * n),
-              (cause) => fail(cause),
-            ),
-          ),
-        ),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [9])
-    })
-  })
-})

package/src/operator/switchMapCause.ts

@@ -1,86 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Ref from '@effect/io/Ref/Synchronized'
-
-import { Fx } from '../Fx.js'
-import { withRefCounter } from '../_internal/RefCounter.js'
-import { splitInterrupt } from '../_internal/matchInterruptCause.js'
-
-import { catchTag_ } from './catchTag.js'
-
-export function switchMapCause<E, R2, E2, B>(
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2, A | B> {
-  return (fx) => new SwitchMapCauseFx(fx, f)
-}
-
-export function switchMapCatchTag<
-  K extends E['_tag'] & string,
-  E extends { readonly _tag: string },
-  R2,
-  E2,
-  B,
->(
-  k: K,
-  f: (e: Extract<E, { readonly _tag: K }>) => Fx<R2, E2, B>,
-): <R, A>(fx: Fx<R, E, A>) => Fx<R | R2, E2 | Exclude<E, { readonly _tag: K }>, A | B> {
-  return (fx) => new SwitchMapCauseFx(fx, (cause) => catchTag_(cause, k, f))
-}
-
-class SwitchMapCauseFx<R, E, A, R2, E2, B>
-  extends Fx.Variance<R | R2, E2, A | B>
-  implements Fx<R | R2, E2, A | B>
-{
-  constructor(readonly fx: Fx<R, E, A>, readonly f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E2, A | B>) {
-    return withRefCounter(
-      0,
-      (counter) =>
-        pipe(
-          Ref.make(null as Fiber.RuntimeFiber<never, unknown> | null),
-          Effect.flatMap((refFiber) => {
-            const resetRef = pipe(
-              refFiber,
-              Ref.set<Fiber.RuntimeFiber<never, unknown> | null>(null),
-            )
-
-            return this.fx.run(
-              Fx.Sink(
-                sink.event,
-                (cause) =>
-                  pipe(
-                    refFiber,
-                    Ref.updateEffect((fiber) =>
-                      pipe(
-                        fiber
-                          ? Effect.asUnit(Fiber.interrupt(fiber))
-                          : Effect.asUnit(counter.increment),
-                        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                        Effect.flatMap((_: unknown) =>
-                          Effect.forkScoped(
-                            this.f(cause).run(
-                              Fx.Sink(
-                                sink.event,
-                                splitInterrupt(sink.error, () => counter.decrement),
-                                pipe(counter.decrement, Effect.zipLeft(resetRef)),
-                              ),
-                            ),
-                          ),
-                        ),
-                      ),
-                    ),
-                  ),
-                counter.decrement,
-              ),
-            )
-          }),
-        ),
-      sink.end,
-    )
-  }
-}

package/src/operator/switchMapEffect.ts

@@ -1,13 +0,0 @@
-import { flow } from '@effect/data/Function'
-import type { Effect } from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-import { fromEffect } from '../constructor/fromEffect.js'
-
-import { switchMap } from './switchMap.js'
-
-export function switchMapEffect<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 switchMap(flow(f, fromEffect))
-}

package/src/operator/switchMapError.ts

@@ -1,23 +0,0 @@
-import { match } from '@effect/data/Either'
-import { flow, pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import type * as Effect from '@effect/io/Effect'
-
-import type { Fx } from '../Fx.js'
-import { failCause } from '../constructor/failCause.js'
-import { fromEffect } from '../constructor/fromEffect.js'
-
-import { switchMapCause } from './switchMapCause.js'
-
-export function switchMapError<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> =>
-    pipe(
-      fx,
-      switchMapCause((cause) => pipe(cause, Cause.failureOrCause, match(f, failCause))),
-    )
-}
-
-export function switchMapErrorEffect<E, R2, E2, B>(f: (error: E) => Effect.Effect<R2, E2, B>) {
-  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> =>
-    pipe(fx, switchMapError(flow(f, fromEffect)))
-}

package/src/operator/switchMatch.test.ts

@@ -1,37 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { millis } from '@effect/data/Duration'
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { at } from '../constructor/at.js'
-import { fail } from '../constructor/fail.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { flatten } from './flatMap.js'
-import { mergeAll } from './merge.js'
-import { switchMatchError } from './switchMatch.js'
-
-describe(import.meta.url, () => {
-  describe(switchMatchError.name, () => {
-    it('allows mapping to other Fx while prefering the latest stream', async () => {
-      const test = pipe(
-        mergeAll(
-          at(millis(0), 1),
-          at(millis(20), 2),
-          at(millis(40), 3),
-          pipe(at(millis(60), fail(4)), flatten),
-        ),
-        switchMatchError(
-          (n) => at(millis(60), n * n),
-          (n) => at(millis(60), n * n),
-        ),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [16])
-    })
-  })
-})

package/src/operator/switchMatch.ts

@@ -1,103 +0,0 @@
-import * as Either from '@effect/data/Either'
-import { flow, pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import * as Ref from '@effect/io/Ref/Synchronized'
-
-import { Fx } from '../Fx.js'
-import { withRefCounter } from '../_internal/RefCounter.js'
-import { splitInterrupt } from '../_internal/matchInterruptCause.js'
-import { failCause } from '../constructor/failCause.js'
-
-export function switchMatchCause<E, R2, E2, B, A, R3, E3, C>(
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-  g: (a: A) => Fx<R3, E3, C>,
-): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C> {
-  return (fx) => new SwitchMatchFx(fx, f, g)
-}
-
-export function switchMatchError<E, R2, E2, B, A, R3, E3, C>(
-  f: (error: E) => Fx<R2, E2, B>,
-  g: (a: A) => Fx<R3, E3, C>,
-): <R>(fx: Fx<R, E, A>) => Fx<R | R2 | R3, E2 | E3, B | C> {
-  return switchMatchCause(flow(Cause.failureOrCause, Either.match(f, failCause)), g)
-}
-
-class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
-  extends Fx.Variance<R | R2 | R3, E2 | E3, B | C>
-  implements Fx<R | R2 | R3, E2 | E3, B | C>
-{
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-    readonly g: (a: A) => Fx<R3, E3, C>,
-  ) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E2 | E3, B | C>) {
-    return withRefCounter(
-      1,
-      (counter) =>
-        pipe(
-          Ref.make(null as Fiber.RuntimeFiber<never, unknown> | null),
-          Effect.flatMap((refFiber) => {
-            const resetRef = pipe(
-              refFiber,
-              Ref.set<Fiber.RuntimeFiber<never, unknown> | null>(null),
-            )
-
-            let firstError = true
-
-            const handleError = Effect.suspend(() =>
-              firstError ? ((firstError = false), Effect.asUnit(counter.decrement)) : Effect.unit(),
-            )
-
-            const runWith = <R>(fx: Fx<R, E2 | E3, B | C>) =>
-              pipe(
-                refFiber,
-                Ref.updateEffect((fiber) =>
-                  pipe(
-                    fiber
-                      ? Effect.asUnit(Fiber.interrupt(fiber))
-                      : Effect.asUnit(counter.increment),
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    Effect.flatMap((_: unknown) =>
-                      pipe(
-                        fx.run(
-                          Fx.Sink(
-                            sink.event,
-                            splitInterrupt(sink.error, () =>
-                              Effect.zip(counter.decrement, resetRef),
-                            ),
-                            pipe(counter.decrement, Effect.zipLeft(resetRef)),
-                          ),
-                        ),
-                        Effect.catchAllCause((cause) =>
-                          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                        ),
-                        Effect.forkScoped,
-                      ),
-                    ),
-                  ),
-                ),
-              )
-
-            return this.fx.run(
-              Fx.Sink(
-                (a) => runWith(this.g(a)),
-                (a) =>
-                  pipe(
-                    runWith(this.f(a)),
-                    Effect.flatMap(() => handleError),
-                  ),
-                counter.decrement,
-              ),
-            )
-          }),
-        ),
-      sink.end,
-    )
-  }
-}

package/src/operator/take.ts

@@ -1,6 +0,0 @@
-import type { Fx } from '../Fx.js'
-
-import { slice } from './slice.js'
-
-export const take: (amount: number) => <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = (amount) =>
-  slice(0, amount)

package/src/operator/takeUntil.test.ts

@@ -1,25 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import { describe, it } from 'vitest'
-
-import { fromArray } from '../constructor/fromArray.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { takeUntil } from './takeUntil.js'
-
-describe(import.meta.url, () => {
-  describe(takeUntil.name, () => {
-    it('ends an Fx once a predicate has been matched', async () => {
-      const test = pipe(
-        fromArray([1, 2, 3, 4, 5, 6, 7, 8]),
-        takeUntil((x) => x === 4),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3])
-    })
-  })
-})