effect 2.4.18 → 2.4.19

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

@@ -2668,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> =>
@@ -2988,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<
@@ -3552,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))

package/src/internal/subscriptionRef.ts

@@ -2,8 +2,10 @@ import * as Effect from "../Effect.js"
 import { dual, pipe } from "../Function.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as PubSub from "../PubSub.js"
+import * as Readable from "../Readable.js"
 import * as Ref from "../Ref.js"
 import type { Stream } from "../Stream.js"
+import * as Subscribable from "../Subscribable.js"
 import type * as SubscriptionRef from "../SubscriptionRef.js"
 import * as Synchronized from "../SynchronizedRef.js"
 import * as _circular from "./effect/circular.js"
@@ -25,6 +27,8 @@ const subscriptionRefVariance = {
 
 /** @internal */
 class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A> {
+  readonly [Readable.TypeId]: Readable.TypeId
+  readonly [Subscribable.TypeId]: Subscribable.TypeId
   readonly [Ref.RefTypeId] = _ref.refVariance
   readonly [Synchronized.SynchronizedRefTypeId] = _circular.synchronizedVariance
   readonly [SubscriptionRefTypeId] = subscriptionRefVariance
@@ -33,10 +37,14 @@ class SubscriptionRefImpl<in out A> implements SubscriptionRef.SubscriptionRef<A
     readonly pubsub: PubSub.PubSub<A>,
     readonly semaphore: Effect.Semaphore
   ) {
+    this[Readable.TypeId] = Readable.TypeId
+    this[Subscribable.TypeId] = Subscribable.TypeId
+    this.get = Ref.get(this.ref)
   }
   pipe() {
     return pipeArguments(this, arguments)
   }
+  readonly get: Effect.Effect<A>
   get changes(): Stream<A> {
     return pipe(
       Ref.get(this.ref),

package/src/internal/trie.ts

@@ -420,7 +420,7 @@ export const unsafeGet = dual<
 >(2, (self, key) => {
   const element = get(self, key)
   if (Option.isNone(element)) {
-    throw new Error("Error: Expected trie to contain key")
+    throw new Error("Expected trie to contain key")
   }
   return element.value
 })

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "2.4.18"
+let moduleVersion = "2.4.19"
 
 export const getCurrentVersion = () => moduleVersion