@typed/fx 0.0.8 → 0.0.10

package/src/multicast.ts

@@ -0,0 +1,112 @@
+import * as Cause from '@effect/core/io/Cause'
+import * as Deferred from '@effect/core/io/Deferred'
+import * as Effect from '@effect/core/io/Effect'
+import * as Fiber from '@effect/core/io/Fiber'
+import { Scope } from '@effect/core/io/Scope'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+import { Env } from '@tsplus/stdlib/service/Env'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new Multicast(fx)
+}
+
+export interface MulticastObserver<E, A> {
+  readonly emitter: Emitter<any, E, A>
+  readonly env: Env<any>
+  readonly deferred: Deferred.Deferred<never, void>
+}
+
+export class Multicast<R, E, A> implements Fx<R, E, A>, Emitter<never, E, A> {
+  protected observers: MulticastObserver<E, A>[] = []
+  protected fiber: Fiber.Fiber<never, unknown> | undefined
+
+  constructor(readonly fx: Fx<R, E, A>) {
+    this.emit = this.emit.bind(this)
+    this.failCause = this.failCause.bind(this)
+  }
+
+  run<RO>(emitter: Emitter<RO, E, A>): Effect.Effect<R | RO | Scope, never, unknown> {
+    return pipe(
+      Effect.environment<RO>(),
+      Effect.zip(Deferred.make<never, void>()),
+      Effect.tap(([env, deferred]) => {
+        this.observers.push({ emitter, env, deferred })
+
+        return this.fiber
+          ? Effect.unit
+          : pipe(
+              this.fx.run(this),
+              Effect.delay(Duration.millis(0)),
+              Effect.forkScoped,
+              Effect.tap((fiber) => Effect.sync(() => (this.fiber = fiber))),
+            )
+      }),
+
+      Effect.flatMap(([, deferred]) => deferred.await),
+    )
+  }
+
+  emit(a: A) {
+    return Effect.suspendSucceed(() =>
+      Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEvent(a, observer)),
+    )
+  }
+
+  failCause(e: Cause.Cause<E>) {
+    return pipe(
+      Effect.suspendSucceed(() =>
+        Effect.forEachDiscard(this.observers.slice(), (observer) => this.runFailCause(e, observer)),
+      ),
+      Effect.flatMap(() => this.cleanup()),
+    )
+  }
+
+  get end() {
+    return pipe(
+      Effect.suspendSucceed(() =>
+        Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEnd(observer)),
+      ),
+      Effect.flatMap(() => this.cleanup()),
+    )
+  }
+
+  protected runEvent(a: A, observer: MulticastObserver<E, A>) {
+    return pipe(
+      observer.emitter.emit(a),
+      Effect.onError((c) => this.runFailCause(c, observer)),
+      Effect.provideEnvironment(observer.env),
+    )
+  }
+
+  protected runFailCause(e: Cause.Cause<E>, observer: MulticastObserver<E, A>) {
+    this.observers.splice(this.observers.indexOf(observer), 1)
+
+    return pipe(
+      observer.emitter.failCause(e),
+      Effect.intoDeferred(observer.deferred),
+      Effect.provideEnvironment(observer.env),
+    )
+  }
+
+  protected runEnd(observer: MulticastObserver<E, A>) {
+    this.observers.splice(this.observers.indexOf(observer), 1)
+
+    return pipe(
+      observer.emitter.end,
+      Effect.intoDeferred(observer.deferred),
+      Effect.provideEnvironment(observer.env),
+    )
+  }
+
+  protected cleanup() {
+    return this.fiber
+      ? pipe(
+          Fiber.interrupt(this.fiber),
+          Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+        )
+      : Effect.unit
+  }
+}

package/src/orElse.test.ts

@@ -0,0 +1,22 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.orElse.name, () => {
+    it('allows recovering from failures', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.flatMap((n) => Fx.fail(n)),
+        Fx.orElse((n) => Fx.fromIterable([n, n, n])),
+        Fx.runCollect,
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 1, 1])
+    })
+  })
+})

package/src/orElse.ts

@@ -0,0 +1,33 @@
+import * as Cause from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import { flow, pipe } from '@fp-ts/data/Function'
+import * as Either from '@tsplus/stdlib/data/Either'
+
+import { Fx } from './Fx.js'
+import { failCause } from './fromEffect.js'
+import { runObserve } from './runObserve.js'
+
+export function orElseCause<E, R2, E2, B>(f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R | R2, E2, A | B> => orElseCause_(fx, f)
+}
+
+export function orElse<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> =>
+    orElseCause_(fx, flow(Cause.failureOrCause, Either.fold(f, failCause)))
+}
+
+function orElseCause_<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((emitter) => {
+    return pipe(
+      fx,
+      runObserve(emitter.emit),
+      Effect.foldCauseEffect(
+        (c) => f(c).run(emitter),
+        () => emitter.end,
+      ),
+    )
+  })
+}

