@typed/fx 1.27.4 → 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"
@@ -101,12 +103,7 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   }
 
   protected interruptScopes = Effect.fiberIdWith((id) =>
-    Effect.tap(
-      Effect.forEach(this.sinks, ([, , scope]) => Scope.close(scope, Exit.interrupt(id)), DISCARD),
-      () => {
-        this.sinks.clear()
-      }
-    )
+    Effect.forEach(Array.from(this.sinks), ([, , scope]) => Scope.close(scope, Exit.interrupt(id)), DISCARD)
   )
 
   readonly interrupt = this.interruptScopes
@@ -134,7 +131,7 @@ 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
+    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)
@@ -148,14 +145,14 @@ export class SubjectImpl<A, E> extends FxBase<A, E, Scope.Scope> implements Subj
   }
 
   protected onCause(cause: Cause.Cause<E>) {
-    if (this.sinks.size === 0) return Effect.unit
+    if (this.sinks.size === 0) return Effect.void
     else if (this.sinks.size === 1) {
-      const [sink, ctx] = this.sinks.values().next().value
-      return runSinkCause(sink, ctx, cause)
+      const [sink, ctx, scope] = this.sinks.values().next().value
+      return runSinkCause(sink, ctx, scope, cause)
     } else {
       return Effect.forEach(
         this.sinks,
-        ([sink, ctx]) => runSinkCause(sink, ctx, cause),
+        ([sink, ctx, scope]) => runSinkCause(sink, ctx, scope, cause),
         DISCARD
       )
     }
@@ -166,8 +163,16 @@ function runSinkEvent<A, E>(sink: Sink<A, E, any>, ctx: Context.Context<any>, 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>, cause: Cause.Cause<E>) {
-  return Effect.provide(Effect.catchAllCause(sink.onFailure(cause), () => Effect.unit), 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
+  )
 }
 
 /**

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)
 }

package/src/internal/core.ts

@@ -1,36 +1,36 @@
 import * as Context from "@typed/context"
-import {
-  type ConfigProvider,
-  type Duration,
-  type Equivalence,
-  type FiberId,
-  type FiberRef,
-  type HashSet,
-  type Queue,
-  type Request,
-  type Runtime,
-  type Schedule,
-  type Scheduler,
-  Unify
-} from "effect"
+import { Data, Record } from "effect"
 import * as Boolean from "effect/Boolean"
 import * as Cause from "effect/Cause"
 import * as Clock from "effect/Clock"
+import type * as ConfigProvider from "effect/ConfigProvider"
 import * as Deferred from "effect/Deferred"
+import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Equal from "effect/Equal"
+import type * as Equivalence from "effect/Equivalence"
 import { boolean } from "effect/Equivalence"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
+import type * as FiberRef from "effect/FiberRef"
 import { constFalse, constTrue } from "effect/Function"
+import type * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import type * as Queue from "effect/Queue"
 import * as Ref from "effect/Ref"
+import type * as Request from "effect/Request"
+import type * as Runtime from "effect/Runtime"
+import type * as Schedule from "effect/Schedule"
+import type * as Scheduler from "effect/Scheduler"
 import * as Scope from "effect/Scope"
 import * as Tracer from "effect/Tracer"
+import * as Unify from "effect/Unify"
+import type * as Utils from "effect/Utils"
 import type { FlattenStrategy, Fx, FxFork, MergeStrategy } from "../Fx.js"
 import * as Sink from "../Sink.js"
 import type { Bounds } from "./bounds.js"
@@ -284,7 +284,7 @@ export const observe = <A, E, R, B, E2, R2>(
   f: (a: A) => Effect.Effect<B, E2, R2>
 ): Effect.Effect<void, E | E2, R | R2> => Observe.make(fx, f)
 
-const constUnit = () => Effect.unit
+const constUnit = () => Effect.void
 
 export const drain = <A, E, R>(fx: Fx<A, E, R>): Effect.Effect<void, E, R> => Observe.make(fx, constUnit)
 
@@ -303,7 +303,7 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
 
       return Effect.zipRight(
         fx.run(Sink.make(onFailure, (a) => Effect.catchAllCause(f(a), onFailure))),
-        Effect.sync(() => resume(Effect.unit))
+        Effect.sync(() => resume(Effect.void))
       )
     })
   }
@@ -313,7 +313,7 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
     f: (a: A) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<void, E | E2, R | R2> {
     if (isEmpty(fx)) {
-      return Effect.unit
+      return Effect.void
     } else if (isNever(fx)) {
       return Effect.never
     } else if (isProducer(fx)) {
@@ -326,13 +326,13 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
-                SyncProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.unit))
+                SyncProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.void))
               ),
             FilterMap: (op) =>
               SyncProducer.effectOnce(() =>
                 SyncProducer.runEffect(
                   fx.i0,
-                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.void, onSome: f }))
                 )
               )
           }),
@@ -342,12 +342,12 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               SyncProducer.runEffect(fx.i0, (a) =>
-                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.void, onSome: f })))),
             FilterEffect: (op) =>
               SyncProducer.runEffect(
                 fx.i0,
                 Unify.unify((a) =>
-                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.unit))
+                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.void))
                 )
               ),
             TapEffect: (op) => SyncProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
@@ -400,13 +400,13 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, (a) => f(op.f(a)))),
             Filter: (op) =>
               SyncProducer.effectOnce(() =>
-                EffectProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.unit))
+                EffectProducer.runEffect(fx.i0, Unify.unify((a) => op.f(a) ? f(a) : Effect.void))
               ),
             FilterMap: (op) =>
               SyncProducer.effectOnce(() =>
                 EffectProducer.runEffect(
                   fx.i0,
-                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.unit, onSome: f }))
+                  Unify.unify((a) => Option.match(op.f(a), { onNone: () => Effect.void, onSome: f }))
                 )
               )
           }),
@@ -416,12 +416,12 @@ class Observe<A, E, R, B, E2, R2> extends EffectBase<void, E | E2, R | R2> {
               EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), f)),
             FilterMapEffect: (op) =>
               EffectProducer.runEffect(fx.i0, (a) =>
-                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.unit, onSome: f })))),
+                Effect.flatMap(op.f(a), Unify.unify(Option.match({ onNone: () => Effect.void, onSome: f })))),
             FilterEffect: (op) =>
               EffectProducer.runEffect(
                 fx.i0,
                 Unify.unify((a) =>
-                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.unit))
+                  Effect.flatMap(op.f(a), Unify.unify((b) => b ? f(a) : Effect.void))
                 )
               ),
             TapEffect: (op) => EffectProducer.runEffect(fx.i0, (a) => Effect.flatMap(op.f(a), () => f(a)))
@@ -617,10 +617,41 @@ export function skipRepeatsWith<A, E, R>(
   })
 }
 
+const toDeepEquals = (u: unknown): unknown => {
+  switch (typeof u) {
+    case "object": {
+      if (Predicate.isNullable(u)) {
+        return u
+      } else if (Equal.symbol in u) {
+        return u
+      } else if (Array.isArray(u)) {
+        return Data.tuple(u.map(toDeepEquals))
+      } else if (u instanceof Set) {
+        return Data.tuple(Array.from(u, toDeepEquals))
+      } else if (u instanceof Map) {
+        return Data.tuple(Array.from(u, ([k, v]) => Data.tuple([toDeepEquals(k), toDeepEquals(v)])))
+      } else {
+        return Data.struct(Record.map(u, toDeepEquals))
+      }
+    }
+    default:
+      return u
+  }
+}
+
+/**
+ * @internal
+ */
+export const deepEquals = (a: unknown, b: unknown) => {
+  // Attempt reference equality first for performance
+  if (Object.is(a, b)) return true
+  return Equal.equals(toDeepEquals(a), toDeepEquals(b))
+}
+
 export function skipRepeats<A, E, R>(
   fx: Fx<A, E, R>
 ): Fx<A, E, R> {
-  return skipRepeatsWith(fx, Equal.equals)
+  return skipRepeatsWith(fx, deepEquals)
 }
 
 class ProducerEffectTransformer<A, E, R, B, E2, R2> extends FxBase<B, E | E2, R | R2> {
@@ -644,7 +675,7 @@ export function isProducerEffectTransformer<A, E, R>(
 
 class Empty extends FxBase<never, never, never> {
   run<R2>(): Effect.Effect<unknown, never, R2> {
-    return Effect.unit
+    return Effect.void
   }
 }
 
@@ -983,22 +1014,25 @@ class FromFxEffect<
   }
 }
 
-export function gen<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+export function gen<Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>
+  YieldWrapError<Y> | Fx.Error<FX>,
+  YieldWrapContext<Y> | Fx.Context<FX>
 > {
   return fromFxEffect(Effect.gen(f))
 }
 
-export function genScoped<Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+type YieldWrapError<T> = T extends Utils.YieldWrap<Effect.Effect<infer _, infer E, any>> ? E : never
+type YieldWrapContext<T> = T extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never
+
+export function genScoped<Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ): Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>
+  YieldWrapError<Y> | Fx.Error<FX>,
+  Exclude<YieldWrapContext<Y> | Fx.Context<FX>, Scope.Scope>
 > {
   return scoped(fromFxEffect(Effect.gen(f)))
 }
