@typed/fx 1.5.2 → 1.5.6

package/src/operator/race.ts

@@ -7,7 +7,6 @@ import * as Exit from '@effect/io/Exit'
 import * as Scope from '@effect/io/Scope'
 
 import { Fx } from '../Fx.js'
-import { asap } from '../_internal/RefCounter.js'
 import { run } from '../run/run.js'
 
 import { tap } from './tap.js'
@@ -55,7 +54,7 @@ class RaceAllFx<Streams extends readonly Fx<any, any, any>[]>
                 s,
                 tap(() => cleanupScopes(i)),
                 run(sink.event, sink.error, sink.end),
-                Effect.scheduleForked(asap), // Schedule starts so that all Scopes can be returned *before* attempting to cleanup
+                Effect.forkScoped, // Schedule starts so that all Scopes can be returned *before* attempting to cleanup
                 Effect.as(scope),
                 Effect.provideService(Scope.Scope, scope),
               ),

package/src/operator/switchMap.ts

@@ -53,12 +53,23 @@ class SwitchMapFx<R, E, A, R2, E2, B>
                             this.f(a).run(
                               Fx.Sink(
                                 sink.event,
-                                flow(sink.error, Effect.zipLeft(resetRef)),
+                                flow(
+                                  Effect.unified((cause) =>
+                                    Cause.isInterruptedOnly(cause)
+                                      ? counter.decrement
+                                      : sink.error(cause),
+                                  ),
+                                  Effect.zipLeft(resetRef),
+                                ),
                                 pipe(counter.decrement, Effect.zipLeft(resetRef)),
                               ),
                             ),
-                            Effect.onError((cause) =>
-                              Cause.isInterruptedOnly(cause) ? Effect.unit() : sink.error(cause),
+                            Effect.onError(
+                              Effect.unified((cause) =>
+                                Cause.isInterruptedOnly(cause)
+                                  ? counter.decrement
+                                  : sink.error(cause),
+                              ),
                             ),
                             Effect.forkScoped,
                           ),

package/src/operator/switchMapCause.ts

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

package/src/operator/switchMatch.ts

@@ -67,7 +67,14 @@ class SwitchMatchFx<R, E, A, R2, E2, B, R3, E3, C>
                         fx.run(
                           Fx.Sink(
                             sink.event,
-                            flow(sink.error, Effect.zipLeft(resetRef)),
+                            flow(
+                              Effect.unified((cause) =>
+                                Cause.isInterruptedOnly(cause)
+                                  ? counter.decrement
+                                  : sink.error(cause),
+                              ),
+                              Effect.zipLeft(resetRef),
+                            ),
                             pipe(counter.decrement, Effect.zipLeft(resetRef)),
                           ),
                         ),

package/src/subject/SynchronizedSubject.ts

@@ -1,12 +1,12 @@
 import { equals } from '@effect/data/Equal'
 import { identity, pipe } from '@effect/data/Function'
-import * as MutableRef from '@effect/data/MutableRef'
 import * as Option from '@effect/data/Option'
 import * as Effect from '@effect/io/Effect'
 import * as Ref from '@effect/io/Ref'
 import * as Synchronized from '@effect/io/Ref/Synchronized'
 
 import { Fx } from '../Fx.js'
+import { Mutable } from '../_internal/Mutable.js'
 
 import { HoldSubject } from './HoldSubject.js'
 import { Computed, isRefSubject, RefSubject } from './RefSubject.js'
@@ -28,17 +28,17 @@ export namespace SynchronizedSubject {
     initial: () => A,
     eq: (a: A, b: A) => boolean = equals,
   ): SynchronizedSubject<A> {
-    const mutableRef = MutableRef.make(Option.some(initial()))
-    const subject = HoldSubject.unsafeMake<never, A>(mutableRef)
+    const current = Mutable(Option.some(initial()))
+    const subject = HoldSubject.unsafeMake<never, A>(current)
     const locked = Effect.unsafeMakeSemaphore(1).withPermits(1)
 
     const getValue = () =>
       pipe(
-        MutableRef.get(mutableRef),
+        current.get(),
         Option.getOrElse(() => {
           const a = initial()
 
-          MutableRef.set(mutableRef, Option.some(a))
+          current.set(Option.some(a))
 
           return a
         }),
@@ -49,14 +49,14 @@ export namespace SynchronizedSubject {
     ): Effect.Effect<R2, E2, B> =>
       locked(
         Effect.gen(function* ($) {
-          const current = getValue()
-          const [b, a] = yield* $(f(current))
+          const next = getValue()
+          const [b, a] = yield* $(f(next))
 
-          if (eq(current, a)) {
+          if (eq(next, a)) {
             return b
           }
 
-          MutableRef.set(mutableRef, Option.some(a))
+          current.set(Option.some(a))
 
           yield* $(subject.event(a))
 
@@ -82,6 +82,7 @@ export namespace SynchronizedSubject {
       error: subject.error.bind(subject),
       end: subject.end,
       value: subject.value,
+      current,
       eq,
       modify,
       modifyEffect,
@@ -100,7 +101,7 @@ export namespace SynchronizedSubject {
       delete: Effect.sync(() => {
         const value = getValue()
 
-        MutableRef.set(mutableRef, Option.some(value))
+        current.set(Option.some(value))
 
         return value
       }),