effect 2.4.19 → 3.0.1

package/src/internal/core-effect.ts

@@ -1,3 +1,4 @@
+import * as Arr 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)
+    Arr.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)
+      Arr.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), Arr.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 = Arr.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(
+    Arr.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(
+    Arr.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) => Arr.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 ?? Arr.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>(

package/src/internal/core.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Context from "../Context.js"
@@ -27,7 +28,6 @@ import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, isObject, isPromiseLike, isString, type Predicate, type Refinement } from "../Predicate.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
 import type * as RequestResolver from "../RequestResolver.js"
@@ -35,7 +35,7 @@ import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
-import type { NoInfer, NotFunction } from "../Types.js"
+import type { NotFunction } from "../Types.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
@@ -430,7 +430,7 @@ export const as: {
 )
 
 /* @internal */
-export const asUnit = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
+export const asVoid = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
 
 /* @internal */
 export const custom: {
@@ -515,7 +515,7 @@ export const async = <A, E = never, R = never>(
         if (controllerRef) {
           controllerRef.abort()
         }
-        return cancelerRef ?? unit
+        return cancelerRef ?? void_
       }) :
       effect
   })
@@ -886,8 +886,8 @@ export const forEachSequential: {
   2,
   <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<B, E, R>): Effect.Effect<Array<B>, E, R> =>
     suspend(() => {
-      const arr = ReadonlyArray.fromIterable(self)
-      const ret = new Array(arr.length)
+      const arr = Arr.fromIterable(self)
+      const ret = Arr.allocate<B>(arr.length)
       let i = 0
       return as(
         whileLoop({
@@ -897,7 +897,7 @@ export const forEachSequential: {
             ret[i++] = b
           }
         }),
-        ret
+        ret as Array<B>
       )
     })
 )
