@typed/fx 0.0.9 → 0.0.12

package/src/hold.ts

@@ -1,71 +1,77 @@
 import { Cause } from '@effect/core/io/Cause'
-import { Deferred } from '@effect/core/io/Deferred'
 import * as Effect from '@effect/core/io/Effect'
 import * as Fiber from '@effect/core/io/Fiber'
 import * as FiberId from '@effect/core/io/FiberId'
+import { Scope } from '@effect/core/io/Scope'
 import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
-import { Env } from '@tsplus/stdlib/service/Env'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { asap } from './_internal.js'
-import { Multicast } from './multicast.js'
+import { Emitter, Fx } from './Fx.js'
+import { Multicast, MulticastObserver } from './multicast.js'
 
-export function hold<R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> {
+export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
   return new Hold(fx)
 }
 
-export class Hold<R, E, E1, A> extends Multicast<R, E, A, E1> {
+export class Hold<R, E, A> extends Multicast<R, E, A> {
   protected _value: Maybe.Maybe<A> = Maybe.none
-  protected _pendingSinks: Array<readonly [Sink<E, A, any, any, any>, A[]]> = []
+  protected _pendingEmitters: Array<readonly [Emitter<unknown, E, A>, A[]]> = []
   protected _scheduledFiber: Fiber.RealFiber<any, any> | undefined
 
-  constructor(readonly fx: Fx<R, E, A, E1>) {
+  constructor(readonly fx: Fx<R, E, A>) {
     super(fx)
   }
 
-  run<R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> {
+  readonly get = Effect.sync(() => this._value)
+
+  run<R2>(emitter: Emitter<R2, E, A>): Effect.Effect<R | R2 | Scope, never, unknown> {
     if (this.shouldScheduleFlush()) {
       return pipe(
-        this.scheduleFush(sink),
-        Effect.flatMap(() => super.run(sink)),
+        this.scheduleFlush(emitter),
+        Effect.flatMap(() => super.run(emitter)),
       )
     }
 
-    return super.run(sink)
+    return super.run(emitter)
   }
 
-  event(value: A) {
-    this.addValue(value)
+  emit(value: A) {
+    return Effect.suspendSucceed(() => {
+      this.addValue(value)
 
-    return pipe(
-      this.flushPending(),
-      Effect.flatMap(() => super.event(value)),
-    )
+      return pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.emit(value)),
+      )
+    })
   }
 
-  error(cause: Cause<E>) {
-    return pipe(
-      this.flushPending(),
-      Effect.flatMap(() => super.error(cause)),
+  failCause(cause: Cause<E>) {
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.failCause(cause)),
+      ),
     )
   }
 
   get end() {
-    return pipe(
-      this.flushPending(),
-      Effect.flatMap(() => super.end),
+    return Effect.suspendSucceed(() =>
+      pipe(
+        this.flushPending(),
+        Effect.flatMap(() => super.end),
+      ),
     )
   }
 
   protected shouldScheduleFlush() {
-    return Maybe.isSome(this._value) && this.sinks.length > 0
+    return Maybe.isSome(this._value) && this.observers.length > 0
   }
 
-  protected scheduleFush(sink: Sink<E, A, any, any, any>) {
-    this._pendingSinks.push([
-      sink,
+  protected scheduleFlush<R>(observer: Emitter<R, E, A>) {
+    this._pendingEmitters.push([
+      observer,
       pipe(
         this._value,
         Maybe.fold(
@@ -84,8 +90,8 @@ export class Hold<R, E, E1, A> extends Multicast<R, E, A, E1> {
     return pipe(
       interrupt,
       Effect.flatMap(() => this.flushPending()),
-      Effect.schedule(asap),
-      Effect.fork,
+      Effect.delay(Duration.millis(0)),
+      Effect.forkScoped,
       Effect.tap((fiber: Fiber.RealFiber<any, any>) =>
         Effect.sync(() => (this._scheduledFiber = fiber)),
       ),
@@ -93,17 +99,17 @@ export class Hold<R, E, E1, A> extends Multicast<R, E, A, E1> {
   }
 
   protected flushPending() {
-    if (this._pendingSinks.length === 0) {
+    if (this._pendingEmitters.length === 0) {
       return Effect.unit
     }
 
-    const pendingSinks = this._pendingSinks
-    this._pendingSinks = []
+    const pendingEmitters = this._pendingEmitters
+    this._pendingEmitters = []
 
-    return Effect.forEachDiscard(pendingSinks, (pending) =>
+    return Effect.forEachDiscard(pendingEmitters, (pending) =>
       Effect.suspendSucceed(() => {
-        const [sink, values] = pending
-        const observer = this.findSink(sink)
+        const [emitter, values] = pending
+        const observer = this.findObserver(emitter)
 
         if (!observer) {
           return Effect.unit
@@ -117,14 +123,12 @@ export class Hold<R, E, E1, A> extends Multicast<R, E, A, E1> {
   protected addValue(value: A) {
     this._value = Maybe.some(value)
 
-    this._pendingSinks.forEach(([, values]) => {
+    this._pendingEmitters.forEach(([, values]) => {
       values.push(value)
     })
   }
 
-  protected findSink(
-    sink: Sink<E, A, any, any, any>,
-  ): readonly [Sink<E, A, any, any, any>, Env<any>, Deferred<any, any>] | undefined {
-    return this.sinks.find(([s]) => s === sink)
+  protected findObserver(emitter: Emitter<unknown, E, A>): MulticastObserver<E, A> | undefined {
+    return this.observers.find((o) => o.emitter === emitter)
   }
 }

package/src/index.ts

@@ -2,36 +2,40 @@ export * from './combine.js'
 export * from './continueWith.js'
 export * from './debounce.js'
 export * from './delay.js'
-export * from './drain.js'
 export * from './during.js'
-export * from './empty.js'
+export * from './filterLoop.js'
+export * from './filterMap.js'
 export * from './flatMap.js'
 export * from './flatMapConcurrently.js'
-export * from './from.js'
-export * from './fromCallback.js'
 export * from './fromEffect.js'
+export * from './fromIterable.js'
+export * from './Fx.js'
 export * from './hold.js'
-export * from './loop.js'
-export * from './map.js'
+export * from './mapCause.js'
+export * from './mapEffect.js'
 export * from './merge.js'
-export * from './never.js'
-export * from './observe.js'
+export * from './multicast.js'
 export * from './orElse.js'
 export * from './periodic.js'
 export * from './provide.js'
-export * from './reduce.js'
+export * from './runCollect.js'
+export * from './runDrain.js'
+export * from './runObserve.js'
+export * from './runReduce.js'
 export * from './scheduled.js'
 export * from './since.js'
-export * as Sink from './Sink.js'
 export * from './skipRepeats.js'
+export * from './skipWhile.js'
 export * from './slice.js'
 export * from './snapshot.js'
-export * from './Fx.js'
+export * from './Subject.js'
 export * from './suspendSucceed.js'
 export * from './switchMap.js'
-export * from './tap.js'
+export * from './takeWhile.js'
+export * from './tapEffect.js'
 export * from './throttle.js'
-export * from './TSemaphore.js'
-export * from './until.js'
 export * from './transform.js'
-export * from './zipItems.js'
+export * from './until.js'
+export * from './withEmitter.js'
+export * from './zip.js'
+export * from './zipIterable.js'

package/src/mapCause.test.ts

@@ -0,0 +1,34 @@
+import { deepEqual } from 'assert'
+
+import * as Cause from '@effect/core/io/Cause'
+import * as Effect from '@effect/core/io/Effect'
+import * as Exit from '@effect/core/io/Exit'
+import { pipe } from '@fp-ts/data/Function'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.mapCause.name, () => {
+    it('maps the cause', async () => {
+      const value = Math.random()
+      const cause = Cause.fail(value)
+      const test = pipe(Fx.failCause(cause), Fx.mapCause(Cause.map((x) => x + 1)), Fx.runDrain)
+
+      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
+    })
+  })
+
+  describe(Fx.mapError.name, () => {
+    it('maps the error', async () => {
+      const value = Math.random()
+      const cause = Cause.fail(value)
+      const test = pipe(
+        Fx.failCause(cause),
+        Fx.mapError((x) => x + 1),
+        Fx.runDrain,
+      )
+
+      deepEqual(await Effect.unsafeRunPromiseExit(test), Exit.fail(value + 1))
+    })
+  })
+})

package/src/mapCause.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/core/io/Cause'
+import { flow } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function mapCause<E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, f)
+}
+
+export function mapError<E, E2>(f: (error: E) => E2) {
+  return <R, A>(fx: Fx<R, E, A>): Fx<R, E2, A> => mapCause_(fx, Cause.map(f))
+}
+
+function mapCause_<R, E, A, E2>(fx: Fx<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>) {
+  return Fx((emitter) => fx.run(Emitter(emitter.emit, flow(f, emitter.failCause), emitter.end)))
+}

package/src/mapEffect.test.ts

@@ -0,0 +1,21 @@
+import { deepEqual } 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.mapEffect.name, () => {
+    it('applies an Effect to the output value of a Fx', async () => {
+      const value = Math.random()
+      const test = pipe(
+        Fx.succeed(value),
+        Fx.mapEffect((a) => Effect.succeed(a + 1)),
+        Fx.runCollect,
+      )
+
+      deepEqual(await Effect.unsafeRunPromise(test), [value + 1])
+    })
+  })
+})

package/src/mapEffect.ts

@@ -0,0 +1,17 @@
+import * as Effect from '@effect/core/io/Effect'
+import { flow } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+
+export const mapEffect =
+  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) =>
+  <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    Fx((emitter) =>
+      fx.run(
+        Emitter(
+          flow(f, Effect.foldCauseEffect(emitter.failCause, emitter.emit)),
+          emitter.failCause,
+          emitter.end,
+        ),
+      ),
+    )

package/src/merge.test.ts

@@ -1,41 +1,21 @@
 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 * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { delay } from './delay.js'
-import { flatMap } from './flatMap.js'
-import { from } from './from.js'
-import { merge } from './merge.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
-  describe('merge', () => {
-    it('merges 2 fx together', async () => {
-      const values = [1, 2, 3]
-      const test = pipe(
-        from(values),
-        flatMap((a) =>
-          pipe(from([a, a + 1]), merge(pipe(from([a * a, a ** a]), delay(Duration.millis(10))))),
-        ),
+  describe(Fx.mergeAll.name, () => {
+    it('merges together emits', async () => {
+      const result = await pipe(
+        Fx.mergeAll([Fx.fromIterable([1, 2, 3]), Fx.fromIterable([4, 5, 6])]),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
       )
-      const events = await pipe(test, collectAll, unsafeRunPromise)
 
-      deepStrictEqual(events, [
-        values[0],
-        values[0] + 1,
-        values[1],
-        values[1] + 1,
-        values[2],
-        values[2] + 1,
-        values[0] * values[0],
-        values[1] * values[1],
-        values[2] * values[2],
-        values[0] ** values[0],
-        values[1] ** values[1],
-        values[2] ** values[2],
-      ])
+      deepStrictEqual(result, [1, 2, 3, 4, 5, 6])
     })
   })
 })

package/src/merge.ts

@@ -1,50 +1,29 @@
 import * as Effect from '@effect/core/io/Effect'
-import { flow, pipe } from '@fp-ts/data/Function'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
 
-export function merge<R2, E2, B, E3>(other: Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(self: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
-    mergeAll([self, other])
+export function merge<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> => mergeAll([first, second])
 }
 
-export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any, any>>>(
+export function mergeAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: readonly [...FX],
-): Fx<
-  Fx.ResourcesOf<FX[number]>,
-  Fx.ErrorsOf<FX[number]>,
-  Fx.OutputOf<FX[number]>,
-  Fx.ReturnErrorsOf<FX[number]>
->
+): Fx<Fx.ResourcesOf<FX[number]>, Fx.ErrorsOf<FX[number]>, Fx.OutputOf<FX[number]>>
 
-export function mergeAll<R2, E2, B, E3>(fx: Iterable<Fx<R2, E2, B, E3>>): Fx<R2, E2, B, E3>
+export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A>
 
-export function mergeAll<R2, E2, B, E3>(fx: Iterable<Fx<R2, E2, B, E3>>): Fx<R2, E2, B, E3> {
-  return Fx(<R4, E4, C>(sink: Sink<E2, B, R4, E4, C>) =>
-    Effect.gen(function* ($) {
-      const array = Array.from(fx)
-      const deferred = yield* $(refCountDeferred<E3 | E4, C>(true, array.length))
+export function mergeAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, A> {
+  return Fx((emitter) => {
+    const array = Array.from(iterable)
 
-      yield* $(
+    return withDynamicCountdownLatch(
+      array.length,
+      ({ latch }) =>
         Effect.forEachDiscard(array, (fx) =>
-          Effect.fork(
-            fx.run(
-              Sink(
-                sink.event,
-                flow(sink.error, deferred.error),
-                pipe(
-                  deferred.decrement,
-                  Effect.flatMap(() => deferred.endIfComplete(sink.end)),
-                ),
-              ),
-            ),
-          ),
+          Effect.forkScoped(fx.run(Emitter(emitter.emit, emitter.failCause, latch.countDown))),
         ),
-      )
-
-      return yield* $(deferred.await)
-    }),
-  )
+      emitter.end,
+    )
+  })
 }

package/src/multicast.test.ts

@@ -1,16 +1,10 @@
 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 * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { delay } from './delay.js'
-import { flatMap } from './flatMap.js'
-import { from } from './from.js'
-import { merge } from './merge.js'
-import { multicast } from './multicast.js'
-import { collectAll } from './reduce.js'
-import { suspendSucceed } from './suspendSucceed.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('multicast', () => {
@@ -18,36 +12,36 @@ describe(import.meta.url, () => {
       const values = [1, 2, 3]
       let started = 0
       const test = pipe(
-        suspendSucceed(() => {
+        Fx.suspendSucceed(() => {
           started++
           return pipe(
-            from(values),
-            flatMap((a) =>
+            Fx.fromIterable(values),
+            Fx.flatMap((a) =>
               pipe(
-                from([a, a + 1]),
-                merge(pipe(from([a * a, a ** a]), delay(Duration.millis(50)))),
+                Fx.fromIterable([a, a + 1]),
+                Fx.merge(pipe(Fx.fromIterable([a * a, a ** a]), Fx.delay(Duration.millis(50)))),
               ),
             ),
           )
         }),
-        multicast,
+        Fx.multicast,
       )
-      const events = pipe(test, collectAll, unsafeRunPromise)
-      const events2 = pipe(test, collectAll, unsafeRunPromise)
+      const events = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+      const events2 = pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
 
       deepStrictEqual(await events, [
-        values[0],
-        values[0] + 1,
-        values[1],
-        values[1] + 1,
-        values[2],
-        values[2] + 1,
-        values[0] * values[0],
-        values[1] * values[1],
-        values[2] * values[2],
-        values[0] ** values[0],
-        values[1] ** values[1],
-        values[2] ** values[2],
+        1,
+        1 + 1,
+        2,
+        2 + 1,
+        3,
+        3 + 1,
+        1 * 1,
+        2 * 2,
+        3 * 3,
+        1 ** 1,
+        2 ** 2,
+        3 ** 3,
       ])
 
       deepStrictEqual(await events, await events2)