effect 2.0.0-next.56 → 2.0.0-next.57

package/src/GroupBy.ts

@@ -7,6 +7,7 @@ import type { Predicate } from "./Predicate.js"
 import type * as Queue from "./Queue.js"
 import type * as Stream from "./Stream.js"
 import type * as Take from "./Take.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -42,10 +43,10 @@ export declare namespace GroupBy {
    */
   export interface Variance<out R, out E, out K, out V> {
     readonly [GroupByTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
-      readonly _K: (_: never) => K
-      readonly _V: (_: never) => V
+      readonly _R: Types.Covariant<R>
+      readonly _E: Types.Covariant<E>
+      readonly _K: Types.Covariant<K>
+      readonly _V: Types.Covariant<V>
     }
   }
 }

package/src/HKT.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -37,8 +38,8 @@ export type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
   })["type"]
   : {
     readonly F: F
-    readonly In: (_: In) => void
-    readonly Out2: () => Out2
-    readonly Out1: () => Out1
-    readonly Target: (_: Target) => Target
+    readonly In: Types.Contravariant<In>
+    readonly Out2: Types.Covariant<Out2>
+    readonly Out1: Types.Covariant<Out1>
+    readonly Target: Types.Invariant<Target>
   }

package/src/Inspectable.ts

@@ -41,7 +41,5 @@ export const toJSON = (x: unknown): unknown => {
   return x
 }
 
-/**
- * @since 2.0.0
- */
-export const toString = (x: unknown): string => JSON.stringify(x, null, 2)
+/** @internal */
+export const format = (x: unknown): string => JSON.stringify(x, null, 2)

package/src/KeyedPool.ts

