@typed/fx 0.0.35 → 1.0.2

package/src/provide.ts

@@ -1,61 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Layer from '@effect/core/io/Layer'
-import * as Scope from '@effect/core/io/Scope'
-import { pipe } from '@fp-ts/data/Function'
-import { Env } from '@tsplus/stdlib/service/Env'
-import { Tag } from '@tsplus/stdlib/service/Tag'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function provideSomeEnvironment<R2>(env: Env<R2>) {
-  return <R, E, A>(fx: Fx<R | R2, E, A>): Fx<Exclude<R, R2>, E, A> =>
-    Fx((emitter) =>
-      pipe(
-        fx.run(emitter),
-        Effect.provideSomeEnvironment(
-          (e: Env<Exclude<R, R2> | Emitter.ResourcesOf<typeof emitter> | Scope.Scope>) =>
-            (e as Env<R | Emitter.ResourcesOf<typeof emitter> | Scope.Scope>).merge(env),
-        ),
-      ),
-    )
-}
-
-export function provideEnvironment<R>(env: Env<R>) {
-  return provideSomeEnvironment(env) as <E, A>(fx: Fx<R, E, A>) => Fx<never, E, A>
-}
-
-export function provideSomeLayer<RI, E2, RO>(layer: Layer.Layer<RI, E2, RO>) {
-  return <R, E, A>(fx: Fx<R | RO, E, A>): Fx<RI | Exclude<R, RO>, E | E2, A> =>
-    Fx(<R2>(emitter: Emitter<R2, E | E2, A>) =>
-      Effect.scopeWith((scope) =>
-        pipe(
-          layer,
-          Layer.buildWithScope(scope),
-          Effect.flatMap((ro) => pipe(fx, provideSomeEnvironment(ro)).run(emitter)),
-          Effect.foldCauseEffect((c) => emitter.failCause(c), Effect.succeed),
-        ),
-      ),
-    )
-}
-
-export function provideLayer<RI, E2, RO>(layer: Layer.Layer<RI, E2, RO>) {
-  return provideSomeLayer(layer) as <E, A>(fx: Fx<RO, E, A>) => Fx<RI, E | E2, A>
-}
-
-export function provideService<S>(
-  tag: Tag<S>,
-  service: S,
-): <R, E, A>(fx: Fx<S | R, E, A>) => Fx<Exclude<R, S>, E, A> {
-  return provideSomeEnvironment(Env(tag, service))
-}
-
-export function provideServiceEffect<S, R2, E2>(tag: Tag<S>, service: Effect.Effect<R2, E2, S>) {
-  return <R, E, A>(fx: Fx<R | S, E, A>): Fx<R2 | Exclude<R, S>, E | E2, A> =>
-    Fx((emitter) =>
-      pipe(
-        fx.run(emitter),
-        Effect.provideServiceEffect(tag, service),
-        Effect.foldCauseEffect(emitter.failCause, Effect.succeed),
-      ),
-    )
-}

package/src/runCollect.ts

@@ -1,21 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-import { onEarlyExitFailure } from './_internal.js'
-import { runObserve } from './runObserve.js'
-
-export function runCollect<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, ReadonlyArray<A>> {
-  return pipe(
-    Effect.sync<A[]>(() => []),
-    Effect.flatMap((values) =>
-      pipe(
-        fx,
-        runObserve((a) => Effect.sync(() => values.push(a))),
-        onEarlyExitFailure(Effect.unit),
-        Effect.map(() => values),
-      ),
-    ),
-    Effect.scoped,
-  )
-}

package/src/runDrain.ts

@@ -1,25 +0,0 @@
-import * as Deferred from '@effect/core/io/Deferred'
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Fx } from './Fx.js'
-import { onEarlyExitFailure } from './_internal.js'
-
-export function runDrain<R, E, A>(fx: Fx<R, E, A>): Effect.Effect<R, E, void> {
-  return pipe(
-    Deferred.make<E, void>(),
-    Effect.flatMap((deferred) =>
-      pipe(
-        fx.run({
-          emit: () => Effect.unit,
-          failCause: (c) => deferred.failCauseSync(c),
-          end: deferred.succeed(undefined),
-        }),
-        Effect.forkScoped,
-        Effect.zipRight(deferred.await),
-        onEarlyExitFailure(Effect.sync(() => deferred.succeed(undefined))),
-      ),
-    ),
-    Effect.scoped,
-  )
-}