@@ -1102,7 +1136,7 @@ class OrElse<
   run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.catchAll(
       Effect.asyncEffect<unknown, E, never, never, never, R | R2 | R3>((resume) =>
-        Effect.asUnit(Effect.zipRight(
+        Effect.asVoid(Effect.zipRight(
           this.i0.run(
             Sink.make(
               (cause) =>
@@ -1113,7 +1147,7 @@ class OrElse<
               sink.onSuccess
             )
           ),
-          Effect.sync(() => resume(Effect.unit))
+          Effect.sync(() => resume(Effect.void))
         ))
       ),
       (error: E) => this.i1(error).run(sink)
@@ -1264,16 +1298,16 @@ function runOrdered<
   sink: Sink.Sink<any, any, R2>,
   concurrency: number | "unbounded"
 ): Effect.Effect<unknown, never, R2 | Fx.Context<FX[number]>> {
-  return Effect.suspend(
-    () => {
-      const buffers = withBuffers(fx.length, sink)
+  return Effect.fiberIdWith(
+    (id) => {
+      const buffers = withBuffers(fx.length, sink, id)
       return Effect.forEach(
         fx,
         (fx, i) =>
           Effect.flatMap(
             fx.run(
               Sink.make(
-                (cause) => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause),
+                (cause) => Cause.isInterruptedOnly(cause) ? buffers.onEnd(i) : sink.onFailure(cause),
                 (a) => buffers.onSuccess(i, a)
               )
             ),
@@ -1529,7 +1563,7 @@ class During<A, E, R, B, E2, R2, E3, R3> extends FxBase<A, E | E2 | E3, R | R2 |
                 this.i0.run(
                   Sink.make(
                     onFailure,
-                    (a) => taking ? s.onSuccess(a) : Effect.unit
+                    (a) => taking ? s.onSuccess(a) : Effect.void
                   )
                 )
               )
@@ -1654,7 +1688,7 @@ export function withMaxOpsBeforeYield<A, E, R>(
 
 export function withParentSpan<A, E, R>(
   fx: Fx<A, E, R>,
-  parentSpan: Tracer.ParentSpan
+  parentSpan: Tracer.AnySpan
 ): Fx<A, E, R> {
   return middleware(fx, (effect) => Effect.withParentSpan(effect, parentSpan))
 }
@@ -2479,10 +2513,10 @@ class FromAsyncIterable<A> extends FxBase<A, never, never> {
       const iterator = this.i0[Symbol.asyncIterator]()
       const loop = (result: IteratorResult<A>): Effect.Effect<unknown, never, R> =>
         result.done
-          ? Effect.sync(() => cb(Effect.unit))
+          ? Effect.sync(() => cb(Effect.void))
           : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop))
 
-      return Effect.asUnit(Effect.flatMap(
+      return Effect.asVoid(Effect.flatMap(
         Effect.promise(() => iterator.next()),
         loop
       ))
@@ -2492,7 +2526,7 @@ class FromAsyncIterable<A> extends FxBase<A, never, never> {
 
 export function findFirst<A, E, R>(fx: Fx<A, E, R>, predicate: Predicate.Predicate<A>): Effect.Effect<A, E, R> {
   return Effect.asyncEffect((cb) =>
-    observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit)
+    observe(fx, (a) => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.void)
   )
 }
 
@@ -2544,13 +2578,13 @@ class MergeRace<A, E, R, B, E2, R2> extends FxBase<A | B, E | E2, R | R2> {
 
   run<R3>(sink: Sink.Sink<A | B, E | E2, R3>): Effect.Effect<unknown, never, R | R2 | R3> {
     return Effect.gen(this, function*(_) {
-      const fiber1 = yield* _(Effect.fork(this.i0.run(Sink.make(
+      const fiber1 = yield* Effect.fork(this.i0.run(Sink.make(
         sink.onFailure,
         (a) => Effect.flatMap(sink.onSuccess(a), () => Fiber.interrupt(fiber2))
-      ))))
-      const fiber2 = yield* _(Effect.fork(this.i1.run(sink)))
+      )))
+      const fiber2 = yield* Effect.fork(this.i1.run(sink))
 
-      return yield* _(Fiber.joinAll([fiber1, fiber2]))
+      return yield* Fiber.joinAll([fiber1, fiber2])
     })
   }
 }
@@ -2585,22 +2619,22 @@ class RaceAll<const FX extends ReadonlyArray<Fx<any, any, any>>> extends FxBase<
     sink: Sink.Sink<Fx.Success<FX[number]>, Fx.Error<FX[number]>, R2>
   ): Effect.Effect<unknown, never, Fx.Context<FX[number]> | R2> {
     return Effect.gen(this, function*(_) {
-      const winner = yield* _(Deferred.make<Fiber.RuntimeFiber<unknown>>())
+      const winner = yield* Deferred.make<Fiber.RuntimeFiber<unknown>>()
       const fibers: Array<Fiber.RuntimeFiber<unknown>> = []
 
       for (const fx of this.i0) {
-        const fiber: Fiber.RuntimeFiber<unknown> = yield* _(Effect.fork(fx.run(Sink.make(
+        const fiber: Fiber.RuntimeFiber<unknown> = yield* Effect.fork(fx.run(Sink.make(
           sink.onFailure,
           (a) => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))
-        ))))
+        )))
         fibers.push(fiber)
       }
 
-      const winningFiber = yield* _(Deferred.await(winner))
+      const winningFiber = yield* Deferred.await(winner)
 
-      yield* _(Fiber.interruptAll(fibers.filter((x) => x !== winningFiber)))
+      yield* Fiber.interruptAll(fibers.filter((x) => x !== winningFiber))
 
-      return yield* _(Fiber.join(winningFiber))
+      return yield* Fiber.join(winningFiber)
     })
   }
 }
@@ -2644,7 +2678,7 @@ class Snapshot<A, E, R, B, E2, R2, C> extends FxBase<C, E | E2, R | R2> {
               Effect.flatMap(
                 Ref.get(ref),
                 Option.match({
-                  onNone: () => Effect.unit,
+                  onNone: () => Effect.void,
                   onSome: (b) => sink.onSuccess(this.i2(a, b))
                 })
               )
@@ -2688,7 +2722,7 @@ class SnapshotEffect<A, E, R, B, E2, R2, C, E3, R3> extends FxBase<C, E | E2 | E
                 Effect.flatMap(
                   Ref.get(ref),
                   Option.match({
-                    onNone: () => Effect.unit,
+                    onNone: () => Effect.void,
                     onSome: (b) => Effect.matchCauseEffect(this.i2(a, b), sink)
                   })
                 )))
@@ -2720,11 +2754,8 @@ export function when<B, E, R, C>(
     readonly onTrue: B
     readonly onFalse: C
   }
-): Fx<B | C, E, R | Scope.Scope> {
-  return if_(bool, {
-    onTrue: succeed(options.onTrue),
-    onFalse: succeed(options.onFalse)
-  })
+): Fx<B | C, E, R> {
+  return map(skipRepeatsWith(bool, boolean), (b) => (b ? options.onTrue : options.onFalse))
 }
 
 export function mapBoth<A, E, R, B, C>(

package/src/internal/diff.ts

@@ -1,5 +1,5 @@
-import type { Equivalence } from "effect"
 import * as Equal from "effect/Equal"
+import type * as Equivalence from "effect/Equivalence"
 import { identity } from "effect/Function"
 
 export type DiffResult<A, B> = ReadonlyArray<Diff<A, B>>