package/src/periodic.test.ts

@@ -0,0 +1,20 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+import { periodic } from './periodic.js'
+import { runCollect } from './runCollect.js'
+import { take } from './slice.js'
+
+describe(import.meta.url, () => {
+  describe('periodic', () => {
+    it('emits a value every period', async () => {
+      const test = pipe(periodic(millis(100)), take(3), runCollect, Effect.scoped)
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [undefined, undefined, undefined])
+    })
+  })
+})

package/src/periodic.ts

@@ -0,0 +1,11 @@
+import { unit } from '@effect/core/io/Effect'
+import * as Schedule from '@effect/core/io/Schedule'
+import { pipe } from '@fp-ts/data/Function'
+import { Duration } from '@tsplus/stdlib/data/Duration'
+
+import { Fx } from './Fx.js'
+import { scheduled } from './scheduled.js'
+
+export function periodic(delay: Duration): Fx<never, never, void> {
+  return pipe(unit, scheduled(Schedule.delayed(() => delay)(Schedule.repeatForever)))
+}

package/src/provide.test.ts

@@ -0,0 +1,56 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import * as Scope from '@effect/core/io/Scope'
+import { pipe } from '@fp-ts/data/Function'
+import { Tag } from '@tsplus/stdlib/service/Tag'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.provideService.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const scope = yield* $(Scope.make)
+
+        const result = yield* $(
+          pipe(
+            Fx.service(Scope.Scope.Tag),
+            Fx.flatMap((s) => Fx.fromIterable([s, s])),
+            Fx.provideService(Scope.Scope.Tag, scope),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [scope, scope])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+
+  describe(Fx.provideLayer.name, () => {
+    it('provides a layer to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const value = `${Math.random()}`
+        class Foo {
+          static Tag = Tag<Foo>()
+          constructor(readonly foo: string) {}
+        }
+
+        const result = yield* $(
+          pipe(
+            Fx.service(Foo.Tag),
+            Fx.flatMap((s) => Fx.succeed(s.foo)),
+            Fx.provideLayer(Effect.toLayer(Foo.Tag)(Effect.succeed(new Foo(value)))),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [value])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/provide.ts

@@ -0,0 +1,61 @@
+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, E, A>): Fx<R | R2, E | E2, A> =>
+    Fx((emitter) =>
+      pipe(
+        fx.run(emitter),
+        Effect.provideServiceEffect(tag, service),
+        Effect.foldCauseEffect(emitter.failCause, Effect.succeed),
+      ),
+    )
+}

package/src/runCollect.ts

@@ -0,0 +1,19 @@
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Fx } from './Fx.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))),
+        Effect.map(() => values),
+      ),
+    ),
+    Effect.scoped,
+  )
+}

package/src/runDrain.ts

@@ -0,0 +1,23 @@
+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'
+
+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),
+      ),
+    ),
+    Effect.scoped,
+  )
+}

package/src/runObserve.ts

@@ -0,0 +1,31 @@
+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'
+
+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),
+      Effect.scoped,
+    )
+}

package/src/runReduce.ts

@@ -0,0 +1,64 @@
+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/scheduled.ts

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

@@ -0,0 +1,31 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { millis } from '@tsplus/stdlib/data/Duration'
+
+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 test = pipe(
+        Fx.periodic(millis(10)),
+        Fx.scan(0, (x) => x + 1),
+        Fx.since(Fx.at(millis(100))(null)),
+        Fx.take(5),
+        Fx.runCollect,
+      )
+      const events = await Effect.unsafeRunPromise(test)
+
+      // Effect-ts doesn't have a very deterministic way to deal with ordering of events
+      // so we first test what we actually expect, and if that fails, test that it worked, but
+      // the timing was slightly off.
+      try {
+        deepStrictEqual(events, [10, 11, 12, 13, 14])
+      } catch (e) {
+        deepStrictEqual(events, [9, 10, 11, 12, 13])
+      }
+    })
+  })
+})

package/src/since.ts

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

@@ -0,0 +1,28 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/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

@@ -0,0 +1,33 @@
+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,
+            ),
+          ),
+        ),
+      ),
+    )
+}