@typed/fx 1.27.3 → 1.28.0

package/src/Sink.ts

@@ -4,13 +4,14 @@
  */
 
 import * as C from "@typed/context"
-import type { Predicate, Tracer } from "effect"
 import * as Cause from "effect/Cause"
 import * as Clock from "effect/Clock"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import type * as Predicate from "effect/Predicate"
+import type * as Tracer from "effect/Tracer"
 import { type Bounds } from "./internal/bounds.js"
 
 /**
@@ -98,10 +99,10 @@ export function withEarlyExit<A, E, R, B, R2>(
   return Effect.asyncEffect((resume: (effect: Effect.Effect<void>) => void) => {
     const earlyExit: WithEarlyExit<A, E, R> = {
       ...sink,
-      earlyExit: Effect.sync(() => resume(Effect.unit))
+      earlyExit: Effect.sync(() => resume(Effect.void))
     }
 
-    return Effect.asUnit(Effect.matchCauseEffect(f(earlyExit), {
+    return Effect.asVoid(Effect.matchCauseEffect(f(earlyExit), {
       onFailure: (cause) => sink.onFailure(cause),
       onSuccess: () => earlyExit.earlyExit
     }))
@@ -163,7 +164,7 @@ class FilterSink<A, E, R> implements Sink<A, E, R> {
 
   onSuccess(value: A) {
     if (this.predicate(value)) return this.sink.onSuccess(value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -190,7 +191,7 @@ class FilterMapSink<A, E, R, B> implements Sink<A, E, R> {
   onSuccess(value: A) {
     const option = this.f(value)
     if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -264,7 +265,7 @@ class FilterMapEffectSink<A, E, R, B, E2, R2> implements Sink<B, E2, R | R2> {
       onFailure: (cause) => this.sink.onFailure(cause),
       onSuccess: (option) => {
         if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -303,7 +304,7 @@ class FilterEffectSink<A, E, R> implements Sink<A, E, R> {
       onFailure: (cause) => this.sink.onFailure(cause),
       onSuccess: (b) => {
         if (b) return this.sink.onSuccess(value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -457,7 +458,7 @@ class FilterMapLoopSink<A, E, R, B, C> implements Sink<A, E, R> {
     const [option, acc] = this.f(this.seed, value)
     this.seed = acc
     if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 }
 
@@ -495,7 +496,7 @@ class FilterMapLoopCauseSink<A, E, R, B, C> implements Sink<A, E, R> {
     const [option, acc] = this.f(this.seed, cause)
     this.seed = acc
     if (Option.isSome(option)) return this.sink.onFailure(option.value)
-    else return Effect.unit
+    else return Effect.void
   }
 
   onSuccess(value: A) {
@@ -588,7 +589,7 @@ class FilterMapLoopEffectSink<A, E, R, B, R2, C> implements Sink<A, E, R | R2> {
       onSuccess: ([option, acc]) => {
         this.seed = acc
         if (Option.isSome(option)) return this.sink.onSuccess(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -669,7 +670,7 @@ class FilterMapLoopCauseEffectSink<A, E, R, B, E2, R2, C> implements Sink<A, E,
       onSuccess: ([option, acc]) => {
         this.seed = acc
         if (Option.isSome(option)) return this.sink.onFailure(option.value)
-        else return Effect.unit
+        else return Effect.void
       }
     })
   }
@@ -721,10 +722,10 @@ class SliceSink<A, E, R> implements Sink<A, E, R> {
   onSuccess(value: A) {
     if (this.drop > 0) {
       this.drop--
-      return Effect.unit
+      return Effect.void
     }
     if (this.take-- > 0) {
-      return Effect.tap(this.sink.onSuccess(value), () => this.take === 0 ? this.sink.earlyExit : Effect.unit)
+      return Effect.tap(this.sink.onSuccess(value), () => this.take === 0 ? this.sink.earlyExit : Effect.void)
     }
     return this.sink.earlyExit
   }
@@ -1019,7 +1020,7 @@ class FromTag<I, S, B, E2, R2> implements Sink<B, E2, I | R2> {
  */
 export function ignoreInterrupt<A, E, R>(sink: Sink<A, E, R>): Sink<A, E, R> {
   return make(
-    (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
+    (cause) => Cause.isInterruptedOnly(cause) ? Effect.void : sink.onFailure(cause),
     sink.onSuccess
   )
 }

package/src/Subject.ts

@@ -4,14 +4,16 @@
  */
 
 import * as C from "@typed/context"
-import type { Cause, Layer, Pipeable } from "effect"
+import type * as Cause from "effect/Cause"
 import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import { dual, identity } from "effect/Function"
+import type * as Layer from "effect/Layer"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
+import type * as Pipeable from "effect/Pipeable"
 import { hasProperty } from "effect/Predicate"
 import * as Scope from "effect/Scope"
 import { type Fx } from "./Fx.js"
@@ -78,8 +80,7 @@ const DISCARD = { discard: true } as const
  * @internal
  */
 export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subject<A, E> {
-  protected sinks: Set<readonly [Sink<A, E, any>, Context.Context<any>]> = new Set()
-  protected scopes: Set<Scope.CloseableScope> = new Set()
+  protected sinks: Set<readonly [Sink<A, E, any>, Context.Context<any>, Scope.CloseableScope]> = new Set()
 
   constructor() {
     super()
@@ -101,16 +102,12 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
     return this.onEvent(a)
   }
 
-  readonly interrupt = Effect.fiberIdWith((id) =>
-    Effect.tap(
-      Effect.forEach(this.scopes, (scope) => Scope.close(scope, Exit.interrupt(id)), DISCARD),
-      () => {
-        this.sinks.clear()
-        this.scopes.clear()
-      }
-    )
+  protected interruptScopes = Effect.fiberIdWith((id) =>
+    Effect.forEach(Array.from(this.sinks), ([, , scope]) => Scope.close(scope, Exit.interrupt(id)), DISCARD)
   )
 
+  readonly interrupt = this.interruptScopes
+
   protected addSink<R, B, R2>(
     sink: Sink<A, E, R>,
     f: (scope: Scope.Scope) => Effect.Effect<B, never, R2>
@@ -118,19 +115,13 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
     return withScope(
       (innerScope) =>
         Effect.contextWithEffect((ctx) => {
-          const entry = [sink, ctx] as const
-          const add = Effect.sync(() => {
-            this.sinks.add(entry)
-            this.scopes.add(innerScope)
-          })
-          const remove = Effect.sync(() => {
-            this.sinks.delete(entry)
-            this.scopes.delete(innerScope)
-          })
+          const entry = [sink, ctx, innerScope] as const
+          this.sinks.add(entry)
+          const remove = Effect.sync(() => this.sinks.delete(entry))
 
           return Effect.zipRight(
             Scope.addFinalizer(innerScope, remove),
-            Effect.zipRight(add, f(innerScope))
+            f(innerScope)
           )
         }),
       ExecutionStrategy.sequential
@@ -140,21 +131,50 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   readonly subscriberCount: Effect.Effect<number> = Effect.sync(() => this.sinks.size)
 
   protected onEvent(a: A) {
-    if (this.sinks.size === 0) return Effect.unit
-    else {
-      return Effect.forEach(this.sinks, ([sink, ctx]) => Effect.provide(sink.onSuccess(a), ctx), DISCARD)
+    if (this.sinks.size === 0) return Effect.void
+    else if (this.sinks.size === 1) {
+      const [sink, ctx] = this.sinks.values().next().value
+      return runSinkEvent(sink, ctx, a)
+    } else {
+      return Effect.forEach(
+        this.sinks,
+        ([sink, ctx]) => runSinkEvent(sink, ctx, a),
+        DISCARD
+      )
     }
   }
 
   protected onCause(cause: Cause.Cause<E>) {
-    return Effect.forEach(
-      this.sinks,
-      ([sink, ctx]) => Effect.provide(sink.onFailure(cause), ctx),
-      DISCARD
-    )
+    if (this.sinks.size === 0) return Effect.void
+    else if (this.sinks.size === 1) {
+      const [sink, ctx, scope] = this.sinks.values().next().value
+      return runSinkCause(sink, ctx, scope, cause)
+    } else {
+      return Effect.forEach(
+        this.sinks,
+        ([sink, ctx, scope]) => runSinkCause(sink, ctx, scope, cause),
+        DISCARD
+      )
+    }
   }
 }
 
+function runSinkEvent<A, E>(sink: Sink<A, E, any>, ctx: Context.Context<any>, a: A) {
+  return Effect.provide(Effect.catchAllCause(sink.onSuccess(a), sink.onFailure), ctx)
+}
+
+function runSinkCause<A, E>(
+  sink: Sink<A, E, any>,
+  ctx: Context.Context<any>,
+  scope: Scope.CloseableScope,
+  cause: Cause.Cause<E>
+) {
+  return Effect.provide(
+    Effect.catchAllCause(sink.onFailure(cause), (error) => Scope.close(scope, Exit.failCause(error))),
+    ctx
+  )
+}
+
 /**
  * @internal
  */
@@ -185,11 +205,9 @@ export class HoldSubjectImpl<A, E> extends SubjectImpl<A, E> implements Subject<
       }))
   }
 
-  readonly interrupt = Effect.fiberIdWith((id) =>
-    Effect.tap(
-      Effect.forEach(this.scopes, (scope) => Scope.close(scope, Exit.interrupt(id)), DISCARD),
-      () => MutableRef.set(this.lastValue, Option.none())
-    )
+  readonly interrupt = Effect.tap(
+    this.interruptScopes,
+    () => MutableRef.set(this.lastValue, Option.none())
   )
 }
 
@@ -216,11 +234,9 @@ export class ReplaySubjectImpl<A, E> extends SubjectImpl<A, E> {
     )
   }
 
