@typed/fx 0.0.8 → 0.0.10

package/src/skipWhile.test.ts

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

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

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

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

@@ -0,0 +1,51 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+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)
+    })
+  })
+})

package/src/snapshot.ts

@@ -0,0 +1,58 @@
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import { AtomicReference } from '@tsplus/stdlib/data/AtomicReference'
+import * as Maybe from '@tsplus/stdlib/data/Maybe'
+
+import { Emitter, Fx } from './Fx.js'
+
+export function snapshot<R2, E2, B, A, R3, E3, C>(sampled: Fx<R2, E2, B>, f: (b: B, a: A) => C) {
+  return <R, E>(sampler: Fx<R, E, A>): Fx<R & R2 & R3, E | E2 | E3, C> =>
+    snapshot_(sampler, sampled, f)
+}
+
+export function sample<R2, E2, B>(sampled: Fx<R2, E2, B>) {
+  return <R, E, A>(sampler: Fx<R, E, A>): Fx<R | R2, E | E2, readonly [A, B]> =>
+    pipe(
+      sampler,
+      snapshot(sampled, (b, a) => [a, b]),
+    )
+}
+
+function snapshot_<R, E, A, R2, E2, B, R3, E3, C>(
+  sampler: Fx<R, E, A>,
+  sampled: Fx<R2, E2, B>,
+  f: (b: B, a: A) => C,
+): Fx<R | R2 | R3, E | E2 | E3, C> {
+  return Fx((emitter) =>
+    pipe(
+      Effect.sync(() => new AtomicReference<Maybe.Maybe<B>>(Maybe.none)),
+      Effect.tap((ref) =>
+        Effect.forkScoped(
+          sampled.run(
+            Emitter(
+              (a) => Effect.sync(() => ref.set(Maybe.some(a))),
+              emitter.failCause,
+              Effect.unit,
+            ),
+          ),
+        ),
+      ),
+      Effect.flatMap((ref) =>
+        sampler.run(
+          Emitter(
+            (a) =>
+              pipe(
+                ref.get,
+                Maybe.fold(
+                  () => Effect.unit,
+                  (b) => emitter.emit(f(b, a)),
+                ),
+              ),
+            emitter.failCause,
+            emitter.end,
+          ),
+        ),
+      ),
+    ),
+  )
+}

package/src/suspendSucceed.ts

@@ -0,0 +1,5 @@
+import { Fx } from './Fx.js'
+
+export function suspendSucceed<R, E, A>(f: () => Fx<R, E, A>): Fx<R, E, A> {
+  return Fx((emitter) => f().run(emitter))
+}

package/src/switchMap.test.ts

@@ -0,0 +1,35 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/core/io/Effect'
+import { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import * as Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.switchMap.name, () => {
+    it('allows chaining multiple synchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.switchMap((n) => Fx.fromIterable([n, n, n])),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [1, 1, 1, 2, 2, 2, 3, 3, 3])
+    })
+
+    it('allows chaining multiple asynchronous streams', async () => {
+      const result = await pipe(
+        Fx.fromIterable([1, 2, 3]),
+        Fx.switchMap((n) => Fx.delay(Duration.millis(10))(Fx.fromIterable([n, n, n]))),
+        Fx.runCollect,
+
+        Effect.unsafeRunPromise,
+      )
+
+      deepStrictEqual(result, [3, 3, 3])
+    })
+  })
+})

package/src/switchMap.ts

@@ -0,0 +1,46 @@
+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 { pipe } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
+
+export function switchMap<A, R2, E2, B>(f: (a: A) => Fx<R2, E2, B>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, B> =>
+    Fx(<R3>(emitter: Emitter<R3, E | E2, B>) =>
+      pipe(
+        Ref.makeSynchronized<Fiber.Fiber<never, unknown> | null>(() => null),
+        Effect.flatMap((ref) =>
+          withDynamicCountdownLatch(
+            1,
+            ({ increment, latch }) =>
+              fx.run(
+                Emitter(
+                  (a) =>
+                    ref.updateEffect((fiber) =>
+                      pipe(
+                        fiber ? Fiber.interrupt(fiber) : increment,
+                        Effect.flatMap(() =>
+                          Effect.forkScoped(
+                            f(a).run(
+                              Emitter(
+                                emitter.emit,
+                                (e) => pipe(ref.set(null), Effect.zipRight(emitter.failCause(e))),
+                                pipe(ref.set(null), Effect.zipRight(latch.countDown)),
+                              ),
+                            ),
+                          ),
+                        ),
+                      ),
+                    ),
+                  emitter.failCause,
+                  latch.countDown,
+                ),
+              ),
+            emitter.end,
+          ),
+        ),
+      ),
+    )
+}

package/src/takeWhile.test.ts

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

package/src/takeWhile.ts

@@ -0,0 +1,28 @@
+import { pipe } from '@fp-ts/data/Function'
+import { Predicate, not } from '@tsplus/stdlib/data/Predicate'
+
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
+
+export function takeWhile<A>(predicate: Predicate<A>) {
+  return <R, E>(fx: Fx<R, E, A>): Fx<R, E, A> => takeWhile_(fx, predicate)
+}
+
+export function takeUntil<A>(predicate: Predicate<A>) {
+  return takeWhile(not(predicate))
+}
+
+function takeWhile_<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx((emitter) =>
+    pipe(
+      fx.run(
+        Emitter(
+          (a) => (predicate(a) ? emitter.emit(a) : exitEarly),
+          emitter.failCause,
+          emitter.end,
+        ),
+      ),
+      onEarlyExitFailure(emitter.end),
+    ),
+  )
+}

