@typed/fx 1.6.2 → 1.8.0

package/src/exhaustMapLatestCause.ts

@@ -0,0 +1,111 @@
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import type { Scope } from '@effect/io/Scope'
+
+import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { failCause } from './failCause.js'
+import { fromEffect } from './fromEffect.js'
+
+export function exhaustMapLatestCause<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(<R3>(sink: Sink<R3, E2, A | B>) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+        const nextValue = yield* $(Ref.make<Option.Option<Cause.Cause<E>>>(Option.none()))
+        const reset = Ref.set(ref, void 0)
+
+        // Wait for the current fiber to finish
+        const awaitNext = Effect.gen(function* ($) {
+          // Wait for the last fiber to finish
+          const fiber = yield* $(Ref.get(ref))
+
+          if (fiber) {
+            // Wait for the fiber to end to check to see if we need to run another
+            yield* $(Fiber.join(fiber))
+          }
+        })
+
+        // Run the next value that's be saved for replay if it exists
+        const runNext: Effect.Effect<R2 | R3 | Scope, never, void> = Effect.gen(function* ($) {
+          const next = yield* $(Ref.get(nextValue))
+
+          if (Option.isSome(next)) {
+            // Clear the next A to be replayed
+            yield* $(Ref.set(nextValue, Option.none()))
+
+            // Replay the next A
+            yield* $(exhaustMapLatestError(next.value))
+
+            // Ensure we don't close the scope until the last fiber completes
+            yield* $(awaitNext)
+          }
+        })
+
+        const exhaustMapLatestError = (cause: Cause.Cause<E>) =>
+          Effect.gen(function* ($) {
+            const currentFiber = yield* $(Ref.get(ref))
+
+            // Always allow the current fiber to continue
+            if (currentFiber) {
+              // Track the latest A to be replayed layer
+              return yield* $(Ref.set(nextValue, Option.some(cause)))
+            }
+
+            // Run our Fx with the current value
+            const fiber = yield* $(
+              pipe(
+                f(cause).run(
+                  Sink(sink.event, (cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                  ),
+                ),
+                // Clear the current fiber when finished
+                Effect.zipRight(reset),
+                // See if there's another value to replay
+                Effect.zipRight(runNext),
+                Effect.catchAllCause((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
+                Effect.forkScoped,
+              ),
+            )
+
+            yield* $(Ref.set(ref, fiber))
+          })
+
+        yield* $(fx.run(Sink(sink.event, exhaustMapLatestError)))
+
+        // Wait for the last fiber to finish
+        yield* $(awaitNext)
+      }),
+    ),
+  )
+}
+
+export function exhaustMapLatestCauseEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, A | B> {
+  return exhaustMapLatestCause(fx, (a) => fromEffect(f(a)))
+}
+
+export function exhaustMapLatestError<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (e: E) => Fx<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return exhaustMapLatestCause(fx, (cause) =>
+    pipe(cause, Cause.failureOrCause, Either.match(f, failCause)),
+  )
+}
+
+export function exhaustMapLatestErrorEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (error: E) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E2, A | B> {
+  return exhaustMapLatestError(fx, (a) => fromEffect(f(a)))
+}

package/src/{internal/externals.ts → externals.ts}

@@ -1,17 +1,18 @@
 export * as Chunk from '@effect/data/Chunk'
 export * as Context from '@effect/data/Context'
-export * as Debug from '@effect/data/Debug'
 export * as Duration from '@effect/data/Duration'
 export * as Either from '@effect/data/Either'
-export * from '@effect/data/Function'
+export * as MutableRef from '@effect/data/MutableRef'
 export * as Option from '@effect/data/Option'
 export * as Cause from '@effect/io/Cause'
 export * as Deferred from '@effect/io/Deferred'
 export * as Effect from '@effect/io/Effect'
 export * as Exit from '@effect/io/Exit'
 export * as Fiber from '@effect/io/Fiber'
-export * as Random from '@effect/io/Random'
+export * as FiberId from '@effect/io/Fiber/Id'
+export * as Layer from '@effect/io/Layer'
 export * as Ref from '@effect/io/Ref'
