effect 2.3.5 → 2.3.7

package/src/internal/dataSource.ts

@@ -7,6 +7,7 @@ import { dual, pipe } from "../Function.js"
 import * as RA from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as RequestResolver from "../RequestResolver.js"
+import type { NoInfer } from "../Types.js"
 import * as core from "./core.js"
 import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
@@ -71,6 +72,32 @@ export const around = dual<
     Chunk.make("Around", self, before, after)
   ))
 
+/** @internal */
+export const aroundRequests = dual<
+  <A, R2, A2, R3, _>(
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ) => <R>(
+    self: RequestResolver.RequestResolver<A, R>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
+  <R, A, R2, A2, R3, _>(
+    self: RequestResolver.RequestResolver<A, R>,
+    before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+  ) => RequestResolver.RequestResolver<A, R | R2 | R3>
+>(3, (self, before, after) =>
+  new core.RequestResolverImpl(
+    (requests) => {
+      const flatRequests = requests.flatMap((chunk) => chunk.map((entry) => entry.request))
+      return core.acquireUseRelease(
+        before(flatRequests),
+        () => self.runAll(requests),
+        (a2) => after(flatRequests, a2)
+      )
+    },
+    Chunk.make("AroundRequests", self, before, after)
+  ))
+
 /** @internal */
 export const batchN = dual<
   (n: number) => <R, A>(

package/src/internal/defaultServices.ts

@@ -58,8 +58,8 @@ export const currentTimeNanos: Effect.Effect<bigint> = clockWith((clock) => cloc
 
 /** @internal */
 export const withClock = dual<
-  <A extends Clock.Clock>(value: A) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A extends Clock.Clock, E, R>(effect: Effect.Effect<A, E, R>, value: A) => Effect.Effect<A, E, R>
+  <X extends Clock.Clock>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <X extends Clock.Clock, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
 >(2, (effect, value) =>
   core.fiberRefLocallyWith(
     currentServices,
@@ -102,6 +102,16 @@ export const randomWith = <A, E, R>(f: (random: Random.Random) => Effect.Effect<
     (services) => f(Context.get(services, random.randomTag))
   )
 
+/** @internal */
+export const withRandom = dual<
+  <X extends Random.Random>(value: X) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <X extends Random.Random, A, E, R>(effect: Effect.Effect<A, E, R>, value: X) => Effect.Effect<A, E, R>
+>(2, (effect, value) =>
+  core.fiberRefLocallyWith(
+    currentServices,
+    Context.add(random.randomTag, value)
+  )(effect))
+
 /** @internal */
 export const next: Effect.Effect<number> = randomWith((random) => random.next)
 

package/src/internal/effectable.ts

@@ -7,7 +7,7 @@ import { pipeArguments } from "../Pipeable.js"
 import type * as Sink from "../Sink.js"
 import type * as Stream from "../Stream.js"
 import * as OpCodes from "./opCodes/effect.js"
-import { moduleVersion } from "./version.js"
+import * as version from "./version.js"
 
 /** @internal */
 export const EffectTypeId: Effect.EffectTypeId = Symbol.for("effect/Effect") as Effect.EffectTypeId
@@ -30,7 +30,7 @@ export const effectVariance = {
   /* c8 ignore next */
   _A: (_: never) => _,
 
-  _V: moduleVersion
+  _V: version.getCurrentVersion()
 }
 
 const sinkVariance = {

package/src/internal/fiberId.ts

@@ -40,7 +40,9 @@ const emptyHash = Hash.string(`${FiberIdSymbolKey}-${OP_NONE}`)
 /** @internal */
 class None implements FiberId.None {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
-  readonly _tag = OP_NONE;
+  readonly _tag = OP_NONE
+  readonly id = -1
+  readonly startTimeMillis = -1;
   [Hash.symbol](): number {
     return emptyHash
   }
@@ -141,15 +143,15 @@ class Composite implements FiberId.Composite {
 }
 
 /** @internal */
-export const none: FiberId.FiberId = new None()
+export const none: FiberId.None = new None()
 
 /** @internal */
-export const runtime = (id: number, startTimeMillis: number): FiberId.FiberId => {
+export const runtime = (id: number, startTimeMillis: number): FiberId.Runtime => {
   return new Runtime(id, startTimeMillis)
 }
 
 /** @internal */
-export const composite = (left: FiberId.FiberId, right: FiberId.FiberId): FiberId.FiberId => {
+export const composite = (left: FiberId.FiberId, right: FiberId.FiberId): FiberId.Composite => {
   return new Composite(left, right)
 }
 

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,13 +60,14 @@ 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"
 import * as supervisor from "./supervisor.js"
 import * as SupervisorPatch from "./supervisor/patch.js"
 import * as tracer from "./tracer.js"
-import { moduleVersion } from "./version.js"
+import * as version from "./version.js"
 
 /** @internal */
 export const fiberStarted = metric.counter("effect_fiber_started")
@@ -1285,11 +1287,11 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
         // @ts-expect-error
         cur = this._tracer.context(
           () => {
-            if (moduleVersion !== (cur as core.Primitive)[EffectTypeId]._V) {
+            if (version.getCurrentVersion() !== (cur as core.Primitive)[EffectTypeId]._V) {
               return core.dieMessage(
                 `Cannot execute an Effect versioned ${
                   (cur as core.Primitive)[EffectTypeId]._V
-                } with a Runtime of version ${moduleVersion}`
+                } with a Runtime of version ${version.getCurrentVersion()}`
               )
             }
             // @ts-expect-error
@@ -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/option.ts

@@ -42,6 +42,7 @@ const SomeProto = Object.assign(Object.create(CommonProto), {
   }
 })
 
+const NoneHash = Hash.hash("None")
 const NoneProto = Object.assign(Object.create(CommonProto), {
   _tag: "None",
   _op: "None",
@@ -49,7 +50,7 @@ const NoneProto = Object.assign(Object.create(CommonProto), {
     return isOption(that) && isNone(that)
   },
   [Hash.symbol]<A>(this: Option.None<A>) {
-    return Hash.combine(Hash.hash(this._tag))
+    return NoneHash
   },
   toJSON<A>(this: Option.None<A>) {
     return {

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,7 @@
-export const moduleVersion = "2.3.5"
+let moduleVersion = "2.3.7"
+
+export const getCurrentVersion = () => moduleVersion
+
+export const setCurrentVersion = (version: string) => {
+  moduleVersion = version
+}