effect 2.4.18 → 3.0.0

package/src/internal/fiber.ts

@@ -81,9 +81,9 @@ export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => ({
   id: () => FiberId.none,
   await: core.succeed(exit),
   children: core.succeed([]),
-  inheritAll: core.unit,
+  inheritAll: core.void,
   poll: core.succeed(Option.some(exit)),
-  interruptAsFork: () => core.unit
+  interruptAsFork: () => core.void
 })
 
 /** @internal */
@@ -254,7 +254,7 @@ export const orElse = dual<
     pipe(
       core.interruptAsFiber(self, id),
       core.zipRight(pipe(that, core.interruptAsFiber(id))),
-      core.asUnit
+      core.asVoid
     )
 }))
 
@@ -334,8 +334,11 @@ export const status = <A, E>(self: Fiber.RuntimeFiber<A, E>): Effect.Effect<Fibe
 /** @internal */
 export const succeed = <A>(value: A): Fiber.Fiber<A> => done(Exit.succeed(value))
 
-/** @internal */
-export const unit: Fiber.Fiber<void> = succeed(void 0)
+const void_: Fiber.Fiber<void> = succeed(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const currentFiberURI = "effect/FiberCurrent"

package/src/internal/fiberRefs/patch.ts

@@ -1,9 +1,9 @@
+import * as Arr from "../../Array.js"
 import { equals } from "../../Equal.js"
 import type * as FiberId from "../../FiberId.js"
 import type * as FiberRefs from "../../FiberRefs.js"
 import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
 import { dual } from "../../Function.js"
-import * as Arr from "../../ReadonlyArray.js"
 import * as _fiberRefs from "../fiberRefs.js"
 
 /** @internal */

package/src/internal/fiberRefs.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Effect from "../Effect.js"
 import * as Equal from "../Equal.js"
 import type * as FiberId from "../FiberId.js"
@@ -7,7 +8,6 @@ import { dual, pipe } from "../Function.js"
 import * as HashSet from "../HashSet.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as Arr from "../ReadonlyArray.js"
 import * as core from "./core.js"
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -1,3 +1,4 @@
+import * as RA from "../Array.js"
 import * as Boolean from "../Boolean.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -31,7 +32,6 @@ 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"
 import type * as RequestBlock from "../RequestBlock.js"
@@ -41,7 +41,7 @@ import { currentScheduler, type Scheduler } from "../Scheduler.js"
 import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
-import type { Concurrency, NoInfer } from "../Types.js"
+import type { Concurrency } from "../Types.js"
 import * as _RequestBlock from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"
@@ -184,7 +184,7 @@ const contOpSuccess = {
       self.pushStack(cont)
       return cont.effect_instruction_i1()
     } else {
-      return core.unit
+      return core.void
     }
   }
 }
@@ -743,7 +743,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
       const body = () => {
         const next = it.next()
         if (!next.done) {
-          return core.asUnit(next.value.await)
+          return core.asVoid(next.value.await)
         } else {
           return core.sync(() => {
             isDone = true
@@ -895,10 +895,10 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
           if (op._op === OpCodes.OP_YIELD) {
             if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
               this.tell(FiberMessage.yieldNow())
-              this.tell(FiberMessage.resume(core.exitUnit))
+              this.tell(FiberMessage.resume(core.exitVoid))
               effect = null
             } else {
-              effect = core.exitUnit
+              effect = core.exitVoid
             }
           } else if (op._op === OpCodes.OP_ASYNC) {
             // Terminate this evaluation, async resumption will continue evaluation:
@@ -1209,7 +1209,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
         this.pushStack(new core.RevertFlags(revertFlags, op))
         return op.effect_instruction_i1(oldRuntimeFlags)
       } else {
-        return core.exitUnit
+        return core.exitVoid
       }
     }
   }
@@ -1254,7 +1254,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
       this.pushStack(op)
       return body()
     } else {
-      return core.exitUnit
+      return core.exitVoid
     }
   }
 
