@typed/fx 1.17.4 → 1.18.0

package/src/snapshotEffect.ts

@@ -1,49 +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 { Fx, Sink } from './Fx.js'
-
-export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  sampled: Fx<R2, E2, B>,
-  f: (a: A, b: B) => Effect.Effect<R3, E3, C>,
-): Fx<R | R2 | R3, E | E2 | E3, C> {
-  return Fx((sink) =>
-    Effect.gen(function* ($) {
-      const current = yield* $(Ref.make(Option.none<B>()))
-
-      const sampledFiber = yield* $(
-        sampled.run(Sink((b) => Ref.set(current, Option.some(b)), sink.error)),
-        Effect.fork,
-      )
-
-      yield* $(
-        fx.run(
-          Sink(
-            (a) =>
-              Effect.gen(function* ($) {
-                const b = yield* $(Ref.get(current))
-
-                if (Option.isSome(b)) {
-                  yield* $(Effect.catchAllCause(f(a, b.value), sink.error))
-                }
-              }),
-            sink.error,
-          ),
-        ),
-      )
-
-      yield* $(Fiber.interrupt(sampledFiber))
-    }),
-  )
-}
-
-export function snapshot<R, E, A, R2, E2, B, C>(
-  fx: Fx<R, E, A>,
-  sampled: Fx<R2, E2, B>,
-  f: (a: A, b: B) => C,
-): Fx<R | R2, E | E2, C> {
-  return snapshotEffect(fx, sampled, (a, b) => Effect.sync(() => f(a, b)))
-}

package/src/struct.ts

@@ -1,18 +0,0 @@
-import { Fx } from './Fx.js'
-import { combineAll } from './combineAll.js'
-import { map } from './map.js'
-
-export function struct<FXS extends Readonly<Record<string, Fx<any, any, any>>>>(
-  fx: FXS,
-): Fx<
-  Fx.Context<FXS[string]>,
-  Fx.Error<FXS[string]>,
-  {
-    readonly [K in keyof FXS]: Fx.Success<FXS[K]>
-  }
-> {
-  return map(
-    combineAll(...Object.entries(fx).map(([key, value]) => map(value, (x) => [key, x] as const))),
-    Object.fromEntries,
-  )
-}

package/src/succeed.ts

@@ -1,7 +0,0 @@
-import { Fx } from './Fx.js'
-
-export function succeed<A>(value: A): Fx<never, never, A> {
-  return Fx((sink) => sink.event(value))
-}
-
-export const unit = succeed<void>(undefined)

package/src/suspend.ts

@@ -1,5 +0,0 @@
-import { Fx } from './Fx.js'
-
-export function suspend<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
-  return Fx((sink) => f().run(sink))
-}

package/src/switchMap.test.ts

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

package/src/switchMap.ts

@@ -1,38 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { withSwitch } from './helpers.js'
-
-export function switchMap<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((sink) => withSwitch((fork) => fx.run(Sink((a) => fork(f(a).run(sink)), sink.error))))
-}
-
-export function switchMapEffect<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 Fx((sink) =>
-    withSwitch((fork) =>
-      fx.run(
-        Sink(
-          (a) =>
-            fork(Effect.matchCauseEffect(f(a), { onFailure: sink.error, onSuccess: sink.event })),
-          sink.error,
-        ),
-      ),
-    ),
-  )
-}
-
-export function switchLatest<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
-  return switchMap(fx, (a) => a)
-}
-
-export function switchLatestEffect<R, E, R2, E2, B>(
-  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
-): Fx<R | R2, E | E2, B> {
-  return switchMapEffect(fx, (a) => a)
-}

package/src/switchMapCause.test.ts

@@ -1,23 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { delay } from './delay.js'
-import { fail } from './failCause.js'
-import { fromArray } from './fromArray.js'
-import { mergeAll } from './mergeAll.js'
-import { switchMapCause, switchMapError } from './switchMapCause.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(switchMapCause.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'merges multiple streams together when they error, favoring the latest',
-      switchMapError(mergeAll(...array.map((n) => fail(n))), (x) =>
-        delay(fromArray([x]), Duration.millis(10)),
-      ),
-      [array[2]],
-    )
-  })
-})

