@typed/fx 0.0.9 → 0.0.12

package/src/combine.ts

@@ -1,66 +1,62 @@
 import * as Effect from '@effect/core/io/Effect'
-import * as Ref from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import { pipe } from '@fp-ts/data/Function'
 import * as Maybe from '@tsplus/stdlib/data/Maybe'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred, tupleRef } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
 
-export function combine<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, readonly [A, B], E1 | E3> =>
-    combineAll([self, other])
+export function combine<R2, E2, B>(second: Fx<R2, E2, B>) {
+  return <R, E, A>(first: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
+    combineAll([first, second])
 }
 
-export function combineAll<FX extends ReadonlyArray<Fx<any, any, any, any>>>(
+export function combineAll<FX extends ReadonlyArray<Fx<any, any, any>>>(
   fx: readonly [...FX],
 ): Fx<
   Fx.ResourcesOf<FX[number]>,
   Fx.ErrorsOf<FX[number]>,
-  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> },
-  Fx.ReturnErrorsOf<FX[number]>
+  { readonly [K in keyof FX]: Fx.OutputOf<FX[K]> }
 >
 
-export function combineAll<R2, E2, B, E3>(
-  fx: Iterable<Fx<R2, E2, B, E3>>,
-): Fx<R2, E2, ReadonlyArray<B>, E3>
-
-export function combineAll<R2, E2, B, E3>(
-  fx: Iterable<Fx<R2, E2, B, E3>>,
-): Fx<R2, E2, ReadonlyArray<B>, E3> {
-  return Fx(<R4, E4, C>(sink: Sink<E2, ReadonlyArray<B>, R4, E4, C>) =>
-    Effect.gen(function* ($) {
-      const array = Array.from(fx)
-      const deferred = yield* $(refCountDeferred<E3 | E4, C>(true, array.length))
-      const refs = Array.from(
-        yield* $(Effect.forEach(array, () => Ref.makeRef<Maybe.Maybe<B>>(() => Maybe.none))),
-      )
-      const ref = tupleRef(refs)
-
-      const emitIfReady = pipe(
-        ref.get,
-        Effect.map((as) => as.filter(Maybe.isSome).map((x) => x.value)),
-        Effect.flatMap((bs) => (bs.length === array.length ? sink.event(bs) : Effect.unit)),
-      )
-
-      yield* $(
-        Effect.forEachParWithIndex(array, (fx, i) =>
-          Effect.fork(
-            fx.run(
-              Sink(
-                (a) => pipe(refs[i].set(Maybe.some(a)), Effect.zipRight(emitIfReady)),
-                flow(sink.error, deferred.error),
-                pipe(
-                  deferred.decrement,
-                  Effect.flatMap(() => deferred.endIfComplete(sink.end)),
+export function combineAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>>
+
+export function combineAll<R, E, A>(iterable: Iterable<Fx<R, E, A>>): Fx<R, E, ReadonlyArray<A>> {
+  return Fx((emitter) =>
+    Effect.suspendSucceed(() => {
+      const array = Array.from(iterable)
+
+      return pipe(
+        Effect.sync<Maybe.Maybe<A>[]>(() => Array(array.length)),
+        Effect.flatMap((ref) =>
+          Effect.suspendSucceed(() => {
+            const emitIfReady = pipe(
+              Effect.sync(() => ref.filter(Maybe.isSome).map((x) => x.value)),
+              Effect.flatMap((bs) => (bs.length === array.length ? emitter.emit(bs) : Effect.unit)),
+            )
+
+            return withDynamicCountdownLatch(
+              array.length,
+              ({ latch }) =>
+                Effect.forEachWithIndex(array, (fx, i) =>
+                  Effect.forkScoped(
+                    fx.run(
+                      Emitter(
+                        (a) =>
+                          pipe(
+                            Effect.sync(() => (ref[i] = Maybe.some(a))),
+                            Effect.zipRight(emitIfReady),
+                          ),
+                        emitter.failCause,
+                        latch.countDown,
+                      ),
+                    ),
+                  ),
                 ),
-              ),
-            ),
-          ),
+              emitter.end,
+            )
+          }),
         ),
       )
-
-      return yield* $(deferred.await)
     }),
   )
 }

package/src/continueWith.test.ts

@@ -0,0 +1,26 @@
+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.continueWith.name, () => {
+    it('provides a service to the Fx', async () => {
+      const test = Effect.gen(function* ($) {
+        const result = yield* $(
+          pipe(
+            Fx.fromIterable([1, 2]),
+            Fx.continueWith(() => Fx.fromIterable([3, 4])),
+            Fx.runCollect,
+          ),
+        )
+
+        deepStrictEqual(result, [1, 2, 3, 4])
+      })
+
+      await Effect.unsafeRunPromise(test)
+    })
+  })
+})

package/src/continueWith.ts

@@ -1,23 +1,21 @@
 import * as Effect from '@effect/core/io/Effect'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
+import { Emitter, Fx } from './Fx.js'
 import { succeed } from './fromEffect.js'
 
-export function continueWith<R2, E2, B, E3>(continueWith: () => Fx<R2, E2, B, E3>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2, E | E2, A | B, E1 | E3> =>
-    Fx((sink) =>
+export function continueWith<R2, E2, B>(f: () => Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    Fx((emitter) =>
       fx.run(
-        Sink(
-          sink.event,
-          sink.error,
-          Effect.suspendSucceed(() => continueWith().run(sink)),
+        Emitter(
+          emitter.emit,
+          emitter.failCause,
+          Effect.suspendSucceed(() => f().run(emitter)),
         ),
       ),
     )
 }
 
 export function startWith<B>(value: B) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A | B, E1> =>
-    continueWith(() => fx)(succeed(value))
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B | A> => continueWith(() => fx)(succeed(value))
 }

package/src/debounce.test.ts

@@ -1,19 +1,17 @@
 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 { debounce } from './debounce.js'
-import { from } from './from.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('debounce', () => {
     it('favors the latest overlapping event', async () => {
-      const test = pipe(from([1, 2, 3]), debounce(millis(100)), collectAll)
+      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.debounce(millis(100)), Fx.runCollect)
 
-      deepStrictEqual(await unsafeRunPromise(test), [3])
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [3])
     })
   })
 })

package/src/debounce.ts

@@ -1,68 +1,49 @@
 import * as Effect from '@effect/core/io/Effect'
 import * as Fiber from '@effect/core/io/Fiber'
 import * as Ref from '@effect/core/io/Ref'
-import * as Schedule from '@effect/core/io/Schedule'
-import { flow, pipe } from '@fp-ts/data/Function'
-import { Duration } from '@tsplus/stdlib/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
 
-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 debounce(duration: Duration) {
-  return <R, E, A, E1>(fx: Fx<R, E, A>): Fx<R, E, A, E1> =>
-    Fx(
-      <R2, E2, B>(sink: Sink<E, A, R2, E2, B>): Effect.Effect<R | R2, E1 | E2, B> =>
-        Effect.gen(function* ($) {
-          const ref = yield* $(
-            Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
-          )
-          const deferred = yield* $(refCountDeferred<E1 | E2, B>(true))
+export function debounce(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => debounce_(fx, duration)
+}
 
-          return yield* $(
+function debounce_<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
+      Effect.flatMap((ref) =>
+        withDynamicCountdownLatch(
+          1,
+          ({ increment, latch }) =>
             fx.run(
-              Sink<E, A, R | R2, E1 | E2, B>(
+              Emitter(
                 (a) =>
                   ref.updateEffect((previous) =>
-                    Effect.gen(function* (_) {
-                      if (previous) {
-                        yield* _(Fiber.interrupt(previous))
-                      } else {
-                        yield* $(deferred.increment)
-                      }
-
-                      return yield* _(
+                    pipe(
+                      previous ? Fiber.interrupt(previous) : increment,
+                      Effect.flatMap(() =>
                         pipe(
-                          sink.event(a),
-                          Effect.schedule(Schedule.delayed(() => duration)(Schedule.once)),
+                          emitter.emit(a),
+                          Effect.delay(duration),
                           Effect.interruptible,
-                          Effect.tap(() =>
-                            pipe(
-                              deferred.decrement,
-                              Effect.zipRight(deferred.endIfComplete(sink.end)),
-                            ),
-                          ),
+                          Effect.tap(() => latch.countDown),
                           Effect.uninterruptible,
                           Effect.fork,
                         ),
-                      )
-                    }),
+                      ),
+                    ),
                   ),
-                flow(sink.error, deferred.error, Effect.zipRight(deferred.await)),
-                pipe(sink.end, deferred.endIfComplete, Effect.zipRight(deferred.await)),
+                emitter.failCause,
+                latch.countDown,
               ),
             ),
-          )
-        }),
-    )
-}
-
-/**
- *     pipe(
-        Ref.makeSynchronized<Fiber.Fiber<unknown, unknown> | null>(() => null),
-        Effect.flatMap((ref) =>
-          ,
+          emitter.end,
         ),
-        Effect.scoped,
       ),
- */
+    ),
+  )
+}

package/src/delay.test.ts

@@ -1,20 +1,19 @@
 import { deepStrictEqual, ok } 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 { at } from './delay.js'
-import { collectAll } from './reduce.js'
+import * as Fx from './index.js'
 
 describe(import.meta.url, () => {
   describe('delay', () => {
     it('adds a delay to an event', async () => {
+      const start = performance.now()
       const value = Math.random()
       const delayMs = 100
-      const test = at(Duration.millis(delayMs))(value)
-      const start = performance.now()
-      const events = await pipe(test, collectAll, unsafeRunPromise)
+      const test = Fx.at(Duration.millis(delayMs))(value)
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
       const end = performance.now()
 
       ok(end - start >= delayMs)

package/src/delay.ts

@@ -2,15 +2,16 @@ import * as Effect from '@effect/core/io/Effect'
 import { flow } from '@fp-ts/data/Function'
 import * as Duration from '@tsplus/stdlib/data/Duration'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { fromEffect } from './fromEffect.js'
+import { Emitter, Fx } from './Fx.js'
+import { succeed } from './fromEffect.js'
 
-export function delay(delayDuration: Duration.Duration) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R, E, A, E1> =>
-    Fx((sink) => fx.run(Sink(flow(sink.event, Effect.delay(delayDuration)), sink.error, sink.end)))
+export function delay(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
+    Fx((emitter) =>
+      fx.run(Emitter(flow(emitter.emit, Effect.delay(duration)), emitter.failCause, emitter.end)),
+    )
 }
 
-export function at(delayDuration: Duration.Duration) {
-  return <A>(value: A) => fromEffect(Effect.delay(delayDuration)(Effect.succeed(value)))
+export function at(duration: Duration.Duration) {
+  return flow(succeed, delay(duration))
 }

package/src/during.test.ts

@@ -0,0 +1,39 @@
+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 { 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.during.name, () => {
+    it('runs a stream during 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.during(Fx.at(millis(50))(Fx.at(millis(50))(null))),
+            Fx.runCollect,
+            Effect.fork,
+          ),
+        )
+
+        for (let i = 0; i < 10; 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, [6, 7, 8, 9, 10])
+    })
+  })
+})

package/src/during.ts

@@ -1,58 +1,54 @@
 import * as Effect from '@effect/core/io/Effect'
-import { makeRef } from '@effect/core/io/Ref'
-import { flow, pipe } from '@fp-ts/data/Function'
+import { joinAll } from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
+import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
 
-import { Fx } from './Fx.js'
-import { Sink } from './Sink.js'
-import { refCountDeferred } from './_internal.js'
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
 
-export function during<R2, E2, R3, E3, B, E4, E5>(signal: Fx<R2, E2, Fx<R3, E3, B, E4>, E5>) {
-  return <R, E, A, E1>(fx: Fx<R, E, A, E1>): Fx<R | R2 | R3, E, A, E1 | E2 | E3 | E4 | E5> =>
-    Fx(<R6, E6, C>(sink: Sink<E, A, R6, E6, C>) =>
-      Effect.gen(function* ($) {
-        const ref = yield* $(makeRef(() => false))
-        const deferred = yield* $(refCountDeferred<E1 | E2 | E3 | E4 | E5 | E6, C>(true))
+export function during<R2, E2, R3, E3, B>(signal: Fx<R2, E2, Fx<R3, E3, B>>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E | E2 | E3, A> => during_(fx, signal)
+}
 
-        yield* $(
-          Effect.fork(
-            signal.run(
-              Sink(
-                (endSignal) =>
-                  pipe(
-                    ref.set(true),
-                    Effect.zipRight(
-                      endSignal.run(
-                        Sink(
-                          () => deferred.endIfComplete(sink.end),
-                          flow(Effect.failCause, deferred.error),
-                          deferred.endIfComplete(sink.end),
-                        ),
-                      ),
-                    ),
+function during_<R, E, A, R2, E2, R3, E3, B>(
+  fx: Fx<R, E, A>,
+  signal: Fx<R2, E2, Fx<R3, E3, B>>,
+): Fx<R | R2 | R3, E | E2 | E3, A> {
+  return Fx((emitter) =>
+    pipe(
+      Effect.sync(() => new AtomicReference(false)),
+      Effect.flatMap((ref) =>
+        pipe(
+          signal.run(
+            Emitter(
+              (endSignal) =>
+                pipe(
+                  Effect.sync(() => ref.set(true)),
+                  Effect.flatMap(() =>
+                    endSignal.run(Emitter(() => exitEarly, emitter.failCause, Effect.unit)),
                   ),
-                flow(Effect.failCause, deferred.error),
-                deferred.endIfComplete(sink.end),
-              ),
+                ),
+              emitter.failCause,
+              Effect.unit,
             ),
           ),
-        )
-
-        yield* $(
-          Effect.fork(
-            fx.run(
-              Sink(
-                (a) =>
-                  pipe(
-                    ref.get,
-                    Effect.flatMap((started) => (started ? sink.event(a) : Effect.unit)),
-                  ),
-                flow(sink.error, deferred.error),
-                deferred.endIfComplete(sink.end),
+          Effect.forkScoped,
+          Effect.flatMap((fiber) =>
+            pipe(
+              fx.run(
+                Emitter(
+                  (a) => (ref.get ? emitter.emit(a) : Effect.unit),
+                  emitter.failCause,
+                  exitEarly,
+                ),
               ),
+              Effect.forkScoped,
+              Effect.flatMap((fiber2) => joinAll([fiber, fiber2])),
+              onEarlyExitFailure(emitter.end),
             ),
           ),
-        )
-        return yield* $(deferred.await)
-      }),
-    )
+        ),
+      ),
+    ),
+  )
 }

package/src/filterLoop.test.ts

@@ -0,0 +1,63 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.loop.name, () => {
+    it('tracks state and atomically computing a value', async () => {
+      const values = ['foo', 'bar', 'baz', 'quux']
+      const test = pipe(
+        Fx.fromIterable(values),
+        Fx.loop(1, (a, b) => [a + b.length, a]),
+      )
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+
+      deepStrictEqual(events, [1, 4, 7, 10])
+    })
+  })
+
+  describe(Fx.scan.name, () => {
+    it('emits seed value and tracks applies a reducer to events and accumulator', async () => {
+      const values = ['foo', 'bar', 'baz', 'quux']
+      const test = pipe(
+        Fx.fromIterable(values),
+        Fx.scan(1, (a, b) => a + b.length),
+      )
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+
+      deepStrictEqual(events, [1, 4, 7, 10, 14])
+    })
+  })
+
+  describe(Fx.filterLoop.name, () => {
+    it('tracks state and atomically computing a value, using Maybe for filtering', async () => {
+      const values = ['foo', 'bar', 'baz', 'quux']
+      const test = pipe(
+        Fx.fromIterable(values),
+        Fx.filterLoop(1, (a, b) =>
+          b.startsWith('b') ? Maybe.some([a + b.length, a]) : Maybe.none,
+        ),
+      )
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+
+      deepStrictEqual(events, [1, 4])
+    })
+  })
+
+  describe(Fx.filterScan.name, () => {
+    it('emits seed value and tracks applies a reducer to events and accumulator, using Maybe for filtering', async () => {
+      const values = ['foo', 'bar', 'baz', 'quux']
+      const test = pipe(
+        Fx.fromIterable(values),
+        Fx.filterScan(1, (a, b) => (b.startsWith('b') ? Maybe.some(a + b.length) : Maybe.none)),
+      )
+      const events = await pipe(test, Fx.runCollect, Effect.unsafeRunPromise)
+
+      deepStrictEqual(events, [1, 4, 7])
+    })
+  })
+})