@@ -1477,7 +1477,7 @@ export const batchedLogger = dual<
     let buffer: Array<Output> = []
     const flush = core.suspend(() => {
       if (buffer.length === 0) {
-        return core.unit
+        return core.void
       }
       const arr = buffer
       buffer = []
@@ -1597,7 +1597,7 @@ export const exists: {
         core.matchEffect(
           forEach(
             elements,
-            (a, i) => core.if_(f(a, i), { onTrue: core.fail(_existsParFound), onFalse: core.unit }),
+            (a, i) => core.if_(f(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
             options
           ),
           {
@@ -1735,7 +1735,7 @@ const allValidate = (
           core.fail(reconcile.value(errors)) :
           core.fail(errors)
       } else if (options?.discard) {
-        return core.unit
+        return core.void
       }
       return reconcile._tag === "Some" ?
         core.succeed(reconcile.value(successes)) :
@@ -1996,7 +1996,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
         let todos = Array.from(self).reverse()
         let target = todos.length
         if (target === 0) {
-          return core.unit
+          return core.void
         }
         let counter = 0
         let interrupted = false
@@ -2018,7 +2018,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             .sort((a, b) => a.index < b.index ? -1 : a.index === b.index ? 0 : 1)
             .map(({ exit }) => exit)
           if (exits.length === 0) {
-            exits.push(core.exitUnit)
+            exits.push(core.exitVoid)
           }
           return exits
         }
@@ -2108,7 +2108,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                   if (results.length === target) {
                     resume(core.succeed(Option.getOrElse(
                       core.exitCollectAll(collectExits(), { parallel: true }),
-                      () => core.exitUnit
+                      () => core.exitVoid
                     )))
                   } else if (residual.length + results.length === target) {
                     const requests = residual.map((blocked) => blocked.effect_instruction_i0).reduce(_RequestBlock.par)
@@ -2118,7 +2118,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                         [
                           Option.getOrElse(
                             core.exitCollectAll(collectExits(), { parallel: true }),
-                            () => core.exitUnit
+                            () => core.exitVoid
                           ),
                           ...residual.map((blocked) => blocked.effect_instruction_i1)
                         ],
@@ -2139,7 +2139,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             }
           })
         )
-        return core.asUnit(
+        return core.asVoid(
           core.onExit(
             core.flatten(restore(internalFiber.join(processingFiber))),
             core.exitMatch({
@@ -2413,7 +2413,7 @@ export const validateAll = dual<
       }),
       ([es, bs]) =>
         es.length === 0
-          ? options?.discard ? core.unit : core.succeed(bs)
+          ? options?.discard ? core.void : core.succeed(bs)
           : core.fail(es)
     )
 )
@@ -2455,7 +2455,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                   core.tap((fibers) =>
                     pipe(
                       fibers,
-                      RA.reduce(core.unit, (effect, fiber) =>
+                      RA.reduce(core.void, (effect, fiber) =>
                         pipe(
                           effect,
                           core.zipRight(
@@ -2463,7 +2463,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                               internalFiber._await(fiber),
                               core.flatMap(raceAllArbiter(fibers, fiber, done, fails)),
                               fork,
-                              core.asUnit
+                              core.asVoid
                             )
                           )
                         ))
@@ -2476,7 +2476,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                         pipe(
                           fibers,
                           RA.reduce(
-                            core.unit,
+                            core.void,
                             (effect, fiber) => pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
                           )
                         )
@@ -2506,8 +2506,8 @@ const raceAllArbiter = <E, E1, A, A1>(
         Ref.modify(fails, (fails) =>
           [
             fails === 0 ?
-              pipe(core.deferredFailCause(deferred, cause), core.asUnit) :
-              core.unit,
+              pipe(core.deferredFailCause(deferred, cause), core.asVoid) :
+              core.void,
             fails - 1
           ] as const),
         core.flatten
@@ -2520,14 +2520,14 @@ const raceAllArbiter = <E, E1, A, A1>(
             pipe(
               Chunk.fromIterable(fibers),
               RA.reduce(
-                core.unit,
+                core.void,
                 (effect, fiber) =>
                   fiber === winner ?
                     effect :
                     pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
               )
             ) :
-            core.unit
+            core.void
         )
       )
   })
@@ -2668,7 +2668,7 @@ export const scopeWith = <A, E, R>(
 
 /* @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(scope)(effect))
+  core.flatMap(scopeMake(), (scope) => scopeUse(effect, scope))
 
 /* @internal */
 export const sequentialFinalizers = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -2798,7 +2798,7 @@ export const validateAllParDiscard = dual<
     partition(elements, f),
     ([es, _]) =>
       es.length === 0
-        ? core.unit
+        ? core.void
         : core.fail(es)
   ))
 
@@ -2971,7 +2971,7 @@ export const withRuntimeFlagsScoped = (
   update: RuntimeFlagsPatch.RuntimeFlagsPatch
 ): Effect.Effect<void, never, Scope.Scope> => {
   if (update === RuntimeFlagsPatch.empty) {
-    return core.unit
+    return core.void
   }
   return pipe(
     core.runtimeFlags,
@@ -2981,68 +2981,13 @@ export const withRuntimeFlagsScoped = (
       return pipe(
         core.updateRuntimeFlags(update),
         core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))),
-        core.asUnit
+        core.asVoid
       )
     }),
     core.uninterruptible
   )
 }
 