package/src/switchMapCause.ts

@@ -1,57 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import * as Either from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { failCause } from './failCause.js'
-import { fromEffect } from './fromEffect.js'
-import { withSwitch } from './helpers.js'
-
-export function switchMapCause<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((sink) =>
-    withSwitch((fork) => fx.run(Sink(sink.event, (cause) => fork(f(cause).run(sink))))),
-  )
-}
-
-export function switchMapCauseEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E2, A | B> {
-  return switchMapCause(fx, (a) => fromEffect(f(a)))
-}
-
-export function switchMapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: E) => Fx<R2, E2, B>,
-): Fx<R | R2, E2, A | B> {
-  return switchMapCause(fx, (cause) =>
-    pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
-  )
-}
-
-export function switchMapErrorEffect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E2, A | B> {
-  return switchMapError(fx, (a) => fromEffect(f(a)))
-}
-
-export function switchMapDefect<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (e: unknown) => Fx<R2, E2, B>,
-): Fx<R | R2, E | E2, A | B> {
-  return switchMapCause(fx, (cause): Fx<R | R2, E | E2, A | B> => {
-    const defects = Cause.defects(cause)
-
-    if (Chunk.size(defects) > 0) {
-      return f(Chunk.unsafeHead(defects))
-    }
-
-    return failCause(cause)
-  })
-}

package/src/switchMatch.test.ts

@@ -1,26 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { delay } from './delay.js'
-import { fail } from './failCause.js'
-import { fromArray } from './fromArray.js'
-import { mergeAll } from './mergeAll.js'
-import { succeed } from './succeed.js'
-import { switchMatch } from './switchMatch.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(switchMatch.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'merges multiple streams together, handling errors and successes, favoring the latest',
-      switchMatch(
-        mergeAll(succeed(array[0]), fail(array[1]), succeed(array[2])),
-        (x) => delay(fromArray([x]), Duration.millis(10)),
-        (x) => delay(fromArray([x]), Duration.millis(10)),
-      ),
-      [array[2]],
-    )
-  })
-})

package/src/switchMatch.ts

@@ -1,62 +0,0 @@
-import * as Either from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { failCause } from './failCause.js'
-import { fromEffect } from './fromEffect.js'
-import { withSwitch } from './helpers.js'
-
-export function switchMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
-  g: (a: A) => Fx<R3, E3, C>,
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return Fx((sink) =>
-    withSwitch((fork) =>
-      fx.run(
-        Sink(
-          (a) => fork(g(a).run(sink)),
-          (cause) => fork(f(cause).run(sink)),
-        ),
-      ),
-    ),
-  )
-}
-
-export function switchMatch<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => Fx<R2, E2, B>,
-  g: (a: A) => Fx<R3, E3, C>,
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return switchMatchCause(
-    fx,
-    (cause) => pipe(cause, Cause.failureOrCause, Either.match({ onLeft: f, onRight: failCause })),
-    g,
-  )
-}
-
-export function switchMatchCauseEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
-  g: (a: A) => Effect.Effect<R3, E3, C>,
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return switchMatchCause(
-    fx,
-    (a) => fromEffect(f(a)),
-    (b) => fromEffect(g(b)),
-  )
-}
-
-export function switchMatchEffect<R, E, A, R2, E2, B, R3, E3, C>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => Effect.Effect<R2, E2, B>,
-  g: (a: A) => Effect.Effect<R3, E3, C>,
-): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return switchMatch(
-    fx,
-    (a) => fromEffect(f(a)),
-    (b) => fromEffect(g(b)),
-  )
-}

package/src/takeWhile.test.ts

@@ -1,27 +0,0 @@
-import { describe } from 'vitest'
-
-import { fromArray } from './fromArray.js'
-import { takeUntil, takeWhile } from './takeWhile.js'
-import { testCollectAll } from './test-utils.js'
-
-describe(__filename, () => {
-  describe(takeWhile.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'takes values until the predicate returns false',
-      takeWhile(fromArray(array), (x) => x !== array[2]),
-      [array[0], array[1]],
-    )
-  })
-
-  describe(takeUntil.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'takes values while the predicate returns true',
-      takeUntil(fromArray(array), (x) => x === array[2]),
-      [array[0], array[1]],
-    )
-  })
-})

