@typed/fx 1.9.2 → 1.10.1

package/src/flatMap.ts

@@ -1,62 +1,57 @@
 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 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>>>([]))
+  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<Set<Fiber.RuntimeFiber<never, void>>>(new Set()))
 
-        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),
-                        ),
-                      ),
+      yield* $(
+        fx.run(
+          Sink(
+            (a: A) =>
+              Effect.gen(function* ($) {
+                const fiber = runFork(
+                  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.add(fiber)))
 
-                  // 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
 
-                  // 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,
-            ),
+                pipe(
+                  Fiber.join(fiber),
+                  Effect.flatMap(() => Ref.update(ref, (fs) => (fs.delete(fiber), fs))),
+                  Effect.catchAllCause((cause) =>
+                    Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                  ),
+                  // but don't allow this to be blocking
+                  runFork,
+                )
+              }),
+            sink.error,
           ),
-        )
+        ),
+      )
 
-        // 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.length > 0) {
-          yield* $(Fiber.joinAll(fibers))
-        }
-      }),
-    ),
+      if (fibers.size > 0) {
+        yield* $(Fiber.joinAll(fibers))
+      }
+    }),
   )
 }
 

package/src/index.ts

@@ -106,6 +106,15 @@ export const combine: {
   <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, readonly [A, B]>
 } = dualWithTrace(2, (trace) => (fx, other) => internal.combine(fx, other).addTrace(trace))
 
