effect 2.0.0-next.55 → 2.0.0-next.57

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"
@@ -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
@@ -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.
@@ -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> => {
@@ -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>
@@ -760,13 +761,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 +789,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 +868,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

@@ -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
@@ -35,8 +36,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,10 +48,10 @@ 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
+      readonly _Message: Types.Contravariant<Message>
+      readonly _Output: Types.Covariant<Output>
     }
   }
 
@@ -58,7 +59,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

@@ -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"
 
 /**
@@ -33,32 +33,32 @@ 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
-    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>
-  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
-    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>
-  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
 }
 
 /**
@@ -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>(
@@ -550,7 +562,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 +664,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 +672,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

@@ -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
@@ -21,7 +22,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,13 +32,13 @@ 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
-      _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/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

@@ -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
@@ -49,15 +50,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,11 +122,11 @@ 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
-      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