-export * as Synchronized from '@effect/io/Ref/Synchronized'
+export * as RefS from '@effect/io/Ref/Synchronized'
+export * as Runtime from '@effect/io/Runtime'
 export * as Schedule from '@effect/io/Schedule'
 export * as Scope from '@effect/io/Scope'

package/src/failCause.test.ts

@@ -0,0 +1,20 @@
+import { describe } from 'vitest'
+
+import { Cause, FiberId } from './externals.js'
+import { failCause } from './failCause.js'
+import { testCause } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(failCause.name, () => {
+    for (const cause of [
+      Cause.fail(1),
+      Cause.die(1),
+      Cause.empty,
+      Cause.interrupt(FiberId.make(0, 0)),
+      Cause.sequential(Cause.interrupt(FiberId.make(0, 0)), Cause.fail(2)),
+      Cause.parallel(Cause.interrupt(FiberId.make(0, 0)), Cause.fail(2)),
+    ]) {
+      testCause('fails with the given Cause', failCause(cause), cause)
+    }
+  })
+})

package/src/failCause.ts

@@ -0,0 +1,16 @@
+import * as Cause from '@effect/io/Cause'
+import type { FiberId } from '@effect/io/Fiber/Id'
+
+import { Fx } from './Fx.js'
+
+export function failCause<E>(cause: Cause.Cause<E>): Fx<never, E, never> {
+  return Fx((sink) => sink.error(cause))
+}
+
+export function fail<E>(error: E): Fx<never, E, never> {
+  return failCause(Cause.fail(error))
+}
+
+export function interrupt(id: FiberId): Fx<never, never, never> {
+  return Fx((sink) => sink.error(Cause.interrupt(id)))
+}

package/src/filter.ts

@@ -0,0 +1,25 @@
+import type { Predicate, Refinement } from '@effect/data/Predicate'
+import { not } from '@effect/data/Predicate'
+
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function filter<R, E, A, B extends A>(
+  fx: Fx<R, E, A>,
+  refinement: Refinement<A, B>,
+): Fx<R, E, B>
+export function filter<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
+export function filter<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return Fx((sink) =>
+    fx.run(Sink((a) => (predicate(a) ? sink.event(a) : Effect.unit()), sink.error)),
+  )
+}
+
+export function remove<R, E, A, B extends A>(
+  fx: Fx<R, E, A>,
+  refinement: Refinement<A, B>,
+): Fx<R, E, Exclude<A, B>>
+export function remove<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A>
+export function remove<R, E, A>(fx: Fx<R, E, A>, predicate: Predicate<A>): Fx<R, E, A> {
+  return filter(fx, not(predicate))
+}

package/src/filterMap.ts

@@ -0,0 +1,10 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect, Option } from './externals.js'
+
+export function filterMap<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => Option.Option<B>): Fx<R, E, B> {
+  return Fx((sink) => fx.run(Sink((a) => Option.match(f(a), Effect.unit, sink.event), sink.error)))
+}
+
+export function compact<R, E, A>(fx: Fx<R, E, Option.Option<A>>): Fx<R, E, A> {
+  return filterMap(fx, (a) => a)
+}

package/src/flatMap.test.ts

@@ -0,0 +1,19 @@
+import { describe } from 'vitest'
+
+import { delay } from './delay.js'
+import { Duration } from './externals.js'
+import { flatMap } from './flatMap.js'
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(flatMap.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+
+    testCollectAll(
+      'merges multiple streams together, infinite concurrency',
+      flatMap(fromArray(array), (x) => delay(fromArray([x]), Duration.millis(10))),
+      array,
+    )
+  })
+})

package/src/flatMap.ts

