effect 2.4.18 → 3.0.0

package/src/internal/layer.ts

@@ -203,7 +203,7 @@ class MemoMapImpl implements Layer.MemoMap {
             acquire as Effect.Effect<readonly [FiberRefsPatch.FiberRefsPatch, Context.Context<ROut>], E>,
             core.flatMap(([patch, b]) => pipe(effect.patchFiberRefs(patch), core.as(b))),
             core.onExit(core.exitMatch({
-              onFailure: () => core.unit,
+              onFailure: () => core.void,
               onSuccess: () => core.scopeAddFinalizerExit(scope, release)
             }))
           )
@@ -216,7 +216,7 @@ class MemoMapImpl implements Layer.MemoMap {
               core.deferredMake<readonly [FiberRefsPatch.FiberRefsPatch, Context.Context<ROut>], E>(),
               core.flatMap((deferred) =>
                 pipe(
-                  ref.make<Scope.Scope.Finalizer>(() => core.unit),
+                  ref.make<Scope.Scope.Finalizer>(() => core.void),
                   core.map((finalizerRef) => {
                     const resource = core.uninterruptibleMask((restore) =>
                       pipe(
@@ -245,7 +245,7 @@ class MemoMapImpl implements Layer.MemoMap {
                                         core.whenEffect(
                                           ref.modify(observers, (n) => [n === 1, n - 1] as const)
                                         ),
-                                        core.asUnit
+                                        core.asVoid
                                       )),
                                     core.zipRight(ref.update(observers, (n) => n + 1)),
                                     core.zipRight(
@@ -270,7 +270,7 @@ class MemoMapImpl implements Layer.MemoMap {
                       pipe(
                         core.deferredAwait(deferred),
                         core.onExit(core.exitMatchEffect({
-                          onFailure: () => core.unit,
+                          onFailure: () => core.void,
                           onSuccess: () => ref.update(observers, (n) => n + 1)
                         }))
                       ),
@@ -1117,7 +1117,7 @@ export const withSpan = 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
     readonly onEnd?:
@@ -1127,7 +1127,7 @@ export const withSpan = dual<
   <A, E, R>(self: Layer.Layer<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
     readonly onEnd?:
@@ -1150,9 +1150,9 @@ export const withSpan = dual<
 /** @internal */
 export const withParentSpan = dual<
   (
-    span: Tracer.ParentSpan
+    span: Tracer.AnySpan
   ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>,
-  <A, E, R>(self: Layer.Layer<A, E, R>, span: Tracer.ParentSpan) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Layer.Layer<A, E, R>, span: Tracer.AnySpan) => Layer.Layer<A, E, Exclude<R, Tracer.ParentSpan>>
 >(2, (self, span) => provide(self, succeedContext(Context.make(tracer.spanTag, span))))
 
 // circular with Effect
@@ -1197,7 +1197,7 @@ const provideSomeRuntime = dual<
         core.withFiberRuntime((fiber) => {
           fiber.setFiberRefs(FiberRefsPatch.patch(fiber.id(), fiber.getFiberRefs())(rollbackRefs))
           fiber._runtimeFlags = runtimeFlags.patch(rollbackFlags)(fiber._runtimeFlags)
-          return core.unit
+          return core.void
         })
       )
     })

package/src/internal/logger.ts

@@ -168,11 +168,21 @@ export const stringLogger: Logger.Logger<unknown, string> = makeLogger<unknown,
     ]
 
     let output = outputArray.join(" ")
-    const stringMessage = Inspectable.toStringUnknown(message)
 
-    if (stringMessage.length > 0) {
-      output = output + " message="
-      output = appendQuoted(stringMessage, output)
+    if (Array.isArray(message)) {
+      for (let i = 0; i < message.length; i++) {
+        const stringMessage = Inspectable.toStringUnknown(message[i])
+        if (stringMessage.length > 0) {
+          output = output + " message="
+          output = appendQuoted(stringMessage, output)
+        }
+      }
+    } else {
+      const stringMessage = Inspectable.toStringUnknown(message)
+      if (stringMessage.length > 0) {
+        output = output + " message="
+        output = appendQuoted(stringMessage, output)
+      }
     }
 
     if (cause != null && cause._tag !== "Empty") {
@@ -235,11 +245,21 @@ export const logfmtLogger = makeLogger<unknown, string>(
     ]
 
     let output = outputArray.join(" ")
-    const stringMessage = Inspectable.toStringUnknown(message, 0)
 
-    if (stringMessage.length > 0) {
-      output = output + " message="
-      output = appendQuotedLogfmt(stringMessage, output)
+    if (Array.isArray(message)) {
+      for (let i = 0; i < message.length; i++) {
+        const stringMessage = Inspectable.toStringUnknown(message[i], 0)
+        if (stringMessage.length > 0) {
+          output = output + " message="
+          output = appendQuotedLogfmt(stringMessage, output)
+        }
+      }
+    } else {
+      const stringMessage = Inspectable.toStringUnknown(message, 0)
+      if (stringMessage.length > 0) {
+        output = output + " message="
+        output = appendQuotedLogfmt(stringMessage, output)
+      }
     }
 
     if (cause != null && cause._tag !== "Empty") {

package/src/internal/managedRuntime.ts

@@ -71,7 +71,7 @@ export const make = <R, ER>(
     disposeEffect: core.suspend(() => {
       ;(self as any).runtime = core.die("ManagedRuntime disposed")
       self.cachedRuntime = undefined
-      return Scope.close(self.scope, core.exitUnit)
+      return Scope.close(self.scope, core.exitVoid)
     }),
     runFork<A, E>(effect: Effect.Effect<A, E, R>, options?: Runtime.RunForkOptions): Fiber.RuntimeFiber<A, E | ER> {
       return self.cachedRuntime === undefined ?

package/src/internal/matcher.ts

@@ -508,7 +508,7 @@ export const orElseAbsurd = <I, R, RA, A, Pr>(
   self: Matcher<I, R, RA, A, Pr>
 ): [Pr] extends [never] ? (input: I) => Unify<A> : Unify<A> =>
   orElse(() => {
-    throw new Error("absurd")
+    throw new Error("effect/Match/orElseAbsurd: absurd")
   })(self)
 
 /** @internal */
@@ -565,6 +565,8 @@ export const option: <I, F, R, A, Pr>(
       })
   }) as any
 
+const getExhaustiveAbsurdErrorMessage = "effect/Match/exhaustive: absurd"
+
 /** @internal */
 export const exhaustive: <I, F, A, Pr>(
   self: Matcher<I, F, never, A, Pr>
@@ -578,7 +580,7 @@ export const exhaustive: <I, F, A, Pr>(
       return toEither.right
     }
 
-    throw new Error("@effect/match: exhaustive absurd")
+    throw new Error(getExhaustiveAbsurdErrorMessage)
   }
 
   return (u: I): A => {
@@ -589,6 +591,6 @@ export const exhaustive: <I, F, A, Pr>(
       return result.right as any
     }
 
-    throw new Error("@effect/match: exhaustive absurd")
+    throw new Error(getExhaustiveAbsurdErrorMessage)
   }
 }) as any

package/src/internal/metric/boundaries.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
@@ -5,7 +6,6 @@ import * as Hash from "../../Hash.js"
 import type * as MetricBoundaries from "../../MetricBoundaries.js"
 import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 
 /** @internal */
 const MetricBoundariesSymbolKey = "effect/MetricBoundaries"
@@ -44,8 +44,8 @@ export const isMetricBoundaries = (u: unknown): u is MetricBoundaries.MetricBoun
 export const fromIterable = (iterable: Iterable<number>): MetricBoundaries.MetricBoundaries => {
   const values = pipe(
     iterable,
-    ReadonlyArray.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
-    ReadonlyArray.dedupe
+    Array.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
+    Array.dedupe
   )
   return new MetricBoundariesImpl(values)
 }
@@ -57,7 +57,7 @@ export const linear = (options: {
   readonly count: number
 }): MetricBoundaries.MetricBoundaries =>
   pipe(
-    ReadonlyArray.makeBy(options.count - 1, (i) => options.start + i * options.width),
+    Array.makeBy(options.count - 1, (i) => options.start + i * options.width),
     Chunk.unsafeFromArray,
     fromIterable
   )
@@ -69,7 +69,7 @@ export const exponential = (options: {
   readonly count: number
 }): MetricBoundaries.MetricBoundaries =>
   pipe(
-    ReadonlyArray.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
+    Array.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
     Chunk.unsafeFromArray,
     fromIterable
   )

package/src/internal/metric/hook.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import * as Duration from "../../Duration.js"
 import type { LazyArg } from "../../Function.js"
 import { dual, pipe } from "../../Function.js"
@@ -7,7 +8,6 @@ import type * as MetricState from "../../MetricState.js"
 import * as number from "../../Number.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as metricState from "./state.js"
 
 /** @internal */
@@ -78,8 +78,11 @@ export const counter = <A extends (number | bigint)>(
 }
 
 /** @internal */
-export const frequency = (_key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency => {
+export const frequency = (key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency => {
   const values = new Map<string, number>()
+  for (const word of key.keyType.preregisteredWords) {
+    values.set(word, 0)
+  }
   const update = (word: string) => {
     const slotCount = values.get(word) ?? 0
     values.set(word, slotCount + 1)
@@ -120,8 +123,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 
   pipe(
     bounds,
-    ReadonlyArray.sort(number.Order),
-    ReadonlyArray.map((n, i) => {
+    Array.sort(number.Order),
+    Array.map((n, i) => {
       boundaries[i] = n
     })
   )
@@ -159,7 +162,7 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
   }
 
   const getBuckets = (): ReadonlyArray<readonly [number, number]> => {
-    const builder: Array<readonly [number, number]> = Array(size)
+    const builder: Array<readonly [number, number]> = Array.allocate(size) as any
     let cumulated = 0
     for (let i = 0; i < size; i++) {
       const boundary = boundaries[i]
@@ -186,8 +189,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 /** @internal */
 export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary => {
   const { error, maxAge, maxSize, quantiles } = key.keyType
-  const sortedQuantiles = pipe(quantiles, ReadonlyArray.sort(number.Order))
-  const values = Array<readonly [number, number]>(maxSize)
+  const sortedQuantiles = pipe(quantiles, Array.sort(number.Order))
+  const values = Array.allocate<readonly [number, number]>(maxSize)
 
   let head = 0
   let count = 0
@@ -225,7 +228,7 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
     return calculateQuantiles(
       error,
       sortedQuantiles,
-      ReadonlyArray.sort(builder, number.Order)
+      Array.sort(builder, number.Order)
     )
   }
 
@@ -288,8 +291,8 @@ const calculateQuantiles = (
 ): ReadonlyArray<readonly [number, Option.Option<number>]> => {
   // The number of samples examined
   const sampleCount = sortedSamples.length
-  if (!ReadonlyArray.isNonEmptyReadonlyArray(sortedQuantiles)) {
-    return ReadonlyArray.empty()
+  if (!Array.isNonEmptyReadonlyArray(sortedQuantiles)) {
+    return Array.empty()
   }
   const head = sortedQuantiles[0]
   const tail = sortedQuantiles.slice(1)
@@ -301,7 +304,7 @@ const calculateQuantiles = (
     head,
     sortedSamples
   )
-  const resolved = ReadonlyArray.of(resolvedHead)
+  const resolved = Array.of(resolvedHead)
   tail.forEach((quantile) => {
     resolved.push(
       resolveQuantile(
@@ -314,7 +317,7 @@ const calculateQuantiles = (
       )
     )
   })
-  return ReadonlyArray.map(resolved, (rq) => [rq.quantile, rq.value] as const)
+  return Array.map(resolved, (rq) => [rq.quantile, rq.value] as const)
 }
 
 /** @internal */
@@ -341,7 +344,7 @@ const resolveQuantile = (
   // eslint-disable-next-line no-constant-condition
   while (1) {
     // If the remaining list of samples is empty, there is nothing more to resolve
-    if (!ReadonlyArray.isNonEmptyReadonlyArray(rest_1)) {
+    if (!Array.isNonEmptyReadonlyArray(rest_1)) {
       return {
         quantile: quantile_1,
         value: Option.none(),
@@ -354,14 +357,14 @@ const resolveQuantile = (
     if (quantile_1 === 1) {
       return {
         quantile: quantile_1,
-        value: Option.some(ReadonlyArray.lastNonEmpty(rest_1)),
+        value: Option.some(Array.lastNonEmpty(rest_1)),
         consumed: consumed_1 + rest_1.length,
         rest: []
       }
     }
     // Split into two chunks - the first chunk contains all elements of the same
     // value as the chunk head
-    const sameHead = ReadonlyArray.span(rest_1, (n) => n <= rest_1[0])
+    const sameHead = Array.span(rest_1, (n) => n <= rest_1[0])
     // How many elements do we want to accept for this quantile
     const desired = quantile_1 * sampleCount_1
     // The error margin
@@ -375,7 +378,7 @@ const resolveQuantile = (
     if (candConsumed < desired - allowedError) {
       error_2 = error_1
       sampleCount_2 = sampleCount_1
-      current_2 = ReadonlyArray.head(rest_1)
+      current_2 = Array.head(rest_1)
       consumed_2 = candConsumed
       quantile_2 = quantile_1
       rest_2 = sameHead[1]
@@ -403,7 +406,7 @@ const resolveQuantile = (
       case "None": {
         error_2 = error_1
         sampleCount_2 = sampleCount_1
-        current_2 = ReadonlyArray.head(rest_1)
+        current_2 = Array.head(rest_1)
         consumed_2 = candConsumed
         quantile_2 = quantile_1
         rest_2 = sameHead[1]
@@ -420,7 +423,7 @@ const resolveQuantile = (
         if (candError < prevError) {
           error_2 = error_1
           sampleCount_2 = sampleCount_1
-          current_2 = ReadonlyArray.head(rest_1)
+          current_2 = Array.head(rest_1)
           consumed_2 = candConsumed
           quantile_2 = quantile_1
           rest_2 = sameHead[1]

package/src/internal/metric/key.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import type * as Duration from "../../Duration.js"
 import * as Equal from "../../Equal.js"
 import { dual, pipe } from "../../Function.js"
@@ -9,7 +10,6 @@ import type * as MetricLabel from "../../MetricLabel.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as metricKeyType from "./keyType.js"
 import * as metricLabel from "./label.js"
 
@@ -26,7 +26,7 @@ const metricKeyVariance = {
   _Type: (_: never) => _
 }
 
-const arrayEquivilence = ReadonlyArray.getEquivalence(Equal.equals)
+const arrayEquivilence = Array.getEquivalence(Equal.equals)
 
 /** @internal */
 class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
@@ -83,8 +83,11 @@ export const counter: {
   )
 
 /** @internal */
-export const frequency = (name: string, description?: string): MetricKey.MetricKey.Frequency =>
-  new MetricKeyImpl(name, metricKeyType.frequency, Option.fromNullable(description))
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKey.MetricKey.Frequency =>
+  new MetricKeyImpl(name, metricKeyType.frequency(options), Option.fromNullable(options?.description))
 
 /** @internal */
 export const gauge: {
@@ -161,4 +164,4 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) =>
   extraTags.length === 0
     ? self
-    : new MetricKeyImpl(self.name, self.keyType, self.description, ReadonlyArray.union(self.tags, extraTags)))
+    : new MetricKeyImpl(self.name, self.keyType, self.description, Array.union(self.tags, extraTags)))

package/src/internal/metric/keyType.ts

@@ -86,7 +86,8 @@ const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
 /** @internal */
 class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId;
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
+  constructor(readonly preregisteredWords: ReadonlyArray<string>) {}
   [Hash.symbol](): number {
     return FrequencyKeyTypeHash
   }
@@ -192,7 +193,9 @@ export const counter: <A extends number | bigint>(options?: {
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: MetricKeyType.MetricKeyType.Frequency = new FrequencyKeyType()
+export const frequency = (options?: {
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
 
 /**
  * @since 2.0.0

package/src/internal/metric/state.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
@@ -5,7 +6,6 @@ import type * as MetricState from "../../MetricState.js"
 import type * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 
 /** @internal */
 const MetricStateSymbolKey = "effect/MetricState"
@@ -80,7 +80,7 @@ class CounterState<A extends (number | bigint)> implements MetricState.MetricSta
   }
 }
 
-const arrayEquals = ReadonlyArray.getEquivalence(Equal.equals)
+const arrayEquals = Array.getEquivalence(Equal.equals)
 
 /** @internal */
 class FrequencyState implements MetricState.MetricState.Frequency {
@@ -91,14 +91,14 @@ class FrequencyState implements MetricState.MetricState.Frequency {
   [Hash.symbol](): number {
     return pipe(
       Hash.string(FrequencyStateSymbolKey),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.occurrences.entries()))),
+      Hash.combine(Hash.array(Array.fromIterable(this.occurrences.entries()))),
       Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyState(that) && arrayEquals(
-      ReadonlyArray.fromIterable(this.occurrences.entries()),
-      ReadonlyArray.fromIterable(that.occurrences.entries())
+      Array.fromIterable(this.occurrences.entries()),
+      Array.fromIterable(that.occurrences.entries())
     )
   }
   pipe() {

package/src/internal/metric.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import * as Clock from "../Clock.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
@@ -14,7 +15,6 @@ import type * as MetricPair from "../MetricPair.js"
 import type * as MetricRegistry from "../MetricRegistry.js"
 import type * as MetricState from "../MetricState.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Cause from "./cause.js"
 import * as _effect from "./core-effect.js"
 import * as core from "./core.js"
@@ -98,8 +98,10 @@ export const counter: {
 } = (name, options) => fromMetricKey(metricKey.counter(name, options as any)) as any
 
 /** @internal */
-export const frequency = (name: string, description?: string): Metric.Metric.Frequency<string> =>
-  fromMetricKey(metricKey.frequency(name, description))
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): Metric.Metric.Frequency<string> => fromMetricKey(metricKey.frequency(name, options))
 
 /** @internal */
 export const withConstantInput = dual<
@@ -273,7 +275,7 @@ export const taggedWithLabelsInput = dual<
       (input, extraTags) =>
         self.unsafeUpdate(
           input,
-          ReadonlyArray.union(f(input), extraTags)
+          Array.union(f(input), extraTags)
         ),
       self.unsafeValue
     ),
@@ -292,8 +294,8 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) => {
   return make(
     self.keyType,
-    (input, extraTags1) => self.unsafeUpdate(input, ReadonlyArray.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(ReadonlyArray.union(extraTags, extraTags1))
+    (input, extraTags1) => self.unsafeUpdate(input, Array.union(extraTags, extraTags1)),
+    (extraTags1) => self.unsafeValue(Array.union(extraTags, extraTags1))
   )
 })
 

package/src/internal/pool.ts

@@ -75,13 +75,13 @@ interface Strategy<S, R, E, A> {
  */
 class NoneStrategy implements Strategy<unknown, never, never, never> {
   initial(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
   track(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
   run(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 }
 
@@ -100,7 +100,7 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
         )))
   }
   track(state: readonly [Clock.Clock, Ref.Ref<number>]): Effect.Effect<void> {
-    return core.asUnit(core.flatMap(
+    return core.asVoid(core.flatMap(
       state[0].currentTimeMillis,
       (now) => ref.set(state[1], now)
     ))
@@ -222,7 +222,7 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
             if (state.size <= this.min) {
               return [allocateUinterruptible(this), { ...state, free: state.free + 1 }] as const
             }
-            return [core.unit, { ...state, size: state.size - 1 }] as const
+            return [core.void, { ...state, size: state.size - 1 }] as const
           })),
         onSuccess: (item) =>
           core.flatMap(ref.get(this.invalidated), (set) => {
@@ -303,7 +303,7 @@ const finalizeInvalid = <A, E>(
         if (state.size <= self.min) {
           return [allocateUinterruptible(self), { ...state, free: state.free + 1 }] as const
         }
-        return [core.unit, { ...state, size: state.size - 1 }] as const
+        return [core.void, { ...state, size: state.size - 1 }] as const
       }))
     )
   )
@@ -317,7 +317,7 @@ const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
     if (state.free > 0) {
       return [
         core.matchCauseEffect(queue.take(self.items), {
-          onFailure: () => core.unit,
+          onFailure: () => core.void,
           onSuccess: (attempted) =>
             pipe(
               forEach(attempted, (a) => ref.update(self.invalidated, HashSet.remove(a))),
@@ -330,7 +330,7 @@ const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
       ] as const
     }
     if (state.size > 0) {
-      return [core.unit, state] as const
+      return [core.void, state] as const
     }
     return [queue.shutdown(self.items), { ...state, size: state.size - 1 }] as const
   }))
@@ -348,7 +348,7 @@ const initialize = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
             { size: state.size + 1, free: state.free + 1 }
           ] as const
         }
-        return [core.unit, state] as const
+        return [core.void, state] as const
       }))
     ),
     self.min,
@@ -376,7 +376,7 @@ const shrink = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
           { ...state, free: state.free - 1 }
         ] as const
       }
-      return [core.unit, state] as const
+      return [core.void, state] as const
     }))
   )
 
@@ -393,7 +393,7 @@ const forEach = <E, A, E2, R>(
   f: (a: A) => Effect.Effect<unknown, E2, R>
 ): Effect.Effect<unknown, E2, R> =>
   core.exitMatch(self.result, {
-    onFailure: () => core.unit,
+    onFailure: () => core.void,
     onSuccess: f
   })
 

package/src/internal/pubsub.ts

@@ -885,7 +885,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
             this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers)
           })),
           core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-          core.asUnit
+          core.asVoid
         )
       })
     )
@@ -1053,7 +1053,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
         this.scope.close(core.exitInterrupt(state.id())),
         core.zipRight(this.strategy.shutdown),
         core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-        core.asUnit
+        core.asVoid
       )
     }))
   }