-  readonly interrupt = Effect.fiberIdWith((id) =>
-    Effect.tap(
-      Effect.forEach(this.scopes, (scope) => Scope.close(scope, Exit.interrupt(id)), DISCARD),
-      () => this.buffer.clear()
-    )
+  readonly interrupt = Effect.tap(
+    this.interruptScopes,
+    () => this.buffer.clear()
   )
 }
 

package/src/Versioned.ts

@@ -6,12 +6,14 @@
  */
 
 import type * as Context from "@typed/context"
-import type { Layer, Runtime, Scope } from "effect"
-import { Exit } from "effect"
 import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
 import { dual, flow } from "effect/Function"
+import type * as Layer from "effect/Layer"
 import { sum } from "effect/Number"
 import * as Option from "effect/Option"
+import type * as Runtime from "effect/Runtime"
+import type * as Scope from "effect/Scope"
 import type { Fx } from "./Fx.js"
 import * as core from "./internal/core.js"
 import { MulticastEffect } from "./internal/helpers.js"

package/src/internal/DeferredRef.ts

@@ -1,35 +1,41 @@
-import type { Equivalence, FiberId } from "effect"
+import { MutableRef } from "effect"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import type * as Equivalence from "effect/Equivalence"
 import * as Exit from "effect/Exit"