package/src/runObserve.ts

@@ -1,33 +0,0 @@
-import * as Deferred from '@effect/core/io/Deferred'
-import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { onEarlyExitFailure } from './_internal.js'
-
-export function runObserve<A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) {
-  return <R, E>(fx: Fx<R, E, A>): Effect.Effect<R | R2, E | E2, void> =>
-    pipe(
-      Deferred.make<E | E2, void>(),
-      Effect.tap((deferred) =>
-        Effect.forkScoped(
-          fx.run(
-            Emitter(
-              flow(
-                f,
-                Effect.foldCauseEffect(
-                  (c) => deferred.failCauseSync(c),
-                  () => Effect.unit,
-                ),
-              ),
-              (c) => deferred.failCauseSync(c),
-              deferred.succeed(undefined),
-            ),
-          ),
-        ),
-      ),
-      Effect.flatMap((deferred) => deferred.await),
-      onEarlyExitFailure(Effect.unit),
-      Effect.scoped,
-    )
-}

package/src/runReduce.ts

@@ -1,64 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-
-import { Fx } from './Fx.js'
-import { runObserve } from './runObserve.js'
-
-export function runReduce<A, B>(seed: A, f: (a: A, b: B) => A) {
-  return <R, E>(fx: Fx<R, E, B>): Effect.Effect<R, E, A> => {
-    return runReduce_(fx, seed, f)
-  }
-}
-
-export function runFilterReduce<A, B>(seed: A, f: (a: A, b: B) => Maybe.Maybe<A>) {
-  return <R, E>(fx: Fx<R, E, B>): Effect.Effect<R, E, A> => {
-    return runFilterReduce_(fx, seed, f)
-  }
-}
-
-function runReduce_<R, E, A, B>(
-  fx: Fx<R, E, B>,
-  seed: A,
-  f: (a: A, b: B) => A,
-): Effect.Effect<R, E, A> {
-  return pipe(
-    Ref.makeRef<A>(() => seed),
-    Effect.flatMap((ref) =>
-      pipe(
-        fx,
-        runObserve((b) => Effect.sync(() => ref.update((a) => f(a, b)))),
-        Effect.flatMap(() => ref.get),
-      ),
-    ),
-    Effect.scoped,
-  )
-}
-
-function runFilterReduce_<R, E, A, B>(
-  fx: Fx<R, E, B>,
-  seed: A,
-  f: (a: A, b: B) => Maybe.Maybe<A>,
-): Effect.Effect<R, E, A> {
-  return pipe(
-    Ref.makeRef<A>(() => seed),
-    Effect.flatMap((ref) =>
-      pipe(
-        fx,
-        runObserve((b) =>
-          Effect.sync(() =>
-            ref.update((a) =>
-              pipe(
-                f(a, b),
-                Maybe.getOrElse(() => a),
-              ),
-            ),
-          ),
-        ),
-        Effect.flatMap(() => ref.get),
-      ),
-    ),
-    Effect.scoped,
-  )
-}

package/src/scanEffect.ts

@@ -1,32 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function scanEffect<A, B, R2, E2>(seed: A, f: (a: A, B: B) => Effect.Effect<R2, E2, A>) {
-  return <R, E>(fx: Fx<R, E, B>): Fx<R | R2, E | E2, A> =>
-    Fx(<R3>(emitter: Emitter<R3, E | E2, A>) =>
-      pipe(
-        Ref.makeSynchronized<A>(() => seed),
-        Effect.flatMap((ref) =>
-          pipe(
-            emitter.emit(seed),
-            Effect.flatMap(() =>
-              fx.run(
-                Emitter(
-                  (b) =>
-                    pipe(
-                      ref.updateAndGetEffect((a) => f(a, b)),
-                      Effect.foldCauseEffect(emitter.failCause, emitter.emit),
-                    ),
-                  emitter.failCause,
-                  emitter.end,
-                ),
-              ),
-            ),
-          ),
-        ),
-      ),
-    )
-}