@@ -6,6 +6,7 @@ import type * as Effect from "./Effect.js"
 import * as internal from "./internal/keyedPool.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -53,9 +54,9 @@ export declare namespace KeyedPool {
    */
   export interface Variance<in K, out E, in out A> {
     readonly [KeyedPoolTypeId]: {
-      readonly _K: (_: K) => void
-      readonly _E: (_: never) => E
-      readonly _A: (_: A) => A
+      readonly _K: Types.Contravariant<K>
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Layer.ts

@@ -41,6 +41,7 @@ import type * as Schedule from "./Schedule.js"
 import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Tracer from "./Tracer.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -70,9 +71,9 @@ export declare namespace Layer {
    */
   export interface Variance<out RIn, out E, in ROut> {
     readonly [LayerTypeId]: {
-      readonly _RIn: (_: never) => RIn
-      readonly _E: (_: never) => E
-      readonly _ROut: (_: ROut) => void
+      readonly _RIn: Types.Covariant<RIn>
+      readonly _E: Types.Covariant<E>
+      readonly _ROut: Types.Contravariant<ROut>
     }
   }
   /**
@@ -415,24 +416,23 @@ export const memoize: <RIn, E, ROut>(
 ) => Effect.Effect<Scope.Scope, never, Layer<RIn, E, ROut>> = internal.memoize
 
 /**
- * Combines this layer with the specified layer, producing a new layer that
- * has the inputs and outputs of both.
+ * Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const merge: {
   <RIn2, E2, ROut2>(
     that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E2 | E, ROut2 | ROut>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
+  ): <RIn, E1, ROut>(self: Layer<RIn, E1, ROut>) => Layer<RIn2 | RIn, E2 | E1, ROut2 | ROut>
+  <RIn, E1, ROut, RIn2, E2, ROut2>(
+    self: Layer<RIn, E1, ROut>,
     that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | RIn2, E | E2, ROut | ROut2>
+  ): Layer<RIn | RIn2, E1 | E2, ROut | ROut2>
 } = internal.merge
 
 /**
- * Merges all the layers together in parallel.
+ * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
  *
  * @since 2.0.0
  * @category zipping
@@ -496,24 +496,6 @@ export const project: {
   ): Layer<RIn, E, Context.Tag.Identifier<B>>
 } = internal.project
 
-/**
- * Feeds the output services of this builder into the input of the specified
- * builder, resulting in a new builder with the inputs of this builder as
- * well as any leftover inputs, and the outputs of the specified builder.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provide: {
-  <RIn2, E2, ROut2>(
-    that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
-    that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
-} = internal.provide
-
 /**
  * @since 2.0.0
  * @category utils
@@ -567,24 +549,6 @@ export const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never, nev
 export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never, never, never> =
   internal.fiberRefLocallyScopedWith
 
-/**
- * Feeds the output services of this layer into the input of the specified
- * layer, resulting in a new layer with the inputs of this layer, and the
- * outputs of both layers.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provideMerge: {
-  <RIn2, E2, ROut2>(
-    that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2 | ROut>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
-    that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>
-} = internal.provideMerge
-
 /**
  * Retries constructing this layer according to the specified schedule.
  *
@@ -787,7 +751,7 @@ export const toRuntime: <RIn, E, ROut>(
  * @since 2.0.0
  * @category utils
  */
-export const use: {
+export const provide: {
   <RIn, E, ROut>(
     self: Layer<RIn, E, ROut>
   ): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
@@ -795,7 +759,7 @@ export const use: {
     that: Layer<RIn2, E2, ROut2>,
     self: Layer<RIn, E, ROut>
   ): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2>
-} = internal.use
+} = internal.provide
 
 /**
  * Feeds the output services of this layer into the input of the specified
@@ -805,7 +769,7 @@ export const use: {
  * @since 2.0.0
  * @category utils
  */
-export const useMerge: {
+export const provideMerge: {
   <RIn, E, ROut>(
     self: Layer<RIn, E, ROut>
   ): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>
@@ -813,17 +777,16 @@ export const useMerge: {
     that: Layer<RIn2, E2, ROut2>,
     self: Layer<RIn, E, ROut>
   ): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2 | ROut>
-} = internal.useMerge
+} = internal.provideMerge
 
 /**
- * Combines this layer the specified layer, producing a new layer that has the
- * inputs of both, and the outputs of both combined using the specified
- * function.
+ * Combines this layer with the specified layer concurrently, creating a new layer with merged input types and
+ * combined output types using the provided function.
  *
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithPar: {
+export const zipWith: {
   <R2, E2, B, A, C>(
     that: Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -833,7 +796,7 @@ export const zipWithPar: {
     that: Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
   ): Layer<R | R2, E | E2, C>
-} = internal.zipWithPar
+} = internal.zipWith
 
 /**
  * @since 2.0.0

package/src/List.ts

@@ -27,7 +27,7 @@ import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
 import { dual, identity, unsafeCoerce } from "./Function.js"
 import * as Hash from "./Hash.js"
-import { type Inspectable, NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+import { format, type Inspectable, NodeInspectSymbol, toJSON } from "./Inspectable.js"
 import * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
@@ -99,7 +99,7 @@ const ConsProto: Omit<Cons<unknown>, "head" | "tail"> = {
   [TypeId]: TypeId,
   _tag: "Cons",
   toString(this: Cons<unknown>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON(this: Cons<unknown>) {
     return {
@@ -165,7 +165,7 @@ const NilProto: Nil<unknown> = {
   [TypeId]: TypeId,
   _tag: "Nil",
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {
@@ -315,29 +315,29 @@ export const make = <Elements extends readonly [any, ...Array<any>]>(
 export const append: {
   <B>(element: B): <A>(self: List<A>) => Cons<A | B>
   <A, B>(self: List<A>, element: B): Cons<A | B>
-} = dual(2, <A, B>(self: List<A>, element: B): Cons<A | B> => appendAllNonEmpty(self, of(element)))
+} = dual(2, <A, B>(self: List<A>, element: B): Cons<A | B> => appendAll(self, of(element)))
 
 /**
- * Concatentates the specified lists together.
+ * Concatenates two lists, combining their elements.
+ * If either list is non-empty, the result is also a non-empty list.
+ *
+ * @example
+ * import * as List from "effect/List"
+ *
+ * assert.deepStrictEqual(
+ *   List.make(1, 2).pipe(List.appendAll(List.make("a", "b")), List.toArray),
+ *   [1, 2, "a", "b"]
+ * )
  *
  * @category concatenating
  * @since 2.0.0
  */
 export const appendAll: {
-  <B>(that: List<B>): <A>(self: List<A>) => List<A | B>
-  <A, B>(self: List<A>, that: List<B>): List<A | B>
-} = dual(2, <A, B>(self: List<A>, that: List<B>): List<A | B> => prependAll(that, self))
-
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export const appendAllNonEmpty: {
-  <B>(that: Cons<B>): <A>(self: List<A>) => Cons<B | A>
-  <B>(that: List<B>): <A>(self: Cons<A>) => Cons<B | A>
+  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.With2<S, T, List.Infer<S> | List.Infer<T>>
   <A, B>(self: List<A>, that: Cons<B>): Cons<A | B>
   <A, B>(self: Cons<A>, that: List<B>): Cons<A | B>
-} = dual(2, <A, B>(self: Cons<A>, that: List<B>): Cons<A | B> => appendAll(self, that) as any)
+  <A, B>(self: List<A>, that: List<B>): List<A | B>
+} = dual(2, <A, B>(self: List<A>, that: List<B>): List<A | B> => prependAll(that, self))
 
 /**
  * Prepends the specified element to the beginning of the list.
@@ -352,13 +352,24 @@ export const prepend: {
 
 /**
  * Prepends the specified prefix list to the beginning of the specified list.
+ * If either list is non-empty, the result is also a non-empty list.
+ *
+ * @example
+ * import * as List from "effect/List"
+ *
+ * assert.deepStrictEqual(
+ *   List.make(1, 2).pipe(List.prependAll(List.make("a", "b")), List.toArray),
+ *   ["a", "b", 1, 2]
+ * )
  *
  * @category concatenating
  * @since 2.0.0
  */
 export const prependAll: {
-  <B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>
-  <A, B>(self: List<A>, prefix: List<B>): List<A | B>
+  <S extends List<any>, T extends List<any>>(that: T): (self: S) => List.With2<S, T, List.Infer<S> | List.Infer<T>>
+  <A, B>(self: List<A>, that: Cons<B>): Cons<A | B>
+  <A, B>(self: Cons<A>, that: List<B>): Cons<A | B>
+  <A, B>(self: List<A>, that: List<B>): List<A | B>
 } = dual(2, <A, B>(self: List<A>, prefix: List<B>): List<A | B> => {
   if (isNil(self)) {
     return prefix
@@ -378,17 +389,6 @@ export const prependAll: {
   }
 })
 
-/**
- * @category concatenating
- * @since 2.0.0
- */
-export const prependAllNonEmpty: {
-  <B>(that: Cons<B>): <A>(self: List<A>) => Cons<B | A>
-  <B>(that: List<B>): <A>(self: Cons<A>) => Cons<B | A>
-  <A, B>(self: List<A>, that: Cons<B>): Cons<A | B>
-  <A, B>(self: Cons<A>, that: List<B>): Cons<A | B>
-} = dual(2, <A, B>(self: Cons<A>, that: List<B>): Cons<A | B> => prependAll(self, that) as any)
-
 /**
  * Prepends the specified prefix list (in reverse order) to the beginning of the
  * specified list.
@@ -633,14 +633,17 @@ export const findFirst: {
 })
 
 /**
- * Flat maps a list using the specified function.
+ * Applies a function to each element in a list and returns a new list containing the concatenated mapped elements.
  *
  * @since 2.0.0
  * @category sequencing
  */
 export const flatMap: {
-  <A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>
-  <A, B>(self: List<A>, f: (a: A) => List<B>): List<B>
+  <S extends List<any>, T extends List<any>>(
+    f: (a: List.Infer<S>, i: number) => T
+  ): (self: S) => List.With2<S, T, List.Infer<T>>
+  <A, B>(self: Cons<A>, f: (a: A, i: number) => Cons<B>): Cons<B>
+  <A, B>(self: List<A>, f: (a: A, i: number) => List<B>): List<B>
 } = dual(2, <A, B>(self: List<A>, f: (a: A) => List<B>): List<B> => {
   let rest = self
   let head: MutableCons<B> | undefined = undefined
@@ -665,15 +668,6 @@ export const flatMap: {
   return head
 })
 
-/**
- * @category sequencing
- * @since 2.0.0
- */
-export const flatMapNonEmpty: {
-  <A, B>(f: (a: A) => Cons<B>): (self: Cons<A>) => Cons<B>
-  <A, B>(self: Cons<A>, f: (a: A) => Cons<B>): Cons<B>
-} = flatMap as any
-
 /**
  * Applies the specified function to each element of the `List`.
  *
@@ -722,13 +716,20 @@ export declare namespace List {
    * @since 2.0.0
    */
   export type With<T extends List<any>, A> = T extends Cons<any> ? Cons<A> : List<A>
+
+  /**
+   * @since 2.0.0
+   */
+  export type With2<S extends List<any>, T extends List<any>, A> = S extends Cons<any> ? Cons<A>
+    : T extends Cons<any> ? Cons<A>
+    : List<A>
 }
 
 /**
  * Applies the specified mapping function to each element of the list.
  *
  * @since 2.0.0
- * @category combinators
+ * @category mapping
  */
 export const map: {
   <T extends List<any>, B>(f: (a: List.Infer<T>, i: number) => B): (self: T) => List.With<T, B>

package/src/Logger.ts

@@ -18,6 +18,7 @@ import type * as LogSpan from "./LogSpan.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Scope } from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -49,8 +50,8 @@ export declare namespace Logger {
    */
   export interface Variance<in Message, out Output> {
     readonly [LoggerTypeId]: {
-      readonly _Message: (_: Message) => void
-      readonly _Output: (_: never) => Output
+      readonly _Message: Types.Contravariant<Message>
+      readonly _Output: Types.Covariant<Output>
     }
   }
 

package/src/Match.ts

@@ -6,7 +6,7 @@ import * as internal from "./internal/matcher.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
-import type { UnionToIntersection } from "./Types.js"
+import type { Contravariant, Covariant, UnionToIntersection } from "./Types.js"
 import type { Unify } from "./Unify.js"
 
 /**
@@ -36,10 +36,10 @@ export type Matcher<Input, Filters, RemainingApplied, Result, Provided> =
 export interface TypeMatcher<in Input, out Filters, out Remaining, out Result> extends Pipeable {
   readonly _tag: "TypeMatcher"
   readonly [MatcherTypeId]: {
-    readonly _input: (_: Input) => unknown
-    readonly _filters: (_: never) => Filters
-    readonly _remaining: (_: never) => Remaining
-    readonly _result: (_: never) => Result
+    readonly _input: Contravariant<Input>
+    readonly _filters: Covariant<Filters>
+    readonly _remaining: Covariant<Remaining>
+    readonly _result: Covariant<Result>
   }
   readonly cases: ReadonlyArray<Case>
   add<I, R, RA, A>(_case: Case): TypeMatcher<I, R, RA, A>
@@ -52,9 +52,9 @@ export interface TypeMatcher<in Input, out Filters, out Remaining, out Result> e
 export interface ValueMatcher<in Input, Filters, out Remaining, out Result, Provided> extends Pipeable {
   readonly _tag: "ValueMatcher"
   readonly [MatcherTypeId]: {
-    readonly _input: (_: Input) => unknown
-    readonly _filters: (_: never) => Filters
-    readonly _result: (_: never) => Result
+    readonly _input: Contravariant<Input>
+    readonly _filters: Covariant<Filters>
+    readonly _result: Covariant<Result>
   }
   readonly provided: Provided
   readonly value: Either.Either<Remaining, Provided>
@@ -107,11 +107,13 @@ export const value: <const I>(
  */
 export const valueTags: <
   const I,
-  P extends {
-    readonly [Tag in Types.Tags<"_tag", I> & string]: (
-      _: Extract<I, { readonly _tag: Tag }>
-    ) => any
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<"_tag", I> & string]: (
+        _: Extract<I, { readonly _tag: Tag }>
+      ) => any
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
 >(fields: P) => (input: I) => Unify<ReturnType<P[keyof P]>> = internal.valueTags
 
 /**
@@ -119,11 +121,13 @@ export const valueTags: <
  * @since 1.0.0
  */
 export const typeTags: <I>() => <
-  P extends {
-    readonly [Tag in Types.Tags<"_tag", I> & string]: (
-      _: Extract<I, { readonly _tag: Tag }>
-    ) => any
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<"_tag", I> & string]: (
+        _: Extract<I, { readonly _tag: Tag }>
+      ) => any
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
 >(fields: P) => (input: I) => Unify<ReturnType<P[keyof P]>> = internal.typeTags
 
 /**
@@ -246,11 +250,13 @@ export const discriminators: <D extends string>(
   field: D
 ) => <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<D, R> & string]?:
-      | ((_: Extract<R, Record<D, Tag>>) => any)
-      | undefined
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<D, R> & string]?:
+        | ((_: Extract<R, Record<D, Tag>>) => any)
+        | undefined
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(
@@ -271,11 +277,13 @@ export const discriminatorsExhaustive: <D extends string>(
   field: D
 ) => <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<D, R> & string]: (
-      _: Extract<R, Record<D, Tag>>
-    ) => any
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<D, R> & string]: (
+        _: Extract<R, Record<D, Tag>>
+      ) => any
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(
@@ -329,11 +337,13 @@ export const tagStartsWith: <R, P extends string, B>(
  */
 export const tags: <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<"_tag", R> & string]?:
-      | ((_: Extract<R, Record<"_tag", Tag>>) => any)
-      | undefined
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<"_tag", R> & string]?:
+        | ((_: Extract<R, Record<"_tag", Tag>>) => any)
+        | undefined
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(
@@ -355,11 +365,13 @@ export const tags: <
  */
 export const tagsExhaustive: <
   R,
-  P extends {
-    readonly [Tag in Types.Tags<"_tag", R> & string]: (
-      _: Extract<R, Record<"_tag", Tag>>
-    ) => any
-  }
+  P extends
+    & {
+      readonly [Tag in Types.Tags<"_tag", R> & string]: (
+        _: Extract<R, Record<"_tag", Tag>>
+      ) => any
+    }
+    & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
   fields: P
 ) => <I, F, A, Pr>(

package/src/MergeDecision.ts

@@ -4,6 +4,7 @@
 import type * as Effect from "./Effect.js"
 import type * as Exit from "./Exit.js"
 import * as internal from "./internal/channel/mergeDecision.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -33,11 +34,11 @@ export declare namespace MergeDecision {
    */
   export interface Variance<out R, in E0, in Z0, out E, out Z> {
     readonly [MergeDecisionTypeId]: {
-      _R: (_: never) => R
-      _E0: (_: E0) => void
-      _Z0: (_: Z0) => void
-      _E: (_: never) => E
-      _Z: (_: never) => Z
+      _R: Types.Covariant<R>
+      _E0: Types.Contravariant<E0>
+      _Z0: Types.Contravariant<Z0>
+      _E: Types.Covariant<E>
+      _Z: Types.Covariant<Z>
     }
   }
 }

package/src/Metric.ts

@@ -16,6 +16,7 @@ import type * as MetricPair from "./MetricPair.js"
 import type * as MetricRegistry from "./MetricRegistry.js"
 import type * as MetricState from "./MetricState.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -123,9 +124,9 @@ export declare namespace Metric {
    */
   export interface Variance<in out Type, in In, out Out> {
     readonly [MetricTypeId]: {
-      readonly _Type: (_: Type) => Type
-      readonly _In: (_: In) => void
-      readonly _Out: (_: never) => Out
+      readonly _Type: Types.Invariant<Type>
+      readonly _In: Types.Contravariant<In>
+      readonly _Out: Types.Covariant<Out>
     }
   }
 }
