@typed/fx 1.5.7 → 1.5.8

package/src/_internal/matchInterruptCause.ts

@@ -0,0 +1,50 @@
+import { dualWithTrace } from '@effect/data/Debug'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+
+export const matchInterruptCause: {
+  <E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
+    onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onInterrupt: () => Effect.Effect<R3, E3, C>,
+    onSuccess: (a: A) => Effect.Effect<R4, E4, D>,
+  ): <R>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R | R2 | R3 | R4, E2 | E3 | E4, B | C | D>
+  <R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
+    effect: Effect.Effect<R, E, A>,
+    onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onInterrupt: () => Effect.Effect<R3, E3, C>,
+    onSuccess: (a: A) => Effect.Effect<R4, E4, D>,
+  ): Effect.Effect<R | R2 | R3 | R4, E2 | E3 | E4, B | C | D>
+} = dualWithTrace(
+  4,
+  (trace) =>
+    <R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
+      effect: Effect.Effect<R, E, A>,
+      onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+      onInterrupt: () => Effect.Effect<R3, E3, C>,
+      onSuccess: (a: A) => Effect.Effect<R4, E4, D>,
+    ): Effect.Effect<R | R2 | R3 | R4, E2 | E3 | E4, B | C | D> =>
+      Effect.matchCauseEffect(effect, splitInterrupt(onCause, onInterrupt), onSuccess).traced(
+        trace,
+      ),
+)
+
+export const splitInterrupt: {
+  <E, R2, E2, B, R3, E3, C>(
+    onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onInterrupt: () => Effect.Effect<R3, E3, C>,
+  ): (cause: Cause.Cause<E>) => Effect.Effect<R2 | R3, E2 | E3, B | C>
+  <E, R2, E2, B, R3, E3, C>(
+    cause: Cause.Cause<E>,
+    onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+    onInterrupt: () => Effect.Effect<R3, E3, C>,
+  ): Effect.Effect<R2 | R3, E2 | E3, B | C>
+} = dualWithTrace(
+  3,
+  (trace) =>
+    <E, R2, E2, B, R3, E3, C>(
+      cause: Cause.Cause<E>,
+      onCause: (cause: Cause.Cause<E>) => Effect.Effect<R2, E2, B>,
+      onInterrupt: () => Effect.Effect<R3, E3, C>,
+    ): Effect.Effect<R2 | R3, E2 | E3, B | C> =>
+      (Cause.isInterruptedOnly(cause) ? onInterrupt() : onCause(cause)).traced(trace),
+)

package/src/operator/combine.ts

@@ -3,6 +3,7 @@ import * as Effect from '@effect/io/Effect'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 
 export function combineAll<Streams extends readonly Fx<any, any, any>[]>(
   ...streams: Streams
@@ -75,7 +76,7 @@ class CombineAllFx<Streams extends readonly Fx<any, any, any>[]>
                     Effect.sync(() => results.set(i, a)),
                     Effect.zipRight(emitIfReady),
                   ),
-                sink.error,
+                splitInterrupt(sink.error, () => counter.decrement),
                 counter.decrement,
               ),
             ),

package/src/operator/debounce.ts

@@ -1,11 +1,11 @@
 import type * as Duration from '@effect/data/Duration'
 import { pipe } from '@effect/data/Function'