+import type * as FiberId from "effect/FiberId"
 import * as Option from "effect/Option"
 import { EffectBase } from "./protos.js"
 
 export class DeferredRef<E, A> extends EffectBase<A, E, never> {
   // Keep track of the latest value emitted by the stream
-  public current!: Option.Option<Exit.Exit<A, E>>
   public version!: number
   public deferred!: Deferred.Deferred<A, E>
 
-  constructor(private id: FiberId.FiberId, private eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
+  constructor(
+    private id: FiberId.FiberId,
+    private eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
+    readonly current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>
+  ) {
     super()
     this.reset()
   }
 
   toEffect() {
     return Effect.suspend(() => {
-      if (Option.isNone(this.current)) {
+      const current = MutableRef.get(this.current)
+      if (Option.isNone(current)) {
         return Deferred.await(this.deferred)
       } else {
-        return this.current.value
+        return current.value
       }
     })
   }
 
   done(exit: Exit.Exit<A, E>) {
-    const current = this.current
+    const current = MutableRef.get(this.current)
 
-    this.current = Option.some(exit)
+    MutableRef.set(this.current, Option.some(exit))
 
     if (Option.isSome(current) && this.eq(current.value, exit)) {
       return false
@@ -42,7 +48,7 @@ export class DeferredRef<E, A> extends EffectBase<A, E, never> {
   }
 
   reset() {
-    this.current = Option.none()
+    MutableRef.set(this.current, Option.none())
     this.version = -1
 
     if (this.deferred) {
@@ -54,9 +60,13 @@ export class DeferredRef<E, A> extends EffectBase<A, E, never> {
 }
 
 export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
-  return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq))
+  return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq, MutableRef.make(Option.none())))
 }
 
-export function unsafeMake<E, A>(id: FiberId.FiberId, eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
-  return new DeferredRef(id, eq)
+export function unsafeMake<E, A>(
+  id: FiberId.FiberId,
+  eq: Equivalence.Equivalence<Exit.Exit<A, E>>,
+  current: MutableRef.MutableRef<Option.Option<Exit.Exit<A, E>>>
+) {
+  return new DeferredRef(id, eq, current)
 }