effect 3.0.0 → 3.0.1

package/src/internal/cause.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Either from "../Either.js"
@@ -584,7 +584,7 @@ const flattenCauseLoop = (
   while (1) {
     const [parallel, sequential] = pipe(
       causes,
-      Array.reduce(
+      Arr.reduce(
         [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
         ([parallel, sequential], cause) => {
           const [par, seq] = evaluateCause(cause)

package/src/internal/configProvider.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+import * as Arr from "../Array.js"
 import type * as Config from "../Config.js"
 import type * as ConfigError from "../ConfigError.js"
 import type * as ConfigProvider from "../ConfigProvider.js"
@@ -85,12 +85,12 @@ export const makeFlat = (
 export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
   make({
     load: (config) =>
-      core.flatMap(fromFlatLoop(flat, Array.empty(), config, false), (chunk) =>
-        Option.match(Array.head(chunk), {
+      core.flatMap(fromFlatLoop(flat, Arr.empty(), config, false), (chunk) =>
+        Option.match(Arr.head(chunk), {
           onNone: () =>
             core.fail(
               configError.MissingData(
-                Array.empty(),
+                Arr.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, Array.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 
   const getEnv = () =>
@@ -134,7 +134,7 @@ export const fromEnv = (
       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, Array.unsafeGet(i))
+          const pathComponent = pipe(path, Arr.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -154,7 +154,7 @@ 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, Array.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
   const mapWithIndexSplit = splitIndexInKeys(
     map,
@@ -180,10 +180,10 @@ export const fromMap = (
     path: ReadonlyArray<string>
   ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
-      const keyPaths = Array.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
+      const keyPaths = Arr.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, Array.unsafeGet(i))
+          const pathComponent = pipe(path, Arr.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 = Array.unfold(
+  const leftPad = Arr.unfold(
     left.length,
     (index) =>
       index >= right.length ?
         Option.none() :
         Option.some([leftDef(index), index + 1])
   )
-  const rightPad = Array.unfold(
+  const rightPad = Arr.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(Array.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Arr.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, Array.of(op.name)),
+          concat(prefix, Arr.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(Array.last(prefix), Option.getOrElse(() => "<n/a>"))
+                const name = pipe(Arr.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), Array.of)
+                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Arr.of)
                 ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
                   indices,
-                  (index) => fromFlatLoop(flat, Array.append(prefix, `[${index}]`), op.config, true)
+                  (index) => fromFlatLoop(flat, Arr.append(prefix, `[${index}]`), op.config, true)
                 ),
                 core.map((chunkChunk) => {
-                  const flattened = Array.flatten(chunkChunk)
+                  const flattened = Arr.flatten(chunkChunk)
                   if (flattened.length === 0) {
-                    return Array.of(Array.empty<A>())
+                    return Arr.of(Arr.empty<A>())
                   }
-                  return Array.of(flattened)
+                  return Arr.of(flattened)
                 })
               ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
             })
@@ -363,18 +363,18 @@ const fromFlatLoop = <A>(
                   core.forEachSequential((key) =>
                     fromFlatLoop(
                       flat,
-                      concat(prefix, Array.of(key)),
+                      concat(prefix, Arr.of(key)),
                       op.valueConfig,
                       split
                     )
                   ),
                   core.map((matrix) => {
                     if (matrix.length === 0) {
-                      return Array.of(HashMap.empty())
+                      return Arr.of(HashMap.empty())
                     }
                     return pipe(
                       transpose(matrix),
-                      Array.map((values) => HashMap.fromIterable(Array.zip(Array.fromIterable(keys), values)))
+                      Arr.map((values) => HashMap.fromIterable(Arr.zip(Arr.fromIterable(keys), values)))
                     )
                   })
                 )
@@ -404,17 +404,17 @@ const fromFlatLoop = <A>(
                   return core.fail(right.left)
                 }
                 if (Either.isRight(left) && Either.isRight(right)) {
-                  const path = pipe(prefix, Array.join("."))
+                  const path = pipe(prefix, Arr.join("."))
                   const fail = fromFlatLoopFail(prefix, path)
                   const [lefts, rights] = extend(
                     fail,
                     fail,
-                    pipe(left.right, Array.map(Either.right)),
-                    pipe(right.right, Array.map(Either.right))
+                    pipe(left.right, Arr.map(Either.right)),
+                    pipe(right.right, Arr.map(Either.right))
                   )
                   return pipe(
                     lefts,
-                    Array.zip(rights),
+                    Arr.zip(rights),
                     core.forEachSequential(([left, right]) =>
                       pipe(
                         core.zip(left, right),
@@ -587,8 +587,8 @@ export const within = dual<
     f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
   ) => ConfigProvider.ConfigProvider
 >(3, (self, path, f) => {
-  const unnest = Array.reduce(path, self, (provider, name) => unnested(provider, name))
-  const nest = Array.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
+  const unnest = Arr.reduce(path, self, (provider, name) => unnested(provider, name))
+  const nest = Arr.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
   return orElse(nest, () => self)
 })
 
@@ -609,7 +609,7 @@ const parsePrimitive = <A>(
       primitive.parse(text),
       core.mapBoth({
         onFailure: configError.prefixed(path),
-        onSuccess: Array.of
+        onSuccess: Arr.of
       })
     )
   }
@@ -628,8 +628,8 @@ const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<Read
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({
-      onFailure: () => Array.empty<number>(),
-      onSuccess: Array.sort(number.Order)
+      onFailure: () => Arr.empty<number>(),
+      onSuccess: Arr.sort(number.Order)
     }),
     core.either,
     core.map(Either.merge)
@@ -661,10 +661,10 @@ const splitIndexInKeys = (
   for (const [pathString, value] of map) {
     const keyWithIndex = pipe(
       unmakePathString(pathString),
-      Array.flatMap((key) =>
+      Arr.flatMap((key) =>
         Option.match(splitIndexFrom(key), {
-          onNone: () => Array.of(key),
-          onSome: ([key, index]) => Array.make(key, `[${index}]`)
+          onNone: () => Arr.of(key),
+          onSome: ([key, index]) => Arr.make(key, `[${index}]`)
         })
       )
     )
@@ -717,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 = Array.map(
+  const indexedEntries = Arr.map(
     getIndexedEntries(json as JsonMap),
     ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
   )
@@ -759,38 +759,38 @@ const getIndexedEntries = (
     value: string | number | boolean | JsonMap | JsonArray | null
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
     if (typeof value === "string") {
-      return Array.make([path, value] as [ReadonlyArray<KeyComponent>, string])
+      return Arr.make([path, value] as [ReadonlyArray<KeyComponent>, string])
     }
     if (typeof value === "number" || typeof value === "boolean") {
-      return Array.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
+      return Arr.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
     }
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
       return loopArray(path, value)
     }
     if (typeof value === "object" && value !== null) {
       return loopObject(path, value)
     }
-    return Array.empty<[ReadonlyArray<KeyComponent>, string]>()
+    return Arr.empty<[ReadonlyArray<KeyComponent>, string]>()
   }
   const loopArray = (
     path: ReadonlyArray<KeyComponent>,
     values: JsonArray
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
-    Array.match(values, {
-      onEmpty: () => Array.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
-      onNonEmpty: Array.flatMap((value, index) => loopAny(Array.append(path, keyIndex(index)), value))
+    Arr.match(values, {
+      onEmpty: () => Arr.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
+      onNonEmpty: Arr.flatMap((value, index) => loopAny(Arr.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 = Array.append(path, keyName(key))
+      const newPath = Arr.append(path, keyName(key))
       const result = loopAny(newPath, value)
-      if (Array.isEmptyReadonlyArray(result)) {
-        return Array.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
+      if (Arr.isEmptyReadonlyArray(result)) {
+        return Arr.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
       }
       return result
     })
-  return loopObject(Array.empty(), config)
+  return loopObject(Arr.empty(), config)
 }

package/src/internal/core-effect.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+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"
@@ -512,7 +512,7 @@ export const filterMap = dual<
 >(2, (elements, pf) =>
   core.map(
     core.forEachSequential(elements, identity),
-    Array.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),
-      Array.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)
     )
   })
 
@@ -1020,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.fromIterable)
+    : core.map(loopInternal(initial, options.while, options.step, options.body), Arr.fromIterable)
 
 const loopInternal = <Z, A, E, R>(
   initial: Z,
@@ -1184,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.fromIterable(internalCause.failures(cause))
+      const errors = Arr.fromIterable(internalCause.failures(cause))
       return errors.length === 0
         ? core.failCause(cause as Cause.Cause<never>)
         : core.fail(errors)
@@ -1278,7 +1278,7 @@ export const reduce = dual<
     zero: Z,
     f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
   ) =>
-    Array.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>
     )
@@ -1298,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>) =>
-    Array.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>
     )
@@ -1435,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) => Array.union(old, labels))
+  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => Arr.union(old, labels))
 )
 
 /* @internal */
@@ -2082,7 +2082,7 @@ export const unsafeMakeSpan = <XA, XE>(
         ...(options?.links ?? [])
       ] :
       Chunk.toReadonlyArray(linksFromEnv.value) :
-    options?.links ?? Array.empty()
+    options?.links ?? Arr.empty()
 
   const span = tracer.span(
     name,

package/src/internal/core.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+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"
@@ -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 = Array.fromIterable(self)
-      const ret = Array.allocate<B>(arr.length)
+      const arr = Arr.fromIterable(self)
+      const ret = Arr.allocate<B>(arr.length)
       let i = 0
       return as(
         whileLoop({
@@ -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 = Array.fromIterable(self)
+      const arr = Arr.fromIterable(self)
       let i = 0
       return whileLoop({
         while: () => i < arr.length,
@@ -1156,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>] =>
-  Array.fromIterable(elements).reduceRight(
+  Arr.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
       const either = f(current)
       switch (either._tag) {
@@ -1168,7 +1168,7 @@ export const partitionMap = <A, A1, A2>(
         }
       }
     },
-    [Array.empty<A1>(), Array.empty<A2>()]
+    [Arr.empty<A1>(), Arr.empty<A2>()]
   )
 
 /* @internal */
@@ -2000,7 +2000,7 @@ export const withUnhandledErrorLogLevel = dual<
 /** @internal */
 export const currentMetricLabels: FiberRef.FiberRef<ReadonlyArray<MetricLabel.MetricLabel>> = globalValue(
   Symbol.for("effect/FiberRef/currentMetricLabels"),
-  () => fiberRefUnsafeMakeReadonlyArray(Array.empty())
+  () => fiberRefUnsafeMakeReadonlyArray(Arr.empty())
 )
 
 /* @internal */
@@ -2110,8 +2110,8 @@ export const causeSquashWith = dual<
         Chunk.head,
         Option.match({
           onNone: () => {
-            const interrupts = Array.fromIterable(internalCause.interruptors(self)).flatMap((fiberId) =>
-              Array.fromIterable(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)
           },
@@ -2694,7 +2694,7 @@ const exitCollectAllInternal = <A, E>(
   }
   return pipe(
     Chunk.tailNonEmpty(list),
-    Array.reduce(
+    Arr.reduce(
       pipe(Chunk.headNonEmpty(list), exitMap<A, Chunk.Chunk<A>>(Chunk.of)),
       (accumulator, current) =>
         pipe(

package/src/internal/differ/readonlyArrayPatch.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import type * as Differ from "../../Differ.js"
 import * as Equal from "../../Equal.js"
 import * as Dual from "../../Function.js"
@@ -135,7 +135,7 @@ export const diff = <Value, Patch>(
     patch = combine(patch, makeSlice(0, i))
   }
   if (i < options.newValue.length) {
-    patch = combine(patch, makeAppend(Array.drop(i)(options.newValue)))
+    patch = combine(patch, makeAppend(Arr.drop(i)(options.newValue)))
   }
   return patch
 }
@@ -173,10 +173,10 @@ export const patch = Dual.dual<
     return oldValue
   }
   let readonlyArray = oldValue.slice()
-  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = Array.of(self)
-  while (Array.isNonEmptyArray(patches)) {
-    const head: Instruction = Array.headNonEmpty(patches) as Instruction
-    const tail = Array.tailNonEmpty(patches)
+  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = Arr.of(self)
+  while (Arr.isNonEmptyArray(patches)) {
+    const head: Instruction = Arr.headNonEmpty(patches) as Instruction
+    const tail = Arr.tailNonEmpty(patches)
     switch (head._tag) {
       case "Empty": {
         patches = tail

package/src/internal/metric/boundaries.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
@@ -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,
-    Array.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
-    Array.dedupe
+    Arr.appendAll(Chunk.of(Number.POSITIVE_INFINITY)),
+    Arr.dedupe
   )
   return new MetricBoundariesImpl(values)
 }
@@ -57,7 +57,7 @@ export const linear = (options: {
   readonly count: number
 }): MetricBoundaries.MetricBoundaries =>
   pipe(
-    Array.makeBy(options.count - 1, (i) => options.start + i * options.width),
+    Arr.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(
-    Array.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
+    Arr.makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)),
     Chunk.unsafeFromArray,
     fromIterable
   )

package/src/internal/metric/hook.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import * as Duration from "../../Duration.js"
 import type { LazyArg } from "../../Function.js"
 import { dual, pipe } from "../../Function.js"
@@ -123,8 +123,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 
   pipe(
     bounds,
-    Array.sort(number.Order),
-    Array.map((n, i) => {
+    Arr.sort(number.Order),
+    Arr.map((n, i) => {
       boundaries[i] = n
     })
   )
@@ -162,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.allocate(size) as any
+    const builder: Array<readonly [number, number]> = Arr.allocate(size) as any
     let cumulated = 0
     for (let i = 0; i < size; i++) {
       const boundary = boundaries[i]
@@ -189,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, Array.sort(number.Order))
-  const values = Array.allocate<readonly [number, number]>(maxSize)
+  const sortedQuantiles = pipe(quantiles, Arr.sort(number.Order))
+  const values = Arr.allocate<readonly [number, number]>(maxSize)
 
   let head = 0
   let count = 0
@@ -228,7 +228,7 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
     return calculateQuantiles(
       error,
       sortedQuantiles,
-      Array.sort(builder, number.Order)
+      Arr.sort(builder, number.Order)
     )
   }
 
@@ -291,8 +291,8 @@ const calculateQuantiles = (
 ): ReadonlyArray<readonly [number, Option.Option<number>]> => {
   // The number of samples examined
   const sampleCount = sortedSamples.length
-  if (!Array.isNonEmptyReadonlyArray(sortedQuantiles)) {
-    return Array.empty()
+  if (!Arr.isNonEmptyReadonlyArray(sortedQuantiles)) {
+    return Arr.empty()
   }
   const head = sortedQuantiles[0]
   const tail = sortedQuantiles.slice(1)
@@ -304,7 +304,7 @@ const calculateQuantiles = (
     head,
     sortedSamples
   )
-  const resolved = Array.of(resolvedHead)
+  const resolved = Arr.of(resolvedHead)
   tail.forEach((quantile) => {
     resolved.push(
       resolveQuantile(
@@ -317,7 +317,7 @@ const calculateQuantiles = (
       )
     )
   })
-  return Array.map(resolved, (rq) => [rq.quantile, rq.value] as const)
+  return Arr.map(resolved, (rq) => [rq.quantile, rq.value] as const)
 }
 
 /** @internal */
@@ -344,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 (!Array.isNonEmptyReadonlyArray(rest_1)) {
+    if (!Arr.isNonEmptyReadonlyArray(rest_1)) {
       return {
         quantile: quantile_1,
         value: Option.none(),
@@ -357,14 +357,14 @@ const resolveQuantile = (
     if (quantile_1 === 1) {
       return {
         quantile: quantile_1,
-        value: Option.some(Array.lastNonEmpty(rest_1)),
+        value: Option.some(Arr.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 = Array.span(rest_1, (n) => n <= rest_1[0])
+    const sameHead = Arr.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
@@ -378,7 +378,7 @@ const resolveQuantile = (
     if (candConsumed < desired - allowedError) {
       error_2 = error_1
       sampleCount_2 = sampleCount_1
-      current_2 = Array.head(rest_1)
+      current_2 = Arr.head(rest_1)
       consumed_2 = candConsumed
       quantile_2 = quantile_1
       rest_2 = sameHead[1]
@@ -406,7 +406,7 @@ const resolveQuantile = (
       case "None": {
         error_2 = error_1
         sampleCount_2 = sampleCount_1
-        current_2 = Array.head(rest_1)
+        current_2 = Arr.head(rest_1)
         consumed_2 = candConsumed
         quantile_2 = quantile_1
         rest_2 = sameHead[1]
@@ -423,7 +423,7 @@ const resolveQuantile = (
         if (candError < prevError) {
           error_2 = error_1
           sampleCount_2 = sampleCount_1
-          current_2 = Array.head(rest_1)
+          current_2 = Arr.head(rest_1)
           consumed_2 = candConsumed
           quantile_2 = quantile_1
           rest_2 = sameHead[1]

package/src/internal/metric/key.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import type * as Duration from "../../Duration.js"
 import * as Equal from "../../Equal.js"
 import { dual, pipe } from "../../Function.js"
@@ -26,7 +26,7 @@ const metricKeyVariance = {
   _Type: (_: never) => _
 }
 
-const arrayEquivilence = Array.getEquivalence(Equal.equals)
+const arrayEquivilence = Arr.getEquivalence(Equal.equals)
 
 /** @internal */
 class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
@@ -164,4 +164,4 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) =>
   extraTags.length === 0
     ? self
-    : new MetricKeyImpl(self.name, self.keyType, self.description, Array.union(self.tags, extraTags)))
+    : new MetricKeyImpl(self.name, self.keyType, self.description, Arr.union(self.tags, extraTags)))