@typed/fx 1.5.9 → 1.6.2

package/src/operator/scan.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 { scan } from './scan.js'
-
-describe(import.meta.url, () => {
-  describe(scan.name, () => {
-    it('allows accumulating a value over time', async () => {
-      const test = pipe(
-        fromArray([1, 2, 3]),
-        scan(0, (acc, n) => acc + n),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [0, 1, 3, 6])
-    })
-  })
-})

package/src/operator/scan.ts

@@ -1,19 +0,0 @@
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '../Fx.js'
-
-import { loop } from './loop.js'
-import { startWith } from './startWith.js'
-
-export function scan<B, A>(seed: B, f: (b: B, a: A) => B) {
-  return <R, E>(self: Fx<R, E, A>): Fx<R, E, B> =>
-    pipe(
-      self,
-      loop(seed, (b, a) => {
-        const c = f(b, a)
-
-        return [c, c]
-      }),
-      startWith(seed),
-    )
-}

package/src/operator/scanEffect.test.ts

@@ -1,42 +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 { fromArray } from '../constructor/fromArray.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { scanEffect } from './scanEffect.js'
-
-describe(import.meta.url, () => {
-  describe(scanEffect.name, () => {
-    it('allows accumulating a value over time using Effect', async () => {
-      const test = pipe(
-        fromArray([1, 2, 3]),
-        scanEffect(Effect.succeed(0), (acc, n) => Effect.sync(() => acc + n)),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [0, 1, 3, 6])
-    })
-
-    it('allows ensures reducers are applied in order', async () => {
-      const test = pipe(
-        fromArray([10, 20, 30]),
-        scanEffect(Effect.succeed(0), (acc, n) =>
-          pipe(
-            Effect.sync(() => acc + n),
-            Effect.delay(millis(100 - acc - n)),
-          ),
-        ),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [0, 10, 30, 60])
-    })
-  })
-})

package/src/operator/scanEffect.ts

@@ -1,66 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-import type * as Scope from '@effect/io/Scope'
-
-import { Fx, Sink } from '../Fx.js'
-
-export function scanEffect<R2, E2, B, A, R3, E3>(
-  seed: Effect.Effect<R2, E2, B>,
-  f: (b: B, a: A) => Effect.Effect<R3, E3, B>,
-) {
-  return <R, E>(self: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, B> =>
-    new ScanEffectFx(self, seed, f)
-}
-
-class ScanEffectFx<R, E, A, R2, E2, B, R3, E3>
-  extends Fx.Variance<R | R2 | R3, E | E2 | E3, B>
-  implements Fx<R | R2 | R3, E | E2 | E3, B>
-{
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly seed: Effect.Effect<R2, E2, B>,
-    readonly f: (b: B, a: A) => Effect.Effect<R3, E3, B>,
-  ) {
-    super()
-  }
-
-  run<R4>(
-    sink: Sink<R4, E | E2 | E3, B>,
-  ): Effect.Effect<R | R2 | R3 | R4 | Scope.Scope, never, unknown> {
-    return pipe(
-      this.seed,
-      Effect.matchCauseEffect(sink.error, (acc) =>
-        pipe(
-          sink.event(acc),
-          Effect.flatMap(() => this.fx.run(new ScanEffectSink(sink, acc, this.f))),
-        ),
-      ),
-    )
-  }
-}
-
-class ScanEffectSink<E, A, E2, B, R3, E3, R4> implements Fx.Sink<R3 | R4, E, A> {
-  protected acc: B = this.seed
-  protected semaphore = Effect.unsafeMakeSemaphore(1)
-
-  constructor(
-    readonly sink: Sink<R4, E | E2 | E3, B>,
-    readonly seed: B,
-    readonly f: (b: B, a: A) => Effect.Effect<R3, E3, B>,
-  ) {}
-
-  event = (a: A): Effect.Effect<R3 | R4, never, unknown> => {
-    return pipe(
-      this.f(this.acc, a),
-      Effect.matchCauseEffect(this.sink.error, (acc) => {
-        this.acc = acc
-
-        return this.sink.event(acc)
-      }),
-      this.semaphore.withPermits(1),
-    )
-  }
-
-  error = this.sink.error
-  end = this.sink.end
-}

package/src/operator/separate.test.ts