package/src/takeWhile.ts

@@ -1,34 +0,0 @@
-import { not } from '@effect/data/Predicate'
-import type { Predicate } from '@effect/data/Predicate'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function takeWhile<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
-  return Fx(<R2>(sink: Sink<R2, E, A>) =>
-    Effect.asyncEffect<never, never, void, R | R2, never, void>((cb) => {
-      const exit = Effect.sync(() => cb(Effect.unit))
-
-      return Effect.tap(
-        fx.run(
-          Sink(
-            (a) =>
-              Effect.suspend(() => {
-                if (predicate(a)) {
-                  return sink.event(a)
-                }
-
-                return exit
-              }),
-            sink.error,
-          ),
-        ),
-        () => exit,
-      )
-    }),
-  )
-}
-
-export function takeUntil<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
-  return takeWhile(fx, not(predicate))
-}

package/src/tap.ts

@@ -1,22 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function tap<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (a: A) => Effect.Effect<R2, E2, B>,
-): Fx<R | R2, E | E2, A> {
-  return Fx(<R3>(sink: Sink<R3, E | E2, A>) =>
-    fx.run<R2 | R3>(
-      Sink(
-        (a: A) =>
-          Effect.matchCauseEffect(f(a), { onFailure: sink.error, onSuccess: () => sink.event(a) }),
-        sink.error,
-      ),
-    ),
-  )
-}
-
-export function tapSync<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B): Fx<R, E, A> {
-  return tap(fx, (a) => Effect.sync(() => f(a)))
-}

package/src/tapCause.ts

@@ -1,44 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-
-export function tapCause<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => Effect.Effect<R, E2, B>,
-): Fx<R | R2, E | E2, A> {
-  return Fx((sink) =>
-    fx.run(
-      Sink(sink.event, (cause) =>
-        Effect.matchCauseEffect(f(cause), {
-          onFailure: (cause2) => sink.error(Cause.sequential(cause, cause2)),
-          onSuccess: () => sink.error(cause),
-        }),
-      ),
-    ),
-  )
-}
-
-export function tapCauseSync<R, E, A, B>(
-  fx: Fx<R, E, A>,
-  f: (cause: Cause.Cause<E>) => B,
-): Fx<R, E, A> {
-  return tapCause(fx, (cause) => Effect.sync(() => f(cause)))
-}
-
-export function tapError<R, E, A, R2, E2, B>(
-  fx: Fx<R, E, A>,
-  f: (error: E) => Effect.Effect<R, E2, B>,
-): Fx<R | R2, E | E2, A> {
-  return tapCause(fx, (cause) =>
-    pipe(
-      Cause.failureOrCause(cause),
-      Effect.matchEffect({ onFailure: f, onSuccess: Effect.failCause }),
-    ),
-  )
-}
-
-export function tapErrorSync<R, E, A, B>(fx: Fx<R, E, A>, f: (error: E) => B): Fx<R, E, A> {
-  return tapError(fx, (e) => Effect.sync(() => f(e)))
-}

package/src/test-utils.ts