package/src/scheduled.ts

@@ -1,79 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Exit from '@effect/core/io/Exit'
-import * as Schedule from '@effect/core/io/Schedule'
-import { millis } from '@tsplus/stdlib/data/Duration'
-import { isRight } from '@tsplus/stdlib/data/Either'
-
-import { Emitter, Fx } from './Fx.js'
-
-/**
- * Schedules an Effect to run, emitting the result of the Effect to the emmiter
- */
-export function scheduled<S, R2, Out>(schedule: Schedule.Schedule<S, R2, any, Out>) {
-  return <R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, A> =>
-    Fx(
-      <R3>(emitter: Emitter<R3, E, A>): Effect.Effect<R | R2 | R3, never, unknown> =>
-        Effect.gen(function* ($) {
-          const clock = yield* $(Effect.clock)
-
-          let now = yield* $(clock.currentTime)
-          let [s, , decision] = yield* $(schedule.step(now, undefined, schedule.initial))
-
-          while (decision._tag === 'Continue') {
-            yield* $(
-              clock.sleep(millis((Schedule.Intervals.start(decision.intervals) - now) as any)),
-            )
-
-            const exit = yield* $(Effect.exit(effect))
-
-            if (Exit.isFailure(exit)) {
-              return yield* $(emitter.failCause(exit.cause))
-            }
-
-            yield* $(emitter.emit(exit.value))
-
-            now = yield* $(clock.currentTime)
-            const [s2, , decision2] = yield* $(schedule.step(now, exit.value, s))
-
-            s = s2
-            decision = decision2
-          }
-
-          return yield* $(emitter.end)
-        }),
-    )
-}
-
-/**
- * Schedules an Effect to run, emitting the result of the Schedule to the emmiter
- *
- * TODO: Needs a better name
- */
-export function scheduledOut<S, R2, A, Out>(schedule: Schedule.Schedule<S, R2, A, Out>) {
-  return <R, E>(effect: Effect.Effect<R, E, A>): Fx<R | R2, E, Out> =>
-    Fx(<R3>(sink: Emitter<R3, E, Out>) =>
-      Effect.gen(function* ($) {
-        const d = yield* $(Schedule.driver(schedule))
-
-        let inputExit = yield* $(Effect.exit(effect))
-
-        if (Exit.isFailure(inputExit)) {
-          return yield* $(sink.failCause(inputExit.cause))
-        }
-
-        let outputEither = yield* $(Effect.either(d.next(inputExit.value)))
-
-        while (isRight(outputEither)) {
-          inputExit = yield* $(Effect.exit(effect))
-
-          if (Exit.isFailure(inputExit)) {
-            return yield* $(sink.failCause(inputExit.cause))
-          }
-
-          outputEither = yield* $(Effect.either(d.next(inputExit.value)))
-        }
-
-        return yield* $(sink.end)
-      }),
-    )
-}

package/src/since.test.ts

@@ -1,40 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Fiber from '@effect/core/io/Fiber'
-import * as TestClock from '@effect/core/testing/TestClock'
-import { TestEnvironment } from '@effect/core/testing/TestEnvironment'
-import { millis } from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.since.name, () => {
-    it('runs a stream since a signal is emitted to stop', async () => {
-      const sut = Effect.gen(function* ($) {
-        const fiber = yield* $(
-          pipe(
-            Fx.periodic(millis(10)),
-            Fx.scan(0, (x) => x + 1),
-            Fx.since(Fx.at(millis(100))(null)),
-            Fx.take(5),
-            Fx.runCollect,
-            Effect.fork,
-          ),
-        )
-
-        for (let i = 0; i < 15; i++) {
-          yield* $(TestClock.adjust(millis(10)))
-        }
-
-        return yield* $(Fiber.join(fiber))
-      })
-
-      const test = pipe(sut, Effect.provideLayer(TestEnvironment))
-      const events = await Effect.unsafeRunPromise(test)
-
-      deepStrictEqual(events, [11, 12, 13, 14, 15])
-    })
-  })
-})