+export const combineAllDiscard: <FX extends readonly internal.Fx<any, any, any>[]>(
+  ...fx: FX
+) => internal.Fx<internal.Fx.ResourcesOf<FX[number]>, internal.Fx.ErrorsOf<FX[number]>, void> =
+  methodWithTrace(
+    (trace) =>
+      (...fx) =>
+        internal.combineAllDiscard(...fx).addTrace(trace),
+  )
+
 export const continueWith: {
   <R2, E2, B>(f: () => Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A | B>
 
@@ -137,6 +146,11 @@ export const continueWithEffect: {
       internal.continueWithEffect(fx, f).addTrace(trace),
 )
 
+export const startWith: {
+  <B>(value: B): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A | B>
+  <R, E, A, B>(fx: Fx<R, E, A>, value: B): Fx<R, E, A | B>
+} = dualWithTrace(2, (trace) => (fx, value) => internal.startWith(fx, value).addTrace(trace))
+
 export const debounce: {
   (duration: Duration): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
   <R, E, A>(fx: Fx<R, E, A>, duration: Duration): Fx<R, E, A>
@@ -542,6 +556,11 @@ export const merge: {
   <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A | B>
 } = dualWithTrace(2, (trace) => (fx, other) => internal.merge(fx, other).addTrace(trace))
 
+export const mergeFirst: {
+  <R2, E2, B>(other: Fx<R2, E2, B>): <R, E, A>(fx: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+  <R, E, A, R2, E2, B>(fx: Fx<R, E, A>, other: Fx<R2, E2, B>): Fx<R | R2, E | E2, A>
+} = dualWithTrace(2, (trace) => (fx, other) => internal.mergeFirst(fx, other).addTrace(trace))
+
 export const multicast: <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A> = methodWithTrace(
   (trace) =>
     <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> =>
@@ -766,6 +785,9 @@ export const take: {
   <R, E, A>(fx: Fx<R, E, A>, n: number): Fx<R, E, A>
 } = dualWithTrace(2, (trace) => (fx, n) => internal.take(fx, n).addTrace(trace))
 
+export const scoped: <R, E, A>(fx: Fx<R, E, A>) => Fx<Exclude<R, Scope.Scope>, E, A> =
+  methodWithTrace((trace) => (fx) => internal.scoped(fx).addTrace(trace))
+
 export const snapshotEffect: {
   <R2, E2, B, R3, E3, A, C>(sampled: Fx<R2, E2, B>, f: (a: A, b: B) => Effect.Effect<R3, E3, C>): <
     R,

package/src/mergeAll.ts

@@ -1,5 +1,7 @@
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect } from './externals.js'
+import { Cause, Effect, Option } from './externals.js'
+import { compact } from './filterMap.js'
+import { map } from './map.js'
 
 export function mergeAll<FXS extends ReadonlyArray<Fx<any, any, any>>>(
   ...fxs: FXS
@@ -21,3 +23,10 @@ export function merge<R, E, A, R2, E2, B>(
 ): Fx<R | R2, E | E2, A | B> {
   return mergeAll(self, other)
 }
+
+export function mergeFirst<R, E, A, R2, E2, B>(
+  self: Fx<R, E, A>,
+  other: Fx<R2, E2, B>,
+): Fx<R | R2, E | E2, A> {
+  return compact(mergeAll(map(self, Option.some), map(other, Option.none)))
+}

package/src/scoped.ts

@@ -0,0 +1,6 @@
+import { Fx } from './Fx.js'
+import { Effect, Scope } from './externals.js'
+
+export function scoped<R, E, A>(fx: Fx<R, E, A>): Fx<Exclude<R, Scope.Scope>, E, A> {
+  return Fx((sink) => Effect.scoped(fx.run(sink)))
+}

package/src/snapshotEffect.ts

@@ -1,5 +1,5 @@
 import { Fx, Sink } from './Fx.js'
-import { Effect, Option, Ref } from './externals.js'
+import { Effect, Fiber, Option, Ref } from './externals.js'
 
 export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
   fx: Fx<R, E, A>,
@@ -7,32 +7,32 @@ export function snapshotEffect<R, E, A, R2, E2, B, R3, E3, C>(
   f: (a: A, b: B) => Effect.Effect<R3, E3, C>,
 ): Fx<R | R2 | R3, E | E2 | E3, C> {
   return Fx((sink) =>
-    Effect.scoped(
-      Effect.gen(function* ($) {
-        const current = yield* $(Ref.make(Option.none<B>()))
+    Effect.gen(function* ($) {
+      const current = yield* $(Ref.make(Option.none<B>()))
 
-        yield* $(
-          sampled.run(Sink((b) => Ref.set(current, Option.some(b)), sink.error)),
-          Effect.forkScoped,
-        )
+      const sampledFiber = yield* $(
+        sampled.run(Sink((b) => Ref.set(current, Option.some(b)), sink.error)),
+        Effect.fork,
+      )
 
-        yield* $(
-          fx.run(
-            Sink(
-              (a) =>
-                Effect.gen(function* ($) {
-                  const b = yield* $(Ref.get(current))
+      yield* $(
+        fx.run(
+          Sink(
+            (a) =>
+              Effect.gen(function* ($) {
+                const b = yield* $(Ref.get(current))
 
-                  if (Option.isSome(b)) {
-                    yield* $(Effect.catchAllCause(f(a, b.value), sink.error))
-                  }
-                }),
-              sink.error,
-            ),
+                if (Option.isSome(b)) {
+                  yield* $(Effect.catchAllCause(f(a, b.value), sink.error))
+                }
+              }),
+            sink.error,
           ),
-        )
-      }),
-    ),
+        ),
+      )
+
+      yield* $(Fiber.interrupt(sampledFiber))
+    }),
   )
 }
 

package/src/switchMap.ts

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

package/src/switchMapCause.ts

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

package/src/switchMatch.ts

@@ -1,7 +1,7 @@
 import { pipe } from '@effect/data/Function'
 
 import { Fx, Sink } from './Fx.js'
-import { Cause, Effect, Either, Fiber, RefS } from './externals.js'
+import { Cause, Effect, Either, Fiber, RefS, Runtime } from './externals.js'
 import { failCause } from './failCause.js'
 import { fromEffect } from './fromEffect.js'
 
@@ -10,50 +10,49 @@ export function switchMatchCause<R, E, A, R2, E2, B, R3, E3, C>(
   f: (cause: Cause.Cause<E>) => Fx<R2, E2, B>,
   g: (a: A) => Fx<R3, E3, C>,
 ): Fx<R | R2 | R3, E2 | E3, B | C> {
-  return Fx((sink) =>
-    Effect.scoped(
-      Effect.gen(function* ($) {
-        const ref = yield* $(RefS.make<Fiber.RuntimeFiber<never, void> | null>(null))
-        const reset = RefS.set(ref, null)
+  return Fx(<R4>(sink: Sink<R4, E2 | E3, B | C>) =>
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2 | R3 | R4>()))
+      const ref = yield* $(RefS.make<Fiber.RuntimeFiber<never, void> | null>(null))
+      const reset = RefS.set(ref, null)
 
-        const switchWith = (f: () => Fx<R2 | R3, E2 | E3, B | C>) =>
-          RefS.updateEffect(ref, (currentFiber) =>
-            pipe(
-              currentFiber ? Fiber.interruptFork(currentFiber) : Effect.unit(),
-              Effect.flatMap(() =>
-                pipe(
-                  f().run(
-                    Sink(sink.event, (cause) =>
-                      Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
-                    ),
-                  ),
-                  Effect.zipLeft(reset),
-                  Effect.catchAllCause((cause) =>
+      const switchWith = (f: () => Fx<R2 | R3, E2 | E3, B | C>) =>
+        RefS.updateEffect(ref, (currentFiber) =>
+          pipe(
+            currentFiber ? Fiber.interruptFork(currentFiber) : Effect.unit(),
+            Effect.map(() =>
+              pipe(
+                f().run(
+                  Sink(sink.event, (cause) =>
                     Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
                   ),
-                  Effect.forkScoped,
                 ),
+                Effect.zipLeft(reset),
+                Effect.catchAllCause((cause) =>
+                  Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                ),
+                runFork,
               ),
             ),
-          )
-
-        yield* $(
-          fx.run(
-            Sink(
-              (a) => switchWith(() => g(a)),
-              (cause) => switchWith(() => f(cause)),
-            ),
           ),
         )
 
-        // Wait for the last fiber to finish
-        const fiber = yield* $(RefS.get(ref))
+      yield* $(
+        fx.run(
+          Sink(
+            (a) => switchWith(() => g(a)),
+            (cause) => switchWith(() => f(cause)),
+          ),
+        ),
+      )
+
+      // Wait for the last fiber to finish
+      const fiber = yield* $(RefS.get(ref))
 
-        if (fiber) {
-          yield* $(Fiber.join(fiber))
-        }
-      }),
-    ),
+      if (fiber) {
+        yield* $(Fiber.join(fiber))
+      }
+    }),
   )
 }
 

package/src/throttle.ts

@@ -1,40 +1,39 @@
 import { pipe } from '@effect/data/Function'
 
 import { Fx, Sink } from './Fx.js'
-import type { Duration } from './externals.js'
-import { Effect, Fiber, Ref } from './externals.js'
+import { Duration, Runtime, Effect, Fiber, Ref } from './externals.js'
 
 export function throttle<R, E, A>(fx: Fx<R, E, A>, duration: Duration.Duration): Fx<R, E, A> {
-  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)
-
-        const throttleEvent = (a: A) =>
-          Effect.gen(function* ($) {
-            const currentFiber = yield* $(Ref.get(ref))
-
-            if (currentFiber) {
-              return
-            }
-
-            const fiber = yield* $(
-              pipe(sink.event(a), Effect.zipLeft(Effect.delay(reset, duration)), Effect.forkScoped),
-            )
-
-            yield* $(Ref.set(ref, fiber))
-          })
-
-        yield* $(fx.run(Sink(throttleEvent, sink.error)))
-
-        // Wait for the last fiber to finish
-        const fiber = yield* $(Ref.get(ref))
-
-        if (fiber) {
-          yield* $(Fiber.join(fiber))
-        }
-      }),
-    ),
+  return Fx(<R2>(sink: Sink<R2, E, A>) =>
+    Effect.gen(function* ($) {
+      const runFork = Runtime.runFork(yield* $(Effect.runtime<R | R2>()))
+      const ref = yield* $(Ref.make<Fiber.RuntimeFiber<never, void> | void>(void 0))
+      const reset = Ref.set(ref, void 0)
+
+      const throttleEvent = (a: A) =>
+        Effect.gen(function* ($) {
+          const currentFiber = yield* $(Ref.get(ref))
+
+          if (currentFiber) {
+            return
+          }
+
+          yield* $(
+            Ref.set(
+              ref,
+              pipe(sink.event(a), Effect.zipLeft(Effect.delay(reset, duration)), runFork),
+            ),
+          )
+        })
+
+      yield* $(fx.run(Sink(throttleEvent, sink.error)))
+
+      // Wait for the last fiber to finish
+      const fiber = yield* $(Ref.get(ref))
+
+      if (fiber) {
+        yield* $(Fiber.join(fiber))
+      }
+    }),
   )
 }