@@ -481,7 +482,8 @@ export const taggedWithLabels: {
  * @category constructors
  */
 export const timer: (
-  name: string
+  name: string,
+  description?: string
 ) => Metric<MetricKeyType.MetricKeyType.Histogram, Duration.Duration, MetricState.MetricState.Histogram> =
   internal.timer
 
@@ -496,7 +498,8 @@ export const timer: (
  */
 export const timerWithBoundaries: (
   name: string,
-  boundaries: Chunk.Chunk<number>
+  boundaries: Chunk.Chunk<number>,
+  description?: string
 ) => Metric<MetricKeyType.MetricKeyType.Histogram, Duration.Duration, MetricState.MetricState.Histogram> =
   internal.timerWithBoundaries
 

package/src/MetricHook.ts

@@ -6,6 +6,7 @@ import * as internal from "./internal/metric/hook.js"
 import type * as MetricKey from "./MetricKey.js"
 import type * as MetricState from "./MetricState.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -80,8 +81,8 @@ export declare namespace MetricHook {
    */
   export interface Variance<in In, out Out> {
     readonly [MetricHookTypeId]: {
-      readonly _In: (_: In) => void
-      readonly _Out: (_: never) => Out
+      readonly _In: Types.Contravariant<In>
+      readonly _Out: Types.Covariant<Out>
     }
   }
 }