effect 2.2.1 → 2.2.3

package/src/Effect.ts

@@ -3095,7 +3095,7 @@ export const provide: {
 
 /**
  * Provides the effect with the single service it requires. If the effect
- * requires more than one service use `provideContext` instead.
+ * requires more than one service use `provide` instead.
  *
  * @since 2.0.0
  * @category context
@@ -3114,7 +3114,7 @@ export const provideService: {
 
 /**
  * Provides the effect with the single service it requires. If the effect
- * requires more than one service use `provideContext` instead.
+ * requires more than one service use `provide` instead.
  *
  * @since 2.0.0
  * @category context
@@ -3306,6 +3306,11 @@ export const either: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Either
 export const exit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Exit.Exit<E, A>> = core.exit
 
 /**
+ * Returns an effect that will succeed or fail the specified `Deferred` based
+ * upon the result of the effect. Also synchronizes interruption, so if the
+ * provided effect is interrupted, the specified `Deferred` will be interrupted
+ * as well.
+ *
  * @since 2.0.0
  * @category conversions
  */

package/src/internal/channel.ts

@@ -1246,21 +1246,25 @@ export const mergeAllWith = (
             ),
           onSuccess: Either.match({
             onLeft: (outDone) =>
-              Effect.raceWith(Deferred.await(errorSignal), withPermits(concurrencyN)(Effect.unit), {
-                onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
-                onOtherDone: (_, failureAwait) =>
-                  Effect.zipRight(
-                    Fiber.interrupt(failureAwait),
-                    pipe(
-                      Ref.get(lastDone),
-                      Effect.flatMap(Option.match({
-                        onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
-                        onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
-                      })),
-                      Effect.as(false)
+              Effect.raceWith(
+                Effect.interruptible(Deferred.await(errorSignal)),
+                Effect.interruptible(withPermits(concurrencyN)(Effect.unit)),
+                {
+                  onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
+                  onOtherDone: (_, failureAwait) =>
+                    Effect.zipRight(
+                      Fiber.interrupt(failureAwait),
+                      pipe(
+                        Ref.get(lastDone),
+                        Effect.flatMap(Option.match({
+                          onNone: () => Queue.offer(queue, Effect.succeed(Either.left(outDone))),
+                          onSome: (lastDone) => Queue.offer(queue, Effect.succeed(Either.left(f(lastDone, outDone))))
+                        })),
+                        Effect.as(false)
+                      )
                     )
-                  )
-              }),
+                }
+              ),
             onRight: (channel) =>
               _mergeStrategy.match(mergeStrategy, {
                 onBackPressure: () =>
@@ -1273,7 +1277,7 @@ export const mergeAllWith = (
                       Effect.flatMap((pull) =>
                         Effect.race(
                           evaluatePull(pull),
-                          Deferred.await(errorSignal)
+                          Effect.interruptible(Deferred.await(errorSignal))
                         )
                       ),
                       Effect.scoped
@@ -1306,8 +1310,8 @@ export const mergeAllWith = (
                       Effect.flatMap((pull) =>
                         pipe(
                           evaluatePull(pull),
-                          Effect.race(Deferred.await(errorSignal)),
-                          Effect.race(Deferred.await(canceler))
+                          Effect.race(Effect.interruptible(Deferred.await(errorSignal))),
+                          Effect.race(Effect.interruptible(Deferred.await(canceler)))
                         )
                       ),
                       Effect.scoped

package/src/internal/fiberId.ts

@@ -35,16 +35,14 @@ const OP_COMPOSITE = "Composite" as const
 /** @internal */
 export type OP_COMPOSITE = typeof OP_COMPOSITE
 
+const emptyHash = Hash.string(`${FiberIdSymbolKey}-${OP_NONE}`)
+
 /** @internal */
 class None implements FiberId.None {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
-  readonly _tag = OP_NONE
-  readonly _hash: number
-  constructor() {
-    this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}`)
-  }
+  readonly _tag = OP_NONE;
   [Hash.symbol](): number {
-    return this._hash
+    return emptyHash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFiberId(that) && that._tag === OP_NONE
@@ -67,14 +65,15 @@ class None implements FiberId.None {
 class Runtime implements FiberId.Runtime {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
   readonly _tag = OP_RUNTIME
-  readonly _hash: number
   constructor(
     readonly id: number,
     readonly startTimeMillis: number
-  ) {
-    this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`)
-  }
+  ) {}
+  _hash: number | undefined;
   [Hash.symbol](): number {
+    if (this._hash == undefined) {
+      this._hash = Hash.string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`)
+    }
     return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
@@ -103,18 +102,20 @@ class Runtime implements FiberId.Runtime {
 class Composite implements FiberId.Composite {
   readonly [FiberIdTypeId]: FiberId.FiberIdTypeId = FiberIdTypeId
   readonly _tag = OP_COMPOSITE
-  readonly _hash: number
   constructor(
     readonly left: FiberId.FiberId,
     readonly right: FiberId.FiberId
   ) {
-    this._hash = pipe(
-      Hash.string(`${FiberIdSymbolKey}-${this._tag}`),
-      Hash.combine(Hash.hash(this.left)),
-      Hash.combine(Hash.hash(this.right))
-    )
   }
+  _hash: number | undefined;
   [Hash.symbol](): number {
+    if (this._hash == undefined) {
+      this._hash = pipe(
+        Hash.string(`${FiberIdSymbolKey}-${this._tag}`),
+        Hash.combine(Hash.hash(this.left)),
+        Hash.combine(Hash.hash(this.right))
+      )
+    }
     return this._hash
   }
   [Equal.symbol](that: unknown): boolean {

package/src/internal/scopedRef.ts

@@ -5,7 +5,6 @@ import { dual, pipe } from "../Function.js"
 import { pipeArguments } from "../Pipeable.js"
 import type * as Scope from "../Scope.js"
 import type * as ScopedRef from "../ScopedRef.js"
-import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
 import * as fiberRuntime from "./fiberRuntime.js"
@@ -34,39 +33,30 @@ const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<never, never, voi
 export const fromAcquire = <R, E, A>(
   acquire: Effect.Effect<R, E, A>
 ): Effect.Effect<R | Scope.Scope, E, ScopedRef.ScopedRef<A>> =>
-  core.uninterruptibleMask((restore) =>
-    pipe(
-      fiberRuntime.scopeMake(),
-      core.flatMap((newScope) =>
-        pipe(
-          restore(
-            pipe(
-              acquire,
-              core.mapInputContext<R, Scope.Scope | R>(Context.add(fiberRuntime.scopeTag, newScope))
-            )
-          ),
-          core.onError((cause) => newScope.close(core.exitFail(cause))),
-          core.flatMap((value) =>
-            pipe(
-              circular.makeSynchronized([newScope, value] as const),
-              core.flatMap((ref) => {
-                const scopedRef: ScopedRef.ScopedRef<A> = {
-                  [ScopedRefTypeId]: scopedRefVariance,
-                  pipe() {
-                    return pipeArguments(this, arguments)
-                  },
-                  ref
-                }
-                return pipe(
-                  fiberRuntime.addFinalizer<R | Scope.Scope, void>(() => close(scopedRef)),
-                  core.as(scopedRef)
-                )
-              })
-            )
+  core.uninterruptible(
+    fiberRuntime.scopeMake().pipe(core.flatMap((newScope) =>
+      acquire.pipe(
+        core.mapInputContext<R, Scope.Scope | R>(Context.add(fiberRuntime.scopeTag, newScope)),
+        core.onError((cause) => newScope.close(core.exitFail(cause))),
+        core.flatMap((value) =>
+          circular.makeSynchronized([newScope, value] as const).pipe(
+            core.flatMap((ref) => {
+              const scopedRef: ScopedRef.ScopedRef<A> = {
+                [ScopedRefTypeId]: scopedRefVariance,
+                pipe() {
+                  return pipeArguments(this, arguments)
+                },
+                ref
+              }
+              return pipe(
+                fiberRuntime.addFinalizer<R | Scope.Scope, void>(() => close(scopedRef)),
+                core.as(scopedRef)
+              )
+            })
           )
         )
       )
-    )
+    ))
   )
 
 /** @internal */
@@ -92,38 +82,28 @@ export const set = dual<
 ) =>
   core.flatten(
     synchronized.modifyEffect(self.ref, ([oldScope, value]) =>
-      core.uninterruptibleMask((restore) =>
-        pipe(
-          fiberRuntime.scopeMake(),
+      core.uninterruptible(
+        core.scopeClose(oldScope, core.exitUnit).pipe(
+          core.zipRight(fiberRuntime.scopeMake()),
           core.flatMap((newScope) =>
-            pipe(
-              restore(
-                pipe(
-                  acquire,
-                  core.mapInputContext<Exclude<R, Scope.Scope>, R>(
-                    Context.add(fiberRuntime.scopeTag, newScope) as any
-                  )
-                )
-              ),
-              core.exit,
-              core.flatMap(
-                core.exitMatch({
+            core.exit(fiberRuntime.scopeExtend(acquire, newScope)).pipe(
+              core.flatMap((exit) =>
+                core.exitMatch(exit, {
                   onFailure: (cause) =>
-                    pipe(
-                      newScope.close(core.exitUnit),
-                      effect.ignore,
+                    core.scopeClose(newScope, core.exitUnit).pipe(
                       core.as(
                         [
-                          core.failCause(cause) as unknown as Effect.Effect<never, never, void>,
+                          core.failCause(cause) as Effect.Effect<never, E, void>,
                           [oldScope, value] as const
                         ] as const
                       )
                     ),
                   onSuccess: (value) =>
-                    pipe(
-                      oldScope.close(core.exitUnit),
-                      effect.ignore,
-                      core.as([core.unit, [newScope, value] as const] as const)
+                    core.succeed(
+                      [
+                        core.unit as Effect.Effect<never, E, void>,
+                        [newScope, value] as const
+                      ] as const
                     )
                 })
               )

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.2.1"
+export const moduleVersion = "2.2.3"