package/src/tapEffect.ts

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

package/src/throttle.test.ts

@@ -0,0 +1,17 @@
+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.throttle.name, () => {
+    it('favors the first overlapping event', async () => {
+      const test = pipe(Fx.fromIterable([1, 2, 3]), Fx.throttle(millis(100)), Fx.runCollect)
+
+      deepStrictEqual(await Effect.unsafeRunPromise(test), [1])
+    })
+  })
+})

package/src/throttle.ts

@@ -0,0 +1,53 @@
+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 { pipe } from '@fp-ts/data/Function'
+import * as Duration from '@tsplus/stdlib/data/Duration'
+
+import { Emitter, Fx } from './Fx.js'
+import { withDynamicCountdownLatch } from './_internal.js'
+
+export function throttle(duration: Duration.Duration) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => throttle_(fx, duration)
+}
+
+function throttle_<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(
+              Emitter(
+                (a) =>
+                  ref.updateEffect((previous) =>
+                    previous
+                      ? Effect.succeed(previous)
+                      : pipe(
+                          increment,
+                          Effect.flatMap(() =>
+                            pipe(
+                              emitter.emit(a),
+                              Effect.delay(duration),
+                              Effect.interruptible,
+                              Effect.tap(() =>
+                                pipe(ref.set(null), Effect.zipRight(latch.countDown)),
+                              ),
+                              Effect.uninterruptible,
+                              Effect.fork,
+                            ),
+                          ),
+                        ),
+                  ),
+                emitter.failCause,
+                latch.countDown,
+              ),
+            ),
+          emitter.end,
+        ),
+      ),
+    ),
+  )
+}

package/src/transform.ts

@@ -0,0 +1,42 @@
+import { Clock } from '@effect/core/io/Clock'
+import * as Effect from '@effect/core/io/Effect'
+import { Exit } from '@effect/core/io/Exit'
+import { RuntimeFlagsPatch } from '@effect/core/io/RuntimeFlags/patch'
+import { Scope } from '@effect/core/io/Scope'
+import * as TSemaphore from '@effect/core/stm/TSemaphore'
+
+import { Fx } from './Fx.js'
+
+export function transform<R2 = never>(
+  f: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E, A>,
+) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E, A> => Fx((emitter) => f(fx.run(emitter)))
+}
+
+export function withParallelism(parallelism: number) {
+  return transform(Effect.withParallelism(parallelism))
+}
+
+export const withParallelismUnbounded = transform(Effect.withParallelismUnbounded)
+
+export const withFinalizer = <R2, X>(finalizer: Effect.Effect<R2, never, X>) =>
+  transform<R2 | Scope>(Effect.withFinalizer(finalizer))
+
+export const withFinalizerExit = <R2, X>(
+  finalizer: <E, A>(exit: Exit<E, A>) => Effect.Effect<R2, never, X>,
+) => transform<R2 | Scope>(Effect.withFinalizerExit(finalizer))
+
+export const withRuntimeFlags = (updated: RuntimeFlagsPatch) =>
+  transform(Effect.withRuntimeFlags(updated))
+
+export const scoped = transform(Effect.scoped)
+
+export const withClock = (clock: Clock) => transform(Effect.withClock(clock))
+
+export const uninterruptible = transform(Effect.uninterruptible)
+export const interruptible = transform(Effect.interruptible)
+
+export const withPermit = (self: TSemaphore.TSemaphore) => transform(TSemaphore.withPermit(self))
+
+export const withPermits = (permits: number) => (self: TSemaphore.TSemaphore) =>
+  transform(TSemaphore.withPermits(permits)(self))

package/src/until.test.ts

@@ -0,0 +1,18 @@
+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.until.name, () => {
+    it('runs a stream until a signal is emitted to stop', async () => {
+      const test = pipe(Fx.periodic(millis(20)), Fx.until(Fx.at(millis(200))(null)), Fx.runCollect)
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events.length, 9)
+    })
+  })
+})

package/src/until.ts

@@ -0,0 +1,27 @@
+import * as Effect from '@effect/core/io/Effect'
+import { joinAll } from '@effect/core/io/Fiber'
+import { pipe } from '@fp-ts/data/Function'
+
+import { Emitter, Fx } from './Fx.js'
+import { exitEarly, onEarlyExitFailure } from './_internal.js'
+
+export function until<R2, E2, B>(signal: Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A> => until_(fx, signal)
+}
+
+function until_<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(
+      signal.run(Emitter(() => exitEarly, emitter.failCause, exitEarly)),
+      Effect.forkScoped,
+      Effect.flatMap((fiber) =>
+        pipe(
+          fx.run(emitter),
+          Effect.forkScoped,
+          Effect.flatMap((fiber2) => joinAll([fiber, fiber2])),
+        ),
+      ),
+      onEarlyExitFailure(emitter.end),
+    ),
+  )
+}

package/src/withEmitter.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 Fx from './index.js'
+
+describe(import.meta.url, () => {
+  describe(Fx.withEmitter.name, () => {
+    it('should allow converting sync callbacks into an Fx', async () => {
+      const test = pipe(
+        Fx.withEmitter((emitter) => {
+          emitter.emit(1)
+          emitter.emit(2)
+          emitter.emit(3)
+          emitter.end()
+
+          return Effect.unit
+        }),
+        Fx.runCollect,
+      )
+
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1, 2, 3])
+    })
+  })
+})