effect 3.19.0 → 3.19.2

package/src/FiberMap.ts

@@ -607,16 +607,20 @@ const runImpl = <K, A, E, R, XE extends E, XA extends A>(
     readonly propagateInterruption?: boolean | undefined
   }
 ) =>
-  Effect.fiberIdWith((fiberId) => {
+  Effect.withFiberRuntime((parent) => {
     if (self.state._tag === "Closed") {
       return Effect.interrupt
     } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
       return Effect.sync(constInterruptedFiber)
     }
-    return Effect.tap(
-      Effect.forkDaemon(effect),
-      (fiber) => unsafeSet(self, key, fiber, { ...options, interruptAs: fiberId })
-    )
+    const runtime = Runtime.make<R>({
+      context: parent.currentContext as any,
+      fiberRefs: parent.getFiberRefs(),
+      runtimeFlags: Runtime.defaultRuntime.runtimeFlags
+    })
+    const fiber = Runtime.runFork(runtime)(effect)
+    unsafeSet(self, key, fiber, { ...options, interruptAs: parent.id() })
+    return Effect.succeed(fiber)
   })
 
 /**

package/src/internal/context.ts

@@ -299,10 +299,10 @@ export const mergeAll = <T extends Array<unknown>>(
   ...ctxs: [...{ [K in keyof T]: C.Context<T[K]> }]
 ): C.Context<T[number]> => {
   const map = new Map()
-  for (const ctx of ctxs) {
-    for (const [tag, s] of ctx.unsafeMap) {
-      map.set(tag, s)
-    }
+  for (let i = 0; i < ctxs.length; i++) {
+    ctxs[i].unsafeMap.forEach((value, key) => {
+      map.set(key, value)
+    })
   }
   return makeContext(map)
 }

package/src/internal/layer.ts

@@ -1,3 +1,4 @@
+import type * as Arr from "../Array.js"
 import * as Cause from "../Cause.js"
 import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
@@ -24,6 +25,7 @@ import type * as Types from "../Types.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
+import * as ExecutionStrategy from "./executionStrategy.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as circularManagedRuntime from "./managedRuntime/circular.js"
 import * as EffectOpCodes from "./opCodes/effect.js"
@@ -84,6 +86,7 @@ export type Primitive =
   | ProvideTo
   | ZipWith
   | ZipWithPar
+  | MergeAll
 
 /** @internal */
 export type Op<Tag extends string, Body = {}> = Layer.Layer<unknown, unknown, unknown> & Body & {
@@ -168,6 +171,13 @@ export interface ZipWithPar extends
   }>
 {}
 
+/** @internal */
+export interface MergeAll extends
+  Op<OpCodes.OP_MERGE_ALL, {
+    readonly layers: Arr.NonEmptyReadonlyArray<Layer.Layer<unknown>>
+  }>
+{}
+
 /** @internal */
 export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown> => hasProperty(u, LayerTypeId)
 
@@ -444,15 +454,41 @@ const makeBuilder = <RIn, E, ROut>(
       )
     }
     case "ZipWith": {
-      return core.sync(() => (memoMap: Layer.MemoMap) =>
-        pipe(
-          memoMap.getOrElseMemoize(op.first, scope),
-          fiberRuntime.zipWithOptions(
-            memoMap.getOrElseMemoize(op.second, scope),
-            op.zipK,
-            { concurrent: true }
+      return core.gen(function*() {
+        const parallelScope = yield* core.scopeFork(scope, ExecutionStrategy.parallel)
+        const firstScope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
+        const secondScope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
+        return (memoMap: Layer.MemoMap) =>
+          pipe(
+            memoMap.getOrElseMemoize(op.first, firstScope),
+            fiberRuntime.zipWithOptions(
+              memoMap.getOrElseMemoize(op.second, secondScope),
+              op.zipK,
+              { concurrent: true }
+            )
           )
-        )
+      })
+    }
+    case "MergeAll": {
+      const layers = op.layers
+      return core.map(
+        core.scopeFork(scope, ExecutionStrategy.parallel),
+        (parallelScope) => (memoMap: Layer.MemoMap) => {
+          const contexts = new Array<Context.Context<any>>(layers.length)
+          return core.map(
+            fiberRuntime.forEachConcurrentDiscard(
+              layers,
+              core.fnUntraced(function*(layer, i) {
+                const scope = yield* core.scopeFork(parallelScope, ExecutionStrategy.sequential)
+                const context = yield* memoMap.getOrElseMemoize(layer, scope)
+                contexts[i] = context
+              }),
+              false,
+              false
+            ),
+            () => Context.mergeAll(...contexts)
+          )
+        }
       )
     }
   }
@@ -788,11 +824,10 @@ export const mergeAll = <
   { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
   { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
 > => {
-  let final = layers[0]
-  for (let i = 1; i < layers.length; i++) {
-    final = merge(final, layers[i])
-  }
-  return final as any
+  const mergeAll = Object.create(proto)
+  mergeAll._op_layer = OpCodes.OP_MERGE_ALL
+  mergeAll.layers = layers
+  return mergeAll as any
 }
 
 /** @internal */

package/src/internal/opCodes/layer.ts

@@ -46,6 +46,12 @@ export const OP_PROVIDE_MERGE = "ProvideMerge" as const
 /** @internal */
 export type OP_PROVIDE_MERGE = typeof OP_PROVIDE_MERGE
 
+/** @internal */
+export const OP_MERGE_ALL = "MergeAll" as const
+
+/** @internal */
+export type OP_MERGE_ALL = typeof OP_MERGE_ALL
+
 /** @internal */
 export const OP_ZIP_WITH = "ZipWith" as const
 

package/src/internal/version.ts

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