effect 2.4.17 → 2.4.19

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

package/src/internal/effect/circular.ts

@@ -15,6 +15,7 @@ import * as MutableHashMap from "../../MutableHashMap.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import * as Predicate from "../../Predicate.js"
+import * as Readable from "../../Readable.js"
 import type * as Ref from "../../Ref.js"
 import type * as Schedule from "../../Schedule.js"
 import { currentScheduler } from "../../Scheduler.js"
@@ -556,10 +557,15 @@ export const synchronizedVariance = {
 class SynchronizedImpl<in out A> implements Synchronized.SynchronizedRef<A> {
   readonly [SynchronizedTypeId] = synchronizedVariance
   readonly [internalRef.RefTypeId] = internalRef.refVariance
+  readonly [Readable.TypeId]: Readable.TypeId
   constructor(
     readonly ref: Ref.Ref<A>,
     readonly withLock: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  ) {}
+  ) {
+    this[Readable.TypeId] = Readable.TypeId
+    this.get = internalRef.get(this.ref)
+  }
+  readonly get: Effect.Effect<A>
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return this.modifyEffect((a) => core.succeed(f(a)))
   }

package/src/internal/errors.ts

@@ -0,0 +1,7 @@
+/**
+ * @since 2.0.0
+ */
+
+/** @internal */
+export const getBugErrorMessage = (message: string) =>
+  `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`

package/src/internal/fiberRuntime.ts

@@ -1355,50 +1355,41 @@ export const currentMinimumLogLevel: FiberRef.FiberRef<LogLevel.LogLevel> = glob
 )
 
 /** @internal */
-export const getConsole = (refs: FiberRefs.FiberRefs) => {
-  const defaultServicesValue = FiberRefs.getOrDefault(refs, defaultServices.currentServices)
-  const cnsl = Context.get(defaultServicesValue, consoleTag)
-  return cnsl.unsafe
-}
+export const loggerWithConsoleLog = <M, O>(self: Logger<M, O>): Logger<M, void> =>
+  internalLogger.makeLogger((opts) => {
+    const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices)
+    Context.get(services, consoleTag).unsafe.log(self.log(opts))
+  })
+
+/** @internal */
+export const loggerWithConsoleError = <M, O>(self: Logger<M, O>): Logger<M, void> =>
+  internalLogger.makeLogger((opts) => {
+    const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices)
+    Context.get(services, consoleTag).unsafe.error(self.log(opts))
+  })
 
 /** @internal */
 export const defaultLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/defaultLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.stringLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.stringLogger)
 )
 
 /** @internal */
 export const jsonLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/jsonLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.jsonLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.jsonLogger)
 )
 
 /** @internal */
 export const logFmtLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/logFmtLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.logfmtLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.logfmtLogger)
 )
 
 /** @internal */
 export const structuredLogger: Logger<unknown, void> = globalValue(
   Symbol.for("effect/Logger/structuredLogger"),
-  () =>
-    internalLogger.makeLogger((options) => {
-      const formatted = internalLogger.structuredLogger.log(options)
-      getConsole(options.context).log(formatted)
-    })
+  () => loggerWithConsoleLog(internalLogger.structuredLogger)
 )
 
 /** @internal */
@@ -2677,7 +2668,7 @@ export const scopeWith = <A, E, R>(
 
 /* @internal */
 export const scopedEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, Scope.Scope>> =>
-  core.flatMap(scopeMake(), (scope) => scopeUse(scope)(effect))
+  core.flatMap(scopeMake(), (scope) => scopeUse(effect, scope))
 
 /* @internal */
 export const sequentialFinalizers = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -2997,96 +2988,122 @@ export const withRuntimeFlagsScoped = (
   )
 }
 
-// circular with ReleaseMap
+// circular with Scope
+
+/** @internal */
+export const scopeTag = Context.GenericTag<Scope.Scope>("effect/Scope")
 
 /* @internal */
-export const releaseMapReleaseAll = (
-  strategy: ExecutionStrategy.ExecutionStrategy,
-  exit: Exit.Exit<unknown, unknown>
-) =>
-(self: core.ReleaseMap): Effect.Effect<void> =>
-  core.suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
+export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
+
+interface ScopeImpl extends Scope.CloseableScope {
+  state: {
+    readonly _tag: "Open"
+    readonly finalizers: Set<Scope.Scope.Finalizer>
+  } | {
+    readonly _tag: "Closed"
+    readonly exit: Exit.Exit<unknown, unknown>
+  }
+}
+
+const scopeUnsafeAddFinalizer = (scope: ScopeImpl, fin: Scope.Scope.Finalizer): void => {
+  if (scope.state._tag === "Open") {
+    scope.state.finalizers.add(fin)
+  }
+}
+
+const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
+  [core.ScopeTypeId]: core.ScopeTypeId,
+  [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  fork(this: ScopeImpl, strategy) {
+    return core.sync(() => {
+      const newScope = scopeUnsafeMake(strategy)
+      if (this.state._tag === "Closed") {
+        newScope.state = this.state
+        return newScope
+      }
+      const fin = (exit: Exit.Exit<unknown, unknown>) => newScope.close(exit)
+      this.state.finalizers.add(fin)
+      scopeUnsafeAddFinalizer(newScope, (_) =>
+        core.sync(() => {
+          if (this.state._tag === "Open") {
+            this.state.finalizers.delete(fin)
+          }
+        }))
+      return newScope
+    })
+  },
+  close(this: ScopeImpl, exit) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
         return core.unit
       }
-      case "Running": {
-        const finalizersMap = self.state.finalizers
-        const update = self.state.update
-        const finalizers = Array.from(finalizersMap.keys()).sort((a, b) => b - a).map((key) => finalizersMap.get(key)!)
-        self.state = { _tag: "Exited", nextKey: self.state.nextKey, exit, update }
-        return executionStrategy.isSequential(strategy) ?
-          pipe(
-            finalizers,
-            core.forEachSequential((fin) => core.exit(update(fin)(exit))),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
+      const finalizers = Array.from(this.state.finalizers.values()).reverse()
+      this.state = { _tag: "Closed", exit }
+      if (finalizers.length === 0) {
+        return core.unit
+      }
+      return executionStrategy.isSequential(this.strategy) ?
+        pipe(
+          core.forEachSequential(finalizers, (fin) => core.exit(fin(exit))),
+          core.flatMap((results) =>
+            pipe(
+              core.exitCollectAll(results),
+              Option.map(core.exitAsUnit),
+              Option.getOrElse(() => core.exitUnit)
             )
-          ) :
-          executionStrategy.isParallel(strategy) ?
-          pipe(
-            forEachParUnbounded(finalizers, (fin) => core.exit(update(fin)(exit)), false),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results, { parallel: true }),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
+          )
+        ) :
+        executionStrategy.isParallel(this.strategy) ?
+        pipe(
+          forEachParUnbounded(finalizers, (fin) => core.exit(fin(exit)), false),
+          core.flatMap((results) =>
+            pipe(
+              core.exitCollectAll(results, { parallel: true }),
+              Option.map(core.exitAsUnit),
+              Option.getOrElse(() => core.exitUnit)
             )
-          ) :
-          pipe(
-            forEachParN(finalizers, strategy.parallelism, (fin) => core.exit(update(fin)(exit)), false),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results, { parallel: true }),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
+          )
+        ) :
+        pipe(
+          forEachParN(finalizers, this.strategy.parallelism, (fin) => core.exit(fin(exit)), false),
+          core.flatMap((results) =>
+            pipe(
+              core.exitCollectAll(results, { parallel: true }),
+              Option.map(core.exitAsUnit),
+              Option.getOrElse(() => core.exitUnit)
             )
           )
+        )
+    })
+  },
+  addFinalizer(this: ScopeImpl, fin) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return fin(this.state.exit)
       }
-    }
-  })
-
-// circular with Scope
-
-/** @internal */
-export const scopeTag = Context.GenericTag<Scope.Scope>("effect/Scope")
+      this.state.finalizers.add(fin)
+      return core.unit
+    })
+  }
+}
 
-/* @internal */
-export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
+const scopeUnsafeMake = (
+  strategy: ExecutionStrategy.ExecutionStrategy = executionStrategy.sequential
+): ScopeImpl => {
+  const scope = Object.create(ScopeImplProto)
+  scope.strategy = strategy
+  scope.state = { _tag: "Open", finalizers: new Set() }
+  return scope
+}
 
 /* @internal */
 export const scopeMake = (
   strategy: ExecutionStrategy.ExecutionStrategy = executionStrategy.sequential
-): Effect.Effect<Scope.Scope.Closeable> =>
-  core.map(core.releaseMapMake, (rm): Scope.Scope.Closeable => ({
-    [core.ScopeTypeId]: core.ScopeTypeId,
-    [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
-    strategy,
-    pipe() {
-      return pipeArguments(this, arguments)
-    },
-    fork: (strategy) =>
-      core.uninterruptible(
-        pipe(
-          scopeMake(strategy),
-          core.flatMap((scope) =>
-            pipe(
-              core.releaseMapAdd(rm, (exit) => core.scopeClose(scope, exit)),
-              core.tap((fin) => core.scopeAddFinalizerExit(scope, fin)),
-              core.as(scope)
-            )
-          )
-        )
-      ),
-    close: (exit) => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
-    addFinalizer: (fin) => core.asUnit(core.releaseMapAdd(fin)(rm))
-  }))
+): Effect.Effect<Scope.Scope.Closeable> => core.sync(() => scopeUnsafeMake(strategy))
 
 /* @internal */
 export const scopeExtend = dual<
@@ -3561,15 +3578,23 @@ export const makeSpanScoped = (
     readonly context?: Context.Context<never> | undefined
   }
 ): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
