effect 2.0.0-next.57 → 2.0.0-next.59

package/src/internal/fiberRuntime.ts

@@ -126,6 +126,14 @@ const absurd = (_: never): never => {
   )
 }
 
+const YieldedOp = Symbol.for("effect/internal/fiberRuntime/YieldedOp")
+type YieldedOp = typeof YieldedOp
+const yieldedOpChannel: {
+  currentOp: core.Primitive | null
+} = globalValue("effect/internal/fiberRuntime/yieldedOpChannel", () => ({
+  currentOp: null
+}))
+
 const contOpSuccess = {
   [OpCodes.OP_ON_SUCCESS]: (
     _: FiberRuntime<any, any>,
@@ -539,7 +547,7 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   setFiberRef<X>(fiberRef: FiberRef.FiberRef<X>, value: X): void {
-    this._fiberRefs = fiberRefs.updatedAs(this._fiberRefs, {
+    this._fiberRefs = fiberRefs.updateAs(this._fiberRefs, {
       fiberId: this._fiberId,
       fiberRef,
       value
@@ -744,6 +752,9 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
   reportExitValue(exit: Exit.Exit<E, A>) {
     if (_runtimeFlags.runtimeMetrics(this._runtimeFlags)) {
       const tags = this.getFiberRef(core.currentMetricLabels)
+      const startTimeMillis = this.id().startTimeMillis
+      const endTimeMillis = Date.now()
+      fiberLifetimes.unsafeUpdate(endTimeMillis - startTimeMillis, tags)
       fiberActive.unsafeUpdate(-1, tags)
       switch (exit._tag) {
         case OpCodes.OP_SUCCESS: {
@@ -766,16 +777,7 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
 
   setExitValue(exit: Exit.Exit<E, A>) {
     this._exitValue = exit
-
-    if (_runtimeFlags.runtimeMetrics(this._runtimeFlags)) {
-      const tags = this.getFiberRef(core.currentMetricLabels)
-      const startTimeMillis = this.id().startTimeMillis
-      const endTimeMillis = new Date().getTime()
-      fiberLifetimes.unsafeUpdate(endTimeMillis - startTimeMillis, tags)
-    }
-
     this.reportExitValue(exit)
-
     for (let i = this._observers.length - 1; i >= 0; i--) {
       this._observers[i](exit)
     }
@@ -873,9 +875,24 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
           core.exitFailCause(this.getInterruptedCause()) :
           effect0
       while (effect !== null) {
-        try {
-          const eff: Effect.Effect<any, any, any> = effect
-          const exit = this.runLoop(eff)
+        const eff: Effect.Effect<any, any, any> = effect
+        const exit = this.runLoop(eff)
+        if (exit === YieldedOp) {
+          const op = yieldedOpChannel.currentOp!
+          yieldedOpChannel.currentOp = null
+          if (op._op === OpCodes.OP_YIELD) {
+            if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
+              this.tell(FiberMessage.yieldNow())
+              this.tell(FiberMessage.resume(core.exitUnit))
+              effect = null
+            } else {
+              effect = core.exitUnit
+            }
+          } else if (op._op === OpCodes.OP_ASYNC) {
+            // Terminate this evaluation, async resumption will continue evaluation:
+            effect = null
+          }
+        } else {
           this._runtimeFlags = pipe(this._runtimeFlags, _runtimeFlags.enable(_runtimeFlags.WindDown))
           const interruption = this.interruptAllChildren()
           if (interruption !== null) {
@@ -892,23 +909,6 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
             }
             effect = null
           }
-        } catch (e) {
-          if (core.isEffect(e)) {
-            if ((e as core.Primitive)._op === OpCodes.OP_YIELD) {
-              if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
-                this.tell(FiberMessage.yieldNow())
-                this.tell(FiberMessage.resume(core.exitUnit))
-                effect = null
-              } else {
-                effect = core.exitUnit
-              }
-            } else if ((e as core.Primitive)._op === OpCodes.OP_ASYNC) {
-              // Terminate this evaluation, async resumption will continue evaluation:
-              effect = null
-            }
-          } else {
-            throw e
-          }
         }
       }
     } finally {
@@ -1071,7 +1071,8 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
       // @ts-expect-error
       return contOpSuccess[cont._op](this, cont, value)
     } else {
-      throw core.exitSucceed(value)
+      yieldedOpChannel.currentOp = core.exitSucceed(value) as any
+      return YieldedOp
     }
   }
 
@@ -1086,7 +1087,8 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
       // @ts-expect-error
       return contOpSuccess[cont._op](this, cont, oldCur.i0)
     } else {
-      throw oldCur
+      yieldedOpChannel.currentOp = oldCur
+      return YieldedOp
     }
   }
 
@@ -1123,7 +1125,8 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
         }
       }
     } else {
-      throw core.exitFailCause(cause)
+      yieldedOpChannel.currentOp = core.exitFailCause(cause) as any
+      return YieldedOp
     }
   }
 
@@ -1222,12 +1225,14 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
   [OpCodes.OP_ASYNC](op: core.Primitive & { _op: OpCodes.OP_ASYNC }) {
     this._asyncBlockingOn = op.i1
     this.initiateAsync(this._runtimeFlags, op.i0)
-    throw op
+    yieldedOpChannel.currentOp = op
+    return YieldedOp
   }
 
   [OpCodes.OP_YIELD](op: core.Primitive & { op: OpCodes.OP_YIELD }) {
     this.isYielding = false
-    throw op
+    yieldedOpChannel.currentOp = op
+    return YieldedOp
   }
 
   [OpCodes.OP_WHILE](op: core.Primitive & { _op: OpCodes.OP_WHILE }) {
@@ -1250,8 +1255,8 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
    *
    * **NOTE**: This method must be invoked by the fiber itself.
    */
-  runLoop(effect0: Effect.Effect<any, any, any>): Exit.Exit<any, any> {
-    let cur = effect0
+  runLoop(effect0: Effect.Effect<any, any, any>): Exit.Exit<any, any> | YieldedOp {
+    let cur: Effect.Effect<any, any, any> | YieldedOp = effect0
     this.currentOpCount = 0
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -1292,22 +1297,26 @@ export class FiberRuntime<in out E, in out A> implements Fiber.RuntimeFiber<E, A
           },
           this
         )
-      } catch (e) {
-        if (core.isEffect(e)) {
+
+        if (cur === YieldedOp) {
+          const op = yieldedOpChannel.currentOp!
           if (
-            (e as core.Primitive)._op === OpCodes.OP_YIELD ||
-            (e as core.Primitive)._op === OpCodes.OP_ASYNC
-          ) {
-            throw e
-          } else if (
-            (e as core.Primitive)._op === OpCodes.OP_SUCCESS ||
-            (e as core.Primitive)._op === OpCodes.OP_FAILURE
+            op._op === OpCodes.OP_YIELD ||
+            op._op === OpCodes.OP_ASYNC
           ) {
-            return e as Exit.Exit<E, A>
-          } else {
-            cur = core.exitFailCause(internalCause.die(e))
+            return YieldedOp
           }
-        } else if (core.isEffectError(e)) {
+
+          yieldedOpChannel.currentOp = null
+          return (
+              op._op === OpCodes.OP_SUCCESS ||
+              op._op === OpCodes.OP_FAILURE
+            ) ?
+            op as unknown as Exit.Exit<E, A> :
+            core.exitFailCause(internalCause.die(op))
+        }
+      } catch (e) {
+        if (core.isEffectError(e)) {
           cur = core.exitFailCause(e.cause)
         } else if (core.isInterruptedException(e)) {
           cur = core.exitFailCause(
@@ -2596,14 +2605,9 @@ export const tagMetricsScoped = (key: string, value: string): Effect.Effect<Scop
 
 /* @internal */
 export const labelMetricsScoped = (
-  labels: ReadonlyArray<MetricLabel.MetricLabel>
-): Effect.Effect<Scope.Scope, never, void> => labelMetricsScopedSet(HashSet.fromIterable(labels))
-
-/* @internal */
-export const labelMetricsScopedSet = (
-  labels: HashSet.HashSet<MetricLabel.MetricLabel>
+  labels: Iterable<MetricLabel.MetricLabel>
 ): Effect.Effect<Scope.Scope, never, void> =>
-  fiberRefLocallyScopedWith(core.currentMetricLabels, (set) => pipe(set, HashSet.union(labels)))
+  fiberRefLocallyScopedWith(core.currentMetricLabels, (old) => RA.union(old, labels))
 
 /* @internal */
 export const using = dual<
@@ -3081,7 +3085,7 @@ export const fiberAll = <E, A>(fibers: Iterable<Fiber.Fiber<E, A>>): Fiber.Fiber
   [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
   id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
   await: core.exit(forEachParUnbounded(fibers, (fiber) => core.flatten(fiber.await), false)),
-  children: core.map(forEachParUnbounded(fibers, (fiber) => fiber.children, false), (children) => RA.flatten(children)),
+  children: core.map(forEachParUnbounded(fibers, (fiber) => fiber.children, false), RA.flatten),
   inheritAll: core.forEachSequentialDiscard(fibers, (fiber) => fiber.inheritAll),
   poll: core.map(
     core.forEachSequential(fibers, (fiber) => fiber.poll),

package/src/internal/layer.ts

@@ -55,6 +55,14 @@ const proto = {
   }
 }
 
+/** @internal */
+const MemoMapTypeIdKey = "effect/Layer/MemoMap"
+
+/** @internal */
+export const MemoMapTypeId: Layer.MemoMapTypeId = Symbol.for(
+  MemoMapTypeIdKey
+) as Layer.MemoMapTypeId
+
 /** @internal */
 export type Primitive =
   | ExtendScope
@@ -164,7 +172,8 @@ export const isFresh = <R, E, A>(self: Layer.Layer<R, E, A>): boolean => {
 // -----------------------------------------------------------------------------
 
 /** @internal */
-class MemoMap {
+class MemoMapImpl implements Layer.MemoMap {
+  readonly [MemoMapTypeId]: Layer.MemoMapTypeId
   constructor(
     readonly ref: Synchronized.SynchronizedRef<
       Map<
@@ -173,6 +182,7 @@ class MemoMap {
       >
     >
   ) {
+    this[MemoMapTypeId] = MemoMapTypeId
   }
 
   /**
@@ -214,7 +224,7 @@ class MemoMap {
                         core.flatMap((innerScope) =>
                           pipe(
                             restore(core.flatMap(
-                              withScope(layer, innerScope),
+                              makeBuilder(layer, innerScope, true),
                               (f) => effect.diffFiberRefs(f(this))
                             )),
                             core.exit,
@@ -241,7 +251,8 @@ class MemoMap {
                                     core.zipRight(
                                       core.scopeAddFinalizerExit(scope, (exit) =>
                                         pipe(
-                                          ref.get(finalizerRef),
+                                          core.sync(() => map.delete(layer)),
+                                          core.zipRight(ref.get(finalizerRef)),
                                           core.flatMap((finalizer) => finalizer(exit))
                                         ))
                                     ),
@@ -285,7 +296,8 @@ class MemoMap {
   }
 }
 
-const makeMemoMap = (): Effect.Effect<never, never, MemoMap> =>
+/** @internal */
+export const makeMemoMap: Effect.Effect<never, never, Layer.MemoMap> = core.suspend(() =>
   core.map(
     circular.makeSynchronized<
       Map<
@@ -296,8 +308,9 @@ const makeMemoMap = (): Effect.Effect<never, never, MemoMap> =>
         ]
       >
     >(new Map()),
-    (ref) => new MemoMap(ref)
+    (ref) => new MemoMapImpl(ref)
   )
+)
 
 /** @internal */
 export const build = <RIn, E, ROut>(
@@ -316,28 +329,42 @@ export const buildWithScope = dual<
   ) => Effect.Effect<RIn, E, Context.Context<ROut>>
 >(2, (self, scope) =>
   core.flatMap(
-    makeMemoMap(),
-    (memoMap) => core.flatMap(withScope(self, scope), (run) => run(memoMap))
+    makeMemoMap,
+    (memoMap) => core.flatMap(makeBuilder(self, scope), (run) => run(memoMap))
   ))
 
-const withScope = <RIn, E, ROut>(
+/** @internal */
+export const buildWithMemoMap = dual<
+  (
+    memoMap: Layer.MemoMap,
+    scope: Scope.Scope
+  ) => <RIn, E, ROut>(self: Layer.Layer<RIn, E, ROut>) => Effect.Effect<RIn, E, Context.Context<ROut>>,
+  <RIn, E, ROut>(
+    self: Layer.Layer<RIn, E, ROut>,
+    memoMap: Layer.MemoMap,
+    scope: Scope.Scope
+  ) => Effect.Effect<RIn, E, Context.Context<ROut>>
+>(3, (self, memoMap, scope) => core.flatMap(makeBuilder(self, scope), (run) => run(memoMap)))
+
+const makeBuilder = <RIn, E, ROut>(
   self: Layer.Layer<RIn, E, ROut>,
-  scope: Scope.Scope
-): Effect.Effect<never, never, (memoMap: MemoMap) => Effect.Effect<RIn, E, Context.Context<ROut>>> => {
+  scope: Scope.Scope,
+  inMemoMap = false
+): Effect.Effect<never, never, (memoMap: Layer.MemoMap) => Effect.Effect<RIn, E, Context.Context<ROut>>> => {
   const op = self as Primitive
   switch (op._tag) {
     case "Locally": {
-      return core.sync(() => (memoMap: MemoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope)))
+      return core.sync(() => (memoMap: Layer.MemoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope)))
     }
     case "ExtendScope": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         fiberRuntime.scopeWith(
           (scope) => memoMap.getOrElseMemoize(op.layer, scope)
         ) as unknown as Effect.Effect<RIn, E, Context.Context<ROut>>
       )
     }
     case "Fold": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.layer, scope),
           core.matchCauseEffect({
@@ -348,13 +375,15 @@ const withScope = <RIn, E, ROut>(
       )
     }
     case "Fresh": {
-      return core.sync(() => (_: MemoMap) => pipe(op.layer, buildWithScope(scope)))
+      return core.sync(() => (_: Layer.MemoMap) => pipe(op.layer, buildWithScope(scope)))
     }
     case "FromEffect": {
-      return core.sync(() => (_: MemoMap) => op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>)
+      return inMemoMap
+        ? core.sync(() => (_: Layer.MemoMap) => op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>)
+        : core.sync(() => (memoMap: Layer.MemoMap) => memoMap.getOrElseMemoize(self, scope))
     }
     case "Provide": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
           core.flatMap((env) =>
@@ -367,15 +396,17 @@ const withScope = <RIn, E, ROut>(
       )
     }
     case "Scoped": {
-      return core.sync(() => (_: MemoMap) =>
-        fiberRuntime.scopeExtend(
-          op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>,
-          scope
+      return inMemoMap
+        ? core.sync(() => (_: Layer.MemoMap) =>
+          fiberRuntime.scopeExtend(
+            op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>,
+            scope
+          )
         )
-      )
+        : core.sync(() => (memoMap: Layer.MemoMap) => memoMap.getOrElseMemoize(self, scope))
     }
     case "Suspend": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         memoMap.getOrElseMemoize(
           op.evaluate(),
           scope
@@ -383,7 +414,7 @@ const withScope = <RIn, E, ROut>(
       )
     }
     case "ProvideMerge": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
           core.zipWith(
@@ -394,7 +425,7 @@ const withScope = <RIn, E, ROut>(
       )
     }
     case "ZipWith": {
-      return core.sync(() => (memoMap: MemoMap) =>
+      return core.sync(() => (memoMap: Layer.MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
           fiberRuntime.zipWithOptions(
@@ -828,9 +859,7 @@ export const scoped = dual<
 /** @internal */
 export const scopedDiscard = <R, E, _>(
   effect: Effect.Effect<R, E, _>
-): Layer.Layer<Exclude<R, Scope.Scope>, E, never> => {
-  return scopedContext(pipe(effect, core.as(Context.empty())))
-}
+): Layer.Layer<Exclude<R, Scope.Scope>, E, never> => scopedContext(pipe(effect, core.as(Context.empty())))
 
 /** @internal */
 export const scopedContext = <R, E, A>(
@@ -856,9 +885,7 @@ export const scope: Layer.Layer<never, never, Scope.Scope.Closeable> = scopedCon
 /** @internal */
 export const service = <T extends Context.Tag<any, any>>(
   tag: T
-): Layer.Layer<Context.Tag.Identifier<T>, never, Context.Tag.Identifier<T>> => {
-  return fromEffect(tag, tag)
-}
+): Layer.Layer<Context.Tag.Identifier<T>, never, Context.Tag.Identifier<T>> => fromEffect(tag, tag)
 
 /** @internal */
 export const succeed = dual<

package/src/internal/metric/boundaries.ts

@@ -18,13 +18,16 @@ export const MetricBoundariesTypeId: MetricBoundaries.MetricBoundariesTypeId = S
 /** @internal */
 class MetricBoundariesImpl implements MetricBoundaries.MetricBoundaries {
   readonly [MetricBoundariesTypeId]: MetricBoundaries.MetricBoundariesTypeId = MetricBoundariesTypeId
-  constructor(readonly values: Chunk.Chunk<number>) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(MetricBoundariesSymbolKey),
-      Hash.combine(Hash.hash(this.values))
+  constructor(readonly values: ReadonlyArray<number>) {
+    this._hash = pipe(
+      Hash.string(MetricBoundariesSymbolKey),
+      Hash.combine(Hash.array(this.values))
     )
   }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
   [Equal.symbol](u: unknown): boolean {
     return isMetricBoundaries(u) && Equal.equals(this.values, u.values)
   }
@@ -38,11 +41,11 @@ export const isMetricBoundaries = (u: unknown): u is MetricBoundaries.MetricBoun
   hasProperty(u, MetricBoundariesTypeId)
 
 /** @internal */
-export const fromChunk = (chunk: Chunk.Chunk<number>): MetricBoundaries.MetricBoundaries => {
+export const fromIterable = (iterable: Iterable<number>): MetricBoundaries.MetricBoundaries => {
   const values = pipe(
-    chunk,
-    Chunk.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
-    Chunk.dedupe
+    iterable,
+    ReadonlyArray.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
+    ReadonlyArray.dedupe
   )
   return new MetricBoundariesImpl(values)
 }
@@ -56,7 +59,7 @@ export const linear = (options: {
   pipe(
     ReadonlyArray.makeBy(options.count - 1, (i) => options.start + i * options.width),
     Chunk.unsafeFromArray,
-    fromChunk
+    fromIterable
   )
 
 /** @internal */
@@ -68,5 +71,5 @@ export const exponential = (options: {
   pipe(
     ReadonlyArray.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
     Chunk.unsafeFromArray,
-    fromChunk
+    fromIterable
   )