@@ -1298,8 +1298,8 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
             publishers,
             ([_, deferred, last]) =>
               last ?
-                pipe(core.deferredInterruptWith(deferred, fiberId), core.asUnit) :
-                core.unit,
+                pipe(core.deferredInterruptWith(deferred, fiberId), core.asVoid) :
+                core.void,
             false,
             false
           )
@@ -1408,7 +1408,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
  */
 export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   handleSurplus(
@@ -1452,7 +1452,7 @@ export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
  */
 export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   handleSurplus(

package/src/internal/query.ts

@@ -12,7 +12,7 @@ import * as core from "./core.js"
 import { ensuring } from "./fiberRuntime.js"
 import { Listeners } from "./request.js"
 
-type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
+type RequestCache = Cache.Cache<Request.Request<any, any>, {
   listeners: Request.Listeners
   handle: Deferred<any, any>
 }>
@@ -21,7 +21,7 @@ type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
 export const currentCache = globalValue(
   Symbol.for("effect/FiberRef/currentCache"),
   () =>
-    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, never, {
+    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, {
       listeners: Request.Listeners
       handle: Deferred<any, any>
     }>(
@@ -153,7 +153,7 @@ export const cacheRequest = <A extends Request.Request<any, any>>(
         core.flatMap(cache.getEither(request), (orNew) => {
           switch (orNew._tag) {
             case "Left": {
-              return core.unit
+              return core.void
             }
             case "Right": {
               return core.deferredComplete(orNew.right.handle, result)
@@ -161,7 +161,7 @@ export const cacheRequest = <A extends Request.Request<any, any>>(
           }
         }))
     }
-    return core.unit
+    return core.void
   })
 }