@@ -910,7 +910,7 @@ export const forEachSequentialDiscard: {
   2,
   <A, B, E, R>(self: Iterable<A>, f: (a: A, i: number) => Effect.Effect<B, E, R>): Effect.Effect<void, E, R> =>
     suspend(() => {
-      const arr = ReadonlyArray.fromIterable(self)
+      const arr = Arr.fromIterable(self)
       let i = 0
       return whileLoop({
         while: () => i < arr.length,
@@ -926,35 +926,33 @@ export const forEachSequentialDiscard: {
 export const if_ = dual<
   <A1, E1, R1, A2, E2, R2>(
     options: {
-      readonly onTrue: Effect.Effect<A1, E1, R1>
-      readonly onFalse: Effect.Effect<A2, E2, R2>
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ) => <E = never, R = never>(
     self: Effect.Effect<boolean, E, R> | boolean
   ) => Effect.Effect<A1 | A2, E | E1 | E2, R | R1 | R2>,
-  {
-    <A1, E1, R1, A2, E2, R2>(
-      self: boolean,
-      options: {
-        readonly onTrue: Effect.Effect<A1, E1, R1>
-        readonly onFalse: Effect.Effect<A2, E2, R2>
-      }
-    ): Effect.Effect<A1 | A2, E1 | E2, R1 | R2>
-    <E, R, A1, E1, R1, A2, E2, R2>(
-      self: Effect.Effect<boolean, E, R>,
-      options: {
-        readonly onTrue: Effect.Effect<A1, E1, R1>
-        readonly onFalse: Effect.Effect<A2, E2, R2>
-      }
-    ): Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
-  }
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: Effect.Effect<boolean, E, R> | boolean,
+    options: {
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
+    }
+  ) => Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
 >(
   (args) => typeof args[0] === "boolean" || isEffect(args[0]),
-  (self: boolean | Effect.Effect<unknown, unknown, unknown>, { onFalse, onTrue }: {
-    readonly onTrue: Effect.Effect<unknown, unknown, unknown>
-    readonly onFalse: Effect.Effect<unknown, unknown, unknown>
-    // eslint-disable-next-line no-extra-boolean-cast
-  }) => isEffect(self) ? flatMap(self, (b) => (b ? onTrue : onFalse)) : Boolean(self) ? onTrue : onFalse
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: Effect.Effect<boolean, E, R> | boolean,
+    options: {
+      readonly onTrue: LazyArg<Effect.Effect<A1, E1, R1>>
+      readonly onFalse: LazyArg<Effect.Effect<A2, E2, R2>>
+    }
+  ): Effect.Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R> =>
+    isEffect(self)
+      ? flatMap(self, (b): Effect.Effect<A1 | A2, E1 | E2, R1 | R2> => (b ? options.onTrue() : options.onFalse()))
+      : self
+      ? options.onTrue()
+      : options.onFalse()
 )
 
 /* @internal */
@@ -1065,7 +1063,7 @@ export const onError: {
   self: Effect.Effect<A, E, R>,
   cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>
 ): Effect.Effect<A, E, R2 | R> =>
-  onExit(self, (exit) => exitIsSuccess(exit) ? unit : cleanup(exit.effect_instruction_i0)))
+  onExit(self, (exit) => exitIsSuccess(exit) ? void_ : cleanup(exit.effect_instruction_i0)))
 
 /* @internal */
 export const onExit: {
@@ -1114,9 +1112,9 @@ export const onInterrupt: {
     exitMatch({
       onFailure: (cause) =>
         internalCause.isInterruptedOnly(cause)
-          ? asUnit(cleanup(internalCause.interruptors(cause)))
-          : unit,
-      onSuccess: () => unit
+          ? asVoid(cleanup(internalCause.interruptors(cause)))
+          : void_,
+      onSuccess: () => void_
     })
   ))
 
@@ -1158,7 +1156,7 @@ export const partitionMap = <A, A1, A2>(
   elements: Iterable<A>,
   f: (a: A) => Either.Either<A2, A1>
 ): [left: Array<A1>, right: Array<A2>] =>
-  ReadonlyArray.fromIterable(elements).reduceRight(
+  Arr.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
       const either = f(current)
       switch (either._tag) {
@@ -1170,7 +1168,7 @@ export const partitionMap = <A, A1, A2>(
         }
       }
     },
-    [new Array<A1>(), new Array<A2>()]
+    [Arr.empty<A1>(), Arr.empty<A2>()]
   )
 
 /* @internal */
@@ -1302,8 +1300,11 @@ export const uninterruptibleMask = <A, E, R>(
     return effect
   })
 
-/* @internal */
-export const unit: Effect.Effect<void> = succeed(void 0)
+const void_: Effect.Effect<void> = succeed(void 0)
+export {
+  /* @internal */
+  void_ as void
+}
 
 /* @internal */
 export const updateRuntimeFlags = (patch: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect.Effect<void> => {
@@ -1668,7 +1669,7 @@ export const fiberRefSet = dual<
 export const fiberRefDelete = <A>(self: FiberRef.FiberRef<A>): Effect.Effect<void> =>
   withFiberRuntime((state) => {
     state.unsafeDeleteFiberRef(self)
-    return unit
+    return void_
   })
 
 /* @internal */
@@ -1999,7 +2000,7 @@ export const withUnhandledErrorLogLevel = dual<
 /** @internal */
 export const currentMetricLabels: FiberRef.FiberRef<ReadonlyArray<MetricLabel.MetricLabel>> = globalValue(
   Symbol.for("effect/FiberRef/currentMetricLabels"),
-  () => fiberRefUnsafeMakeReadonlyArray(ReadonlyArray.empty())
+  () => fiberRefUnsafeMakeReadonlyArray(Arr.empty())
 )
 
 /* @internal */
@@ -2067,7 +2068,7 @@ export const CloseableScopeTypeId: Scope.CloseableScopeTypeId = Symbol.for(
 export const scopeAddFinalizer = (
   self: Scope.Scope,
   finalizer: Effect.Effect<unknown>
-): Effect.Effect<void> => self.addFinalizer(() => asUnit(finalizer))
+): Effect.Effect<void> => self.addFinalizer(() => asVoid(finalizer))
 
 /* @internal */
 export const scopeAddFinalizerExit = (
@@ -2109,8 +2110,8 @@ export const causeSquashWith = dual<
         Chunk.head,
         Option.match({
           onNone: () => {
-            const interrupts = Array.from(internalCause.interruptors(self)).flatMap((fiberId) =>
-              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
+            const interrupts = Arr.fromIterable(internalCause.interruptors(self)).flatMap((fiberId) =>
+              Arr.fromIterable(FiberId.ids(fiberId)).map((id) => `#${id}`)
             )
             return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
           },
@@ -2310,7 +2311,7 @@ export const exitAs = dual<
 })
 
 /** @internal */
-export const exitAsUnit = <A, E>(self: Exit.Exit<A, E>): Exit.Exit<void, E> => exitAs(self, void 0)
+export const exitAsVoid = <A, E>(self: Exit.Exit<A, E>): Exit.Exit<void, E> => exitAs(self, void 0)
 
 /** @internal */
 export const exitCauseOption = <A, E>(self: Exit.Exit<A, E>): Option.Option<Cause.Cause<E>> => {
@@ -2578,7 +2579,7 @@ export const exitSucceed = <A>(value: A): Exit.Exit<A> => {
 }
 
 /** @internal */
-export const exitUnit: Exit.Exit<void> = exitSucceed(void 0)
+export const exitVoid: Exit.Exit<void> = exitSucceed(void 0)
 
 /** @internal */
 export const exitZip = dual<
@@ -2693,7 +2694,7 @@ const exitCollectAllInternal = <A, E>(
   }
   return pipe(
     Chunk.tailNonEmpty(list),
-    ReadonlyArray.reduce(
+    Arr.reduce(
       pipe(Chunk.headNonEmpty(list), exitMap<A, Chunk.Chunk<A>>(Chunk.of)),
       (accumulator, current) =>
         pipe(
@@ -2705,7 +2706,7 @@ const exitCollectAllInternal = <A, E>(
         )
     ),
     exitMap(Chunk.reverse),
-    exitMap((chunk) => Array.from(chunk)),
+    exitMap((chunk) => Chunk.toReadonlyArray(chunk) as Array<A>),
     Option.some
   )
 }
@@ -2949,7 +2950,7 @@ export const mapInputContext = dual<
 /** @internal */
 export const currentSpanFromFiber = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Option.Option<Tracer.Span> => {
   const span = fiber.getFiberRef(currentContext).unsafeMap.get(internalTracer.spanTag.key) as
-    | Tracer.ParentSpan
+    | Tracer.AnySpan
     | undefined
   return span !== undefined && span._tag === "Span" ? Option.some(span) : Option.none()
 }
@@ -2966,7 +2967,7 @@ const NoopSpanProto: Tracer.Span = {
     _tag: "Ended",
     startTime: BigInt(0),
     endTime: BigInt(0),
-    exit: exitUnit
+    exit: exitVoid
   },
   attributes: new Map(),
   links: [],