effect 2.4.18 → 2.4.19

package/src/Ref.ts

@@ -4,7 +4,7 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
+import type { Readable } from "./Readable.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -23,7 +23,7 @@ export type RefTypeId = typeof RefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Ref<in out A> extends Ref.Variance<A>, Pipeable {
+export interface Ref<in out A> extends Ref.Variance<A>, Readable<A> {
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
 }
 

package/src/RegExp.ts

@@ -0,0 +1,17 @@
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Escapes special characters in a regular expression pattern.
+ *
+ * @example
+ * import * as RegExp from "effect/RegExp"
+ *
+ * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ *
+ * @since 2.0.0
+ */
+export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/Subscribable.ts

@@ -0,0 +1,99 @@
+/**
+ * @since 2.0.0
+ */
+import * as Effect from "./Effect.js"
+import { dual } from "./Function.js"
+import { pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+import * as Readable from "./Readable.js"
+import * as Stream from "./Stream.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("effect/Subscribable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<any>, "get" | "changes"> = {
+  [Readable.TypeId]: Readable.TypeId,
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+  make({
+    get: Effect.map(self.get, f),
+    changes: Stream.map(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Subscribable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+): Subscribable<B, E | E2, R | R2> =>
+  make({
+    get: Effect.flatMap(self.get, f),
+    changes: Stream.mapEffect(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes))
+  })

package/src/SubscriptionRef.ts

@@ -4,10 +4,10 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/subscriptionRef.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
 import type * as PubSub from "./PubSub.js"
 import * as Ref from "./Ref.js"
 import type * as Stream from "./Stream.js"
+import type { Subscribable } from "./Subscribable.js"
 import * as Synchronized from "./SynchronizedRef.js"
 import type * as Types from "./Types.js"
 
@@ -31,7 +31,7 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
  * @category models
  */
 export interface SubscriptionRef<in out A>
-  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable
+  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Subscribable<A>
 {
   /** @internal */
   readonly ref: Ref.Ref<A>

package/src/TestAnnotation.ts

@@ -8,6 +8,7 @@ import type * as Fiber from "./Fiber.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import * as HashSet from "./HashSet.js"
+import { getBugErrorMessage } from "./internal/errors.js"
 import type * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
 import type * as SortedSet from "./SortedSet.js"
@@ -96,7 +97,7 @@ export const compose = <A>(
   if (Either.isLeft(left) && Either.isRight(right)) {
     return right
   }
-  throw new Error("BUG: TestAnnotation.compose - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("TestAnnotation.compose"))
 }
 
 /**

package/src/index.ts

@@ -570,6 +570,11 @@ export * as Random from "./Random.js"
  */
 export * as RateLimiter from "./RateLimiter.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Readable from "./Readable.js"
+
 /**
  * This module provides utility functions for working with arrays in TypeScript.
  *
@@ -594,6 +599,13 @@ export * as RedBlackTree from "./RedBlackTree.js"
  */
 export * as Ref from "./Ref.js"
 
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as RegExp from "./RegExp.js"
+
 /**
  * @since 2.0.0
  */
@@ -740,6 +752,11 @@ export * as String from "./String.js"
  */
 export * as Struct from "./Struct.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Subscribable from "./Subscribable.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/cause.ts

@@ -14,6 +14,7 @@ import type { Predicate, Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type { ParentSpan, Span } from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
+import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 
 // -----------------------------------------------------------------------------
@@ -604,7 +605,7 @@ const flattenCauseLoop = (
     causes = sequential
     flattened = updated
   }
-  throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------
@@ -740,7 +741,7 @@ const evaluateCause = (
       }
     }
   }
-  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------

package/src/internal/configProvider.ts

@@ -13,6 +13,7 @@ import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
+import * as regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
@@ -595,7 +596,7 @@ export const within = dual<
 })
 
 const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
-  const split = text.split(new RegExp(`\\s*${escapeRegex(delim)}\\s*`))
+  const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
 
@@ -626,8 +627,6 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-
 const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),

package/src/internal/core-effect.ts

@@ -27,9 +27,11 @@ import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { MergeRecord, NoInfer } from "../Types.js"
 import * as internalCause from "./cause.js"
+import { clockTag } from "./clock.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as fiberRefsPatch from "./fiberRefs/patch.js"
+import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as SingleShotGen from "./singleShotGen.js"
@@ -1072,8 +1074,9 @@ export const mapAccum: {
     let i = 0
     while (!(next = iterator.next()).done) {
       const index = i++
+      const value = next.value
       result = core.flatMap(result, (state) =>
-        core.map(f(state, next.value, index), ([z, b]) => {
+        core.map(f(state, value, index), ([z, b]) => {
           builder.push(b)
           return z
         }))
@@ -2006,13 +2009,6 @@ export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementExceptio
   }
 )
 
-const bigint0 = BigInt(0)
-/** @internal */
-export const currentTimeNanosTracing = core.fiberRefGetWith(
-  core.currentTracerTimingEnabled,
-  (enabled) => enabled ? Clock.currentTimeNanos : core.succeed(bigint0)
-)
-
 /* @internal */
 export const linkSpans = dual<
   (
@@ -2040,8 +2036,11 @@ export const linkSpans = dual<
     )
 )
 
+const bigint0 = BigInt(0)
+
 /** @internal */
-export const makeSpan = (
+export const unsafeMakeSpan = <XA, XE>(
+  fiber: FiberRuntime<XA, XE>,
   name: string,
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
@@ -2050,55 +2049,67 @@ export const makeSpan = (
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }
-): Effect.Effect<Tracer.Span> =>
-  core.flatMap(fiberRefs, (fiberRefs) =>
-    core.sync(() => {
-      const enabled = FiberRefs.getOrDefault(fiberRefs, core.currentTracerEnabled)
-      if (enabled === false) {
-        return core.noopSpan(name)
-      }
+) => {
+  const enabled = fiber.getFiberRef(core.currentTracerEnabled)
+  if (enabled === false) {
+    return core.noopSpan(name)
+  }
 
-      const context = FiberRefs.getOrDefault(fiberRefs, core.currentContext)
-      const services = FiberRefs.getOrDefault(fiberRefs, defaultServices.currentServices)
-
-      const tracer = Context.get(services, internalTracer.tracerTag)
-      const clock = Context.get(services, Clock.Clock)
-      const timingEnabled = FiberRefs.getOrDefault(fiberRefs, core.currentTracerTimingEnabled)
-      const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
-      const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
-
-      const parent = options?.parent
-        ? Option.some(options.parent)
-        : options?.root
-        ? Option.none()
-        : Context.getOption(context, internalTracer.spanTag)
-
-      const links = linksFromEnv._tag === "Some" ?
-        options?.links !== undefined ?
-          [
-            ...Chunk.toReadonlyArray(linksFromEnv.value),
-            ...(options?.links ?? [])
-          ] :
-          Chunk.toReadonlyArray(linksFromEnv.value) :
-        options?.links ?? ReadonlyArray.empty()
-
-      const span = tracer.span(
-        name,
-        parent,
-        options?.context ?? Context.empty(),
-        links,
-        timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0
-      )
+  const context = fiber.getFiberRef(core.currentContext)
+  const services = fiber.getFiberRef(defaultServices.currentServices)
+
+  const tracer = Context.get(services, internalTracer.tracerTag)
+  const clock = Context.get(services, Clock.Clock)
+  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+
+  const fiberRefs = fiber.getFiberRefs()
+  const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+  const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+  const parent = options?.parent
+    ? Option.some(options.parent)
+    : options?.root
+    ? Option.none()
+    : Context.getOption(context, internalTracer.spanTag)
+
+  const links = linksFromEnv._tag === "Some" ?
+    options?.links !== undefined ?
+      [
+        ...Chunk.toReadonlyArray(linksFromEnv.value),
+        ...(options?.links ?? [])
+      ] :
+      Chunk.toReadonlyArray(linksFromEnv.value) :
+    options?.links ?? ReadonlyArray.empty()
+
+  const span = tracer.span(
+    name,
+    parent,
+    options?.context ?? Context.empty(),
+    links,
+    timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0
+  )
 
-      if (annotationsFromEnv._tag === "Some") {
-        HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
-      }
-      if (options?.attributes) {
-        Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
-      }
+  if (annotationsFromEnv._tag === "Some") {
+    HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+  }
+  if (options?.attributes !== undefined) {
+    Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+  }
 
-      return span
-    }))
+  return span
+}
+
+/** @internal */
+export const makeSpan = (
+  name: string,
+  options?: {
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
+  }
+): Effect.Effect<Tracer.Span> => core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
 
 /* @internal */
 export const spanAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
@@ -2134,17 +2145,18 @@ export const useSpan: {
   } | undefined = args.length === 1 ? undefined : args[0]
   const evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R> = args[args.length - 1]
 
-  return core.acquireUseRelease(
-    makeSpan(name, options),
-    evaluate,
-    (span, exit) =>
-      span.status._tag === "Ended" ?
-        core.unit :
-        core.flatMap(
-          currentTimeNanosTracing,
-          (endTime) => core.sync(() => span.end(endTime, exit))
-        )
-  )
+  return core.withFiberRuntime<A, E, R>((fiber) => {
+    const span = unsafeMakeSpan(fiber, name, options)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+    const clock = Context.get(fiber.getFiberRef(defaultServices.currentServices), clockTag)
+    return core.onExit(evaluate(span), (exit) =>
+      core.sync(() => {
+        if (span.status._tag === "Ended") {
+          return
+        }
+        span.end(timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0, exit)
+      }))
+  })
 }
 
 /** @internal */

package/src/internal/core.ts

@@ -41,6 +41,7 @@ import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
 import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
+import { getBugErrorMessage } from "./errors.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
@@ -469,7 +470,7 @@ export const custom: {
       break
     }
     default: {
-      throw new Error("Bug, you're not supposed to end up here")
+      throw new Error(getBugErrorMessage("you're not supposed to end up here"))
     }
   }
   return wrapper