-// circular with ReleaseMap
-
-/* @internal */
-export const releaseMapReleaseAll = (
-  strategy: ExecutionStrategy.ExecutionStrategy,
-  exit: Exit.Exit<unknown, unknown>
-) =>
-(self: core.ReleaseMap): Effect.Effect<void> =>
-  core.suspend(() => {
-    switch (self.state._tag) {
-      case "Exited": {
-        return core.unit
-      }
-      case "Running": {
-        const finalizersMap = self.state.finalizers
-        const update = self.state.update
-        const finalizers = Array.from(finalizersMap.keys()).sort((a, b) => b - a).map((key) => finalizersMap.get(key)!)
-        self.state = { _tag: "Exited", nextKey: self.state.nextKey, exit, update }
-        return executionStrategy.isSequential(strategy) ?
-          pipe(
-            finalizers,
-            core.forEachSequential((fin) => core.exit(update(fin)(exit))),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
-            )
-          ) :
-          executionStrategy.isParallel(strategy) ?
-          pipe(
-            forEachParUnbounded(finalizers, (fin) => core.exit(update(fin)(exit)), false),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results, { parallel: true }),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
-            )
-          ) :
-          pipe(
-            forEachParN(finalizers, strategy.parallelism, (fin) => core.exit(update(fin)(exit)), false),
-            core.flatMap((results) =>
-              pipe(
-                core.exitCollectAll(results, { parallel: true }),
-                Option.map(core.exitAsUnit),
-                Option.getOrElse(() => core.exitUnit)
-              )
-            )
-          )
-      }
-    }
-  })
-
 // circular with Scope
 
 /** @internal */
@@ -3051,33 +2996,114 @@ export const scopeTag = Context.GenericTag<Scope.Scope>("effect/Scope")
 /* @internal */
 export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 
