effect 2.3.5 → 2.3.6

package/src/internal/fiberRefs.ts

@@ -12,7 +12,7 @@ import * as core from "./core.js"
 
 /** @internal */
 export function unsafeMake(
-  fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>
+  fiberRefLocals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>
 ): FiberRefs.FiberRefs {
   return new FiberRefsImpl(fiberRefLocals)
 }
@@ -31,7 +31,7 @@ export class FiberRefsImpl implements FiberRefs.FiberRefs {
   constructor(
     readonly locals: Map<
       FiberRef.FiberRef<any>,
-      Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>
+      Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>
     >
   ) {
   }
@@ -43,8 +43,8 @@ export class FiberRefsImpl implements FiberRefs.FiberRefs {
 /** @internal */
 const findAncestor = (
   _ref: FiberRef.FiberRef<any>,
-  _parentStack: ReadonlyArray<readonly [FiberId.Runtime, unknown]>,
-  _childStack: ReadonlyArray<readonly [FiberId.Runtime, unknown]>,
+  _parentStack: ReadonlyArray<readonly [FiberId.Single, unknown]>,
+  _childStack: ReadonlyArray<readonly [FiberId.Single, unknown]>,
   _childModified = false
 ): readonly [unknown, boolean] => {
   const ref = _ref
@@ -83,8 +83,8 @@ const findAncestor = (
 
 /** @internal */
 export const joinAs = dual<
-  (fiberId: FiberId.Runtime, that: FiberRefs.FiberRefs) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
-  (self: FiberRefs.FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
+  (fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (self: FiberRefs.FiberRefs, fiberId: FiberId.Single, that: FiberRefs.FiberRefs) => FiberRefs.FiberRefs
 >(3, (self, fiberId, that) => {
   const parentFiberRefs = new Map(self.locals)
   that.locals.forEach((childStack, fiberRef) => {
@@ -111,7 +111,7 @@ export const joinAs = dual<
         const oldValue = parentStack[0][1]
         const newValue = fiberRef.join(oldValue, fiberRef.patch(patch)(oldValue))
         if (!Equal.equals(oldValue, newValue)) {
-          let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>
+          let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]>
           const parentFiberId = parentStack[0][0]
           if (parentFiberId[Equal.symbol](fiberId)) {
             newStack = [[parentFiberId, newValue] as const, ...parentStack.slice(1)]
@@ -128,18 +128,18 @@ export const joinAs = dual<
 
 /** @internal */
 export const forkAs = dual<
-  (childId: FiberId.Runtime) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
-  (self: FiberRefs.FiberRefs, childId: FiberId.Runtime) => FiberRefs.FiberRefs
+  (childId: FiberId.Single) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
+  (self: FiberRefs.FiberRefs, childId: FiberId.Single) => FiberRefs.FiberRefs
 >(2, (self, childId) => {
-  const map = new Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, unknown]>>()
+  const map = new Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, unknown]>>()
   unsafeForkAs(self, map, childId)
   return new FiberRefsImpl(map)
 })
 
 const unsafeForkAs = (
   self: FiberRefs.FiberRefs,
-  map: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>,
-  fiberId: FiberId.Runtime
+  map: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>,
+  fiberId: FiberId.Single
 ) => {
   self.locals.forEach((stack, fiberRef) => {
     const oldValue = stack[0][1]
@@ -193,7 +193,7 @@ export const getOrDefault = dual<
 export const updateAs = dual<
   <A>(
     options: {
-      readonly fiberId: FiberId.Runtime
+      readonly fiberId: FiberId.Single
       readonly fiberRef: FiberRef.FiberRef<A>
       readonly value: A
     }
@@ -201,13 +201,13 @@ export const updateAs = dual<
   <A>(
     self: FiberRefs.FiberRefs,
     options: {
-      readonly fiberId: FiberId.Runtime
+      readonly fiberId: FiberId.Single
       readonly fiberRef: FiberRef.FiberRef<A>
       readonly value: A
     }
   ) => FiberRefs.FiberRefs
 >(2, <A>(self: FiberRefs.FiberRefs, { fiberId, fiberRef, value }: {
-  readonly fiberId: FiberId.Runtime
+  readonly fiberId: FiberId.Single
   readonly fiberRef: FiberRef.FiberRef<A>
   readonly value: A
 }) => {
@@ -220,13 +220,13 @@ export const updateAs = dual<
 })
 
 const unsafeUpdateAs = (
-  locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>>,
-  fiberId: FiberId.Runtime,
+  locals: Map<FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>>,
+  fiberId: FiberId.Single,
   fiberRef: FiberRef.FiberRef<any>,
   value: any
 ) => {
-  const oldStack: ReadonlyArray<readonly [FiberId.Runtime, any]> = locals.get(fiberRef) ?? []
-  let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]> | undefined
+  const oldStack: ReadonlyArray<readonly [FiberId.Single, any]> = locals.get(fiberRef) ?? []
+  let newStack: Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]> | undefined
 
   if (Arr.isNonEmptyReadonlyArray(oldStack)) {
     const [currentId, currentValue] = Arr.headNonEmpty(oldStack)
@@ -256,25 +256,25 @@ const unsafeUpdateAs = (
 export const updateManyAs = dual<
   (
     options: {
-      readonly forkAs?: FiberId.Runtime | undefined
+      readonly forkAs?: FiberId.Single | undefined
       readonly entries: Arr.NonEmptyReadonlyArray<
-        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
       >
     }
   ) => (self: FiberRefs.FiberRefs) => FiberRefs.FiberRefs,
   (
     self: FiberRefs.FiberRefs,
     options: {
-      readonly forkAs?: FiberId.Runtime | undefined
+      readonly forkAs?: FiberId.Single | undefined
       readonly entries: Arr.NonEmptyReadonlyArray<
-        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+        readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
       >
     }
   ) => FiberRefs.FiberRefs
 >(2, (self: FiberRefs.FiberRefs, { entries, forkAs }: {
-  readonly forkAs?: FiberId.Runtime | undefined
+  readonly forkAs?: FiberId.Single | undefined
   readonly entries: Arr.NonEmptyReadonlyArray<
-    readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+    readonly [FiberRef.FiberRef<any>, Arr.NonEmptyReadonlyArray<readonly [FiberId.Single, any]>]
   >
 }) => {
   if (self.locals.size === 0) {

package/src/internal/fiberRuntime.ts

@@ -28,6 +28,7 @@ import * as MRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
+import type * as Random from "../Random.js"
 import * as RA from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type { Entry, Request } from "../Request.js"
@@ -59,6 +60,7 @@ import * as metric from "./metric.js"
 import * as metricBoundaries from "./metric/boundaries.js"
 import * as metricLabel from "./metric/label.js"
 import * as OpCodes from "./opCodes/effect.js"
+import { randomTag } from "./random.js"
 import { complete } from "./request.js"
 import * as _runtimeFlags from "./runtimeFlags.js"
 import { OpSupervision } from "./runtimeFlags.js"
@@ -2705,6 +2707,10 @@ export const validateFirst = dual<
 export const withClockScoped = <A extends Clock.Clock>(value: A) =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clock.clockTag, value))
 
+/* @internal */
+export const withRandomScoped = <A extends Random.Random>(value: A) =>
+  fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, value))
+
 /* @internal */
 export const withConfigProviderScoped = (value: ConfigProvider) =>
   fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(configProviderTag, value))
@@ -3073,7 +3079,8 @@ export const fiberAwaitAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.E
 /** @internal */
 export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber<Array<A>, E> => ({
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
-  id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
+  id: () =>
+    RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none as FiberId.FiberId),
   await: core.exit(forEachParUnbounded(fibers, (fiber) => core.flatten(fiber.await), false)),
   children: core.map(forEachParUnbounded(fibers, (fiber) => fiber.children, false), RA.flatten),
   inheritAll: core.forEachSequentialDiscard(fibers, (fiber) => fiber.inheritAll),

package/src/internal/runtime.ts

@@ -388,6 +388,47 @@ export const provideService: {
     updateContext(self, Context.add(tag, service))
 )
 
+/** @internal */
+export const updateFiberRefs: {
+  (f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R>(self: Runtime.Runtime<R>, f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R>(self: Runtime.Runtime<R>, f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): Runtime.Runtime<R> =>
+    make({
+      context: self.context,
+      runtimeFlags: self.runtimeFlags,
+      fiberRefs: f(self.fiberRefs)
+    })
+)
+
+/** @internal */
+export const setFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>, value: A): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>, value: A): Runtime.Runtime<R>
+} = dual(
+  3,
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>, value: A): Runtime.Runtime<R> =>
+    updateFiberRefs(
+      self,
+      FiberRefs.updateAs({
+        fiberId: FiberId.none,
+        fiberRef,
+        value
+      })
+    )
+)
+
+/** @internal */
+export const deleteFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>): Runtime.Runtime<R> =>
+    updateFiberRefs(self, FiberRefs.delete(fiberRef))
+)
+
 /** @internal */
 export const unsafeRunEffect = unsafeRunCallback(defaultRuntime)
 

package/src/internal/tracer.ts

@@ -3,8 +3,6 @@
  */
 import * as Context from "../Context.js"
 import type * as Exit from "../Exit.js"
-import { globalValue } from "../GlobalValue.js"
-import * as MutableRef from "../MutableRef.js"
 import type * as Option from "../Option.js"
 import type * as Tracer from "../Tracer.js"
 
@@ -23,7 +21,17 @@ export const tracerTag = Context.GenericTag<Tracer.Tracer>("effect/Tracer")
 /** @internal */
 export const spanTag = Context.GenericTag<Tracer.ParentSpan>("effect/ParentSpan")
 
-const ids = globalValue("effect/Tracer/SpanId.ids", () => MutableRef.make(0))
+const randomString = (function() {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+  const charactersLength = characters.length
+  return function(length: number) {
+    let result = ""
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength))
+    }
+    return result
+  }
+})()
 
 /** @internal */
 export class NativeSpan implements Tracer.Span {
@@ -48,7 +56,7 @@ export class NativeSpan implements Tracer.Span {
       startTime
     }
     this.attributes = new Map()
-    this.spanId = `span${MutableRef.incrementAndGet(ids)}`
+    this.spanId = `span${randomString(16)}`
   }
 
   end = (endTime: bigint, exit: Exit.Exit<unknown, unknown>): void => {

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.3.5"
+export const moduleVersion = "2.3.6"