package/src/since.ts

@@ -1,30 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
-
-import { Emitter, Fx } from './Fx.js'
-import { exitEarly, onEarlyExitFailure } from './_internal.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> => since_(fx, signal)
-}
-
-function since_<R, E, A, R2, E2, B>(fx: Fx<R, E, A>, signal: Fx<R2, E2, B>): Fx<R | R2, E | E2, A> {
-  return Fx((emitter) =>
-    pipe(
-      Effect.sync(() => new AtomicReference(false)),
-      Effect.tap((ref) =>
-        pipe(
-          signal.run(Emitter(() => exitEarly, emitter.failCause, Effect.unit)),
-          onEarlyExitFailure(Effect.sync(() => ref.set(true))),
-          Effect.forkScoped,
-        ),
-      ),
-      Effect.flatMap((ref) =>
-        fx.run(
-          Emitter((a) => (ref.get ? emitter.emit(a) : Effect.unit), emitter.failCause, emitter.end),
-        ),
-      ),
-    ),
-  )
-}

package/src/skipRepeats.test.ts

@@ -1,28 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-import * as Equivalence from '@tsplus/stdlib/prelude/Equivalence'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.skipRepeats.name, () => {
-    it('skips repeating values', async () => {
-      const test = Effect.gen(function* ($) {
-        const result = yield* $(
-          pipe(
-            Fx.fromIterable([1, 2, 3]),
-            Fx.flatMap((n) => Fx.fromIterable([n, n, n])),
-            Fx.skipRepeats(Equivalence.strict<number>()),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [1, 2, 3])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})

package/src/skipRepeats.ts

@@ -1,33 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { makeRef } from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-import * as Maybe from '@tsplus/stdlib/data/Maybe'
-import { Equivalence } from '@tsplus/stdlib/prelude/Equivalence'
-
-import { Emitter, Fx } from './Fx.js'
-
-export function skipRepeats<A>(E: Equivalence<A>) {
-  const equals = Maybe.getEquivalence(E).equals
-
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> =>
-    Fx((sink) =>
-      pipe(
-        makeRef<Maybe.Maybe<A>>(() => Maybe.none),
-        Effect.flatMap((ref) =>
-          fx.run(
-            Emitter(
-              (a) =>
-                Effect.flatten(
-                  ref.modify((m) => {
-                    const m2 = Maybe.some(a)
-                    return [equals(m, m2) ? Effect.unit : sink.emit(a), m2]
-                  }),
-                ),
-              sink.failCause,
-              sink.end,
-            ),
-          ),
-        ),
-      ),
-    )
-}

package/src/skipWhile.test.ts

@@ -1,44 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.skipWhile.name, () => {
-    it('skips all values until a predicate is reached', async () => {
-      const test = Effect.gen(function* ($) {
-        const result = yield* $(
-          pipe(
-            Fx.fromIterable([1, 2, 3, 4, 3, 2, 1]),
-            Fx.skipWhile((x) => x < 4),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [4, 3, 2, 1])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-
-  describe(Fx.skipUntil.name, () => {
-    it('skips values until a predicate is matched', async () => {
-      const test = Effect.gen(function* ($) {
-        const result = yield* $(
-          pipe(
-            Fx.fromIterable([1, 2, 3, 4, 3, 2, 1]),
-            Fx.skipUntil((x) => x > 3),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [4, 3, 2, 1])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})

package/src/skipWhile.ts

@@ -1,45 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { pipe } from '@fp-ts/data/Function'
-import { Predicate, not } from '@tsplus/stdlib/data/Predicate'
-
-import { Emitter, Fx } from './Fx.js'
-import { onEarlyExitFailure } from './_internal.js'
-
-export function skipWhile<A>(predicate: Predicate<A>) {
-  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => skipWhile_(fx, predicate)
-}
-
-export function skipUntil<A>(predicate: Predicate<A>) {
-  return skipWhile(not(predicate))
-}
-
-function skipWhile_<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
-  return Fx((emitter) =>
-    pipe(
-      Ref.makeRef<boolean>(() => false),
-      Effect.flatMap((ref) =>
-        pipe(
-          fx.run(
-            Emitter(
-              (a) =>
-                pipe(
-                  ref.get,
-                  Effect.flatMap((started) =>
-                    started
-                      ? emitter.emit(a)
-                      : predicate(a)
-                      ? Effect.unit
-                      : pipe(ref.set(true), Effect.zipRight(emitter.emit(a))),
-                  ),
-                ),
-              emitter.failCause,
-              emitter.end,
-            ),
-          ),
-        ),
-      ),
-      onEarlyExitFailure(emitter.end),
-    ),
-  )
-}

package/src/slice.test.ts

@@ -1,21 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.slice.name, () => {
-    it('skips/takes values from a Fx', async () => {
-      const result = await pipe(
-        Fx.fromIterable([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-        Fx.slice(3, 4),
-        Fx.runCollect,
-        Effect.unsafeRunPromise,
-      )
-
-      deepStrictEqual(result, [4, 5, 6, 7])
-    })
-  })
-})

package/src/slice.ts

@@ -1,47 +0,0 @@
-import * as Effect from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
-
-import { Emitter, Fx } from './Fx.js'
-import { exitEarly, onEarlyExitFailure } from './_internal.js'
-
-// TODO: Commutation with map
-// TODO: Fusion with other slices
-
-export function slice(skip: number, take: number) {
-  return <R, E, A>(push: Fx<R, E, A>): Fx<R, E, A> =>
-    Fx((emitter) =>
-      pipe(
-        Effect.suspendSucceed(() => {
-          let toSkip = skip
-          let toTake = take
-
-          return push.run(
-            Emitter(
-              (a) => {
-                if (toSkip > 0) {
-                  --toSkip
-                  return Effect.unit
-                }
-
-                return pipe(
-                  emitter.emit(a),
-                  Effect.flatMap(() => (--toTake === 0 ? exitEarly : Effect.unit)),
-                )
-              },
-              emitter.failCause,
-              emitter.end,
-            ),
-          )
-        }),
-        onEarlyExitFailure(emitter.end),
-      ),
-    )
-}
-
-export function skip(n: number) {
-  return slice(n, Infinity)
-}
-
-export function take(n: number) {
-  return slice(0, n)
-}

package/src/snapshot.test.ts

@@ -1,51 +0,0 @@
-import { deepStrictEqual } from 'assert'
-
-import * as Effect from '@effect/core/io/Effect'
-import * as Duration from '@tsplus/stdlib/data/Duration'
-import { pipe } from '@tsplus/stdlib/data/Function'
-
-import * as Fx from './index.js'
-
-describe(import.meta.url, () => {
-  describe(Fx.snapshot.name, () => {
-    it('provides a service to the Fx', async () => {
-      const test = Effect.gen(function* ($) {
-        const result = yield* $(
-          pipe(
-            Fx.fromIterable([1, 2, 3]),
-            Fx.delay(Duration.millis(10)),
-            Fx.snapshot(Fx.succeed(10), (x, y) => x * y),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [10, 20, 30])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-
-  describe(Fx.sample.name, () => {
-    it('provides a service to the Fx', async () => {
-      const test = Effect.gen(function* ($) {
-        const result = yield* $(
-          pipe(
-            Fx.fromIterable([1, 2, 3]),
-            Fx.delay(Duration.millis(10)),
-            Fx.sample(Fx.succeed(1)),
-            Fx.runCollect,
-          ),
-        )
-
-        deepStrictEqual(result, [
-          [1, 1],
-          [2, 1],
-          [3, 1],
-        ])
-      })
-
-      await Effect.unsafeRunPromise(test)
-    })
-  })
-})