-/* @internal */
-export const scopeMake = (
-  strategy: ExecutionStrategy.ExecutionStrategy = executionStrategy.sequential
-): Effect.Effect<Scope.Scope.Closeable> =>
-  core.map(core.releaseMapMake, (rm): Scope.Scope.Closeable => ({
-    [core.ScopeTypeId]: core.ScopeTypeId,
-    [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
-    strategy,
-    pipe() {
-      return pipeArguments(this, arguments)
-    },
-    fork: (strategy) =>
-      core.uninterruptible(
+interface ScopeImpl extends Scope.CloseableScope {
+  state: {
+    readonly _tag: "Open"
+    readonly finalizers: Set<Scope.Scope.Finalizer>
+  } | {
+    readonly _tag: "Closed"
+    readonly exit: Exit.Exit<unknown, unknown>
+  }
+}
+
+const scopeUnsafeAddFinalizer = (scope: ScopeImpl, fin: Scope.Scope.Finalizer): void => {
+  if (scope.state._tag === "Open") {
+    scope.state.finalizers.add(fin)
+  }
+}
+
+const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
+  [core.ScopeTypeId]: core.ScopeTypeId,
+  [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  fork(this: ScopeImpl, strategy) {
+    return core.sync(() => {
+      const newScope = scopeUnsafeMake(strategy)
+      if (this.state._tag === "Closed") {
+        newScope.state = this.state
+        return newScope
+      }
+      const fin = (exit: Exit.Exit<unknown, unknown>) => newScope.close(exit)
+      this.state.finalizers.add(fin)
+      scopeUnsafeAddFinalizer(newScope, (_) =>
+        core.sync(() => {
+          if (this.state._tag === "Open") {
+            this.state.finalizers.delete(fin)
+          }
+        }))
+      return newScope
+    })
+  },
+  close(this: ScopeImpl, exit) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return core.void
+      }
+      const finalizers = Array.from(this.state.finalizers.values()).reverse()
+      this.state = { _tag: "Closed", exit }
+      if (finalizers.length === 0) {
+        return core.void
+      }
+      return executionStrategy.isSequential(this.strategy) ?
+        pipe(
+          core.forEachSequential(finalizers, (fin) => core.exit(fin(exit))),
+          core.flatMap((results) =>
+            pipe(
+              core.exitCollectAll(results),
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
+            )
+          )
+        ) :
+        executionStrategy.isParallel(this.strategy) ?
+        pipe(
+          forEachParUnbounded(finalizers, (fin) => core.exit(fin(exit)), false),
+          core.flatMap((results) =>
+            pipe(
+              core.exitCollectAll(results, { parallel: true }),
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
+            )
+          )
+        ) :
         pipe(
-          scopeMake(strategy),
-          core.flatMap((scope) =>
+          forEachParN(finalizers, this.strategy.parallelism, (fin) => core.exit(fin(exit)), false),
+          core.flatMap((results) =>
             pipe(
-              core.releaseMapAdd(rm, (exit) => core.scopeClose(scope, exit)),
-              core.tap((fin) => core.scopeAddFinalizerExit(scope, fin)),
-              core.as(scope)
+              core.exitCollectAll(results, { parallel: true }),
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
             )
           )
         )
-      ),
-    close: (exit) => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
-    addFinalizer: (fin) => core.asUnit(core.releaseMapAdd(fin)(rm))
-  }))
+    })
+  },
+  addFinalizer(this: ScopeImpl, fin) {
+    return core.suspend(() => {
+      if (this.state._tag === "Closed") {
+        return fin(this.state.exit)
+      }
+      this.state.finalizers.add(fin)
+      return core.void
+    })
+  }
+}
+
+const scopeUnsafeMake = (
+  strategy: ExecutionStrategy.ExecutionStrategy = executionStrategy.sequential
+): ScopeImpl => {
+  const scope = Object.create(ScopeImplProto)
+  scope.strategy = strategy
+  scope.state = { _tag: "Open", finalizers: new Set() }
+  return scope
+}
+
+/* @internal */
+export const scopeMake = (
+  strategy: ExecutionStrategy.ExecutionStrategy = executionStrategy.sequential
+): Effect.Effect<Scope.Scope.Closeable> => core.sync(() => scopeUnsafeMake(strategy))
 
 /* @internal */
 export const scopeExtend = dual<