-import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { matchInterruptCause } from '../_internal/matchInterruptCause.js'
 
 export function debounce(duration: Duration.Duration) {
   return <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, A> => new DebounceFx(fx, duration)
@@ -36,11 +36,12 @@ class DebounceFx<R, E, A> extends Fx.Variance<R, E, A> implements Fx<R, E, A> {
                       sink.event(a),
                       Effect.delay(duration),
                       Effect.interruptible,
-                      Effect.zipRight(counter.decrement),
-                      Effect.uninterruptible,
-                      Effect.onError((cause) =>
-                        Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                      matchInterruptCause(
+                        sink.error,
+                        () => counter.decrement,
+                        () => counter.decrement,
                       ),
+                      Effect.uninterruptible,
                       Effect.forkScoped,
                       Effect.tap((fiber) =>
                         Effect.sync(() => {

package/src/operator/exhaustMap.ts

@@ -1,12 +1,12 @@
 import { dual, pipe } from '@effect/data/Function'
 import type { FlatMap } from '@effect/data/typeclass/FlatMap'
-import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import type * as Fiber from '@effect/io/Fiber'
 import * as Ref from '@effect/io/Ref/Synchronized'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 import type { FxTypeLambda } from '../typeclass/TypeLambda.js'
 
 export const exhaustMap: FlatMap<FxTypeLambda>['flatMap'] = dual(
@@ -51,10 +51,8 @@ class ExhaustMapFx<R, E, A, R2, E2, B>
                                       pipe(resetRef, Effect.zipRight(counter.decrement)),
                                     ),
                                   ),
-                                  Effect.onError((cause) =>
-                                    Cause.isInterruptedOnly(cause)
-                                      ? Effect.unit()
-                                      : sink.error(cause),
+                                  Effect.catchAllCause(
+                                    splitInterrupt(sink.error, () => counter.decrement),
                                   ),
                                 ),
                               ),

package/src/operator/exhaustMapLatest.ts

@@ -55,7 +55,7 @@ class ExhaustMapLatestFx<R, E, A, R2, E2, B>
                       pipe(resetRef, Effect.zipRight(runNextFx)),
                     ),
                   ),
-                  Effect.onError((e) =>
+                  Effect.catchAllCause((e) =>
                     Cause.isInterruptedOnly(e)
                       ? resetRef
                       : pipe(resetRef, Effect.zipRight(sink.error(e))),

package/src/operator/flatMap.ts

@@ -35,7 +35,7 @@ class FlatMapFx<R, E, A, R2, E2, B>
                 Effect.flatMap(() =>
                   this.f(a).run(Fx.Sink(sink.event, sink.error, counter.decrement)),
                 ),
-                Effect.onError((cause) =>
+                Effect.catchAllCause((cause) =>
                   Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
                 ),
                 Effect.forkScoped,

package/src/operator/flatMapCause.ts

@@ -32,7 +32,7 @@ class FlatMapCauseFx<R, E, A, R2, E2, B>
                 Effect.flatMap(() =>
                   this.f(cause).run(Fx.Sink(sink.event, sink.error, counter.decrement)),
                 ),
-                Effect.onError((cause) =>
+                Effect.catchAllCause((cause) =>
                   Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
                 ),
                 Effect.forkScoped,

package/src/operator/mergeRace.ts

@@ -20,7 +20,7 @@ export function mergeRace<R2, E2, B>(raced: Fx<R2, E2, B>) {
         const racedFiber = yield* $(
           pipe(
             raced.run(Fx.Sink(sink.event, sink.error, Effect.unit())),
-            Effect.onError((cause) =>
+            Effect.catchAllCause((cause) =>
               Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
             ),
             Effect.forkScoped,

package/src/operator/snapshot.ts

@@ -33,7 +33,7 @@ class SnapshotFx<R, E, A, R2, E2, B, C>
         pipe(
           sampled,
           run((b) => pipe(ref, Ref.set(Option.some(b))), sink.error, Effect.unit()),
-          Effect.onError((cause) =>
+          Effect.catchAllCause((cause) =>
             Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
           ),
           Effect.forkScoped,

package/src/operator/snapshotEffect.ts

@@ -37,7 +37,7 @@ class SnapshotEffectFx<R, E, A, R2, E2, B, R3, E3, C>
         pipe(
           sampled,
           run((b) => pipe(ref, Ref.set(Option.some(b))), sink.error, Effect.unit()),
-          Effect.onError((cause) =>
+          Effect.catchAllCause((cause) =>
             Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
           ),
           Effect.forkScoped,

package/src/operator/switchMap.ts

@@ -7,6 +7,7 @@ import * as Ref from '@effect/io/Ref/Synchronized'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 import type { FxTypeLambda } from '../typeclass/TypeLambda.js'
 
 export const switchMap: FlatMap<FxTypeLambda>['flatMap'] = dual(
@@ -64,6 +65,11 @@ class SwitchMapFx<R, E, A, R2, E2, B>
                                 pipe(counter.decrement, Effect.zipLeft(resetRef)),
                               ),
                             ),
+                            Effect.catchAllCause(
+                              splitInterrupt(sink.error, () =>
+                                pipe(resetRef, Effect.zipRight(counter.decrement)),
+                              ),
+                            ),
                             Effect.forkScoped,
                           ),
                         ),
@@ -75,6 +81,7 @@ class SwitchMapFx<R, E, A, R2, E2, B>
               ),
             )
           }),
+          Effect.catchAllCause(splitInterrupt(sink.error, () => counter.decrement)),
         ),
       sink.end,
     )

package/src/operator/switchMapCause.ts

@@ -1,4 +1,4 @@
-import { flow, pipe } from '@effect/data/Function'
+import { pipe } from '@effect/data/Function'
 import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Fiber from '@effect/io/Fiber'
@@ -6,6 +6,7 @@ import * as Ref from '@effect/io/Ref/Synchronized'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 
 import { catchTag_ } from './catchTag.js'
 
@@ -65,14 +66,7 @@ class SwitchMapCauseFx<R, E, A, R2, E2, B>
                             this.f(cause).run(
                               Fx.Sink(
                                 sink.event,
-                                flow(
-                                  Effect.unified((cause) =>
-                                    Cause.isInterruptedOnly(cause)
-                                      ? counter.decrement
-                                      : sink.error(cause),
-                                  ),
-                                  Effect.zipLeft(resetRef),
-                                ),
+                                splitInterrupt(sink.error, () => counter.decrement),
                                 pipe(counter.decrement, Effect.zipLeft(resetRef)),
                               ),
                             ),

package/src/operator/switchMatch.ts

@@ -7,6 +7,7 @@ import * as Ref from '@effect/io/Ref/Synchronized'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 import { failCause } from '../constructor/failCause.js'
 
 export function switchMatchCause<E, R2, E2, B, A, R3, E3, C>(
@@ -67,18 +68,13 @@ class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
                         fx.run(
                           Fx.Sink(
                             sink.event,
-                            flow(
-                              Effect.unified((cause) =>
-                                Cause.isInterruptedOnly(cause)
-                                  ? counter.decrement
-                                  : sink.error(cause),
-                              ),
-                              Effect.zipLeft(resetRef),
+                            splitInterrupt(sink.error, () =>
+                              Effect.zip(counter.decrement, resetRef),
                             ),
                             pipe(counter.decrement, Effect.zipLeft(resetRef)),
                           ),
                         ),
-                        Effect.onError((cause) =>
+                        Effect.catchAllCause((cause) =>
                           Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
                         ),
                         Effect.forkScoped,

package/src/operator/zip.ts

@@ -3,6 +3,7 @@ import * as Effect from '@effect/io/Effect'
 
 import { Fx } from '../Fx.js'
 import { withRefCounter } from '../_internal/RefCounter.js'
+import { splitInterrupt } from '../_internal/matchInterruptCause.js'
 
 export function zipAll<Streams extends readonly Fx<any, any, any>[]>(
   ...streams: Streams
@@ -79,7 +80,7 @@ class ZipAllFx<Streams extends readonly Fx<any, any, any>[]>
                     Effect.sync(() => results.set(i, a)),
                     Effect.zipRight(emitIfReady),
                   ),
-                sink.error,
+                splitInterrupt(sink.error, () => counter.decrement),
                 counter.decrement,
               ),
             ),

package/src/run/run.ts

@@ -6,6 +6,7 @@ import * as Fiber from '@effect/io/Fiber'
 import type { Scope } from '@effect/io/Scope'
 
 import { Fx, Sink } from '../Fx.js'
+import { matchInterruptCause } from '../_internal/matchInterruptCause.js'
 
 export function run<A, R2, E2, E, R3, E3, B, R4, E4>(
   event: (a: A) => Effect.Effect<R2, E2, any>,
@@ -26,11 +27,12 @@ export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
       const sink = Sink(
         flow(
           event,
-          Effect.matchCauseEffect(
+          matchInterruptCause(
             (cause) =>
               Effect.sync(() =>
                 Deferred.unsafeDone<E2 | E3 | E4, B>(deferred, Effect.failCause(cause)),
               ),
+            () => pipe(end, Effect.intoDeferred(deferred)),
             Effect.unit,
           ),
         ),
@@ -41,7 +43,7 @@ export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
       const fiber = yield* $(
         pipe(
           fx.run(sink),
-          Effect.onError((cause) =>
+          Effect.catchAllCause((cause) =>
             Effect.sync(() =>
               Cause.isInterruptedOnly(cause)
                 ? null