@typed/fx 1.17.3 → 1.18.0

package/src/multicast.test.ts

@@ -1,88 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import * as Duration from '@effect/data/Duration'
-import { pipe } from '@effect/data/Function'
-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 { flatMap } from './flatMap.js'
-import { fromArray } from './fromArray.js'
-import { merge } from './mergeAll.js'
-import { multicast } from './multicast.js'
-import { never } from './never.js'
-import { onInterrupt } from './onInterrupt.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))
-    })
-
-    describe('when all subscribers are interrupted', () => {
-      it('interrupts the underlying producer', async () => {
-        let interrupted = false
-        const test = Effect.gen(function* ($) {
-          const stream = pipe(
-            onInterrupt(never<never, number>(), () => Effect.sync(() => (interrupted = true))),
-            multicast,
-          )
-
-          const fiber1 = yield* $(Effect.fork(toChunk(stream)))
-          const fiber2 = yield* $(Effect.fork(toChunk(stream)))
-
-          yield* $(Fiber.interrupt(fiber1))
-          yield* $(Fiber.interrupt(fiber2))
-        })
-
-        await Effect.runPromise(Effect.scoped(test))
-
-        expect(interrupted).toEqual(true)
-      })
-    })
-  })
-})

package/src/multicast.ts

@@ -1,131 +0,0 @@
-import type * as Context from '@effect/data/Context'
-import { identity } from '@effect/data/Function'
-import { pipeArguments } from '@effect/data/Pipeable'
-import type * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-
-import { FxTypeId } from './Fx.js'
-import type { Fx, Sink } from './Fx.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,
-  }
-
-  /**@internal */
-  public observers: Array<MulticastObserver<any, E, A>> = []
-  /**@internal */
-  public 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.flatMap(Effect.context<R2>(), (context) =>
-      Effect.suspend(() => {
-        const observer: MulticastObserver<R2, E, A> = { sink, context }
-
-        const effects: Array<Effect.Effect<R, never, void>> = []
-
-        if (observers.push(observer) === 1) {
-          effects.push(
-            Effect.tap(Effect.forkDaemon(that.fx.run(that)), (fiber) =>
-              Effect.sync(() => (that.fiber = fiber)),
-            ),
-          )
-        }
-
-        effects.push(
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          Effect.suspend(() => Effect.ensuring(Fiber.await(that.fiber!), that.removeSink(sink))),
-        )
-
-        return Effect.all(effects)
-      }),
-    )
-  }
-
-  event(a: A) {
-    if (this.observers.length === 0) {
-      return Effect.unit
-    }
-
-    return Effect.suspend(() =>
-      Effect.forEach(this.observers.slice(0), (observer) => this.runEvent(observer, a)),
-    )
-  }
-
-  error(cause: Cause.Cause<E>) {
-    if (this.observers.length === 0) {
-      return Effect.unit
-    }
-
-    return Effect.suspend(() =>
-      Effect.forEach(this.observers.slice(0), (observer) => this.runError(observer, cause)),
-    )
-  }
-
-  pipe() {
-    // eslint-disable-next-line prefer-rest-params
-    return pipeArguments(this, arguments)
-  }
-
-  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 { observers } = this
-
-      if (observers.length === 0) return Effect.unit
-
-      const index = observers.findIndex((o) => o.sink === sink)
-
-      if (index > -1) {
-        observers.splice(index, 1)
-
-        if (observers.length === 0) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          const interrupt = Fiber.interrupt(this.fiber!)
-
-          this.fiber = undefined
-
-          return interrupt
-        }
-      }
-
-      return Effect.unit
-    })
-  }
-}

package/src/never.ts

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

package/src/observe.ts

@@ -1,43 +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 Fiber from '@effect/io/Fiber'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fx } from './Fx.js'
-import { Sink } from './Fx.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.flatMap(Deferred.make<E | E2, void>(), (deferred) => {
-    const error = (cause: Cause.Cause<E | E2>) => Deferred.failCause(deferred, cause)
-    const end = () => Deferred.succeed(deferred, undefined)
-
-    return Effect.flatMap(
-      Effect.forkScoped(
-        Effect.flatMap(fx.run(Sink((a: A) => Effect.catchAllCause(f(a), error), error)), end),
-      ),
-      (fiber) => Effect.flatMap(Deferred.await(deferred), () => Fiber.interruptFork(fiber)),
-    )
-  })
-}
-
-const toUnit = () => Effect.unit
-
-export function drain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, void> {
-  return observe(fx, toUnit)
-}
-
-export function forkScoped<R, E, A>(
-  fx: Fx<R, E, A>,
-): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
-  return Effect.forkScoped(drain(fx))
-}
-
-export function fork<R, E, A>(
-  fx: Fx<R, E, A>,
-): Effect.Effect<R | Scope, never, Fiber.RuntimeFiber<E, void>> {
-  return Effect.fork(drain(fx))
-}

package/src/onExit.ts

@@ -1,13 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Exit from '@effect/io/Exit'
-
-import { Fx } from './Fx.js'
-
-export function onExit<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (exit: Exit.Exit<E, void>) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E | E2, A> {
-  return Fx((sink) =>
-    Effect.onExit(fx.run(sink), (exit) => Effect.catchAllCause(f(exit), sink.error)),
-  )
-}

package/src/onInterrupt.ts

@@ -1,16 +0,0 @@
-import type { HashSet } from '@effect/data/HashSet'
-import * as Effect from '@effect/io/Effect'
-import type { FiberId } from '@effect/io/Fiber/Id'
-
-import { Fx } from './Fx.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/orElse.ts

@@ -1,16 +0,0 @@
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function orElse<R, E, A, R2, E2, B>(
-  self: Fx<R, E, A>,
-  that: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-): Fx<R | R2, E2, A | B> {
-  return Fx((sink) =>
-    Effect.catchAllCause(Effect.scoped(observe(self, sink.event)), (cause) =>
-      that(cause).run(sink),
-    ),
-  )
-}

package/src/promise.ts

@@ -1,37 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import type { Fx } from './Fx.js'
-import { fromEffect } from './fromEffect.js'
-import { fromFxEffect } from './fromFxEffect.js'
-
-export function promise<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, never, A> {
-  return fromEffect(Effect.promise(f))
-}
-
-export function tryPromise<A>(f: (signal: AbortSignal) => Promise<A>): Fx<never, unknown, A> {
-  return fromEffect(Effect.tryPromise(f))
-}
-
-export function tryCatchPromise<A, E>(
-  f: (signal: AbortSignal) => Promise<A>,
-  g: (error: unknown) => E,
-): Fx<never, E, A> {
-  return fromEffect(Effect.tryPromise({ try: f, catch: g }))
-}
-
-export function promiseFx<R, E, A>(f: (signal: AbortSignal) => Promise<Fx<R, E, A>>): Fx<R, E, A> {
-  return fromFxEffect(Effect.promise(f))
-}
-
-export function tryPromiseFx<R, E, A>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-): Fx<R, unknown, A> {
-  return fromFxEffect(Effect.tryPromise(f))
-}
-
-export function tryCatchPromiseFx<R, E, A, E2>(
-  f: (signal: AbortSignal) => Promise<Fx<R, E, A>>,
-  g: (error: unknown) => E2,
-): Fx<R, E | E2, A> {
-  return fromFxEffect(Effect.tryPromise({ try: f, catch: g }))
-}

package/src/provide.ts

@@ -1,76 +0,0 @@
-import * as Context from '@effect/data/Context'
-import * as Effect from '@effect/io/Effect'
-import * as Layer from '@effect/io/Layer'
-
-import { Fx } from './Fx.js'
-import type { Sink } from './Fx.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.mapInputContext(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.mapInputContext(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, {
-        onFailure: sink.error,
-        onSuccess: (s) =>
-          Effect.mapInputContext(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

@@ -1,19 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Scope from '@effect/io/Scope'
-
-import { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function reduce<R, E, A, B>(
-  fx: Fx<R, E, A>,
-  b: B,
-  f: (b: B, a: A) => B,
-): Effect.Effect<R | Scope.Scope, E, B> {
-  return Effect.gen(function* ($) {
-    let acc = b
-
-    yield* $(observe(fx, (a) => Effect.sync(() => (acc = f(acc, a)))))
-
-    return acc
-  })
-}

package/src/scan.ts

@@ -1,15 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.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/scoped.ts

@@ -1,8 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Scope from '@effect/io/Scope'
-
-import { Fx } from './Fx.js'
-
-export function scoped<R, E, A>(fx: Fx<R, E, A>): Fx<Exclude<R, Scope.Scope>, E, A> {
-  return Fx((sink) => Effect.scoped(fx.run(sink)))
-}

package/src/skipRepeats.ts

@@ -1,29 +0,0 @@
-import type { Equivalence } from '@effect/data/Equivalence'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import fastDeepEqual from 'fast-deep-equal/es6'
-
-import { Fx, Sink } from './Fx.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.containsWith(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, fastDeepEqual)
-}

package/src/skipWhile.test.ts

@@ -1,27 +0,0 @@
-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

@@ -1,31 +0,0 @@
-import type { Predicate } 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 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

@@ -1,26 +0,0 @@
-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

@@ -1,43 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.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)
-}