-  acquireRelease(
-    internalEffect.makeSpan(name, options),
-    (span, exit) =>
-      span.status._tag === "Ended" ?
-        core.unit :
-        core.flatMap(
-          internalEffect.currentTimeNanosTracing,
-          (endTime) => core.sync(() => span.end(endTime, exit))
-        )
+  core.uninterruptible(
+    core.withFiberRuntime((fiber) => {
+      const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag)
+      const span = internalEffect.unsafeMakeSpan(fiber, name, options)
+      const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+      const clock_ = Context.get(fiber.getFiberRef(defaultServices.currentServices), clock.clockTag)
+      return core.as(
+        core.scopeAddFinalizerExit(scope, (exit) =>
+          core.sync(() => {
+            if (span.status._tag === "Ended") {
+              return
+            }
+            span.end(timingEnabled ? clock_.unsafeCurrentTimeNanos() : BigInt(0), exit)
+          })),
+        span
+      )
+    })
   )
 
 /* @internal */

package/src/internal/hashMap.ts

@@ -270,7 +270,7 @@ export const unsafeGet = Dual.dual<
 >(2, (self, key) => {
   const element = getHash(self, key, Hash.hash(key))
   if (Option.isNone(element)) {
-    throw new Error("Error: Expected map to contain key")
+    throw new Error("Expected map to contain key")
   }
   return element.value
 })

package/src/internal/matcher.ts

@@ -508,7 +508,7 @@ export const orElseAbsurd = <I, R, RA, A, Pr>(
   self: Matcher<I, R, RA, A, Pr>
 ): [Pr] extends [never] ? (input: I) => Unify<A> : Unify<A> =>
   orElse(() => {
-    throw new Error("absurd")
+    throw new Error("effect/Match/orElseAbsurd: absurd")
   })(self)
 
 /** @internal */
@@ -565,6 +565,8 @@ export const option: <I, F, R, A, Pr>(
       })
   }) as any
 
+const getExhaustiveAbsurdErrorMessage = "effect/Match/exhaustive: absurd"
+
 /** @internal */
 export const exhaustive: <I, F, A, Pr>(
   self: Matcher<I, F, never, A, Pr>
@@ -578,7 +580,7 @@ export const exhaustive: <I, F, A, Pr>(
       return toEither.right
     }
 
-    throw new Error("@effect/match: exhaustive absurd")
+    throw new Error(getExhaustiveAbsurdErrorMessage)
   }
 
   return (u: I): A => {
@@ -589,6 +591,6 @@ export const exhaustive: <I, F, A, Pr>(
       return result.right as any
     }
 
-    throw new Error("@effect/match: exhaustive absurd")
+    throw new Error(getExhaustiveAbsurdErrorMessage)
   }
 }) as any

package/src/internal/ref.ts

@@ -3,6 +3,7 @@ import { dual } from "../Function.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
+import * as Readable from "../Readable.js"
 import type * as Ref from "../Ref.js"
 import * as core from "./core.js"
 
@@ -17,7 +18,12 @@ export const refVariance = {
 
 class RefImpl<in out A> implements Ref.Ref<A> {
   readonly [RefTypeId] = refVariance
-  constructor(readonly ref: MutableRef.MutableRef<A>) {}
+  readonly [Readable.TypeId]: Readable.TypeId
+  constructor(readonly ref: MutableRef.MutableRef<A>) {
+    this[Readable.TypeId] = Readable.TypeId
+    this.get = core.sync(() => MutableRef.get(this.ref))
+  }
+  readonly get: Effect.Effect<A>
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return core.sync(() => {
       const current = MutableRef.get(this.ref)
@@ -40,7 +46,7 @@ export const unsafeMake = <A>(value: A): Ref.Ref<A> => new RefImpl(MutableRef.ma
 export const make = <A>(value: A): Effect.Effect<Ref.Ref<A>> => core.sync(() => unsafeMake(value))
 
 /** @internal */
-export const get = <A>(self: Ref.Ref<A>) => self.modify((a) => [a, a])
+export const get = <A>(self: Ref.Ref<A>) => self.get
 
 /** @internal */
 export const set = dual<

package/src/internal/schedule/intervals.ts

@@ -3,6 +3,7 @@ import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import * as Interval from "../../ScheduleInterval.js"
 import type * as Intervals from "../../ScheduleIntervals.js"
+import { getBugErrorMessage } from "../errors.js"
 
 /** @internal */
 const IntervalsSymbolKey = "effect/ScheduleIntervals"
@@ -109,7 +110,7 @@ const unionLoop = (
         that = Chunk.tailNonEmpty(that)
       }
     } else {
-      throw new Error("BUG: Intervals.unionLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+      throw new Error(getBugErrorMessage("Intervals.unionLoop"))
     }
   }
   return make(pipe(acc, Chunk.prepend(interval), Chunk.reverse))