@typed/fx 1.9.2 → 1.10.1

package/src/catchAllCause.ts

@@ -1,7 +1,7 @@
 import { pipe } from '@effect/data/Function'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+import { Cause, Effect, Either, Fiber, Ref, Runtime } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 
@@ -9,55 +9,50 @@ export function catchAllCause<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((sink) =>
-    Effect.scoped(
-      Effect.gen(function* ($) {
-        const ref = yield* $(Ref.make<Set<Fiber.RuntimeFiber<never, void>>>(new Set()))
+  return Fx(<R3>(sink: Sink<R3, E2, A | B>) =>
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3>()))
+      const ref = yield* $(Ref.make<Set<Fiber.RuntimeFiber<never, void>>>(new Set()))
 
-        yield* $(
-          fx.run(
-            Sink(sink.event, (cause: Cause.Cause<E>) =>
-              Effect.gen(function* ($) {
-                const fiber = yield* $(
-                  Effect.forkScoped(
-                    f(cause).run(
-                      Sink(sink.event, (cause) =>
-                        Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                      ),
-                    ),
+      yield* $(
+        fx.run(
+          Sink(sink.event, (cause: Cause.Cause<E>) =>
+            Effect.gen(function* ($) {
+              const fiber = runFork(
+                f(cause).run(
+                  Sink(sink.event, (cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
                   ),
-                )
+                ),
+              )
 
-                // Add Fiber to fibers
-                yield* $(Ref.update(ref, (fs) => fs.add(fiber)))
+              // Add Fiber to fibers
+              yield* $(Ref.update(ref, (fs) => fs.add(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.delete(fiber)
-                        return fs
-                      }),
-                    ),
-                    // but don't allow this to be blocking
-                    Effect.forkScoped,
-                  ),
-                )
-              }),
-            ),
+              // When the fiber ends, we need to remove it from the list of fibers
+              pipe(
+                Fiber.join(fiber),
+                Effect.ensuring(
+                  Ref.update(ref, (fs) => {
+                    fs.delete(fiber)
+                    return fs
+                  }),
+                ),
+                // but don't allow this to be blocking
+                runFork,
+              )
+            }),
           ),
-        )
+        ),
+      )
 
-        // Wait for the last fibers to finish
-        const fibers = yield* $(Ref.get(ref))
+      // Wait for the last fibers to finish
+      const fibers = yield* $(Ref.get(ref))
 
-        if (fibers.size > 0) {
-          yield* $(Fiber.joinAll(fibers))
-        }
-      }),
-    ),
+      if (fibers.size > 0) {
+        yield* $(Fiber.joinAll(fibers))
+      }
+    }),
   )
 }
 

package/src/combineAllDiscard.ts

@@ -0,0 +1,42 @@
+import { Fx, Sink } from './Fx.js'
+import { Effect } from './externals.js'
+import { map } from './map.js'
+import { succeed } from './succeed.js'
+
+export function combineAllDiscard<FX extends ReadonlyArray<Fx<any, any, any>>>(
+  ...fx: FX
+): Fx<Fx.ResourcesOf<FX[number]>, Fx.ErrorsOf<FX[number]>, void> {
+  if (fx.length === 0) {
+    return succeed([]) as any
+  }
+
+  if (fx.length === 1) {
+    return map(fx[0], (x) => [x]) as any
+  }
+
+  return Fx((sink) =>
+    Effect.gen(function* ($) {
+      const length = fx.length
+      const values = new Map<number, any>()
+
+      const emitIfReady = Effect.suspend(() =>
+        values.size === length ? sink.event() : Effect.unit(),
+      )
+
+      yield* $(
+        Effect.forEachParWithIndex(fx, (f, i) =>
+          f.run(
+            Sink(
+              () =>
+                Effect.suspend(() => {
+                  values.set(i, null)
+                  return emitIfReady
+                }),
+              sink.error,
+            ),
+          ),
+        ),
+      )
+    }),
+  )
+}

package/src/data-first.ts

@@ -1,6 +1,7 @@
 export * from './at.js'
 export * from './catchAllCause.js'
 export * from './combineAll.js'
+export * from './combineAllDiscard.js'
 export * from './continueWith.js'
 export * from './debounce.js'
 export * from './delay.js'