@@ -3127,7 +3153,7 @@ export const fiberRefLocallyScoped = dual<
   <A>(value: A) => (self: FiberRef.FiberRef<A>) => Effect.Effect<void, never, Scope.Scope>,
   <A>(self: FiberRef.FiberRef<A>, value: A) => Effect.Effect<void, never, Scope.Scope>
 >(2, (self, value) =>
-  core.asUnit(
+  core.asVoid(
     acquireRelease(
       core.flatMap(
         core.fiberRefGet(self),
@@ -3188,7 +3214,7 @@ export const currentSupervisor: FiberRef.FiberRef<Supervisor.Supervisor<any>> =
 
 /* @internal */
 export const fiberAwaitAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.Effect<void> =>
-  core.asUnit(internalFiber._await(fiberAll(fibers)))
+  core.asVoid(internalFiber._await(fiberAll(fibers)))
 
 /** @internal */
 export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber<Array<A>, E> => ({
@@ -3234,11 +3260,11 @@ export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber
 
 /* @internal */
 export const fiberInterruptFork = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<void> =>
-  core.asUnit(forkDaemon(core.interruptFiber(self)))
+  core.asVoid(forkDaemon(core.interruptFiber(self)))
 
 /* @internal */
-export const fiberJoinAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<void, E> =>
-  core.asUnit(internalFiber.join(fiberAll(fibers)))
+export const fiberJoinAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<Array<A>, E> =>
+  internalFiber.join(fiberAll(fibers))
 
 /* @internal */
 export const fiberScoped = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Fiber.Fiber<A, E>, never, Scope.Scope> =>
@@ -3547,20 +3573,28 @@ export const makeSpanScoped = (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
-  }
+  } | undefined
 ): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
-  acquireRelease(
-    internalEffect.makeSpan(name, options),
-    (span, exit) =>
-      span.status._tag === "Ended" ?
-        core.unit :
-        core.flatMap(
-          internalEffect.currentTimeNanosTracing,
-          (endTime) => core.sync(() => span.end(endTime, exit))
-        )
+  core.uninterruptible(
+    core.withFiberRuntime((fiber) => {
+      const scope = Context.unsafeGet(fiber.getFiberRef(core.currentContext), scopeTag)
+      const span = internalEffect.unsafeMakeSpan(fiber, name, options)
+      const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+      const clock_ = Context.get(fiber.getFiberRef(defaultServices.currentServices), clock.clockTag)
+      return core.as(
+        core.scopeAddFinalizerExit(scope, (exit) =>
+          core.sync(() => {
+            if (span.status._tag === "Ended") {
+              return
+            }
+            span.end(timingEnabled ? clock_.unsafeCurrentTimeNanos() : BigInt(0), exit)
+          })),
+        span
+      )
+    })
   )
 
 /* @internal */
@@ -3572,14 +3606,14 @@ export const withSpanScoped = dual<
   (name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>,
   <A, E, R>(self: Effect.Effect<A, E, R>, name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { MergeRecord } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"
@@ -442,7 +442,7 @@ export const groupByKey = dual<
                             Queue.offer(innerQueue, take.chunk(values)),
                             Effect.catchSomeCause((cause) =>
                               Cause.isInterruptedOnly(cause) ?
-                                Option.some(Effect.unit) :
+                                Option.some(Effect.void) :
                                 Option.none()
                             )
                           )
@@ -455,7 +455,7 @@ export const groupByKey = dual<
                   Queue.offer(innerQueue, take.chunk(values)),
                   (cause) =>
                     Cause.isInterruptedOnly(cause) ?
-                      Option.some(Effect.unit) :
+                      Option.some(Effect.void) :
                       Option.none()
                 )
               }, { discard: true })
@@ -472,7 +472,7 @@ export const groupByKey = dual<
                     Queue.offer(innerQueue, take.end),
                     Effect.catchSomeCause((cause) =>
                       Cause.isInterruptedOnly(cause) ?
-                        Option.some(Effect.unit) :
+                        Option.some(Effect.void) :
                         Option.none()
                     )
                   ), { discard: true }),

package/src/internal/hashMap.ts

@@ -7,7 +7,6 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
-import type { NoInfer } from "../Types.js"
 import { fromBitmap, hashFragment, toBitmap } from "./hashMap/bitwise.js"
 import { SIZE } from "./hashMap/config.js"
 import * as Node from "./hashMap/node.js"
@@ -270,7 +269,7 @@ export const unsafeGet = Dual.dual<
 >(2, (self, key) => {
   const element = getHash(self, key, Hash.hash(key))
   if (Option.isNone(element)) {
-    throw new Error("Error: Expected map to contain key")
+    throw new Error("Expected map to contain key")
   }
   return element.value
 })

package/src/internal/hashSet.ts

@@ -7,7 +7,6 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
-import type { NoInfer } from "../Types.js"
 import * as HM from "./hashMap.js"
 
 const HashSetSymbolKey = "effect/HashSet"

package/src/internal/layer/circular.ts

@@ -185,7 +185,7 @@ export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider)
   layer.scopedDiscard(fiberRuntime.withConfigProviderScoped(configProvider))
 
 /** @internal */
-export const parentSpan = (span: Tracer.ParentSpan): Layer.Layer<Tracer.ParentSpan> =>
+export const parentSpan = (span: Tracer.AnySpan): Layer.Layer<Tracer.ParentSpan> =>
   layer.succeedContext(Context.make(tracer.spanTag, span))
 
 /** @internal */
@@ -194,7 +194,7 @@ export const span = (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
     readonly onEnd?: