effect 2.0.0-next.57 → 2.0.0-next.59

package/src/internal/metric/hook.ts

@@ -1,8 +1,6 @@
-import * as Chunk from "../../Chunk.js"
 import * as Duration from "../../Duration.js"
 import type { LazyArg } from "../../Function.js"
 import { dual, pipe } from "../../Function.js"
-import * as HashMap from "../../HashMap.js"
 import type * as MetricHook from "../../MetricHook.js"
 import type * as MetricKey from "../../MetricKey.js"
 import type * as MetricState from "../../MetricState.js"
@@ -88,9 +86,8 @@ export const frequency = (_key: MetricKey.MetricKey.Frequency): MetricHook.Metri
     const slotCount = values.get(word) ?? 0
     values.set(word, slotCount + 1)
   }
-  const snapshot = () => HashMap.fromIterable(values.entries())
   return make({
-    get: () => metricState.frequency(snapshot()),
+    get: () => metricState.frequency(values),
     update
   })
 }
@@ -125,8 +122,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 
   pipe(
     bounds,
-    Chunk.sort(number.Order),
-    Chunk.map((n, i) => {
+    ReadonlyArray.sort(number.Order),
+    ReadonlyArray.map((n, i) => {
       boundaries[i] = n
     })
   )
@@ -163,7 +160,7 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
     }
   }
 
-  const getBuckets = (): Chunk.Chunk<readonly [number, number]> => {
+  const getBuckets = (): ReadonlyArray<readonly [number, number]> => {
     const builder: Array<readonly [number, number]> = Array(size)
     let cumulated = 0
     for (let i = 0; i < size; i++) {
@@ -172,7 +169,7 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
       cumulated = cumulated + value
       builder[i] = [boundary, cumulated]
     }
-    return Chunk.unsafeFromArray(builder)
+    return builder
   }
 
   return make({
@@ -191,7 +188,7 @@ 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, Chunk.sort(number.Order))
+  const sortedQuantiles = pipe(quantiles, ReadonlyArray.sort(number.Order))
   const values = Array<readonly [number, number]>(maxSize)
 
   let head = 0
@@ -201,7 +198,7 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
   let max = Number.MIN_VALUE
 
   // Just before the snapshot we filter out all values older than maxAge
-  const snapshot = (now: number): Chunk.Chunk<readonly [number, Option.Option<number>]> => {
+  const snapshot = (now: number): ReadonlyArray<readonly [number, Option.Option<number>]> => {
     const builder: Array<number> = []
     // If the buffer is not full yet it contains valid items at the 0..last
     // indices and null values at the rest of the positions.
@@ -230,7 +227,7 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
     return calculateQuantiles(
       error,
       sortedQuantiles,
-      pipe(Chunk.unsafeFromArray(builder), Chunk.sort(number.Order))
+      ReadonlyArray.sort(builder, number.Order)
     )
   }
 
@@ -282,54 +279,44 @@ interface ResolvedQuantile {
   /**
    * The rest of the samples after the quantile has been resolved.
    */
-  readonly rest: Chunk.Chunk<number>
+  readonly rest: ReadonlyArray<number>
 }
 
 /** @internal */
 const calculateQuantiles = (
   error: number,
-  sortedQuantiles: Chunk.Chunk<number>,
-  sortedSamples: Chunk.Chunk<number>
-): Chunk.Chunk<readonly [number, Option.Option<number>]> => {
+  sortedQuantiles: ReadonlyArray<number>,
+  sortedSamples: ReadonlyArray<number>
+): ReadonlyArray<readonly [number, Option.Option<number>]> => {
   // The number of samples examined
   const sampleCount = sortedSamples.length
-  if (Chunk.isEmpty(sortedQuantiles)) {
-    return Chunk.empty()
+  if (!ReadonlyArray.isNonEmptyReadonlyArray(sortedQuantiles)) {
+    return ReadonlyArray.empty()
   }
-  const head = Chunk.unsafeHead(sortedQuantiles)
-  const tail = pipe(sortedQuantiles, Chunk.drop(1))
-  const resolved = pipe(
-    tail,
-    ReadonlyArray.reduce(
-      Chunk.of(
-        resolveQuantile(
-          error,
-          sampleCount,
-          Option.none(),
-          0,
-          head,
-          sortedSamples
-        )
-      ) as Chunk.Chunk<ResolvedQuantile>,
-      (accumulator, quantile) => {
-        const h = Chunk.unsafeHead(accumulator)
-        return pipe(
-          accumulator,
-          Chunk.append(
-            resolveQuantile(
-              error,
-              sampleCount,
-              h.value,
-              h.consumed,
-              quantile,
-              h.rest
-            )
-          )
-        )
-      }
-    )
+  const head = sortedQuantiles[0]
+  const tail = sortedQuantiles.slice(1)
+  const resolvedHead = resolveQuantile(
+    error,
+    sampleCount,
+    Option.none(),
+    0,
+    head,
+    sortedSamples
   )
-  return pipe(resolved, Chunk.map((rq) => [rq.quantile, rq.value] as const))
+  const resolved = ReadonlyArray.of(resolvedHead)
+  tail.forEach((quantile) => {
+    resolved.push(
+      resolveQuantile(
+        error,
+        sampleCount,
+        resolvedHead.value,
+        resolvedHead.consumed,
+        quantile,
+        resolvedHead.rest
+      )
+    )
+  })
+  return ReadonlyArray.map(resolved, (rq) => [rq.quantile, rq.value] as const)
 }
 
 /** @internal */
@@ -339,7 +326,7 @@ const resolveQuantile = (
   current: Option.Option<number>,
   consumed: number,
   quantile: number,
-  rest: Chunk.Chunk<number>
+  rest: ReadonlyArray<number>
 ): ResolvedQuantile => {
   let error_1 = error
   let sampleCount_1 = sampleCount
@@ -356,12 +343,12 @@ 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 (Chunk.isEmpty(rest_1)) {
+    if (!ReadonlyArray.isNonEmptyReadonlyArray(rest_1)) {
       return {
         quantile: quantile_1,
         value: Option.none(),
         consumed: consumed_1,
-        rest: Chunk.empty()
+        rest: []
       }
     }
     // If the quantile is the 100% quantile, we can take the maximum of all the
@@ -369,14 +356,14 @@ const resolveQuantile = (
     if (quantile_1 === 1) {
       return {
         quantile: quantile_1,
-        value: Option.some(Chunk.unsafeLast(rest_1)),
+        value: Option.some(ReadonlyArray.lastNonEmpty(rest_1)),
         consumed: consumed_1 + rest_1.length,
-        rest: Chunk.empty()
+        rest: []
       }
     }
     // Split into two chunks - the first chunk contains all elements of the same
     // value as the chunk head
-    const sameHead = pipe(rest_1, Chunk.splitWhere((n) => n > Chunk.unsafeHead(rest_1)))
+    const sameHead = ReadonlyArray.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
@@ -390,7 +377,7 @@ const resolveQuantile = (
     if (candConsumed < desired - allowedError) {
       error_2 = error_1
       sampleCount_2 = sampleCount_1
-      current_2 = Chunk.head(rest_1)
+      current_2 = ReadonlyArray.head(rest_1)
       consumed_2 = candConsumed
       quantile_2 = quantile_1
       rest_2 = sameHead[1]
@@ -418,7 +405,7 @@ const resolveQuantile = (
       case "None": {
         error_2 = error_1
         sampleCount_2 = sampleCount_1
-        current_2 = Chunk.head(rest_1)
+        current_2 = ReadonlyArray.head(rest_1)
         consumed_2 = candConsumed
         quantile_2 = quantile_1
         rest_2 = sameHead[1]
@@ -435,7 +422,7 @@ const resolveQuantile = (
         if (candError < prevError) {
           error_2 = error_1
           sampleCount_2 = sampleCount_1
-          current_2 = Chunk.head(rest_1)
+          current_2 = ReadonlyArray.head(rest_1)
           consumed_2 = candConsumed
           quantile_2 = quantile_1
           rest_2 = sameHead[1]

package/src/internal/metric/key.ts

@@ -1,9 +1,7 @@
-import type * as Chunk from "../../Chunk.js"
 import type * as Duration from "../../Duration.js"
 import * as Equal from "../../Equal.js"
 import { dual, pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
-import * as HashSet from "../../HashSet.js"
 import type * as MetricBoundaries from "../../MetricBoundaries.js"
 import type * as MetricKey from "../../MetricKey.js"
 import type * as MetricKeyType from "../../MetricKeyType.js"
@@ -11,6 +9,7 @@ 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"
 
@@ -27,6 +26,8 @@ const metricKeyVariance = {
   _Type: (_: never) => _
 }
 
+const arrayEquivilence = ReadonlyArray.getEquivalence(Equal.equals)
+
 /** @internal */
 class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
   readonly [MetricKeyTypeId] = metricKeyVariance
@@ -34,22 +35,24 @@ class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> impl
     readonly name: string,
     readonly keyType: Type,
     readonly description: Option.Option<string>,
-    readonly tags: HashSet.HashSet<MetricLabel.MetricLabel> = HashSet.empty()
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(this.name),
+    readonly tags: ReadonlyArray<MetricLabel.MetricLabel> = []
+  ) {
+    this._hash = pipe(
+      Hash.string(this.name + this.description),
       Hash.combine(Hash.hash(this.keyType)),
-      Hash.combine(Hash.hash(this.description)),
-      Hash.combine(Hash.hash(this.tags))
+      Hash.combine(Hash.array(this.tags))
     )
   }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
   [Equal.symbol](u: unknown): boolean {
     return isMetricKey(u) &&
       this.name === u.name &&
       Equal.equals(this.keyType, u.keyType) &&
       Equal.equals(this.description, u.description) &&
-      Equal.equals(this.tags, u.tags)
+      arrayEquivilence(this.tags, u.tags)
   }
   pipe() {
     return pipeArguments(this, arguments)
@@ -119,7 +122,7 @@ export const summary = (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
     readonly description?: string | undefined
   }
 ): MetricKey.MetricKey.Summary =>
@@ -142,33 +145,20 @@ export const tagged = dual<
     key: string,
     value: string
   ) => MetricKey.MetricKey<Type>
->(3, (self, key, value) => taggedWithLabelSet(self, HashSet.make(metricLabel.make(key, value))))
+>(3, (self, key, value) => taggedWithLabels(self, [metricLabel.make(key, value)]))
 
 /** @internal */
 export const taggedWithLabels = dual<
   (
-    extraTags: Iterable<MetricLabel.MetricLabel>
-  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>
-  ) => MetricKey.MetricKey<Type>,
-  <Type extends MetricKeyType.MetricKeyType<any, any>>(
-    self: MetricKey.MetricKey<Type>,
-    extraTags: Iterable<MetricLabel.MetricLabel>
-  ) => MetricKey.MetricKey<Type>
->(2, (self, extraTags) => taggedWithLabelSet(self, HashSet.fromIterable(extraTags)))
-
-/** @internal */
-export const taggedWithLabelSet = dual<
-  (
-    extraTags: HashSet.HashSet<MetricLabel.MetricLabel>
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
   ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
     self: MetricKey.MetricKey<Type>
   ) => MetricKey.MetricKey<Type>,
   <Type extends MetricKeyType.MetricKeyType<any, any>>(
     self: MetricKey.MetricKey<Type>,
-    extraTags: HashSet.HashSet<MetricLabel.MetricLabel>
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
   ) => MetricKey.MetricKey<Type>
 >(2, (self, extraTags) =>
-  HashSet.size(extraTags) === 0
+  extraTags.length === 0
     ? self
-    : new MetricKeyImpl(self.name, self.keyType, self.description, pipe(self.tags, HashSet.union(extraTags))))
+    : new MetricKeyImpl(self.name, self.keyType, self.description, ReadonlyArray.union(self.tags, extraTags)))

package/src/internal/metric/keyType.ts

@@ -1,4 +1,3 @@
-import type * as Chunk from "../../Chunk.js"
 import * as Duration from "../../Duration.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
@@ -67,9 +66,12 @@ const metricKeyTypeVariance = {
 class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Counter<A> {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [CounterKeyTypeTypeId]: MetricKeyType.CounterKeyTypeTypeId = CounterKeyTypeTypeId
-  constructor(readonly incremental: boolean, readonly bigint: boolean) {}
+  constructor(readonly incremental: boolean, readonly bigint: boolean) {
+    this._hash = Hash.string(CounterKeyTypeSymbolKey)
+  }
+  readonly _hash: number;
   [Hash.symbol](): number {
-    return Hash.hash(CounterKeyTypeSymbolKey)
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isCounterKey(that)
@@ -82,9 +84,10 @@ class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.Metri
 /** @internal */
 class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId;
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
+  readonly _hash = Hash.string(FrequencyKeyTypeSymbolKey);
   [Hash.symbol](): number {
-    return Hash.hash(FrequencyKeyTypeSymbolKey)
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyKey(that)
@@ -99,8 +102,9 @@ class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricK
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [GaugeKeyTypeTypeId]: MetricKeyType.GaugeKeyTypeTypeId = GaugeKeyTypeTypeId
   constructor(readonly bigint: boolean) {}
+  readonly _hash = Hash.string(GaugeKeyTypeSymbolKey);
   [Hash.symbol](): number {
-    return Hash.hash(GaugeKeyTypeSymbolKey)
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isGaugeKey(that)
@@ -117,13 +121,16 @@ class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricK
 export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
-  constructor(readonly boundaries: MetricBoundaries.MetricBoundaries) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(HistogramKeyTypeSymbolKey),
+  constructor(readonly boundaries: MetricBoundaries.MetricBoundaries) {
+    this._hash = pipe(
+      Hash.string(HistogramKeyTypeSymbolKey),
       Hash.combine(Hash.hash(this.boundaries))
     )
   }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
   [Equal.symbol](that: unknown): boolean {
     return isHistogramKey(that) && Equal.equals(this.boundaries, that.boundaries)
   }
@@ -140,17 +147,20 @@ class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
     readonly maxAge: Duration.Duration,
     readonly maxSize: number,
     readonly error: number,
-    readonly quantiles: Chunk.Chunk<number>
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(SummaryKeyTypeSymbolKey),
+    readonly quantiles: ReadonlyArray<number>
+  ) {
+    this._hash = pipe(
+      Hash.string(SummaryKeyTypeSymbolKey),
       Hash.combine(Hash.hash(this.maxAge)),
       Hash.combine(Hash.hash(this.maxSize)),
       Hash.combine(Hash.hash(this.error)),
-      Hash.combine(Hash.hash(this.quantiles))
+      Hash.combine(Hash.array(this.quantiles))
     )
   }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
   [Equal.symbol](that: unknown): boolean {
     return isSummaryKey(that) &&
       Equal.equals(this.maxAge, that.maxAge) &&
@@ -210,7 +220,7 @@ export const summary = (
     readonly maxAge: Duration.DurationInput
     readonly maxSize: number
     readonly error: number
-    readonly quantiles: Chunk.Chunk<number>
+    readonly quantiles: ReadonlyArray<number>
   }
 ): MetricKeyType.MetricKeyType.Summary => {
   return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)

package/src/internal/metric/label.ts

@@ -1,5 +1,4 @@
 import * as Equal from "../../Equal.js"
-import { pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
 import type * as MetricLabel from "../../MetricLabel.js"
 import { pipeArguments } from "../../Pipeable.js"
@@ -16,13 +15,12 @@ export const MetricLabelTypeId: MetricLabel.MetricLabelTypeId = Symbol.for(
 /** @internal */
 class MetricLabelImpl implements MetricLabel.MetricLabel {
   readonly [MetricLabelTypeId]: MetricLabel.MetricLabelTypeId = MetricLabelTypeId
-  constructor(readonly key: string, readonly value: string) {}
+  readonly _hash: number
+  constructor(readonly key: string, readonly value: string) {
+    this._hash = Hash.string(MetricLabelSymbolKey + this.key + this.value)
+  }
   [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(MetricLabelSymbolKey),
-      Hash.combine(Hash.hash(this.key)),
-      Hash.combine(Hash.hash(this.value))
-    )
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isMetricLabel(that) &&

package/src/internal/metric/registry.ts

@@ -1,5 +1,4 @@
 import { pipe } from "../../Function.js"
-import * as HashSet from "../../HashSet.js"
 import type * as MetricHook from "../../MetricHook.js"
 import type * as MetricKey from "../../MetricKey.js"
 import type * as MetricKeyType from "../../MetricKeyType.js"
@@ -28,12 +27,12 @@ class MetricRegistryImpl implements MetricRegistry.MetricRegistry {
     MetricHook.MetricHook.Root
   >()
 
-  snapshot(): HashSet.HashSet<MetricPair.MetricPair.Untyped> {
+  snapshot(): ReadonlyArray<MetricPair.MetricPair.Untyped> {
     const result: Array<MetricPair.MetricPair.Untyped> = []
     for (const [key, hook] of this.map) {
       result.push(metricPair.unsafeMake(key, hook.get()))
     }
-    return HashSet.fromIterable(result)
+    return result
   }
 
   get<Type extends MetricKeyType.MetricKeyType<any, any>>(

package/src/internal/metric/state.ts

@@ -1,12 +1,11 @@
-import type * as Chunk from "../../Chunk.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
-import type * as HashMap from "../../HashMap.js"
 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,19 +79,29 @@ class CounterState<A extends (number | bigint)> implements MetricState.MetricSta
   }
 }
 
+const arrayEquals = ReadonlyArray.getEquivalence(Equal.equals)
+
 /** @internal */
 class FrequencyState implements MetricState.MetricState.Frequency {
   readonly [MetricStateTypeId] = metricStateVariance
   readonly [FrequencyStateTypeId]: MetricState.FrequencyStateTypeId = FrequencyStateTypeId
-  constructor(readonly occurrences: HashMap.HashMap<string, number>) {}
+  constructor(readonly occurrences: ReadonlyMap<string, number>) {}
+  _hash: number | undefined;
   [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(FrequencyStateSymbolKey),
-      Hash.combine(Hash.hash(this.occurrences))
+    if (this._hash !== undefined) {
+      return this._hash
+    }
+    this._hash = pipe(
+      Hash.string(FrequencyStateSymbolKey),
+      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.occurrences.entries())))
     )
+    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
-    return isFrequencyState(that) && Equal.equals(this.occurrences, that.occurrences)
+    return isFrequencyState(that) && arrayEquals(
+      ReadonlyArray.fromIterable(this.occurrences.entries()),
+      ReadonlyArray.fromIterable(that.occurrences.entries())
+    )
   }
   pipe() {
     return pipeArguments(this, arguments)
@@ -123,7 +132,7 @@ export class HistogramState implements MetricState.MetricState.Histogram {
   readonly [MetricStateTypeId] = metricStateVariance
   readonly [HistogramStateTypeId]: MetricState.HistogramStateTypeId = HistogramStateTypeId
   constructor(
-    readonly buckets: Chunk.Chunk<readonly [number, number]>,
+    readonly buckets: ReadonlyArray<readonly [number, number]>,
     readonly count: number,
     readonly min: number,
     readonly max: number,
@@ -158,7 +167,7 @@ export class SummaryState implements MetricState.MetricState.Summary {
   readonly [SummaryStateTypeId]: MetricState.SummaryStateTypeId = SummaryStateTypeId
   constructor(
     readonly error: number,
-    readonly quantiles: Chunk.Chunk<readonly [number, Option.Option<number>]>,
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>,
     readonly count: number,
     readonly min: number,
     readonly max: number,
@@ -196,7 +205,7 @@ export const counter: {
 } = (count) => new CounterState(count) as any
 
 /** @internal */
-export const frequency = (occurrences: HashMap.HashMap<string, number>): MetricState.MetricState.Frequency => {
+export const frequency = (occurrences: ReadonlyMap<string, number>): MetricState.MetricState.Frequency => {
   return new FrequencyState(occurrences)
 }
 
@@ -209,7 +218,7 @@ export const gauge: {
 /** @internal */
 export const histogram = (
   options: {
-    readonly buckets: Chunk.Chunk<readonly [number, number]>
+    readonly buckets: ReadonlyArray<readonly [number, number]>
     readonly count: number
     readonly min: number
     readonly max: number
@@ -228,7 +237,7 @@ export const histogram = (
 export const summary = (
   options: {
     readonly error: number
-    readonly quantiles: Chunk.Chunk<readonly [number, Option.Option<number>]>
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
     readonly count: number
     readonly min: number
     readonly max: number