@@ -32,6 +33,7 @@ export * from './provide.js'
 export * from './reduce.js'
 export * from './RefSubject.js'
 export * from './scan.js'
+export * from './scoped.js'
 export * from './skipRepeats.js'
 export * from './skipWhile.js'
 export * from './slice.js'

package/src/exhaustMap.ts

@@ -1,55 +1,52 @@
 import { pipe } from '@effect/data/Function'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Fiber, Ref } from './externals.js'
+import { Cause, Effect, Fiber, Ref, Runtime } from './externals.js'
 import { fromEffect } from './fromEffect.js'
 
 export function exhaustMap<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<Fiber.RuntimeFiber<never, void> | void>(void 0))
-        const reset = Ref.set(ref, void 0)
+  return Fx(<R3>(sink: Sink<R3, E | E2, B>) =>
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3>()))
+      const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+      const reset = Ref.set(ref, void 0)
 
-        const exhaustMapEvent = (a: A) =>
-          Effect.gen(function* ($) {
-            const currentFiber = yield* $(Ref.get(ref))
+      const exhaustMapEvent = (a: A) =>
+        Effect.gen(function* ($) {
+          const currentFiber = yield* $(Ref.get(ref))
 
-            if (currentFiber) {
-              return
-            }
+          if (currentFiber) {
+            return
+          }
 
-            const fiber = yield* $(
-              pipe(
-                f(a).run(
-                  Sink(sink.event, (cause) =>
-                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                  ),
-                ),
-                Effect.zipLeft(reset),
-                Effect.catchAllCause((cause) =>
-                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                ),
-                Effect.forkScoped,
+          const fiber = pipe(
+            f(a).run(
+              Sink(sink.event, (cause) =>
+                Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
               ),
-            )
+            ),
+            Effect.zipLeft(reset),
+            Effect.catchAllCause((cause) =>
+              Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+            ),
+            runFork,
+          )
 
-            yield* $(Ref.set(ref, fiber))
-          })
+          yield* $(Ref.set(ref, fiber))
+        })
 
-        yield* $(fx.run(Sink(exhaustMapEvent, sink.error)))
+      yield* $(fx.run(Sink(exhaustMapEvent, sink.error)))
 
-        // Wait for the last fiber to finish
-        const fiber = yield* $(Ref.get(ref))
+      // Wait for the last fiber to finish
+      const fiber = yield* $(Ref.get(ref))
 
-        if (fiber) {
-          yield* $(Fiber.join(fiber))
-        }
-      }),
-    ),
+      if (fiber) {
+        yield* $(Fiber.join(fiber))
+      }
+    }),
   )
 }
 

package/src/exhaustMapCause.ts

@@ -1,7 +1,7 @@
 import { pipe } from '@effect/data/Function'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+import { Cause, Effect, Either, Fiber, Ref, Runtime } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 
@@ -9,48 +9,45 @@ export function exhaustMapCause<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((sink) =>
-    Effect.scoped(
-      Effect.gen(function* ($) {
-        const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
-        const reset = Ref.set(ref, void 0)
+  return Fx(<R3>(sink: Sink<R3, E2, A | B>) =>
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3>()))
+      const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+      const reset = Ref.set(ref, void 0)
 
-        const exhaustMapError = (cause: Cause.Cause<E>) =>
-          Effect.gen(function* ($) {
-            const currentFiber = yield* $(Ref.get(ref))
+      const exhaustMapError = (cause: Cause.Cause<E>) =>
+        Effect.gen(function* ($) {
+          const currentFiber = yield* $(Ref.get(ref))
 
-            if (currentFiber) {
-              return
-            }
+          if (currentFiber) {
+            return
+          }
 
-            const fiber = yield* $(
-              pipe(
-                f(cause).run(
-                  Sink(sink.event, (cause) =>
-                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                  ),
-                ),
-                Effect.zipLeft(reset),
-                Effect.catchAllCause((cause) =>
-                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                ),
-                Effect.forkScoped,
+          const fiber = pipe(
+            f(cause).run(
+              Sink(sink.event, (cause) =>
+                Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
               ),
-            )
+            ),
+            Effect.zipLeft(reset),
+            Effect.catchAllCause((cause) =>
+              Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+            ),
+            runFork,
+          )
 
-            yield* $(Ref.set(ref, fiber))
-          })
+          yield* $(Ref.set(ref, fiber))
+        })
 
-        yield* $(fx.run(Sink(sink.event, exhaustMapError)))
+      yield* $(fx.run(Sink(sink.event, exhaustMapError)))
 
-        // Wait for the last fiber to finish
-        const fiber = yield* $(Ref.get(ref))
+      // Wait for the last fiber to finish
+      const fiber = yield* $(Ref.get(ref))
 
-        if (fiber) {
-          yield* $(Fiber.join(fiber))
-        }
-      }),
-    ),
+      if (fiber) {
+        yield* $(Fiber.join(fiber))
+      }
+    }),
   )
 }
 

