effect 2.4.19 → 3.0.0

package/src/internal/configProvider.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Config from "../Config.js"
 import type * as ConfigError from "../ConfigError.js"
 import type * as ConfigProvider from "../ConfigProvider.js"
@@ -12,7 +13,6 @@ import * as HashSet from "../HashSet.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 regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
@@ -85,12 +85,12 @@ export const makeFlat = (
 export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
   make({
     load: (config) =>
-      core.flatMap(fromFlatLoop(flat, ReadonlyArray.empty(), config, false), (chunk) =>
-        Option.match(ReadonlyArray.head(chunk), {
+      core.flatMap(fromFlatLoop(flat, Array.empty(), config, false), (chunk) =>
+        Option.match(Array.head(chunk), {
           onNone: () =>
             core.fail(
               configError.MissingData(
-                ReadonlyArray.empty(),
+                Array.empty(),
                 `Expected a single value having structure: ${config}`
               )
             ),
@@ -104,7 +104,7 @@ export const fromEnv = (
   config?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Array.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 
   const getEnv = () =>
@@ -131,10 +131,10 @@ export const fromEnv = (
     core.sync(() => {
       const current = getEnv()
       const keys = Object.keys(current)
-      const keyPaths = Array.from(keys).map((value) => unmakePathString(value.toUpperCase()))
+      const keyPaths = keys.map((value) => unmakePathString(value.toUpperCase()))
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Array.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -154,11 +154,11 @@ export const fromMap = (
   config?: Partial<ConfigProvider.ConfigProvider.FromMapConfig>
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({ seqDelim: ",", pathDelim: "." }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Array.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
   const mapWithIndexSplit = splitIndexInKeys(
     map,
-    (str) => Array.from(unmakePathString(str)),
+    (str) => unmakePathString(str),
     makePathString
   )
   const load = <A>(
@@ -180,10 +180,10 @@ export const fromMap = (
     path: ReadonlyArray<string>
   ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
-      const keyPaths = Array.from(mapWithIndexSplit.keys()).map(unmakePathString)
+      const keyPaths = Array.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Array.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -203,14 +203,14 @@ const extend = <A, B>(
   left: ReadonlyArray<A>,
   right: ReadonlyArray<B>
 ): [ReadonlyArray<A>, ReadonlyArray<B>] => {
-  const leftPad = ReadonlyArray.unfold(
+  const leftPad = Array.unfold(
     left.length,
     (index) =>
       index >= right.length ?
         Option.none() :
         Option.some([leftDef(index), index + 1])
   )
-  const rightPad = ReadonlyArray.unfold(
+  const rightPad = Array.unfold(
     right.length,
     (index) =>
       index >= left.length ?
@@ -244,7 +244,7 @@ const fromFlatLoop = <A>(
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Array.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
@@ -296,7 +296,7 @@ const fromFlatLoop = <A>(
       return core.suspend(() =>
         fromFlatLoop(
           flat,
-          concat(prefix, ReadonlyArray.of(op.name)),
+          concat(prefix, Array.of(op.name)),
           op.config,
           split
         )
@@ -310,7 +310,7 @@ const fromFlatLoop = <A>(
             flat.load(prefix, op, split),
             core.flatMap((values) => {
               if (values.length === 0) {
-                const name = pipe(ReadonlyArray.last(prefix), Option.getOrElse(() => "<n/a>"))
+                const name = pipe(Array.last(prefix), Option.getOrElse(() => "<n/a>"))
                 return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
               }
               return core.succeed(values)
@@ -329,20 +329,20 @@ const fromFlatLoop = <A>(
             core.flatMap((indices) => {
               if (indices.length === 0) {
                 return core.suspend(() =>
-                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), ReadonlyArray.of)
+                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Array.of)
                 ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
                   indices,
-                  (index) => fromFlatLoop(flat, ReadonlyArray.append(prefix, `[${index}]`), op.config, true)
+                  (index) => fromFlatLoop(flat, Array.append(prefix, `[${index}]`), op.config, true)
                 ),
                 core.map((chunkChunk) => {
-                  const flattened = ReadonlyArray.flatten(chunkChunk)
+                  const flattened = Array.flatten(chunkChunk)
                   if (flattened.length === 0) {
-                    return ReadonlyArray.of(ReadonlyArray.empty<A>())
+                    return Array.of(Array.empty<A>())
                   }
-                  return ReadonlyArray.of(flattened)
+                  return Array.of(flattened)
                 })
               ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
             })
@@ -363,21 +363,18 @@ const fromFlatLoop = <A>(
                   core.forEachSequential((key) =>
                     fromFlatLoop(
                       flat,
-                      concat(prefix, ReadonlyArray.of(key)),
+                      concat(prefix, Array.of(key)),
                       op.valueConfig,
                       split
                     )
                   ),
-                  core.map((values) => {
-                    if (values.length === 0) {
-                      return ReadonlyArray.of(HashMap.empty())
+                  core.map((matrix) => {
+                    if (matrix.length === 0) {
+                      return Array.of(HashMap.empty())
                     }
-                    const matrix = values.map((x) => Array.from(x))
                     return pipe(
                       transpose(matrix),
-                      ReadonlyArray.map((values) =>
-                        HashMap.fromIterable(ReadonlyArray.zip(ReadonlyArray.fromIterable(keys), values))
-                      )
+                      Array.map((values) => HashMap.fromIterable(Array.zip(Array.fromIterable(keys), values)))
                     )
                   })
                 )
@@ -407,17 +404,17 @@ const fromFlatLoop = <A>(
                   return core.fail(right.left)
                 }
                 if (Either.isRight(left) && Either.isRight(right)) {
-                  const path = pipe(prefix, ReadonlyArray.join("."))
+                  const path = pipe(prefix, Array.join("."))
                   const fail = fromFlatLoopFail(prefix, path)
                   const [lefts, rights] = extend(
                     fail,
                     fail,
-                    pipe(left.right, ReadonlyArray.map(Either.right)),
-                    pipe(right.right, ReadonlyArray.map(Either.right))
+                    pipe(left.right, Array.map(Either.right)),
+                    pipe(right.right, Array.map(Either.right))
                   )
                   return pipe(
                     lefts,
-                    ReadonlyArray.zip(rights),
+                    Array.zip(rights),
                     core.forEachSequential(([left, right]) =>
                       pipe(
                         core.zip(left, right),
@@ -590,8 +587,8 @@ export const within = dual<
     f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
   ) => ConfigProvider.ConfigProvider
 >(3, (self, path, f) => {
-  const unnest = ReadonlyArray.reduce(path, self, (provider, name) => unnested(provider, name))
-  const nest = ReadonlyArray.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
+  const unnest = Array.reduce(path, self, (provider, name) => unnested(provider, name))
+  const nest = Array.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
   return orElse(nest, () => self)
 })
 
@@ -612,7 +609,7 @@ const parsePrimitive = <A>(
       primitive.parse(text),
       core.mapBoth({
         onFailure: configError.prefixed(path),
-        onSuccess: ReadonlyArray.of
+        onSuccess: Array.of
       })
     )
   }
@@ -631,8 +628,8 @@ const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Read
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({
-      onFailure: () => ReadonlyArray.empty<number>(),
-      onSuccess: ReadonlyArray.sort(number.Order)
+      onFailure: () => Array.empty<number>(),
+      onSuccess: Array.sort(number.Order)
     }),
     core.either,
     core.map(Either.merge)
@@ -664,10 +661,10 @@ const splitIndexInKeys = (
   for (const [pathString, value] of map) {
     const keyWithIndex = pipe(
       unmakePathString(pathString),
-      ReadonlyArray.flatMap((key) =>
+      Array.flatMap((key) =>
         Option.match(splitIndexFrom(key), {
-          onNone: () => ReadonlyArray.of(key),
-          onSome: ([key, index]) => ReadonlyArray.make(key, `[${index}]`)
+          onNone: () => Array.of(key),
+          onSome: ([key, index]) => Array.make(key, `[${index}]`)
         })
       )
     )
@@ -720,7 +717,7 @@ interface JsonArray extends Array<string | number | boolean | null | JsonArray |
 /** @internal */
 export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
   const hiddenDelimiter = "\ufeff"
-  const indexedEntries = ReadonlyArray.map(
+  const indexedEntries = Array.map(
     getIndexedEntries(json as JsonMap),
     ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
   )
@@ -762,10 +759,10 @@ const getIndexedEntries = (
     value: string | number | boolean | JsonMap | JsonArray | null
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
     if (typeof value === "string") {
-      return ReadonlyArray.make([path, value] as [ReadonlyArray<KeyComponent>, string])
+      return Array.make([path, value] as [ReadonlyArray<KeyComponent>, string])
     }
     if (typeof value === "number" || typeof value === "boolean") {
-      return ReadonlyArray.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
+      return Array.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
     }
     if (Array.isArray(value)) {
       return loopArray(path, value)
@@ -773,27 +770,27 @@ const getIndexedEntries = (
     if (typeof value === "object" && value !== null) {
       return loopObject(path, value)
     }
-    return ReadonlyArray.empty<[ReadonlyArray<KeyComponent>, string]>()
+    return Array.empty<[ReadonlyArray<KeyComponent>, string]>()
   }
   const loopArray = (
     path: ReadonlyArray<KeyComponent>,
     values: JsonArray
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
-    ReadonlyArray.match(values, {
-      onEmpty: () => ReadonlyArray.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
-      onNonEmpty: ReadonlyArray.flatMap((value, index) => loopAny(ReadonlyArray.append(path, keyIndex(index)), value))
+    Array.match(values, {
+      onEmpty: () => Array.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
+      onNonEmpty: Array.flatMap((value, index) => loopAny(Array.append(path, keyIndex(index)), value))
     })
   const loopObject = (
     path: ReadonlyArray<KeyComponent>,
     value: JsonMap
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
     Object.entries(value).flatMap(([key, value]) => {
-      const newPath = ReadonlyArray.append(path, keyName(key))
+      const newPath = Array.append(path, keyName(key))
       const result = loopAny(newPath, value)
-      if (ReadonlyArray.isEmptyReadonlyArray(result)) {
-        return ReadonlyArray.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
+      if (Array.isEmptyReadonlyArray(result)) {
+        return Array.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
       }
       return result
     })
-  return loopObject(ReadonlyArray.empty(), config)
+  return loopObject(Array.empty(), config)
 }

package/src/internal/core-effect.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Clock from "../Clock.js"
@@ -21,11 +22,10 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as Option from "../Option.js"
 import * as Predicate from "../Predicate.js"
 import type * as Random from "../Random.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { MergeRecord } from "../Types.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
@@ -343,7 +343,7 @@ export const allowInterrupt: Effect.Effect<void> = descriptorWith(
   (descriptor) =>
     HashSet.size(descriptor.interruptors) > 0
       ? core.interrupt
-      : core.unit
+      : core.void
 )
 
 /* @internal */
@@ -512,7 +512,7 @@ export const filterMap = dual<
 >(2, (elements, pf) =>
   core.map(
     core.forEachSequential(elements, identity),
-    ReadonlyArray.filterMap(pf)
+    Array.filterMap(pf)
   ))
 
 /* @internal */
@@ -695,7 +695,7 @@ export const firstSuccessOf = <Eff extends Effect.Effect<any, any, any>>(
     }
     return pipe(
       Chunk.tailNonEmpty(list),
-      ReadonlyArray.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
+      Array.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
     )
   })
 
@@ -842,7 +842,7 @@ export const ignore = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<voi
 export const ignoreLogged = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, never, R> =>
   core.matchCauseEffect(self, {
     onFailure: (cause) => logDebug(cause, "An error was silently ignored because it is not anticipated to be useful"),
-    onSuccess: () => core.unit
+    onSuccess: () => core.void
   })
 
 /* @internal */
@@ -887,68 +887,71 @@ export const iterate: {
     return core.succeed(initial)
   })
 
-const logWithLevel = (level?: LogLevel.LogLevel) =>
-<A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
+/** @internal */
+export const logWithLevel = (level?: LogLevel.LogLevel) =>
+(
+  ...message: ReadonlyArray<any>
 ): Effect.Effect<void> => {
   const levelOption = Option.fromNullable(level)
-  let message: unknown
-  let cause: Cause.Cause<unknown>
-  if (internalCause.isCause(messageOrCause)) {
-    cause = messageOrCause
-    message = (supplementary as unknown) ?? ""
-  } else {
-    message = messageOrCause
-    cause = (supplementary as Cause.Cause<unknown>) ?? internalCause.empty
+  let cause: Cause.Cause<unknown> | undefined = undefined
+  for (let i = 0, len = message.length; i < len; i++) {
+    const msg = message[i]
+    if (internalCause.isCause(msg)) {
+      if (cause !== undefined) {
+        cause = internalCause.sequential(cause, msg)
+      } else {
+        cause = msg
+      }
+      message = [...message.slice(0, i), ...message.slice(i + 1)]
+      i--
+    }
+  }
+  if (message.length === 0) {
+    message = "" as any
+  } else if (message.length === 1) {
+    message = message[0]
+  }
+  if (cause === undefined) {
+    cause = internalCause.empty
   }
   return core.withFiberRuntime((fiberState) => {
     fiberState.log(message, cause, levelOption)
-    return core.unit
+    return core.void
   })
 }
 
 /** @internal */
-export const log: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel()
+export const log: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel()
 
 /** @internal */
-export const logTrace: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Trace)
+export const logTrace: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Trace
+)
 
 /** @internal */
-export const logDebug: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Debug)
+export const logDebug: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Debug
+)
 
 /** @internal */
-export const logInfo: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Info)
+export const logInfo: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Info
+)
 
 /** @internal */
-export const logWarning: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Warning)
+export const logWarning: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Warning
+)
 
 /** @internal */
-export const logError: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Error)
+export const logError: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Error
+)
 
 /** @internal */
-export const logFatal: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Fatal)
+export const logFatal: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Fatal
+)
 
 /* @internal */
 export const withLogSpan = dual<
@@ -1017,7 +1020,7 @@ export const loop: {
 ): any =>
   options.discard
     ? loopDiscard(initial, options.while, options.step, options.body)
-    : core.map(loopInternal(initial, options.while, options.step, options.body), Array.from)
+    : core.map(loopInternal(initial, options.while, options.step, options.body), Array.fromIterable)
 
 const loopInternal = <Z, A, E, R>(
   initial: Z,
@@ -1047,7 +1050,7 @@ const loopDiscard = <S, X, E, R>(
         body(initial),
         () => loopDiscard(inc(initial), cont, inc, body)
       )
-      : core.unit
+      : core.void
   )
 
 /* @internal */
@@ -1143,7 +1146,7 @@ export const none = <A, E, R>(
   core.flatMap(self, (option) => {
     switch (option._tag) {
       case "None":
-        return core.unit
+        return core.void
       case "Some":
         return core.fail(new core.NoSuchElementException())
     }
@@ -1155,7 +1158,7 @@ export const once = <A, E, R>(
 ): Effect.Effect<Effect.Effect<void, E, R>> =>
   core.map(
     Ref.make(true),
-    (ref) => core.asUnit(core.whenEffect(self, Ref.getAndSet(ref, false)))
+    (ref) => core.asVoid(core.whenEffect(self, Ref.getAndSet(ref, false)))
   )
 
 /* @internal */
@@ -1181,7 +1184,7 @@ export const orElseSucceed = dual<
 export const parallelErrors = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Array<E>, R> =>
   core.matchCauseEffect(self, {
     onFailure: (cause) => {
-      const errors = Array.from(internalCause.failures(cause))
+      const errors = Array.fromIterable(internalCause.failures(cause))
       return errors.length === 0
         ? core.failCause(cause as Cause.Cause<never>)
         : core.fail(errors)
@@ -1275,7 +1278,7 @@ export const reduce = dual<
     zero: Z,
     f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
   ) =>
-    ReadonlyArray.fromIterable(elements).reduce(
+    Array.fromIterable(elements).reduce(
       (acc, el, i) => core.flatMap(acc, (a) => f(a, el, i)),
       core.succeed(zero) as Effect.Effect<Z, E, R>
     )
@@ -1295,7 +1298,7 @@ export const reduceRight = dual<
 >(
   3,
   <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect.Effect<Z, E, R>) =>
-    ReadonlyArray.fromIterable(elements).reduceRight(
+    Array.fromIterable(elements).reduceRight(
       (acc, el, i) => core.flatMap(acc, (a) => f(el, a, i)),
       core.succeed(zero) as Effect.Effect<Z, E, R>
     )
@@ -1432,7 +1435,7 @@ export const labelMetrics = dual<
   <A, E, R>(self: Effect.Effect<A, E, R>, labels: Iterable<MetricLabel.MetricLabel>) => Effect.Effect<A, E, R>
 >(
   2,
-  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => ReadonlyArray.union(old, labels))
+  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => Array.union(old, labels))
 )
 
 /* @internal */
@@ -1593,7 +1596,7 @@ export const tapErrorTag = dual<
     if (Predicate.isTagged(e, k)) {
       return f(e as any)
     }
-    return core.unit as any
+    return core.void as any
   }))
 
 /* @internal */
@@ -1776,7 +1779,7 @@ export const updateFiberRefs = (
 ): Effect.Effect<void> =>
   core.withFiberRuntime((state) => {
     state.setFiberRefs(f(state.id(), state.getFiberRefs()))
-    return core.unit
+    return core.void
   })
 
 /* @internal */
@@ -1994,7 +1997,7 @@ export const annotateSpans = dual<
 )
 
 /** @internal */
-export const currentParentSpan: Effect.Effect<Tracer.ParentSpan, Cause.NoSuchElementException> = serviceOptional(
+export const currentParentSpan: Effect.Effect<Tracer.AnySpan, Cause.NoSuchElementException> = serviceOptional(
   internalTracer.spanTag
 )
 
@@ -2002,7 +2005,7 @@ export const currentParentSpan: Effect.Effect<Tracer.ParentSpan, Cause.NoSuchEle
 export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementException> = core.flatMap(
   core.context<never>(),
   (context) => {
-    const span = context.unsafeMap.get(internalTracer.spanTag.key) as Tracer.ParentSpan | undefined
+    const span = context.unsafeMap.get(internalTracer.spanTag.key) as Tracer.AnySpan | undefined
     return span !== undefined && span._tag === "Span"
       ? core.succeed(span)
       : core.fail(new core.NoSuchElementException())
@@ -2012,12 +2015,12 @@ export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementExceptio
 /* @internal */
 export const linkSpans = dual<
   (
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ) => Effect.Effect<A, E, R>
 >(
@@ -2045,7 +2048,7 @@ export const unsafeMakeSpan = <XA, XE>(
   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
   }
@@ -2079,7 +2082,7 @@ export const unsafeMakeSpan = <XA, XE>(
         ...(options?.links ?? [])
       ] :
       Chunk.toReadonlyArray(linksFromEnv.value) :
-    options?.links ?? ReadonlyArray.empty()
+    options?.links ?? Array.empty()
 
   const span = tracer.span(
     name,
@@ -2105,7 +2108,7 @@ export const makeSpan = (
   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
   }
@@ -2125,7 +2128,7 @@ export const useSpan: {
   <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
   }, evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
@@ -2139,7 +2142,7 @@ export const useSpan: {
   const 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 = args.length === 1 ? undefined : args[0]
@@ -2162,9 +2165,9 @@ export const useSpan: {
 /** @internal */
 export const withParentSpan = dual<
   (
-    span: Tracer.ParentSpan
+    span: Tracer.AnySpan
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
-  <A, E, R>(self: Effect.Effect<A, E, R>, span: Tracer.ParentSpan) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Effect.Effect<A, E, R>, span: Tracer.AnySpan) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 >(2, (self, span) => provideService(self, internalTracer.spanTag, span))
 
 /** @internal */
@@ -2172,14 +2175,14 @@ 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
   }) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
   <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>>

package/src/internal/core-stream.ts

@@ -981,8 +981,11 @@ export const sync = <OutDone>(
   return op
 }
 
-/** @internal */
-export const unit: Channel.Channel<never> = succeedNow(void 0)
+const void_: Channel.Channel<never> = succeedNow(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const write = <OutElem>(