@@ -1,38 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import { millis } from '@effect/data/Duration'
-import * as Either from '@effect/data/Either'
-import * as Effect from '@effect/io/Effect'
-import * as Fiber from '@effect/io/Fiber'
-import { describe, it } from 'vitest'
-
-import { at } from '../constructor/at.js'
-import { collectAll } from '../run/collectAll.js'
-
-import { mergeAll } from './merge.js'
-import { separate } from './separate.js'
-
-describe(import.meta.url, () => {
-  describe(separate.name, () => {
-    it('allows separating Eithers to lefts and rights', async () => {
-      const test = Effect.gen(function* ($) {
-        const source = mergeAll(
-          at(millis(0), Either.left(1)),
-          at(millis(200), Either.right(2)),
-          at(millis(100), Either.left(3)),
-          at(millis(150), Either.right(4)),
-          at(millis(250), Either.left(5)),
-        )
-        const [lefts, rights] = separate(source)
-
-        const fiberLefts = yield* $(Effect.fork(collectAll(lefts)))
-        const fiberRights = yield* $(Effect.fork(collectAll(rights)))
-
-        deepStrictEqual(yield* $(Fiber.join(fiberLefts)), [1, 3, 5])
-        deepStrictEqual(yield* $(Fiber.join(fiberRights)), [4, 2])
-      })
-
-      await Effect.runPromise(test)
-    })
-  })
-})

package/src/operator/separate.ts

@@ -1,27 +0,0 @@
-import * as Either from '@effect/data/Either'
-import { pipe } from '@effect/data/Function'
-
-import type { Fx } from '../Fx.js'
-
-import { filter } from './filter.js'
-import { map } from './map.js'
-import { multicast } from './multicast.js'
-
-export function separate<R, E, A, B>(
-  fx: Fx<R, E, Either.Either<A, B>>,
-): readonly [Fx<R, E, A>, Fx<R, E, B>] {
-  const s = multicast(fx)
-
-  return [
-    pipe(
-      s,
-      filter(Either.isLeft<A, B>),
-      map((e) => e.left),
-    ),
-    pipe(
-      s,
-      filter(Either.isRight),
-      map((e) => e.right),
-    ),
-  ]
-}

package/src/operator/since.ts

@@ -1,47 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-import { withEarlyExit } from '../_internal/earlyExit.js'
-
-import { filter } from './filter.js'
-
-export function since<R2, E2, B>(signal: Fx<R2, E2, B>) {
-  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => new SinceFx(fx, signal)
-}
-
-class SinceFx<R, E, A, R2, E2, B>
-  extends Fx.Variance<R | R2, E | E2, A>
-  implements Fx<R | R2, E | E2, A>
-{
-  constructor(readonly fx: Fx<R, E, A>, readonly signal: Fx<R2, E2, B>) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E | E2, A>) {
-    const { fx, signal } = this
-
-    return pipe(
-      Effect.gen(function* ($) {
-        let shouldRun = false
-
-        yield* $(
-          pipe(
-            withEarlyExit(
-              (earlyExit) => signal.run(Fx.Sink(() => earlyExit, sink.error, earlyExit)),
-              Effect.sync(() => (shouldRun = true)),
-            ),
-            Effect.forkScoped,
-          ),
-        )
-
-        return yield* $(
-          pipe(
-            fx,
-            filter(() => shouldRun),
-          ).run(sink),
-        )
-      }),
-    )
-  }
-}

package/src/operator/skip.ts

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

package/src/operator/skipAfter.test.ts

@@ -1,29 +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 { skipAfter } from './skipAfter.js'
-import { tap } from './tap.js'
-
-describe(import.meta.url, () => {
-  describe(skipAfter.name, () => {
-    it('skips values after a predicate has been matched', async () => {
-      let count = 0
-      const test = pipe(
-        fromArray([1, 2, 3, 4, 5, 6, 7, 8]),
-        tap(() => Effect.sync(() => count++)),
-        skipAfter((x) => x === 4),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3])
-      deepStrictEqual(count, 8)
-    })
-  })
-})

package/src/operator/skipAfter.ts

@@ -1,39 +0,0 @@
-import type { Predicate } from '@effect/data/Predicate'
-import { unit } from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export function skipAfter<A>(predicate: Predicate<A>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => new SkipAfterFx(fx, predicate)
-}
-
-class SkipAfterFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly fx: Fx<R, E, A>, readonly predicate: Predicate<A>) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return this.fx.run(new SkipAfterSink(sink, this.predicate))
-  }
-}
-
-class SkipAfterSink<R, E, A> implements Fx.Sink<R, E, A> {
-  protected running = true
-
-  constructor(readonly sink: Fx.Sink<R, E, A>, readonly predicate: Predicate<A>) {}
-
-  event = (a: A) => {
-    const passed = this.predicate(a)
-
-    if (this.running && !passed) {
-      return this.sink.event(a)
-    } else if (passed) {
-      this.running = false
-    }
-
-    return unit()
-  }
-
-  error = this.sink.error
-  end = this.sink.end
-}

package/src/operator/skipRepeats.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 { skipRepeats } from './skipRepeats.js'
-
-describe(import.meta.url, () => {
-  describe(skipRepeats.name, () => {
-    it('allows accumulating a value over time', async () => {
-      const test = pipe(
-        fromArray([1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 1, 2]),
-        skipRepeats,
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [1, 2, 3, 1, 2])
-    })
-  })
-})

package/src/operator/skipRepeats.ts

@@ -1,43 +0,0 @@
-import { equals } from '@effect/data/Equal'
-import { pipe } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export function skipRepeatsWith<A>(equals: (first: A, second: A) => boolean) {
-  return <R, E>(self: Fx<R, E, A>): Fx<R, E, A> => new SkipRepeatsWithFx(self, equals)
-}
-
-export function skipRepeats<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-  return pipe(
-    fx,
-    skipRepeatsWith<A>((first, second) => equals(second)(first)),
-  )
-}
-
-class SkipRepeatsWithFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly self: Fx<R, E, A>, readonly equals: (first: A, second: A) => boolean) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return Effect.suspend(() => {
-      let previous: Option.Option<A> = Option.none()
-
-      return this.self.run({
-        ...sink,
-        event: (a) =>
-          Effect.suspend(() => {
-            if (Option.isNone(previous) || !this.equals(previous.value, a)) {
-              previous = Option.some(a)
-
-              return sink.event(a)
-            }
-
-            return Effect.unit()
-          }),
-      })
-    })
-  }
-}

package/src/operator/skipUntil.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 { skipUntil } from './skipUntil.js'
-
-describe(import.meta.url, () => {
-  describe(skipUntil.name, () => {
-    it('skips values until a predicate has been matched', async () => {
-      const test = pipe(
-        fromArray([1, 2, 3, 4, 5, 6, 7, 8]),
-        skipUntil((x) => x === 4),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [4, 5, 6, 7, 8])
-    })
-  })
-})

package/src/operator/skipUntil.ts

@@ -1,37 +0,0 @@
-import type { Predicate } from '@effect/data/Predicate'
-import { unit } from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-
-export function skipUntil<A>(predicate: Predicate<A>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => new SkipUntilFx(fx, predicate)
-}
-
-class SkipUntilFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly fx: Fx<R, E, A>, readonly predicate: Predicate<A>) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return this.fx.run(new SkipUntilSink(sink, this.predicate))
-  }
-}
-
-class SkipUntilSink<R, E, A> implements Fx.Sink<R, E, A> {
-  protected running = false
-
-  constructor(readonly sink: Fx.Sink<R, E, A>, readonly predicate: Predicate<A>) {}
-
-  event = (a: A) => {
-    if (this.running || this.predicate(a)) {
-      this.running = true
-
-      return this.sink.event(a)
-    }
-
-    return unit()
-  }
-
-  error = this.sink.error
-  end = this.sink.end
-}

package/src/operator/skipWhile.ts

@@ -1,10 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import { type Predicate, not } from '@effect/data/Predicate'
-
-import type { Fx } from '../Fx.js'
-
-import { skipUntil } from './skipUntil.js'
-
-export function skipWhile<A>(predicate: Predicate<A>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => pipe(fx, skipUntil(not(predicate)))
-}

package/src/operator/slice.test.ts

@@ -1,21 +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 { slice } from './slice.js'
-
-describe(import.meta.url, () => {
-  describe(slice.name, () => {
-    it('allows skipping and taking a specified amount of values', async () => {
-      const test = pipe(fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), slice(3, 4), collectAll)
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [4, 5, 6, 7])
-    })
-  })
-})

