effect 3.10.19 → 3.11.0

package/src/internal/fiberRuntime.ts

@@ -620,6 +620,27 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     this.getChildren().delete(child)
   }
 
+  /**
+   * Transfers all children of this fiber that are currently running to the
+   * specified fiber scope.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself after it has
+   * evaluated the effects but prior to exiting.
+   */
+  transferChildren(scope: fiberScope.FiberScope) {
+    const children = this._children
+    // Clear the children of the current fiber
+    this._children = null
+    if (children !== null && children.size > 0) {
+      for (const child of children) {
+        // If the child is still running, add it to the scope
+        if (child._exitValue === null) {
+          scope.add(this.currentRuntimeFlags, child)
+        }
+      }
+    }
+  }
+
   /**
    * On the current thread, executes all messages in the fiber's inbox. This
    * method may return before all work is done, in the event the fiber executes
@@ -1093,23 +1114,21 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
 
   ["Micro"](op: Micro.Micro<any, any, never> & { _op: "Micro" }) {
     return core.unsafeAsync<any, any>((microResume) => {
-      const env = Micro.envUnsafeMakeEmpty().pipe(
-        Micro.envSet(Micro.currentContext, this.getFiberRef(core.currentContext))
-      )
       let resume = microResume
-      op[Micro.runSymbol](env, (result) => {
-        if (result._tag === "Right") {
-          return resume(core.exitSucceed(result.right))
+      const fiber = Micro.runFork(Micro.provideContext(op, this.currentContext))
+      fiber.addObserver((exit) => {
+        if (exit._tag === "Success") {
+          return resume(core.exitSucceed(exit.value))
         }
-        switch (result.left._tag) {
+        switch (exit.cause._tag) {
           case "Interrupt": {
             return resume(core.exitFailCause(internalCause.interrupt(FiberId.none)))
           }
           case "Fail": {
-            return resume(core.fail(result.left.error))
+            return resume(core.fail(exit.cause.error))
           }
           case "Die": {
-            return resume(core.die(result.left.defect))
+            return resume(core.die(exit.cause.defect))
           }
         }
       })
@@ -1117,7 +1136,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
         resume = (_: any) => {
           abortResume(core.void)
         }
-        Micro.envGet(env, Micro.currentAbortController).abort()
+        fiber.unsafeInterrupt()
       })
     })
   }
@@ -2835,6 +2854,11 @@ export const scopeWith = <A, E, R>(
   f: (scope: Scope.Scope) => Effect.Effect<A, E, R>
 ): Effect.Effect<A, E, R | Scope.Scope> => core.flatMap(scopeTag, f)
 
+/** @internal */
+export const scopedWith = <A, E, R>(
+  f: (scope: Scope.Scope) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R> => core.flatMap(scopeMake(), (scope) => core.onExit(f(scope), (exit) => scope.close(exit)))
+
 /* @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(effect, scope))
@@ -2878,12 +2902,7 @@ export const using = dual<
     self: Effect.Effect<A, E, R>,
     use: (a: A) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A2, E | E2, Exclude<R, Scope.Scope> | R2>
->(2, (self, use) =>
-  core.acquireUseRelease(
-    scopeMake(),
-    (scope) => core.flatMap(scopeExtend(self, scope), use),
-    (scope, exit) => core.scopeClose(scope, exit)
-  ))
+>(2, (self, use) => scopedWith((scope) => core.flatMap(scopeExtend(self, scope), use)))
 
 /** @internal */
 export const validate = dual<

package/src/internal/groupBy.ts

@@ -12,6 +12,7 @@ import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, type Predicate } from "../Predicate.js"
 import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
+import * as Scope from "../Scope.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
 import type { NoInfer } from "../Types.js"
@@ -487,29 +488,19 @@ export const groupByKey = dual<
             )
           )
       })
-    return make(stream.unwrapScoped(
-      pipe(
-        Effect.sync(() => new Map<K, Queue.Queue<Take.Take<A, E>>>()),
-        Effect.flatMap((map) =>
-          pipe(
-            Effect.acquireRelease(
-              Queue.unbounded<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>(),
-              (queue) => Queue.shutdown(queue)
-            ),
-            Effect.flatMap((queue) =>
-              pipe(
-                self,
-                stream.toChannel,
-                core.pipeTo(loop(map, queue)),
-                channel.drain,
-                channelExecutor.runScoped,
-                Effect.forkScoped,
-                Effect.as(stream.flattenTake(stream.fromQueue(queue, { shutdown: true })))
-              )
-            )
-          )
+    return make(stream.unwrapScopedWith((scope) =>
+      Effect.gen(function*() {
+        const map = new Map<K, Queue.Queue<Take.Take<A, E>>>()
+        const queue = yield* Queue.unbounded<Take.Take<readonly [K, Queue.Queue<Take.Take<A, E>>], E>>()
+        yield* Scope.addFinalizer(scope, Queue.shutdown(queue))
+        return yield* stream.toChannel(self).pipe(
+          core.pipeTo(loop(map, queue)),
+          channel.drain,
+          channelExecutor.runIn(scope),
+          Effect.forkIn(scope),
+          Effect.as(stream.flattenTake(stream.fromQueue(queue, { shutdown: true })))
         )
-      )
+      })
     ))
   }
 )

package/src/internal/layer.ts

@@ -1274,14 +1274,11 @@ const provideSomeLayer = dual<
     layer: Layer.Layer<A2, E2, R2>
   ) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>
 >(2, (self, layer) =>
-  core.acquireUseRelease(
-    fiberRuntime.scopeMake(),
-    (scope) =>
-      core.flatMap(
-        buildWithScope(layer, scope),
-        (context) => core.provideSomeContext(self, context)
-      ),
-    (scope, exit) => core.scopeClose(scope, exit)
+  fiberRuntime.scopedWith((scope) =>
+    core.flatMap(
+      buildWithScope(layer, scope),
+      (context) => core.provideSomeContext(self, context)
+    )
   ))
 
 const provideSomeRuntime = dual<

package/src/internal/mailbox.ts

@@ -547,10 +547,12 @@ export const fromStream: {
         onFailure: (cause: Cause<E>) => mailbox.failCause(cause),
         onDone: () => mailbox.end
       })
-      return stream.toChannel(self).pipe(
-        coreChannel.pipeTo(writer),
-        channelExecutor.runScoped,
-        circular.forkScoped
+      return channel.unwrapScopedWith((scope) =>
+        stream.toChannel(self).pipe(
+          coreChannel.pipeTo(writer),
+          channelExecutor.runIn(scope),
+          circular.forkIn(scope)
+        )
       )
     }
   ))

package/src/internal/sink.ts

@@ -19,7 +19,7 @@ import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
 import * as PubSub from "../PubSub.js"
 import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
-import type * as Scope from "../Scope.js"
+import * as Scope from "../Scope.js"
 import type * as Sink from "../Sink.js"
 import * as channel from "./channel.js"
 import * as mergeDecision from "./channel/mergeDecision.js"
@@ -1656,38 +1656,43 @@ export const raceWith = dual<
       readonly capacity?: number | undefined
     }
   ): Sink.Sink<A3 | A4, In & In2, L2 | L, E2 | E, R2 | R> => {
-    const scoped = Effect.gen(function*($) {
-      const pubsub = yield* $(
-        PubSub.bounded<Either.Either<Chunk.Chunk<In & In2>, Exit.Exit<unknown>>>(options?.capacity ?? 16)
-      )
-      const channel1 = yield* $(channel.fromPubSubScoped(pubsub))
-      const channel2 = yield* $(channel.fromPubSubScoped(pubsub))
-      const reader = channel.toPubSub(pubsub)
-      const writer = pipe(
-        channel1,
-        core.pipeTo(toChannel(self)),
-        channel.mergeWith({
-          other: pipe(channel2, core.pipeTo(toChannel(options.other))),
-          onSelfDone: options.onSelfDone,
-          onOtherDone: options.onOtherDone
-        })
-      )
-      const racedChannel: Channel.Channel<
-        Chunk.Chunk<L | L2>,
-        Chunk.Chunk<In & In2>,
-        E | E2,
-        never,
-        A3 | A4,
-        unknown,
-        R | R2
-      > = channel.mergeWith(reader, {
-        other: writer,
-        onSelfDone: (_) => mergeDecision.Await((exit) => Effect.suspend(() => exit)),
-        onOtherDone: (done) => mergeDecision.Done(Effect.suspend(() => done))
+    function race(scope: Scope.Scope) {
+      return Effect.gen(function*() {
+        const pubsub = yield* PubSub.bounded<
+          Either.Either<Chunk.Chunk<In & In2>, Exit.Exit<unknown>>
+        >(options?.capacity ?? 16)
+        const subscription1 = yield* Scope.extend(PubSub.subscribe(pubsub), scope)
+        const subscription2 = yield* Scope.extend(PubSub.subscribe(pubsub), scope)
+        const reader = channel.toPubSub(pubsub)
+        const writer = channel.fromQueue(subscription1).pipe(
+          core.pipeTo(toChannel(self)),
+          channel.zipLeft(core.fromEffect(Queue.shutdown(subscription1))),
+          channel.mergeWith({
+            other: channel.fromQueue(subscription2).pipe(
+              core.pipeTo(toChannel(options.other)),
+              channel.zipLeft(core.fromEffect(Queue.shutdown(subscription2)))
+            ),
+            onSelfDone: options.onSelfDone,
+            onOtherDone: options.onOtherDone
+          })
+        )
+        const racedChannel = channel.mergeWith(reader, {
+          other: writer,
+          onSelfDone: () => mergeDecision.Await(identity),
+          onOtherDone: (exit) => mergeDecision.Done(exit)
+        }) as Channel.Channel<
+          Chunk.Chunk<L | L2>,
+          Chunk.Chunk<In & In2>,
+          E | E2,
+          never,
+          A3 | A4,
+          unknown,
+          R | R2
+        >
+        return new SinkImpl(racedChannel)
       })
-      return new SinkImpl(racedChannel)
-    })
-    return unwrapScoped(scoped)
+    }
+    return unwrapScopedWith(race)
   }
 )
 
@@ -1923,9 +1928,24 @@ export const unwrap = <A, In, L, E2, R2, E, R>(
 /** @internal */
 export const unwrapScoped = <A, In, L, E, R>(
   effect: Effect.Effect<Sink.Sink<A, In, L, E, R>, E, R>
-): Sink.Sink<A, In, L, E, Exclude<R, Scope.Scope>> => {
-  return new SinkImpl(channel.unwrapScoped(pipe(effect, Effect.map((sink) => toChannel(sink)))))
-}
+): Sink.Sink<A, In, L, E, Exclude<R, Scope.Scope>> =>
+  new SinkImpl(
+    channel.unwrapScoped(effect.pipe(
+      Effect.map((sink) => toChannel(sink))
+    ))
+  )
+
+/** @internal */
+export const unwrapScopedWith = <A, In, L, E, R>(
+  f: (scope: Scope.Scope) => Effect.Effect<Sink.Sink<A, In, L, E, R>, E, R>
+): Sink.Sink<A, In, L, E, R> =>
+  new SinkImpl(
+    channel.unwrapScopedWith((scope) =>
+      f(scope).pipe(
+        Effect.map((sink) => toChannel(sink))
+      )
+    )
+  )
 
 /** @internal */
 export const withDuration = <A, In, L, E, R>(