@@ -1,38 +0,0 @@
-import { 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 { it, expect } from 'vitest'
-
-import type { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function testCollectAll<E = never, A = never>(
-  name: string,
-  fx: Fx<never, E, A>,
-  expected: ReadonlyArray<A>,
-) {
-  it.concurrent(name, async () => {
-    const test = Effect.scoped(
-      Effect.gen(function* ($) {
-        const values: Array<A> = []
-
-        yield* $(observe(fx, (a) => Effect.sync(() => values.push(a))))
-
-        return values
-      }),
-    )
-
-    expect(await Effect.runPromise(test)).toEqual(expected)
-  })
-}
-
-export function testCause<E, A>(name: string, fx: Fx<never, E, A>, expected: Cause.Cause<E>) {
-  it(name, async () => {
-    const exit = await Effect.runPromiseExit(Effect.scoped(observe(fx, () => Effect.unit)))
-
-    ok(Exit.isFailure(exit))
-    expect(Cause.unannotate(exit.cause)).toEqual(expected)
-  })
-}

package/src/throttle.test.ts

@@ -1,18 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import { describe } from 'vitest'
-
-import { fromArray } from './fromArray.js'
-import { testCollectAll } from './test-utils.js'
-import { throttle } from './throttle.js'
-
-describe(__filename, () => {
-  describe(throttle.name, () => {
-    const array = [Math.random(), Math.random(), Math.random()]
-
-    testCollectAll(
-      'throttles events, favoring the first',
-      throttle(fromArray(array), Duration.millis(10)),
-      [array[0]],
-    )
-  })
-})

package/src/throttle.ts

@@ -1,13 +0,0 @@
-import * as Duration from '@effect/data/Duration'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx, Sink } from './Fx.js'
-import { withExhaust } from './helpers.js'
-
-export function throttle<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
-  return Fx(<R2>(sink: Sink<R2, E, A>) =>
-    withExhaust((fork) =>
-      fx.run(Sink((a) => fork(Effect.zipLeft(sink.event(a), Effect.sleep(duration))), sink.error)),
-    ),
-  )
-}

package/src/toArray.ts

@@ -1,16 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function toArray<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Array<A>> {
-  return Effect.suspend(() => {
-    const array: Array<A> = []
-
-    return Effect.map(
-      observe(fx, (a) => Effect.sync(() => array.push(a))),
-      () => array,
-    )
-  })
-}

package/src/toChunk.ts

@@ -1,16 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function toChunk<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R | Scope, E, Chunk.Chunk<A>> {
-  return Effect.gen(function* ($) {
-    let chunk = Chunk.empty<A>()
-
-    yield* $(observe(fx, (a) => Effect.sync(() => (chunk = Chunk.append(chunk, a)))))
-
-    return chunk
-  })
-}

package/src/toEnqueue.ts

@@ -1,13 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import * as Q from '@effect/io/Queue'
-import * as Scope from '@effect/io/Scope'
-
-import { Fx } from './Fx.js'
-import { observe } from './observe.js'
-
-export function toEnqueue<R, E, A>(
-  fx: Fx<R, E, A>,
-  enqueue: Q.Enqueue<A>,
-): Effect.Effect<R | Scope.Scope, E, void> {
-  return observe(fx, enqueue.offer)
-}

package/src/toReadonlyArray.ts

@@ -1,11 +0,0 @@
-import * as Effect from '@effect/io/Effect'
-import type { Scope } from '@effect/io/Scope'
-
-import type { Fx } from './Fx.js'
-import { toArray } from './toArray.js'
-
-export function toReadonlyArray<R, E, A>(
-  fx: Fx<R, E, A>,
-): Effect.Effect<R | Scope, E, ReadonlyArray<A>> {
-  return toArray(fx)
-}

package/src/toStream.ts

@@ -1,23 +0,0 @@
-import * as Chunk from '@effect/data/Chunk'
-import * as Option from '@effect/data/Option'
-import * as Cause from '@effect/io/Cause'
-import * as Effect from '@effect/io/Effect'
-import * as Stream from '@effect/stream/Stream'
-
-import { Fx, Sink } from './Fx.js'
-
-export function toStream<R, E, A>(fx: Fx<R, E, A>): Stream.Stream<R, E, A> {
-  return Stream.asyncScoped<R, E, A>((emit) =>
-    fx
-      .run(
-        Sink(
-          (a) => Effect.sync(() => emit(Effect.succeed(Chunk.of(a)))),
-          (cause) => Effect.sync(() => emit(Effect.failCause(Cause.map(cause, Option.some)))),
-        ),
-      )
-      .pipe(
-        Effect.zipRight(Effect.sync(() => emit(Effect.fail(Option.none())))),
-        Effect.forkScoped,
-      ),
-  )
-}

package/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": [
-    "src/**/*.test.ts",
-    "src/**/*.test-d.ts",
-    "dist"
-  ]
-}