package/src/operator/slice.ts

@@ -1,52 +0,0 @@
-import { pipe } from '@effect/data/Function'
-import * as Effect from '@effect/io/Effect'
-
-import { Fx } from '../Fx.js'
-import { withEarlyExit } from '../_internal/earlyExit.js'
-
-export function slice(skip: number, take: number) {
-  return function <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
-    return new SliceFx(fx, skip, take)
-  }
-}
-
-class SliceFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
-  constructor(readonly fx: Fx<R, E, A>, readonly skip: number, readonly take: number) {
-    super()
-  }
-
-  run<R2>(sink: Fx.Sink<R2, E, A>) {
-    return withEarlyExit(
-      (earlyExit) => this.fx.run(new SliceSink(sink, this.skip, this.take, earlyExit)),
-      sink.end,
-    )
-  }
-}
-
-class SliceSink<R, E, A> implements Fx.Sink<R, E, A> {
-  constructor(
-    readonly sink: Fx.Sink<R, E, A>,
-    protected skip: number,
-    protected take: number,
-    readonly earlyExit: Effect.Effect<never, never, never>,
-  ) {}
-
-  event = (a: A) => {
-    if (this.take === 0) {
-      return this.earlyExit
-    }
-
-    if (this.skip > 0) {
-      this.skip--
-      return Effect.unit()
-    }
-
-    return pipe(
-      this.sink.event(a),
-      Effect.tap(() => (--this.take === 0 ? this.earlyExit : Effect.unit())),
-    )
-  }
-
-  error = this.sink.error
-  end = this.sink.end
-}

package/src/operator/snapshot.test.ts

@@ -1,27 +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 { collectAll } from '../run/collectAll.js'
-
-import { mergeAll } from './merge.js'
-import { snapshot } from './snapshot.js'
-
-describe(import.meta.url, () => {
-  describe(snapshot.name, () => {
-    it('allows accumulating a value over time', async () => {
-      const test = pipe(
-        mergeAll(at(millis(100), 1), at(millis(200), 5), at(millis(300), 10)),
-        snapshot(mergeAll(at(millis(0), 1), at(millis(100), 5)), (a, b) => a + b),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [2, 10, 15])
-    })
-  })
-})

package/src/operator/snapshot.ts

@@ -1,59 +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'
-
-import { Fx } from '../Fx.js'
-import { run } from '../run/run.js'
-
-export function snapshot<R2, E2, B, A, C>(sampled: Fx<R2, E2, B>, f: (b: B, a: A) => C) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, C> => new SnapshotFx(fx, sampled, f)
-}
-
-class SnapshotFx<R, E, A, R2, E2, B, C>
-  extends Fx.Variance<R | R2, E | E2, C>
-  implements Fx<R | R2, E | E2, C>
-{
-  constructor(
-    readonly fx: Fx<R, E, A>,
-    readonly sampled: Fx<R2, E2, B>,
-    readonly f: (b: B, a: A) => C,
-  ) {
-    super()
-  }
-
-  run<R3>(sink: Fx.Sink<R3, E | E2, 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) =>
-              pipe(
-                ref,
-                Ref.get,
-                Effect.flatMap(Option.match(Effect.unit, (b) => sink.event(f(b, a)))),
-              ),
-            sink.error,
-            sink.end,
-          ),
-        ),
-      )
-    })
-  }
-}

package/src/operator/snapshotEffect.test.ts

@@ -1,29 +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 { collectAll } from '../run/collectAll.js'
-
-import { mergeAll } from './merge.js'
-import { snapshotEffect } from './snapshotEffect.js'
-
-describe(import.meta.url, () => {
-  describe(snapshotEffect.name, () => {
-    it('allows accumulating a value over time using an Effect', async () => {
-      const test = pipe(
-        mergeAll(at(millis(100), 1), at(millis(200), 5), at(millis(300), 10)),
-        snapshotEffect(mergeAll(at(millis(0), 1), at(millis(100), 5)), (a, b) =>
-          Effect.sync(() => a + b),
-        ),
-        collectAll,
-      )
-      const events = await Effect.runPromise(test)
-
-      deepStrictEqual(events, [2, 10, 15])
-    })
-  })
-})