@@ -2086,143 +2087,6 @@ export const scopeFork = (
   strategy: ExecutionStrategy.ExecutionStrategy
 ): Effect.Effect<Scope.Scope.Closeable> => self.fork(strategy)
 
-// -----------------------------------------------------------------------------
-// ReleaseMap
-// -----------------------------------------------------------------------------
-
-/** @internal */
-export type ReleaseMapState = {
-  _tag: "Exited"
-  nextKey: number
-  exit: Exit.Exit<unknown, unknown>
-  update: (finalizer: Scope.Scope.Finalizer) => Scope.Scope.Finalizer
-} | {
-  _tag: "Running"
-  nextKey: number
-  finalizers: Map<number, Scope.Scope.Finalizer>
-  update: (finalizer: Scope.Scope.Finalizer) => Scope.Scope.Finalizer
-}
-
-/** @internal */
-export interface ReleaseMap {
-  state: ReleaseMapState // mutable by design
-}
-
-/* @internal */
-export const releaseMapAdd = dual<
-  (finalizer: Scope.Scope.Finalizer) => (self: ReleaseMap) => Effect.Effect<Scope.Scope.Finalizer>,
-  (self: ReleaseMap, finalizer: Scope.Scope.Finalizer) => Effect.Effect<Scope.Scope.Finalizer>
->(2, (self, finalizer) =>
-  map(
-    releaseMapAddIfOpen(self, finalizer),
-    Option.match({
-      onNone: (): Scope.Scope.Finalizer => () => unit,
-      onSome: (key): Scope.Scope.Finalizer => (exit) => releaseMapRelease(key, exit)(self)
-    })
-  ))
-
-/* @internal */
-export const releaseMapRelease = dual<
-  (key: number, exit: Exit.Exit<unknown, unknown>) => (self: ReleaseMap) => Effect.Effect<void>,
-  (self: ReleaseMap, key: number, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void>
->(3, (self, key, exit) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        return unit
-      }
-      case "Running": {
-        const finalizer = self.state.finalizers.get(key)
-        self.state.finalizers.delete(key)
-        if (finalizer != null) {
-          return self.state.update(finalizer)(exit)
-        }
-        return unit
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapAddIfOpen = dual<
-  (finalizer: Scope.Scope.Finalizer) => (self: ReleaseMap) => Effect.Effect<Option.Option<number>>,
-  (self: ReleaseMap, finalizer: Scope.Scope.Finalizer) => Effect.Effect<Option.Option<number>>
->(2, (self, finalizer) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        self.state.nextKey += 1
-        return as(finalizer(self.state.exit), Option.none())
-      }
-      case "Running": {
-        const key = self.state.nextKey
-        self.state.finalizers.set(key, finalizer)
-        self.state.nextKey += 1
-        return succeed(Option.some(key))
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapGet = dual<
-  (key: number) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (self: ReleaseMap, key: number) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(
-  2,
-  (self, key) =>
-    sync((): Option.Option<Scope.Scope.Finalizer> =>
-      self.state._tag === "Running" ? Option.fromNullable(self.state.finalizers.get(key)) : Option.none()
-    )
-)
-
-/* @internal */
-export const releaseMapReplace = dual<
-  (
-    key: number,
-    finalizer: Scope.Scope.Finalizer
-  ) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (
-    self: ReleaseMap,
-    key: number,
-    finalizer: Scope.Scope.Finalizer
-  ) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(3, (self, key, finalizer) =>
-  suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        return as(finalizer(self.state.exit), Option.none())
-      }
-      case "Running": {
-        const fin = Option.fromNullable(self.state.finalizers.get(key))
-        self.state.finalizers.set(key, finalizer)
-        return succeed(fin)
-      }
-    }
-  }))
-
-/* @internal */
-export const releaseMapRemove = dual<
-  (key: number) => (self: ReleaseMap) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>,
-  (self: ReleaseMap, key: number) => Effect.Effect<Option.Option<Scope.Scope.Finalizer>>
->(2, (self, key) =>
-  sync(() => {
-    if (self.state._tag === "Exited") {
-      return Option.none()
-    }
-    const fin = Option.fromNullable(self.state.finalizers.get(key))
-    self.state.finalizers.delete(key)
-    return fin
-  }))
-
-/* @internal */
-export const releaseMapMake: Effect.Effect<ReleaseMap> = sync((): ReleaseMap => ({
-  state: {
-    _tag: "Running",
-    nextKey: 0,
-    finalizers: new Map(),
-    update: identity
-  }
-}))
-
 // -----------------------------------------------------------------------------
 // Cause
 // -----------------------------------------------------------------------------