@@ -0,0 +1,79 @@
+import { pipe } from '@effect/data/Function'
+
+import { Cause, Effect, Fiber, Ref } from './externals.js'
+
+import { Fx, Sink } from './Fx.js'
+import { fromEffect } from './fromEffect.js'
+
+export function flatMap<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return Fx((sink) =>
+    Effect.scoped(
+      Effect.gen(function* ($) {
+        const ref = yield* $(Ref.make<ReadonlyArray<Fiber.RuntimeFiber<never, void>>>([]))
+
+        yield* $(
+          fx.run(
+            Sink(
+              (a: A) =>
+                Effect.gen(function* ($) {
+                  const fiber = yield* $(
+                    Effect.forkScoped(
+                      f(a).run(
+                        Sink(sink.event, (cause) =>
+                          Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                        ),
+                      ),
+                    ),
+                  )
+
+                  // Add Fiber to fibers
+                  yield* $(Ref.update(ref, (fs) => [...fs, fiber]))
+
+                  // When the fiber ends, we need to remove it from the list of fibers
+                  yield* $(
+                    pipe(
+                      Fiber.join(fiber),
+                      Effect.flatMap(() => Ref.update(ref, (fs) => fs.filter((f) => f !== fiber))),
+                      Effect.catchAllCause((cause) =>
+                        Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                      ),
+                      // but don't allow this to be blocking
+                      Effect.forkScoped,
+                    ),
+                  )
+                }),
+              sink.error,
+            ),
+          ),
+        )
+
+        // Wait for the last fibers to finish
+        const fibers = yield* $(Ref.get(ref))
+
+        if (fibers.length > 0) {
+          yield* $(Fiber.joinAll(fibers))
+        }
+      }),
+    ),
+  )
+}
+
+export function flatMapEffect<R, E, A, R2, E2, B>(
+  fx: Fx<R, E, A>,
+  f: (a: A) => Effect.Effect<R2, E2, B>,
+): Fx<R | R2, E | E2, B> {
+  return flatMap(fx, (a) => fromEffect(f(a)))
+}
+
+export function flatten<R, E, R2, E2, B>(fx: Fx<R, E, Fx<R2, E2, B>>): Fx<R | R2, E | E2, B> {
+  return flatMap(fx, (a) => a)
+}
+
+export function flattenEffect<R, E, R2, E2, B>(
+  fx: Fx<R, E, Effect.Effect<R2, E2, B>>,
+): Fx<R | R2, E | E2, B> {
+  return flatMapEffect(fx, (a) => a)
+}

package/src/fromArray.test.ts

@@ -0,0 +1,11 @@
+import { describe } from 'vitest'
+
+import { fromArray } from './fromArray.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(fromArray.name, () => {
+    const array = [Math.random(), Math.random(), Math.random()]
+    testCollectAll('returns each the array', fromArray(array), array)
+  })
+})

package/src/fromArray.ts

@@ -0,0 +1,20 @@
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function fromArray<A>(array: ReadonlyArray<A>): Fx<never, never, A> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      if (array.length === 0) {
+        return Effect.unit()
+      }
+
+      let eff = sink.event(array[0])
+
+      for (let i = 1; i < array.length; i++) {
+        eff = Effect.flatMap(eff, () => sink.event(array[i]))
+      }
+
+      return eff
+    }),
+  )
+}

package/src/fromEffect.test.ts

@@ -0,0 +1,15 @@
+import { describe } from 'vitest'
+
+import { Cause, Effect } from './externals.js'
+import { fromEffect } from './fromEffect.js'
+import { testCause, testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(fromEffect.name, (): void => {
+    const value = Math.random()
+
+    testCollectAll('returns the output', fromEffect(Effect.succeed(value)), [value])
+
+    testCause('fails with the given Cause', fromEffect(Effect.fail(value)), Cause.fail(value))
+  })
+})

package/src/fromEffect.ts

@@ -0,0 +1,7 @@
+import { Effect } from './externals.js'
+
+import { Fx } from './Fx.js'
+
+export function fromEffect<R, E, A>(effect: Effect.Effect<R, E, A>): Fx<R, E, A> {
+  return Fx((sink) => Effect.matchCauseEffect(effect, sink.error, sink.event))
+}

package/src/fromEmitter.test.ts

@@ -0,0 +1,32 @@
+import { describe } from 'vitest'
+
+import { Cause, Effect } from './externals.js'
+import { fromEmitter } from './fromEmitter.js'
+import { testCause, testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(fromEmitter.name, () => {
+    testCollectAll(
+      'returns each value emitted',
+      fromEmitter((emitter) =>
+        Effect.sync(() => {
+          emitter.event(1)
+          emitter.event(2)
+          emitter.event(3)
+          emitter.end()
+        }),
+      ),
+      [1, 2, 3],
+    )
+
+    testCause(
+      'fails with the given Cause',
+      fromEmitter((emitter) =>
+        Effect.sync(() => {
+          emitter.error(Cause.fail(1))
+        }),
+      ),
+      Cause.fail(1),
+    )
+  })
+})

package/src/fromEmitter.ts

@@ -0,0 +1,50 @@
+import { methodWithTrace } from '@effect/data/Debug'
+import type { Scope } from '@effect/io/Scope'
+
+import type { Sink } from './Fx.js'
+import { Fx } from './Fx.js'
+import type { Cause } from './externals.js'
+import { Deferred, Effect, Runtime } from './externals.js'
+
+export function fromEmitter<E, A, R, E2>(
+  f: (emitter: Emitter<E, A>) => Effect.Effect<R | Scope, E2, void>,
+): Fx<Exclude<R, Scope>, E | E2, A> {
+  return Fx(
+    <R2>(sink: Sink<R2, E | E2, A>): Effect.Effect<Exclude<R, Scope> | R2, never, void> =>
+      Effect.scoped(
+        Effect.gen(function* ($) {
+          // Use to signal this emitter has completed.
+          const deferred = yield* $(Deferred.make<never, void>())
+
+          // Construct an Emitter which uses the current runtime and scope
+          // to run the effects it emits while exposing itself to external APIs
+          // like DOM event listeners and other imperative APIs.
+          const forkIn = Effect.forkIn(yield* $(Effect.scope()))
+          const run = Runtime.runCallback(yield* $(Effect.runtime<R | R2>()))
+          const emitter: Emitter<E, A> = {
+            event: methodWithTrace((trace) => (a) => run(forkIn(sink.event(a)).traced(trace))),
+            error: methodWithTrace(
+              (trace) => (cause) =>
+                run(forkIn(Effect.intoDeferred(sink.error(cause), deferred)).traced(trace)),
+            ),
+            end: methodWithTrace(
+              (trace) => () => run(Deferred.succeed(deferred, undefined).traced(trace)),
+            ),
+          }
+
+          // Run your Effect with this emitter using the same scope as all
+          // of the emitted effects.
+          yield* $(forkIn(Effect.catchAllCause(f(emitter), sink.error)))
+
+          // Wait for this Stream to end before returning
+          return yield* $(Deferred.await(deferred))
+        }),
+      ),
+  )
+}
+
+export interface Emitter<E, A> {
+  readonly event: (a: A) => void
+  readonly error: (cause: Cause.Cause<E>) => void
+  readonly end: () => void
+}

package/src/fromFxEffect.ts

@@ -0,0 +1,8 @@
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function fromFxEffect<R, E, R2, E2, B>(
+  effect: Effect.Effect<R, E, Fx<R2, E2, B>>,
+): Fx<R | R2, E | E2, B> {
+  return Fx((sink) => Effect.matchCauseEffect(effect, sink.error, (fx) => fx.run(sink)))
+}

package/src/fromIterable.test.ts

@@ -0,0 +1,11 @@
+import { describe } from 'vitest'
+
+import { fromIterable } from './fromIterable.js'
+import { testCollectAll } from './test-utils.js'
+
+describe(__filename, () => {
+  describe(fromIterable.name, () => {
+    const set = new Set([Math.random(), Math.random(), Math.random()])
+    testCollectAll('returns each the array', fromIterable(set), Array.from(set))
+  })
+})

package/src/fromIterable.ts

@@ -0,0 +1,26 @@
+import { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+
+export function fromIterable<A>(iterable: Iterable<A>): Fx<never, never, A> {
+  return Fx((sink) =>
+    Effect.suspend(() => {
+      const iterator = iterable[Symbol.iterator]()
+      let result = iterator.next()
+
+      if (result.done) {
+        return Effect.unit()
+      }
+
+      let eff = sink.event(result.value)
+      result = iterator.next()
+
+      while (!result.done) {
+        const value = result.value
+        eff = Effect.flatMap(eff, () => sink.event(value))
+        result = iterator.next()
+      }
+
+      return eff
+    }),
+  )
+}

package/src/gen.ts

@@ -0,0 +1,27 @@
+import type { Fx } from './Fx.js'
+import { Effect } from './externals.js'
+import { fromFxEffect } from './fromFxEffect.js'
+
+export type EffectGenResources<T> = [T] extends [never]
+  ? never
+  : T extends Effect.EffectGen<infer R, any, any>
+  ? R
+  : never
+
+export type EffectGenErrors<T> = [T] extends [never]
+  ? never
+  : T extends Effect.EffectGen<any, infer E, any>
+  ? E
+  : never
+
+export type EffectGenOutput<T> = [T] extends [never]
+  ? never
+  : T extends Effect.EffectGen<any, any, infer A>
+  ? A
+  : never
+
+export function gen<Y extends Effect.EffectGen<any, any, any>, R, E, A>(
+  f: (adapter: Effect.Adapter) => Generator<Y, Fx<R, E, A>>,
+): Fx<R | EffectGenResources<Y>, E | EffectGenErrors<Y>, A> {
+  return fromFxEffect(Effect.gen(f)) as Fx<R | EffectGenResources<Y>, E | EffectGenErrors<Y>, A>
+}

package/src/hold.test.ts

@@ -0,0 +1,37 @@
+import { millis } from '@effect/data/Duration'
+import { range } from '@effect/data/ReadonlyArray'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import { describe, it, expect } from 'vitest'
+
+import { at } from './at.js'
+import { Chunk } from './externals.js'
+import { hold } from './hold.js'
+import { mergeAll } from './mergeAll.js'
+import { toChunk } from './toChunk.js'
+
+describe(__filename, () => {
+  describe(hold.name, () => {
+    it('allows replaying latest events to late subscribers', async () => {
+      const test = Effect.gen(function* ($) {
+        const stream = hold(mergeAll(...range(0, 5).map((n) => at(n + 1, millis(n * 100)))))
+
+        const fiber1 = yield* $(Effect.fork(toChunk(stream)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber2 = yield* $(Effect.fork(toChunk(stream)))
+
+        yield* $(Effect.sleep(millis(75)))
+
+        const fiber3 = yield* $(Effect.fork(toChunk(stream)))
+
+        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber1)))).toEqual([1, 2, 3, 4, 5, 6])
+        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber2)))).toEqual([1, 2, 3, 4, 5, 6])
+        expect(Chunk.toReadonlyArray(yield* $(Fiber.join(fiber3)))).toEqual([2, 3, 4, 5, 6])
+      })
+
+      await Effect.runPromise(Effect.scoped(test))
+    })
+  })
+})

package/src/hold.ts

@@ -0,0 +1,40 @@
+import type { Trace } from '@effect/data/Debug'
+
+import type { Fx, Sink } from './Fx.js'
+import { Traced } from './Fx.js'
+import { Effect, MutableRef, Option } from './externals.js'
+import { MulticastFx } from './multicast.js'
+
+export function hold<R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> {
+  return new HoldFx(fx)
+}
+
+export class HoldFx<R, E, A> extends MulticastFx<R, E, A> {
+  protected current = MutableRef.make(Option.none<A>())
+
+  constructor(public fx: Fx<R, E, A>) {
+    super(fx)
+  }
+
+  run<R2>(sink: Sink<R2, E, A>) {
+    const current = MutableRef.get(this.current)
+
+    if (Option.isSome(current)) {
+      return Effect.flatMap(sink.event(current.value), () => super.run(sink))
+    }
+
+    return super.run(sink)
+  }
+
+  readonly traced = (trace: Trace): Fx<R, E, A> => {
+    return hold(Traced<R, E, A>(this.fx, trace))
+  }
+
+  event(a: A) {
+    return Effect.suspend(() => {
+      MutableRef.set(this.current, Option.some(a))
+
+      return super.event(a)
+    })
+  }
+}