effect 2.0.0-next.55 → 2.0.0-next.56

package/src/Inspectable.ts

@@ -21,9 +21,9 @@ export type NodeInspectSymbol = typeof NodeInspectSymbol
  * @category models
  */
 export interface Inspectable {
-  readonly toString: () => string
-  readonly toJSON: () => unknown
-  readonly [NodeInspectSymbol]: () => unknown
+  toString(): string
+  toJSON(): unknown
+  [NodeInspectSymbol](): unknown
 }
 
 /**

package/src/KeyedPool.ts

@@ -26,21 +26,21 @@ export type KeyedPoolTypeId = typeof KeyedPoolTypeId
  * @since 2.0.0
  * @category models
  */
-export interface KeyedPool<K, E, A> extends KeyedPool.Variance<K, E, A>, Pipeable {
+export interface KeyedPool<in K, out E, in out A> extends KeyedPool.Variance<K, E, A>, Pipeable {
   /**
    * Retrieves an item from the pool belonging to the given key in a scoped
    * effect. Note that if acquisition fails, then the returned effect will fail
    * for that same reason. Retrying a failed acquisition attempt will repeat the
    * acquisition attempt.
    */
-  readonly get: (key: K) => Effect.Effect<Scope.Scope, E, A>
+  get(key: K): Effect.Effect<Scope.Scope, E, A>
 
   /**
    * Invalidates the specified item. This will cause the pool to eventually
    * reallocate the item, although this reallocation may occur lazily rather
    * than eagerly.
    */
-  readonly invalidate: (item: A) => Effect.Effect<never, never, void>
+  invalidate(item: A): Effect.Effect<never, never, void>
 }
 
 /**
@@ -51,11 +51,11 @@ export declare namespace KeyedPool {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<K, E, A> {
+  export interface Variance<in K, out E, in out A> {
     readonly [KeyedPoolTypeId]: {
       readonly _K: (_: K) => void
       readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
     }
   }
 }
@@ -70,7 +70,10 @@ export declare namespace KeyedPool {
  * @category constructors
  */
 export const make: <K, R, E, A>(
-  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: number }
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly size: number
+  }
 ) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.make
 
 /**
@@ -85,7 +88,10 @@ export const make: <K, R, E, A>(
  * @category constructors
  */
 export const makeWith: <K, R, E, A>(
-  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: (key: K) => number }
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly size: (key: K) => number
+  }
 ) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWith
 
 /**

package/src/Layer.ts

@@ -58,7 +58,7 @@ export type LayerTypeId = typeof LayerTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Layer<RIn, E, ROut> extends Layer.Variance<RIn, E, ROut>, Pipeable {}
+export interface Layer<out RIn, out E, in ROut> extends Layer.Variance<RIn, E, ROut>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -68,7 +68,7 @@ export declare namespace Layer {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<RIn, E, ROut> {
+  export interface Variance<out RIn, out E, in ROut> {
     readonly [LayerTypeId]: {
       readonly _RIn: (_: never) => RIn
       readonly _E: (_: never) => E

package/src/List.ts

@@ -62,7 +62,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface Nil<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface Nil<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
   readonly _tag: "Nil"
 }
@@ -71,7 +71,7 @@ export interface Nil<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable
  * @since 2.0.0
  * @category models
  */
-export interface Cons<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface Cons<out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
   readonly _tag: "Cons"
   readonly head: A
@@ -461,9 +461,9 @@ export const every: {
  * @category elements
  */
 export const some: {
-  <A>(predicate: Predicate<A>): <B extends A>(self: List<B>) => self is Cons<B>
-  <B extends A, A = B>(self: List<B>, predicate: Predicate<A>): self is Cons<B>
-} = dual(2, <B extends A, A = B>(self: List<B>, predicate: Predicate<A>): self is Cons<B> => {
+  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => self is Cons<B>
+  <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A>
+} = dual(2, <A>(self: List<A>, predicate: Predicate<A>): self is Cons<A> => {
   let these = self
   while (!isNil(these)) {
     if (predicate(these.head)) {
@@ -481,11 +481,11 @@ export const some: {
  * @category combinators
  */
 export const filter: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: List<C>) => List<B>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
   <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => List<B>
-  <C extends A, B extends A, A = C>(self: List<C>, refinement: Refinement<A, B>): List<B>
-  <B extends A, A = B>(self: List<B>, predicate: Predicate<A>): List<B>
-} = dual(2, <B extends A, A = B>(self: List<B>, predicate: Predicate<A>): List<B> => noneIn(self, predicate, false))
+  <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>
+  <A>(self: List<A>, predicate: Predicate<A>): List<A>
+} = dual(2, <A>(self: List<A>, predicate: Predicate<A>): List<A> => noneIn(self, predicate, false))
 
 // everything seen so far is not included
 const noneIn = <A>(
@@ -618,7 +618,7 @@ export const compact = <A>(self: List<Option.Option<A>>): List<A> => filterMap(s
  */
 export const findFirst: {
   <A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
-  <A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => Option.Option<B>
   <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>
   <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>
 } = dual(2, <A>(self: List<A>, predicate: Predicate<A>): Option.Option<A> => {
@@ -760,13 +760,15 @@ export const map: {
  * @category combinators
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: List<C>) => [List<Exclude<C, B>>, List<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: List<B>) => [List<B>, List<B>]
-  <C extends A, B extends A, A = C>(self: List<C>, refinement: Refinement<A, B>): [List<Exclude<C, B>>, List<B>]
-  <B extends A, A = B>(self: List<B>, predicate: (a: A) => boolean): [List<B>, List<B>]
-} = dual(2, <B extends A, A = B>(self: List<B>, predicate: (a: A) => boolean): [List<B>, List<B>] => {
-  const left: Array<B> = []
-  const right: Array<B> = []
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>
+  ): (self: List<C>) => [excluded: List<Exclude<C, B>>, satisfying: List<B>]
+  <B extends A, A = B>(predicate: Predicate<A>): (self: List<B>) => [excluded: List<B>, satisfying: List<B>]
+  <A, B extends A>(self: List<A>, refinement: Refinement<A, B>): [excluded: List<Exclude<A, B>>, satisfying: List<B>]
+  <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>]
+} = dual(2, <A>(self: List<A>, predicate: Predicate<A>): [excluded: List<A>, satisfying: List<A>] => {
+  const left: Array<A> = []
+  const right: Array<A> = []
   for (const a of self) {
     if (predicate(a)) {
       right.push(a)
@@ -786,9 +788,9 @@ export const partition: {
  * @category combinators
  */
 export const partitionMap: {
-  <A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => [List<B>, List<C>]
-  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [List<B>, List<C>]
-} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [List<B>, List<C>] => {
+  <A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => [left: List<B>, right: List<C>]
+  <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [left: List<B>, right: List<C>]
+} = dual(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): [left: List<B>, right: List<C>] => {
   const left: Array<B> = []
   const right: Array<C> = []
   for (const a of self) {
@@ -865,8 +867,8 @@ export const reverse = <A>(self: List<A>): List<A> => {
  * @category combinators
  */
 export const splitAt: {
-  (n: number): <A>(self: List<A>) => [List<A>, List<A>]
-  <A>(self: List<A>, n: number): [List<A>, List<A>]
+  (n: number): <A>(self: List<A>) => [beforeIndex: List<A>, fromIndex: List<A>]
+  <A>(self: List<A>, n: number): [beforeIndex: List<A>, fromIndex: List<A>]
 } = dual(2, <A>(self: List<A>, n: number): [List<A>, List<A>] => [take(self, n), drop(self, n)])
 
 /**

package/src/Logger.ts

@@ -35,8 +35,8 @@ export type LoggerTypeId = typeof LoggerTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Logger<Message, Output> extends Logger.Variance<Message, Output>, Pipeable {
-  readonly log: (options: Logger.Options<Message>) => Output
+export interface Logger<in Message, out Output> extends Logger.Variance<Message, Output>, Pipeable {
+  log(options: Logger.Options<Message>): Output
 }
 
 /**
@@ -47,7 +47,7 @@ export declare namespace Logger {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Message, Output> {
+  export interface Variance<in Message, out Output> {
     readonly [LoggerTypeId]: {
       readonly _Message: (_: Message) => void
       readonly _Output: (_: never) => Output
@@ -58,7 +58,7 @@ export declare namespace Logger {
    * @since 2.0.0
    * @category models
    */
-  export interface Options<Message> {
+  export interface Options<out Message> {
     readonly fiberId: FiberId.FiberId
     readonly logLevel: LogLevel.LogLevel
     readonly message: Message

package/src/Match.ts

@@ -33,7 +33,7 @@ export type Matcher<Input, Filters, RemainingApplied, Result, Provided> =
  * @category model
  * @since 1.0.0
  */
-export interface TypeMatcher<Input, Filters, Remaining, Result> extends Pipeable {
+export interface TypeMatcher<in Input, out Filters, out Remaining, out Result> extends Pipeable {
   readonly _tag: "TypeMatcher"
   readonly [MatcherTypeId]: {
     readonly _input: (_: Input) => unknown
@@ -42,14 +42,14 @@ export interface TypeMatcher<Input, Filters, Remaining, Result> extends Pipeable
     readonly _result: (_: never) => Result
   }
   readonly cases: ReadonlyArray<Case>
-  readonly add: <I, R, RA, A>(_case: Case) => TypeMatcher<I, R, RA, A>
+  add<I, R, RA, A>(_case: Case): TypeMatcher<I, R, RA, A>
 }
 
 /**
  * @category model
  * @since 1.0.0
  */
-export interface ValueMatcher<Input, Filters, Remaining, Result, Provided> extends Pipeable {
+export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Provided> extends Pipeable {
   readonly _tag: "ValueMatcher"
   readonly [MatcherTypeId]: {
     readonly _input: (_: Input) => unknown
@@ -58,7 +58,7 @@ export interface ValueMatcher<Input, Filters, Remaining, Result, Provided> exten
   }
   readonly provided: Provided
   readonly value: Either.Either<Remaining, Provided>
-  readonly add: <I, R, RA, A, Pr>(_case: Case) => ValueMatcher<I, R, RA, A, Pr>
+  add<I, R, RA, A, Pr>(_case: Case): ValueMatcher<I, R, RA, A, Pr>
 }
 
 /**
@@ -73,8 +73,8 @@ export type Case = When | Not
  */
 export interface When {
   readonly _tag: "When"
-  readonly guard: (u: unknown) => boolean
-  readonly evaluate: (input: unknown) => any
+  guard(u: unknown): boolean
+  evaluate(input: unknown): any
 }
 
 /**
@@ -83,8 +83,8 @@ export interface When {
  */
 export interface Not {
   readonly _tag: "Not"
-  readonly guard: (u: unknown) => boolean
-  readonly evaluate: (input: unknown) => any
+  guard(u: unknown): boolean
+  evaluate(input: unknown): any
 }
 
 /**
@@ -550,7 +550,7 @@ export type SafeRefinementId = typeof SafeRefinementId
  * @category model
  * @since 1.0.0
  */
-export interface SafeRefinement<A, R = A> {
+export interface SafeRefinement<in A, out R = A> {
   readonly [SafeRefinementId]: (a: A) => R
 }
 
@@ -652,7 +652,7 @@ export declare namespace Types {
   /**
    * @since 1.0.0
    */
-  export interface Without<X> {
+  export interface Without<out X> {
     readonly _tag: "Without"
     readonly _X: X
   }
@@ -660,7 +660,7 @@ export declare namespace Types {
   /**
    * @since 1.0.0
    */
-  export interface Only<X> {
+  export interface Only<out X> {
     readonly _tag: "Only"
     readonly _X: X
   }

package/src/MergeDecision.ts

@@ -21,7 +21,7 @@ export type MergeDecisionTypeId = typeof MergeDecisionTypeId
  * @since 2.0.0
  * @category models
  */
-export interface MergeDecision<R, E0, Z0, E, Z> extends MergeDecision.Variance<R, E0, Z0, E, Z> {}
+export interface MergeDecision<out R, in E0, in Z0, out E, out Z> extends MergeDecision.Variance<R, E0, Z0, E, Z> {}
 
 /**
  * @since 2.0.0
@@ -31,7 +31,7 @@ export declare namespace MergeDecision {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E0, Z0, E, Z> {
+  export interface Variance<out R, in E0, in Z0, out E, out Z> {
     readonly [MergeDecisionTypeId]: {
       _R: (_: never) => R
       _E0: (_: E0) => void

package/src/MergeState.ts

@@ -45,7 +45,9 @@ export declare namespace MergeState {
  * @since 2.0.0
  * @category models
  */
-export interface BothRunning<_Env, Err, Err1, _Err2, Elem, Done, Done1, _Done2> extends MergeState.Proto {
+export interface BothRunning<_Env, out Err, out Err1, _Err2, out Elem, out Done, out Done1, _Done2>
+  extends MergeState.Proto
+{
   readonly _tag: "BothRunning"
   readonly left: Fiber.Fiber<Err, Either.Either<Done, Elem>>
   readonly right: Fiber.Fiber<Err1, Either.Either<Done1, Elem>>
@@ -55,18 +57,22 @@ export interface BothRunning<_Env, Err, Err1, _Err2, Elem, Done, Done1, _Done2>
  * @since 2.0.0
  * @category models
  */
-export interface LeftDone<Env, _Err, Err1, Err2, _Elem, _Done, Done1, Done2> extends MergeState.Proto {
+export interface LeftDone<out Env, _Err, in Err1, out Err2, _Elem, _Done, in Done1, out Done2>
+  extends MergeState.Proto
+{
   readonly _tag: "LeftDone"
-  readonly f: (exit: Exit.Exit<Err1, Done1>) => Effect.Effect<Env, Err2, Done2>
+  f(exit: Exit.Exit<Err1, Done1>): Effect.Effect<Env, Err2, Done2>
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface RightDone<Env, Err, _Err1, Err2, _Elem, Done, _Done1, Done2> extends MergeState.Proto {
+export interface RightDone<out Env, in Err, _Err1, out Err2, _Elem, in Done, _Done1, out Done2>
+  extends MergeState.Proto
+{
   readonly _tag: "RightDone"
-  readonly f: (exit: Exit.Exit<Err, Done>) => Effect.Effect<Env, Err2, Done2>
+  f(exit: Exit.Exit<Err, Done>): Effect.Effect<Env, Err2, Done2>
 }
 
 /**

package/src/Metric.ts

@@ -49,15 +49,15 @@ export type MetricTypeId = typeof MetricTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Metric<Type, In, Out> extends Metric.Variance<Type, In, Out>, Pipeable {
+export interface Metric<in out Type, in In, out Out> extends Metric.Variance<Type, In, Out>, Pipeable {
   /**
    * The type of the underlying primitive metric. For example, this could be
    * `MetricKeyType.Counter` or `MetricKeyType.Gauge`.
    */
   readonly keyType: Type
-  readonly unsafeUpdate: (input: In, extraTags: HashSet.HashSet<MetricLabel.MetricLabel>) => void
-  readonly unsafeValue: (extraTags: HashSet.HashSet<MetricLabel.MetricLabel>) => Out
-  /** */
+  unsafeUpdate(input: In, extraTags: HashSet.HashSet<MetricLabel.MetricLabel>): void
+  unsafeValue(extraTags: HashSet.HashSet<MetricLabel.MetricLabel>): Out
+  register(): this
   <R, E, A extends In>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 }
 
@@ -121,7 +121,7 @@ export declare namespace Metric {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Type, In, Out> {
+  export interface Variance<in out Type, in In, out Out> {
     readonly [MetricTypeId]: {
       readonly _Type: (_: Type) => Type
       readonly _In: (_: In) => void

package/src/MetricHook.ts

@@ -23,9 +23,9 @@ export type MetricHookTypeId = typeof MetricHookTypeId
  * @since 2.0.0
  * @category models
  */
-export interface MetricHook<In, Out> extends MetricHook.Variance<In, Out>, Pipeable {
-  readonly get: () => Out
-  readonly update: (input: In) => void
+export interface MetricHook<in In, out Out> extends MetricHook.Variance<In, Out>, Pipeable {
+  get(): Out
+  update(input: In): void
 }
 
 /**
@@ -78,7 +78,7 @@ export declare namespace MetricHook {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<In, Out> {
+  export interface Variance<in In, out Out> {
     readonly [MetricHookTypeId]: {
       readonly _In: (_: In) => void
       readonly _Out: (_: never) => Out

package/src/MetricKey.ts

@@ -34,7 +34,7 @@ export type MetricKeyTypeId = typeof MetricKeyTypeId
  * @since 2.0.0
  * @category models
  */
-export interface MetricKey<Type extends MetricKeyType.MetricKeyType<any, any>>
+export interface MetricKey<out Type extends MetricKeyType.MetricKeyType<any, any>>
   extends MetricKey.Variance<Type>, Equal.Equal, Pipeable
 {
   readonly name: string
@@ -87,7 +87,7 @@ export declare namespace MetricKey {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Type> {
+  export interface Variance<out Type> {
     readonly [MetricKeyTypeId]: {
       _Type: (_: never) => Type
     }

package/src/MetricKeyType.ts

@@ -85,7 +85,7 @@ export type SummaryKeyTypeTypeId = typeof SummaryKeyTypeTypeId
  * @since 2.0.0
  * @category modelz
  */
-export interface MetricKeyType<In, Out> extends MetricKeyType.Variance<In, Out>, Equal.Equal, Pipeable {}
+export interface MetricKeyType<in In, out Out> extends MetricKeyType.Variance<In, Out>, Equal.Equal, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -149,7 +149,7 @@ export declare namespace MetricKeyType {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<In, Out> {
+  export interface Variance<in In, out Out> {
     readonly [MetricKeyTypeTypeId]: {
       readonly _In: (_: In) => void
       readonly _Out: (_: never) => Out

package/src/MetricPair.ts

@@ -23,7 +23,7 @@ export type MetricPairTypeId = typeof MetricPairTypeId
  * @since 2.0.0
  * @category model
  */
-export interface MetricPair<Type extends MetricKeyType.MetricKeyType<any, any>>
+export interface MetricPair<out Type extends MetricKeyType.MetricKeyType<any, any>>
   extends MetricPair.Variance<Type>, Pipeable
 {
   readonly metricKey: MetricKey.MetricKey<Type>
@@ -44,7 +44,7 @@ export declare namespace MetricPair {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Type extends MetricKeyType.MetricKeyType<any, any>> {
+  export interface Variance<out Type extends MetricKeyType.MetricKeyType<any, any>> {
     readonly [MetricPairTypeId]: {
       readonly _Type: (_: never) => Type
     }

package/src/MetricPolling.ts

@@ -13,25 +13,25 @@ import type * as Scope from "./Scope.js"
  * @since 2.0.0
  * @category symbols
  */
-export const PollingMetricTypeId: unique symbol = internal.PollingMetricTypeId
+export const MetricPollingTypeId: unique symbol = internal.MetricPollingTypeId
 
 /**
  * @since 2.0.0
  * @category symbols
  */
-export type PollingMetricTypeId = typeof PollingMetricTypeId
+export type MetricPollingTypeId = typeof MetricPollingTypeId
 
 /**
- * A `PollingMetric` is a combination of a metric and an effect that polls for
+ * A `MetricPolling` is a combination of a metric and an effect that polls for
  * updates to the metric.
  *
  * @since 2.0.0
  * @category models
  */
-export interface PollingMetric<Type, In, R, E, Out> extends Pipeable {
-  readonly [PollingMetricTypeId]: PollingMetricTypeId
+export interface MetricPolling<in out Type, in out In, out R, out E, out Out> extends Pipeable {
+  readonly [MetricPollingTypeId]: MetricPollingTypeId
   /**
-   * The metric that this `PollingMetric` polls to update.
+   * The metric that this `MetricPolling` polls to update.
    */
   readonly metric: Metric.Metric<Type, In, Out>
   /**
@@ -49,7 +49,7 @@ export interface PollingMetric<Type, In, R, E, Out> extends Pipeable {
 export const make: <Type, In, Out, R, E>(
   metric: Metric.Metric<Type, In, Out>,
   poll: Effect.Effect<R, E, In>
-) => PollingMetric<Type, In, R, E, Out> = internal.make
+) => MetricPolling<Type, In, R, E, Out> = internal.make
 
 /**
  * Collects all of the polling metrics into a single polling metric, which
@@ -59,8 +59,8 @@ export const make: <Type, In, Out, R, E>(
  * @category constructors
  */
 export const collectAll: <R, E, Out>(
-  iterable: Iterable<PollingMetric<any, any, R, E, Out>>
-) => PollingMetric<Array<any>, Array<any>, R, E, Array<Out>> = internal.collectAll
+  iterable: Iterable<MetricPolling<any, any, R, E, Out>>
+) => MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> = internal.collectAll
 
 /**
  * Returns an effect that will launch the polling metric in a background
@@ -73,10 +73,10 @@ export const launch: {
   <R2, A2>(
     schedule: Schedule.Schedule<R2, unknown, A2>
   ): <Type, In, R, E, Out>(
-    self: PollingMetric<Type, In, R, E, Out>
+    self: MetricPolling<Type, In, R, E, Out>
   ) => Effect.Effect<R2 | R | Scope.Scope, never, Fiber.Fiber<E, A2>>
   <Type, In, R, E, Out, R2, A2>(
-    self: PollingMetric<Type, In, R, E, Out>,
+    self: MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
   ): Effect.Effect<Scope.Scope | R | R2, never, Fiber.Fiber<E, A2>>
 } = internal.launch
@@ -87,7 +87,7 @@ export const launch: {
  * @since 2.0.0
  * @category utils
  */
-export const poll: <Type, In, R, E, Out>(self: PollingMetric<Type, In, R, E, Out>) => Effect.Effect<R, E, In> =
+export const poll: <Type, In, R, E, Out>(self: MetricPolling<Type, In, R, E, Out>) => Effect.Effect<R, E, In> =
   internal.poll
 
 /**
@@ -97,7 +97,7 @@ export const poll: <Type, In, R, E, Out>(self: PollingMetric<Type, In, R, E, Out
  * @category utils
  */
 export const pollAndUpdate: <Type, In, R, E, Out>(
-  self: PollingMetric<Type, In, R, E, Out>
+  self: MetricPolling<Type, In, R, E, Out>
 ) => Effect.Effect<R, E, void> = internal.pollAndUpdate
 
 /**
@@ -110,11 +110,11 @@ export const pollAndUpdate: <Type, In, R, E, Out>(
 export const retry: {
   <R2, E, _>(
     policy: Schedule.Schedule<R2, E, _>
-  ): <Type, In, R, Out>(self: PollingMetric<Type, In, R, E, Out>) => PollingMetric<Type, In, R2 | R, E, Out>
+  ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
   <Type, In, R, Out, R2, E, _>(
-    self: PollingMetric<Type, In, R, E, Out>,
+    self: MetricPolling<Type, In, R, E, Out>,
     policy: Schedule.Schedule<R2, E, _>
-  ): PollingMetric<Type, In, R | R2, E, Out>
+  ): MetricPolling<Type, In, R | R2, E, Out>
 } = internal.retry
 
 /**
@@ -125,10 +125,10 @@ export const retry: {
  */
 export const zip: {
   <Type2, In2, R2, E2, Out2>(
-    that: PollingMetric<Type2, In2, R2, E2, Out2>
+    that: MetricPolling<Type2, In2, R2, E2, Out2>
   ): <Type, In, R, E, Out>(
-    self: PollingMetric<Type, In, R, E, Out>
-  ) => PollingMetric<
+    self: MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling<
     readonly [Type, Type2], // readonly because invariant
     readonly [In, In2], // readonly because contravariant
     R2 | R,
@@ -136,9 +136,9 @@ export const zip: {
     [Out, Out2]
   >
   <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
-    self: PollingMetric<Type, In, R, E, Out>,
-    that: PollingMetric<Type2, In2, R2, E2, Out2>
-  ): PollingMetric<
+    self: MetricPolling<Type, In, R, E, Out>,
+    that: MetricPolling<Type2, In2, R2, E2, Out2>
+  ): MetricPolling<
     readonly [Type, Type2], // readonly because invariant
     readonly [In, In2], // readonly because contravariant
     R | R2,

package/src/MetricRegistry.ts

@@ -26,20 +26,20 @@ export type MetricRegistryTypeId = typeof MetricRegistryTypeId
  */
 export interface MetricRegistry {
   readonly [MetricRegistryTypeId]: MetricRegistryTypeId
-  readonly snapshot: () => HashSet.HashSet<MetricPair.MetricPair.Untyped>
-  readonly get: <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  snapshot(): HashSet.HashSet<MetricPair.MetricPair.Untyped>
+  get<Type extends MetricKeyType.MetricKeyType<any, any>>(
     key: MetricKey.MetricKey<Type>
-  ) => MetricHook.MetricHook<
+  ): MetricHook.MetricHook<
     MetricKeyType.MetricKeyType.InType<typeof key["keyType"]>,
     MetricKeyType.MetricKeyType.OutType<typeof key["keyType"]>
   >
-  readonly getCounter: <A extends (number | bigint)>(
+  getCounter<A extends (number | bigint)>(
     key: MetricKey.MetricKey.Counter<A>
-  ) => MetricHook.MetricHook.Counter<A>
-  readonly getFrequency: (key: MetricKey.MetricKey.Frequency) => MetricHook.MetricHook.Frequency
-  readonly getGauge: <A extends (number | bigint)>(key: MetricKey.MetricKey.Gauge<A>) => MetricHook.MetricHook.Gauge<A>
-  readonly getHistogram: (key: MetricKey.MetricKey.Histogram) => MetricHook.MetricHook.Histogram
-  readonly getSummary: (key: MetricKey.MetricKey.Summary) => MetricHook.MetricHook.Summary
+  ): MetricHook.MetricHook.Counter<A>
+  getFrequency(key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency
+  getGauge<A extends (number | bigint)>(key: MetricKey.MetricKey.Gauge<A>): MetricHook.MetricHook.Gauge<A>
+  getHistogram(key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram
+  getSummary(key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary
 }
 
 /**