@@ -2877,10 +2741,8 @@ export const deferredAwait = <A, E>(self: Deferred.Deferred<A, E>): Effect.Effec
         return resume(state.effect)
       }
       case DeferredOpCodes.OP_STATE_PENDING: {
-        pipe(
-          self.state,
-          MutableRef.set(deferred.pending([resume, ...state.joiners]))
-        )
+        // we can push here as the internal state is mutable
+        state.joiners.push(resume)
         return deferredInterruptJoiner(self, resume)
       }
     }
@@ -2908,8 +2770,8 @@ export const deferredCompleteWith = dual<
         return false
       }
       case DeferredOpCodes.OP_STATE_PENDING: {
-        pipe(self.state, MutableRef.set(deferred.done(effect)))
-        for (let i = 0; i < state.joiners.length; i++) {
+        MutableRef.set(self.state, deferred.done(effect))
+        for (let i = 0, len = state.joiners.length; i < len; i++) {
           state.joiners[i](effect)
         }
         return true
@@ -3005,8 +2867,8 @@ export const deferredSync = dual<
 export const deferredUnsafeDone = <A, E>(self: Deferred.Deferred<A, E>, effect: Effect.Effect<A, E>): void => {
   const state = MutableRef.get(self.state)
   if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-    pipe(self.state, MutableRef.set(deferred.done(effect)))
-    for (let i = state.joiners.length - 1; i >= 0; i--) {
+    MutableRef.set(self.state, deferred.done(effect))
+    for (let i = 0, len = state.joiners.length; i < len; i++) {
       state.joiners[i](effect)
     }
   }
@@ -3019,10 +2881,11 @@ const deferredInterruptJoiner = <A, E>(
   sync(() => {
     const state = MutableRef.get(self.state)
     if (state._tag === DeferredOpCodes.OP_STATE_PENDING) {
-      pipe(
-        self.state,
-        MutableRef.set(deferred.pending(state.joiners.filter((j) => j !== joiner)))
-      )
+      const index = state.joiners.indexOf(joiner)
+      if (index >= 0) {
+        // we can splice here as the internal state is mutable
+        state.joiners.splice(index, 1)
+      }
     }
   })