package/src/exhaustMapLatest.ts

@@ -1,9 +1,8 @@
 import { pipe } from '@effect/data/Function'
 import * as Option from '@effect/data/Option'
-import type { Scope } from '@effect/io/Scope'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Fiber, Ref } from './externals.js'
+import { Cause, Effect, Fiber, Ref, Runtime } from './externals.js'
 import { fromEffect } from './fromEffect.js'
 
 export function exhaustMapLatest<R, E, A, R2, E2, B>(
@@ -11,77 +10,74 @@ export function exhaustMapLatest<R, E, A, R2, E2, B>(
   f: (a: A) => Fx<R2, E2, B>,
 ): Fx<R | R2, E | E2, B> {
   return Fx(<R3>(sink: Sink<R3, E | E2, 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<A>>(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* $(exhaustMapLatestEvent(next.value))
-
-            // Ensure we don't close the scope until the last fiber completes
-            yield* $(awaitNext)
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3>()))
+      const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+      const nextValue = yield* $(Ref.make<Option.Option<A>>(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, 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* $(exhaustMapLatestEvent(next.value))
+
+          // Ensure we don't close the scope until the last fiber completes
+          yield* $(awaitNext)
+        }
+      })
+
+      const exhaustMapLatestEvent = (a: A) =>
+        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(a)))
           }
-        })
 
-        const exhaustMapLatestEvent = (a: A) =>
-          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(a)))
-            }
-
-            // Run our Fx with the current value
-            const fiber = yield* $(
-              pipe(
-                f(a).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,
+          // Run our Fx with the current value
+          const fiber = pipe(
+            f(a).run(
+              Sink(sink.event, (cause) =>
+                Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
               ),
-            )
-
-            yield* $(Ref.set(ref, fiber))
-          })
+            ),
+            // 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),
+            ),
+            runFork,
+          )
+
+          yield* $(Ref.set(ref, fiber))
+        })
 
-        yield* $(fx.run(Sink(exhaustMapLatestEvent, sink.error)))
+      yield* $(fx.run(Sink(exhaustMapLatestEvent, sink.error)))
 
-        // Wait for the last fiber to finish
-        yield* $(awaitNext)
-      }),
-    ),
+      // Wait for the last fiber to finish
+      yield* $(awaitNext)
+    }),
   )
 }
 

package/src/exhaustMapLatestCause.ts

@@ -1,9 +1,8 @@
 import { pipe } from '@effect/data/Function'
 import * as Option from '@effect/data/Option'
-import type { Scope } from '@effect/io/Scope'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either, Fiber, Ref } from './externals.js'
+import { Cause, Effect, Either, Fiber, Ref, Runtime } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 
@@ -12,77 +11,74 @@ export function exhaustMapLatestCause<R, E, A, R2, E2, B>(
   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)
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3>()))
+      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, 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)))
           }
-        })
 
-        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,
+          // Run our Fx with the current value
+          const fiber = pipe(
+            f(cause).run(
+              Sink(sink.event, (cause) =>
+                Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
               ),
-            )
-
-            yield* $(Ref.set(ref, fiber))
-          })
+            ),
+            // 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),
+            ),
+            runFork,
+          )
+
+          yield* $(Ref.set(ref, fiber))
+        })
 
-        yield* $(fx.run(Sink(sink.event, exhaustMapLatestError)))
+      yield* $(fx.run(Sink(sink.event, exhaustMapLatestError)))
 
-        // Wait for the last fiber to finish
-        yield* $(awaitNext)
-      }),
-    ),
+      // Wait for the last fiber to finish
+      yield* $(awaitNext)
+    }),
   )
 }