@typed/fx 0.0.9 → 0.0.12

package/src/multicast.ts

@@ -2,97 +2,111 @@ 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 { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { asap } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
 
-export function multicast<R, E, A, E1 = never>(self: Fx<R, E, A, E1>): Fx<R, E, A, E1> {
-  return new Multicast(self)
+export function multicast<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new Multicast(fx)
 }
 
-export type MulticastObserver<E, A> = readonly [
-  Sink<E, A, any, any, any>,
-  Env<any>,
-  Deferred.Deferred<any, any>,
-]
-
-export class Multicast<R, E, A, E1> implements Fx<R, E, A, E1>, Sink<E, A, any, any, any> {
-  protected sinks: Array<MulticastObserver<E, A>> = []
-  protected fiber: Fiber.Fiber<any, any> | undefined
-
-  constructor(readonly fx: Fx<R, E, A, E1>) {
-    this.run = this.run.bind(this)
-    this.event = this.event.bind(this)
-    this.error = this.error.bind(this)
-    this.runEvent = this.runEvent.bind(this)
-    this.runError = this.runError.bind(this)
-    this.runEnd = this.runEnd.bind(this)
-  }
-
-  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
-
-    return Effect.gen(function* ($) {
-      const env = yield* $(Effect.environment<R | R2>())
-      const deferred = yield* $(Deferred.make<E2, B>())
+export interface MulticastObserver<E, A> {
+  readonly emitter: Emitter<any, E, A>
+  readonly env: Env<any>
+  readonly deferred: Deferred.Deferred<never, void>
+}
 
-      that.sinks.push([sink, env, deferred])
+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
 
-      if (!that.fiber) {
-        that.fiber = yield* $(Effect.fork(Effect.schedule(asap)(that.fx.run(that))))
-      }
+  constructor(readonly fx: Fx<R, E, A>) {
+    this.emit = this.emit.bind(this)
+    this.failCause = this.failCause.bind(this)
+  }
 
-      return yield* $(deferred.await)
-    })
+  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),
+    )
   }
 
-  event(a: A) {
-    return Effect.forEachDiscard(this.sinks.slice(), (o) => this.runEvent(a, o))
+  emit(a: A) {
+    return Effect.suspendSucceed(() =>
+      Effect.forEachDiscard(this.observers.slice(), (observer) => this.runEvent(a, observer)),
+    )
   }
 
-  error(e: Cause.Cause<E>): Effect.Effect<never, any, void> {
+  failCause(e: Cause.Cause<E>) {
     return pipe(
-      Effect.forEachDiscard(this.sinks.slice(), (o) => this.runError(e, o)),
-      Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+      Effect.suspendSucceed(() =>
+        Effect.forEachDiscard(this.observers.slice(), (observer) => this.runFailCause(e, observer)),
+      ),
+      Effect.flatMap(() => this.cleanup()),
     )
   }
 
-  public get end(): Sink<E, A, any, any, any>['end'] {
+  get end() {
     return pipe(
-      Effect.forEachDiscard(this.sinks.slice(), (o) => this.runEnd(o)),
-      Effect.tap(() => Effect.sync(() => (this.fiber = undefined))),
+      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[0].event(a),
-      Effect.provideEnvironment(observer[1]),
-      Effect.onError((c) => (Cause.isEmpty(c) ? Effect.unit : this.runError(c, observer))),
+      observer.emitter.emit(a),
+      Effect.onError((c) => this.runFailCause(c, observer)),
+      Effect.provideEnvironment(observer.env),
     )
   }
 
-  protected runError(e: Cause.Cause<E>, observer: MulticastObserver<E, A>) {
-    this.sinks.splice(this.sinks.indexOf(observer), 1)
+  protected runFailCause(e: Cause.Cause<E>, observer: MulticastObserver<E, A>) {
+    this.observers.splice(this.observers.indexOf(observer), 1)
 
     return pipe(
-      observer[0].error(e),
-      Effect.intoDeferred(observer[2]),
-      Effect.provideEnvironment(observer[1]),
+      observer.emitter.failCause(e),
+      Effect.intoDeferred(observer.deferred),
+      Effect.provideEnvironment(observer.env),
     )
   }
 
   protected runEnd(observer: MulticastObserver<E, A>) {
-    this.sinks.splice(this.sinks.indexOf(observer), 1)
+    this.observers.splice(this.observers.indexOf(observer), 1)
 
     return pipe(
-      observer[0].end,
-      Effect.intoDeferred(observer[2]),
-      Effect.provideEnvironment(observer[1]),
+      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

@@ -1,46 +1,33 @@
 import * as Cause from '@effect/core/io/Cause'
-import { Effect } from '@effect/core/io/Effect'
-import { pipe } from '@fp-ts/data/Function'
+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 { Sink } from './Sink.js'
-import { fromEffect } from './fromEffect.js'
+import { failCause } from './fromEffect.js'
+import { runObserve } from './runObserve.js'
 
-export function orElseCause<E, R2, E2, B, E3>(f: (e: Cause.Cause<E>) => Fx<R2, E2, B, E3>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
-    Fx((sink) => fx.run(Sink(sink.event, (e) => f(e).run(sink), sink.end)))
+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, E3>(f: (e: E) => Fx<R2, E2, B, E3>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
-    Fx((sink) =>
-      fx.run(
-        Sink(
-          sink.event,
-          (e) =>
-            pipe(
-              Cause.failureOrCause(e),
-              Either.fold((e) => f(e).run(sink), sink.error),
-            ),
-          sink.end,
-        ),
-      ),
-    )
+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)))
 }
 
-export function orElseCauseEffect<E, R2, E2, B>(f: (e: Cause.Cause<E>) => Effect<R2, E2, B>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1> =>
-    pipe(
+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,
-      orElseCause((e) => fromEffect(f(e))),
-    )
-}
-
-export function orElseEffect<E, R2, E2, B>(f: (e: E) => Effect<R2, E2, B>) {
-  return <R, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1> =>
-    pipe(
-      fx,
-      orElse((e: E) => fromEffect(f(e))),
+      runObserve(emitter.emit),
+      Effect.foldCauseEffect(
+        (c) => f(c).run(emitter),
+        () => emitter.end,
+      ),
     )
+  })
 }

package/src/periodic.test.ts

@@ -1,18 +1,18 @@
 import { deepStrictEqual } from 'assert'
 
-import { unsafeRunPromise } from '@effect/core/io/Effect'
+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 { collectAll } from './reduce.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), collectAll)
-      const events = await unsafeRunPromise(test)
+      const test = pipe(periodic(millis(100)), take(3), runCollect, Effect.scoped)
+      const events = await Effect.unsafeRunPromise(test)
 
       deepStrictEqual(events, [undefined, undefined, undefined])
     })

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

@@ -1,50 +1,61 @@
 import * as Effect from '@effect/core/io/Effect'
-import { Layer } from '@effect/core/io/Layer'
+import * as Layer from '@effect/core/io/Layer'
+import * as Scope from '@effect/core/io/Scope'
 import { pipe } from '@fp-ts/data/Function'
-import * as Env from '@tsplus/stdlib/service/Env'
+import { Env } from '@tsplus/stdlib/service/Env'
 import { Tag } from '@tsplus/stdlib/service/Tag'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 
-export const provideEnvironment =
-  <R>(env: Env.Env<R>) =>
-  <E, A, E1>(fx: Fx<R, E, A, E1>): Fx<never, E, A, E1> =>
-    Fx(
-      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R2, E1 | E2, B> =>
-        pipe(
-          fx.run(sink),
-          Effect.provideSomeEnvironment((e: Env.Env<R2>): Env.Env<R | R2> => e.merge<R2, R>(env)),
+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 const provideSomeEnvironment =
-  <R3>(env: Env.Env<R3>) =>
-  <R, E, A, E1>(fx: Fx<R | R3, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx(
-      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> =>
+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(
-          fx.run(sink),
-          Effect.provideSomeEnvironment((e) => e.merge(env)),
+          layer,
+          Layer.buildWithScope(scope),
+          Effect.flatMap((ro) => pipe(fx, provideSomeEnvironment(ro)).run(emitter)),
+          Effect.foldCauseEffect((c) => emitter.failCause(c), Effect.succeed),
         ),
+      ),
     )
+}
 
-export const provideLayer =
-  <RI, E3, RO>(layer: Layer<RI, E3, RO>) =>
-  <E, A, E1>(fx: Fx<RO, E, A, E1>): Fx<RI, E, A, E1 | E3> =>
-    Fx((sink) => pipe(fx.run(sink), Effect.provideSomeLayer(layer)))
+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 const provideSomeLayer =
-  <RI, E3, RO>(layer: Layer<RI, E3, RO>) =>
-  <R, E, A, E1>(fx: Fx<R | RO, E, A, E1>): Fx<R | RI, E, A, E1 | E3> =>
-    Fx((sink) => pipe(fx.run(sink), Effect.provideSomeLayer(layer)))
+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 const provideService =
-  <T>(tag: Tag<T>, resource: T) =>
-  <R, E, A, E1>(fx: Fx<R | T, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx((sink) => pipe(fx.run(sink), Effect.provideService(tag, resource)))
-
-export const provideServiceEffect =
-  <T, R3, E3>(tag: Tag<T>, effect: Effect.Effect<R3, E3, T>) =>
-  <R, E, A, E1>(fx: Fx<R | T, E, A, E1>): Fx<R | R3, E, A, E1 | E3> =>
-    Fx((sink) => pipe(fx.run(sink), Effect.provideServiceEffect(tag, effect)))
+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,
+  )
+}